three-stdlib 2.15.1 → 2.15.2

package/misc/MD2CharacterComplex.mjs

@@ -0,0 +1,328 @@
+import { Object3D, Box3, MathUtils, TextureLoader, UVMapping, sRGBEncoding, 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) {
+    for (let i = 0; i < this.meshes.length; i++) {
+      this.meshes[i].castShadow = enable;
+      this.meshes[i].receiveShadow = enable;
+    }
+  };
+  this.setVisible = function(enable) {
+    for (let i = 0; i < this.meshes.length; i++) {
+      this.meshes[i].visible = enable;
+      this.meshes[i].visible = enable;
+    }
+  };
+  this.shareParts = function(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]);
+    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]);
+      meshWeapon.scale.set(this.scale, this.scale, this.scale);
+      meshWeapon.visible = false;
+      meshWeapon.name = original.weapons[i].name;
+      this.root.add(meshWeapon);
+      this.weapons[i] = meshWeapon;
+      this.meshWeapon = meshWeapon;
+      this.meshes.push(meshWeapon);
+    }
+  };
+  this.loadParts = function(config) {
+    this.animations = config.animations;
+    this.walkSpeed = config.walkSpeed;
+    this.crouchSpeed = config.crouchSpeed;
+    this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
+    var 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();
+    loader.load(config.baseUrl + config.body, function(geo) {
+      var boundingBox = new Box3();
+      boundingBox.setFromBufferAttribute(geo.attributes.position);
+      scope.root.position.y = -scope.scale * boundingBox.min.y;
+      var mesh = 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) {
+      return function(geo) {
+        var mesh = createPart(geo, scope.skinsWeapon[index]);
+        mesh.scale.set(scope.scale, scope.scale, scope.scale);
+        mesh.visible = false;
+        mesh.name = name;
+        scope.root.add(mesh);
+        scope.weapons[index] = mesh;
+        scope.meshWeapon = mesh;
+        scope.meshes.push(mesh);
+        checkLoadingComplete();
+      };
+    };
+    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) {
+    if (this.meshBody)
+      this.meshBody.duration = this.meshBody.baseDuration / rate;
+    if (this.meshWeapon)
+      this.meshWeapon.duration = this.meshWeapon.baseDuration / rate;
+  };
+  this.setWireframe = function(wireframeEnabled) {
+    if (wireframeEnabled) {
+      if (this.meshBody)
+        this.meshBody.material = this.meshBody.materialWireframe;
+      if (this.meshWeapon)
+        this.meshWeapon.material = this.meshWeapon.materialWireframe;
+    } else {
+      if (this.meshBody)
+        this.meshBody.material = this.meshBody.materialTexture;
+      if (this.meshWeapon)
+        this.meshWeapon.material = this.meshWeapon.materialTexture;
+    }
+  };
+  this.setSkin = function(index) {
+    if (this.meshBody && this.meshBody.material.wireframe === false) {
+      this.meshBody.material.map = this.skinsBody[index];
+      this.currentSkin = index;
+    }
+  };
+  this.setWeapon = function(index) {
+    for (let i = 0; i < this.weapons.length; i++)
+      this.weapons[i].visible = false;
+    var activeWeapon = this.weapons[index];
+    if (activeWeapon) {
+      activeWeapon.visible = true;
+      this.meshWeapon = activeWeapon;
+      if (this.activeAnimation) {
+        activeWeapon.playAnimation(this.activeAnimation);
+        this.meshWeapon.setAnimationTime(this.activeAnimation, this.meshBody.getAnimationTime(this.activeAnimation));
+      }
+    }
+  };
+  this.setAnimation = function(animationName) {
+    if (animationName === this.activeAnimation || !animationName)
+      return;
+    if (this.meshBody) {
+      this.meshBody.setAnimationWeight(animationName, 0);
+      this.meshBody.playAnimation(animationName);
+      this.oldAnimation = this.activeAnimation;
+      this.activeAnimation = animationName;
+      this.blendCounter = this.transitionFrames;
+    }
+    if (this.meshWeapon) {
+      this.meshWeapon.setAnimationWeight(animationName, 0);
+      this.meshWeapon.playAnimation(animationName);
+    }
+  };
+  this.update = function(delta) {
+    if (this.controls)
+      this.updateMovementModel(delta);
+    if (this.animations) {
+      this.updateBehaviors();
+      this.updateAnimations(delta);
+    }
+  };
+  this.updateAnimations = function(delta) {
+    var mix = 1;
+    if (this.blendCounter > 0) {
+      mix = (this.transitionFrames - this.blendCounter) / this.transitionFrames;
+      this.blendCounter -= 1;
+    }
+    if (this.meshBody) {
+      this.meshBody.update(delta);
+      this.meshBody.setAnimationWeight(this.activeAnimation, mix);
+      this.meshBody.setAnimationWeight(this.oldAnimation, 1 - mix);
+    }
+    if (this.meshWeapon) {
+      this.meshWeapon.update(delta);
+      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;
+    if (controls.crouch) {
+      moveAnimation = animations["crouchMove"];
+      idleAnimation = animations["crouchIdle"];
+    } else {
+      moveAnimation = animations["move"];
+      idleAnimation = animations["idle"];
+    }
+    if (controls.jump) {
+      moveAnimation = animations["jump"];
+      idleAnimation = animations["jump"];
+    }
+    if (controls.attack) {
+      if (controls.crouch) {
+        moveAnimation = animations["crouchAttack"];
+        idleAnimation = animations["crouchAttack"];
+      } else {
+        moveAnimation = animations["attack"];
+        idleAnimation = animations["attack"];
+      }
+    }
+    if (controls.moveForward || controls.moveBackward || controls.moveLeft || controls.moveRight) {
+      if (this.activeAnimation !== moveAnimation) {
+        this.setAnimation(moveAnimation);
+      }
+    }
+    if (Math.abs(this.speed) < 0.2 * this.maxSpeed && !(controls.moveLeft || controls.moveRight || controls.moveForward || controls.moveBackward)) {
+      if (this.activeAnimation !== idleAnimation) {
+        this.setAnimation(idleAnimation);
+      }
+    }
+    if (controls.moveForward) {
+      if (this.meshBody) {
+        this.meshBody.setAnimationDirectionForward(this.activeAnimation);
+        this.meshBody.setAnimationDirectionForward(this.oldAnimation);
+      }
+      if (this.meshWeapon) {
+        this.meshWeapon.setAnimationDirectionForward(this.activeAnimation);
+        this.meshWeapon.setAnimationDirectionForward(this.oldAnimation);
+      }
+    }
+    if (controls.moveBackward) {
+      if (this.meshBody) {
+        this.meshBody.setAnimationDirectionBackward(this.activeAnimation);
+        this.meshBody.setAnimationDirectionBackward(this.oldAnimation);
+      }
+      if (this.meshWeapon) {
+        this.meshWeapon.setAnimationDirectionBackward(this.activeAnimation);
+        this.meshWeapon.setAnimationDirectionBackward(this.oldAnimation);
+      }
+    }
+  };
+  this.updateMovementModel = function(delta) {
+    var controls = this.controls;
+    if (controls.crouch)
+      this.maxSpeed = this.crouchSpeed;
+    else
+      this.maxSpeed = this.walkSpeed;
+    this.maxReverseSpeed = -this.maxSpeed;
+    if (controls.moveForward) {
+      this.speed = MathUtils.clamp(this.speed + delta * this.frontAcceleration, this.maxReverseSpeed, this.maxSpeed);
+    }
+    if (controls.moveBackward) {
+      this.speed = MathUtils.clamp(this.speed - delta * this.backAcceleration, this.maxReverseSpeed, this.maxSpeed);
+    }
+    var dir = 1;
+    if (controls.moveLeft) {
+      this.bodyOrientation += delta * this.angularSpeed;
+      this.speed = MathUtils.clamp(
+        this.speed + dir * delta * this.frontAcceleration,
+        this.maxReverseSpeed,
+        this.maxSpeed
+      );
+    }
+    if (controls.moveRight) {
+      this.bodyOrientation -= delta * this.angularSpeed;
+      this.speed = MathUtils.clamp(
+        this.speed + dir * delta * this.frontAcceleration,
+        this.maxReverseSpeed,
+        this.maxSpeed
+      );
+    }
+    if (!(controls.moveForward || controls.moveBackward)) {
+      if (this.speed > 0) {
+        var 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);
+        this.speed = MathUtils.clamp(this.speed + k * delta * this.backAcceleration, this.maxReverseSpeed, 0);
+      }
+    }
+    var 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];
+      textures[i].encoding = sRGBEncoding;
+    }
+    return textures;
+  }
+  function createPart(geometry, skinMap) {
+    var materialWireframe = new MeshLambertMaterial({
+      color: 16755200,
+      wireframe: true,
+      morphTargets: true,
+      morphNormals: true
+    });
+    var materialTexture = new MeshLambertMaterial({
+      color: 16777215,
+      wireframe: false,
+      map: skinMap,
+      morphTargets: true,
+      morphNormals: true
+    });
+    var mesh = new MorphBlendMesh(geometry, materialTexture);
+    mesh.rotation.y = -Math.PI / 2;
+    mesh.materialTexture = materialTexture;
+    mesh.materialWireframe = materialWireframe;
+    mesh.autoCreateAnimations(scope.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/misc/MorphAnimMesh.js

@@ -1,48 +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);
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [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(Mesh.prototype);
+MorphAnimMesh.prototype = Object.create(THREE.Mesh.prototype);
 MorphAnimMesh.prototype.constructor = MorphAnimMesh;
-
-MorphAnimMesh.prototype.setDirectionForward = function () {
-  this.mixer.timeScale = 1.0;
+MorphAnimMesh.prototype.setDirectionForward = function() {
+  this.mixer.timeScale = 1;
 };
-
-MorphAnimMesh.prototype.setDirectionBackward = function () {
-  this.mixer.timeScale = -1.0;
+MorphAnimMesh.prototype.setDirectionBackward = function() {
+  this.mixer.timeScale = -1;
 };
-
-MorphAnimMesh.prototype.playAnimation = function (label, fps) {
+MorphAnimMesh.prototype.playAnimation = function(label, fps) {
   if (this.activeAction) {
     this.activeAction.stop();
     this.activeAction = null;
   }
-
-  var clip = AnimationClip.findByName(this, label);
-
+  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()');
+    throw new Error("THREE.MorphAnimMesh: animations[" + label + "] undefined in .playAnimation()");
   }
 };
-
-MorphAnimMesh.prototype.updateAnimation = function (delta) {
+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);
+MorphAnimMesh.prototype.copy = function(source) {
+  THREE.Mesh.prototype.copy.call(this, source);
+  this.mixer = new THREE.AnimationMixer(this);
   return this;
 };
-
-export { MorphAnimMesh };
+exports.MorphAnimMesh = MorphAnimMesh;

package/misc/MorphAnimMesh.mjs

@@ -0,0 +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();
+    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.js

@@ -1,28 +1,26 @@
-import { Mesh, MathUtils } from 'three';
-
-var MorphBlendMesh = function (geometry, material) {
-  Mesh.call(this, geometry, material);
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+var MorphBlendMesh = function(geometry, material) {
+  THREE.Mesh.call(this, geometry, material);
   this.animationsMap = {};
-  this.animationsList = []; // prepare default animation
-  // (all frames played together in 1 second)
-
+  this.animationsList = [];
   var numFrames = Object.keys(this.morphTargetDictionary).length;
-  var name = '__default';
+  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), {
+MorphBlendMesh.prototype = Object.assign(Object.create(THREE.Mesh.prototype), {
   constructor: MorphBlendMesh,
-  createAnimation: function (name, start, end, fps) {
+  createAnimation: function(name, start, end, fps) {
     var animation = {
-      start: start,
-      end: end,
+      start,
+      end,
       length: end - start + 1,
-      fps: fps,
+      fps,
       duration: (end - start) / fps,
       lastFrame: 0,
       currentFrame: 0,
@@ -36,136 +34,117 @@ MorphBlendMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
     this.animationsMap[name] = animation;
     this.animationsList.push(animation);
   },
-  autoCreateAnimations: function (fps) {
+  autoCreateAnimations: function(fps) {
     var pattern = /([a-z]+)_?(\d+)/i;
-    var firstAnimation,
-        frameRanges = {};
+    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
-        };
+        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;
+        if (i < range.start)
+          range.start = i;
+        if (i > range.end)
+          range.end = i;
+        if (!firstAnimation)
+          firstAnimation = name;
       }
-
       i++;
     }
-
-    for (let name in frameRanges) {
-      var range = frameRanges[name];
-      this.createAnimation(name, range.start, range.end, fps);
+    for (let name2 in frameRanges) {
+      var range = frameRanges[name2];
+      this.createAnimation(name2, range.start, range.end, fps);
     }
-
     this.firstAnimation = firstAnimation;
   },
-  setAnimationDirectionForward: function (name) {
+  setAnimationDirectionForward: function(name) {
     var animation = this.animationsMap[name];
-
     if (animation) {
       animation.direction = 1;
       animation.directionBackwards = false;
     }
   },
-  setAnimationDirectionBackward: function (name) {
+  setAnimationDirectionBackward: function(name) {
     var animation = this.animationsMap[name];
-
     if (animation) {
       animation.direction = -1;
       animation.directionBackwards = true;
     }
   },
-  setAnimationFPS: function (name, fps) {
+  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) {
+  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) {
+  setAnimationWeight: function(name, weight) {
     var animation = this.animationsMap[name];
-
     if (animation) {
       animation.weight = weight;
     }
   },
-  setAnimationTime: function (name, time) {
+  setAnimationTime: function(name, time) {
     var animation = this.animationsMap[name];
-
     if (animation) {
       animation.time = time;
     }
   },
-  getAnimationTime: function (name) {
+  getAnimationTime: function(name) {
     var time = 0;
     var animation = this.animationsMap[name];
-
     if (animation) {
       time = animation.time;
     }
-
     return time;
   },
-  getAnimationDuration: function (name) {
+  getAnimationDuration: function(name) {
     var duration = -1;
     var animation = this.animationsMap[name];
-
     if (animation) {
       duration = animation.duration;
     }
-
     return duration;
   },
-  playAnimation: function (name) {
+  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()');
+      console.warn("THREE.MorphBlendMesh: animation[" + name + "] undefined in .playAnimation()");
     }
   },
-  stopAnimation: function (name) {
+  stopAnimation: function(name) {
     var animation = this.animationsMap[name];
-
     if (animation) {
       animation.active = false;
     }
   },
-  update: function (delta) {
+  update: function(delta) {
     for (let i = 0, il = this.animationsList.length; i < il; i++) {
       var animation = this.animationsList[i];
-      if (!animation.active) continue;
+      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;
@@ -173,12 +152,11 @@ MorphBlendMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
         }
       } else {
         animation.time = animation.time % animation.duration;
-        if (animation.time < 0) 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 keyframe = animation.start + THREE.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;
@@ -186,10 +164,9 @@ MorphBlendMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
         animation.lastFrame = animation.currentFrame;
         animation.currentFrame = keyframe;
       }
-
       var mix = animation.time % frameTime / frameTime;
-      if (animation.directionBackwards) mix = 1 - mix;
-
+      if (animation.directionBackwards)
+        mix = 1 - mix;
       if (animation.currentFrame !== animation.lastFrame) {
         this.morphTargetInfluences[animation.currentFrame] = mix * weight;
         this.morphTargetInfluences[animation.lastFrame] = (1 - mix) * weight;
@@ -199,5 +176,4 @@ MorphBlendMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
     }
   }
 });
-
-export { MorphBlendMesh };
+exports.MorphBlendMesh = MorphBlendMesh;