bytev-charts/lib/plugin/three.js/examples/js/misc/MorphBlendMesh.js

基于echarts和JavaScript及ES6封装的一个可以直接调用的图表组件库，内置主题设计，简单快捷，且支持用户自定义配置； npm 安装方式: npm install bytev-charts 若启动提示还需额外install插件,则运行 npm install @babel/runtime-corejs2 即可;

import "core-js/modules/es.regexp.exec.js";
import "core-js/modules/es.string.match.js";
import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
import _Object$assign from "@babel/runtime-corejs2/core-js/object/assign";
import _Object$create from "@babel/runtime-corejs2/core-js/object/create";
console.warn("THREE.MorphBlendMesh: As part of the transition to ES6 Modules, the files in 'examples/js' were deprecated in May 2020 (r117) and will be deleted in December 2020 (r124). You can find more information about developing using ES6 Modules in https://threejs.org/docs/#manual/en/introduction/Installation.");

THREE.MorphBlendMesh = function (geometry, material) {
  THREE.Mesh.call(this, geometry, material);
  this.animationsMap = {};
  this.animationsList = []; // prepare default animation
  // (all frames played together in 1 second)

  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);
};

THREE.MorphBlendMesh.prototype = _Object$assign(_Object$create(THREE.Mesh.prototype), {
  constructor: THREE.MorphBlendMesh,
  createAnimation: function createAnimation(name, start, end, fps) {
    var animation = {
      start: start,
      end: end,
      length: end - start + 1,
      fps: 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 autoCreateAnimations(fps) {
    var pattern = /([a-z]+)_?(\d+)/i;
    var firstAnimation,
        frameRanges = {};
    var i = 0;

    for (var 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 (var name in frameRanges) {
      var range = frameRanges[name];
      this.createAnimation(name, range.start, range.end, fps);
    }

    this.firstAnimation = firstAnimation;
  },
  setAnimationDirectionForward: function setAnimationDirectionForward(name) {
    var animation = this.animationsMap[name];

    if (animation) {
      animation.direction = 1;
      animation.directionBackwards = false;
    }
  },
  setAnimationDirectionBackward: function setAnimationDirectionBackward(name) {
    var animation = this.animationsMap[name];

    if (animation) {
      animation.direction = -1;
      animation.directionBackwards = true;
    }
  },
  setAnimationFPS: function setAnimationFPS(name, fps) {
    var animation = this.animationsMap[name];

    if (animation) {
      animation.fps = fps;
      animation.duration = (animation.end - animation.start) / animation.fps;
    }
  },
  setAnimationDuration: function setAnimationDuration(name, duration) {
    var animation = this.animationsMap[name];

    if (animation) {
      animation.duration = duration;
      animation.fps = (animation.end - animation.start) / animation.duration;
    }
  },
  setAnimationWeight: function setAnimationWeight(name, weight) {
    var animation = this.animationsMap[name];

    if (animation) {
      animation.weight = weight;
    }
  },
  setAnimationTime: function setAnimationTime(name, time) {
    var animation = this.animationsMap[name];

    if (animation) {
      animation.time = time;
    }
  },
  getAnimationTime: function getAnimationTime(name) {
    var time = 0;
    var animation = this.animationsMap[name];

    if (animation) {
      time = animation.time;
    }

    return time;
  },
  getAnimationDuration: function getAnimationDuration(name) {
    var duration = -1;
    var animation = this.animationsMap[name];

    if (animation) {
      duration = animation.duration;
    }

    return duration;
  },
  playAnimation: function playAnimation(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 stopAnimation(name) {
    var animation = this.animationsMap[name];

    if (animation) {
      animation.active = false;
    }
  },
  update: function update(delta) {
    for (var 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 + 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;
        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;
      }
    }
  }
});