bytev-charts/lib/plugin/three.js/examples/jsm/utils/SkeletonUtils.js

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

import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
import _Object$values from "@babel/runtime-corejs2/core-js/object/values";
import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
import _Map from "@babel/runtime-corejs2/core-js/map";
import "core-js/modules/es.function.name.js";
import "core-js/modules/es.array.index-of.js";
import "core-js/modules/es.array.iterator.js";
import "core-js/modules/es.array-buffer.slice.js";
import "core-js/modules/es.object.to-string.js";
import "core-js/modules/es.typed-array.float32-array.js";
import "core-js/modules/es.typed-array.copy-within.js";
import "core-js/modules/es.typed-array.every.js";
import "core-js/modules/es.typed-array.fill.js";
import "core-js/modules/es.typed-array.filter.js";
import "core-js/modules/es.typed-array.find.js";
import "core-js/modules/es.typed-array.find-index.js";
import "core-js/modules/es.typed-array.for-each.js";
import "core-js/modules/es.typed-array.includes.js";
import "core-js/modules/es.typed-array.index-of.js";
import "core-js/modules/es.typed-array.iterator.js";
import "core-js/modules/es.typed-array.join.js";
import "core-js/modules/es.typed-array.last-index-of.js";
import "core-js/modules/es.typed-array.map.js";
import "core-js/modules/es.typed-array.reduce.js";
import "core-js/modules/es.typed-array.reduce-right.js";
import "core-js/modules/es.typed-array.reverse.js";
import "core-js/modules/es.typed-array.set.js";
import "core-js/modules/es.typed-array.slice.js";
import "core-js/modules/es.typed-array.some.js";
import "core-js/modules/es.typed-array.sort.js";
import "core-js/modules/es.typed-array.subarray.js";
import "core-js/modules/es.typed-array.to-locale-string.js";
import "core-js/modules/es.typed-array.to-string.js";
import "core-js/modules/es.string.sub.js";
import "core-js/modules/es.promise.js";
import "core-js/modules/web.dom-collections.iterator.js";
import "core-js/modules/es.regexp.exec.js";
import "core-js/modules/es.array.map.js";
import "core-js/modules/es.function.bind.js";
import { AnimationClip, AnimationMixer, Euler, Matrix4, Quaternion, QuaternionKeyframeTrack, SkeletonHelper, Vector2, Vector3, VectorKeyframeTrack } from "../../../build/three.module.js";
var SkeletonUtils = {
  retarget: function () {
    var pos = new Vector3(),
        quat = new Quaternion(),
        scale = new Vector3(),
        bindBoneMatrix = new Matrix4(),
        relativeMatrix = new Matrix4(),
        globalMatrix = new Matrix4();
    return function (target, source, options) {
      options = options || {};
      options.preserveMatrix = options.preserveMatrix !== undefined ? options.preserveMatrix : true;
      options.preservePosition = options.preservePosition !== undefined ? options.preservePosition : true;
      options.preserveHipPosition = options.preserveHipPosition !== undefined ? options.preserveHipPosition : false;
      options.useTargetMatrix = options.useTargetMatrix !== undefined ? options.useTargetMatrix : false;
      options.hip = options.hip !== undefined ? options.hip : "hip";
      options.names = options.names || {};
      var sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source),
          bones = target.isObject3D ? target.skeleton.bones : this.getBones(target),
          bindBones,
          bone,
          name,
          boneTo,
          bonesPosition,
          i; // reset bones

      if (target.isObject3D) {
        target.skeleton.pose();
      } else {
        options.useTargetMatrix = true;
        options.preserveMatrix = false;
      }

      if (options.preservePosition) {
        bonesPosition = [];

        for (i = 0; i < bones.length; i++) {
          bonesPosition.push(bones[i].position.clone());
        }
      }

      if (options.preserveMatrix) {
        // reset matrix
        target.updateMatrixWorld();
        target.matrixWorld.identity(); // reset children matrix

        for (i = 0; i < target.children.length; ++i) {
          target.children[i].updateMatrixWorld(true);
        }
      }

      if (options.offsets) {
        bindBones = [];

        for (i = 0; i < bones.length; ++i) {
          bone = bones[i];
          name = options.names[bone.name] || bone.name;

          if (options.offsets && options.offsets[name]) {
            bone.matrix.multiply(options.offsets[name]);
            bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
            bone.updateMatrixWorld();
          }

          bindBones.push(bone.matrixWorld.clone());
        }
      }

      for (i = 0; i < bones.length; ++i) {
        bone = bones[i];
        name = options.names[bone.name] || bone.name;
        boneTo = this.getBoneByName(name, sourceBones);
        globalMatrix.copy(bone.matrixWorld);

        if (boneTo) {
          boneTo.updateMatrixWorld();

          if (options.useTargetMatrix) {
            relativeMatrix.copy(boneTo.matrixWorld);
          } else {
            relativeMatrix.getInverse(target.matrixWorld);
            relativeMatrix.multiply(boneTo.matrixWorld);
          } // ignore scale to extract rotation


          scale.setFromMatrixScale(relativeMatrix);
          relativeMatrix.scale(scale.set(1 / scale.x, 1 / scale.y, 1 / scale.z)); // apply to global matrix

          globalMatrix.makeRotationFromQuaternion(quat.setFromRotationMatrix(relativeMatrix));

          if (target.isObject3D) {
            var boneIndex = bones.indexOf(bone),
                wBindMatrix = bindBones ? bindBones[boneIndex] : bindBoneMatrix.getInverse(target.skeleton.boneInverses[boneIndex]);
            globalMatrix.multiply(wBindMatrix);
          }

          globalMatrix.copyPosition(relativeMatrix);
        }

        if (bone.parent && bone.parent.isBone) {
          bone.matrix.getInverse(bone.parent.matrixWorld);
          bone.matrix.multiply(globalMatrix);
        } else {
          bone.matrix.copy(globalMatrix);
        }

        if (options.preserveHipPosition && name === options.hip) {
          bone.matrix.setPosition(pos.set(0, bone.position.y, 0));
        }

        bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
        bone.updateMatrixWorld();
      }

      if (options.preservePosition) {
        for (i = 0; i < bones.length; ++i) {
          bone = bones[i];
          name = options.names[bone.name] || bone.name;

          if (name !== options.hip) {
            bone.position.copy(bonesPosition[i]);
          }
        }
      }

      if (options.preserveMatrix) {
        // restore matrix
        target.updateMatrixWorld(true);
      }
    };
  }(),
  retargetClip: function retargetClip(target, source, clip, options) {
    options = options || {};
    options.useFirstFramePosition = options.useFirstFramePosition !== undefined ? options.useFirstFramePosition : false;
    options.fps = options.fps !== undefined ? options.fps : 30;
    options.names = options.names || [];

    if (!source.isObject3D) {
      source = this.getHelperFromSkeleton(source);
    }

    var numFrames = Math.round(clip.duration * (options.fps / 1000) * 1000),
        delta = 1 / options.fps,
        convertedTracks = [],
        mixer = new AnimationMixer(source),
        bones = this.getBones(target.skeleton),
        boneDatas = [],
        positionOffset,
        bone,
        boneTo,
        boneData,
        name,
        i,
        j;
    mixer.clipAction(clip).play();
    mixer.update(0);
    source.updateMatrixWorld();

    for (i = 0; i < numFrames; ++i) {
      var time = i * delta;
      this.retarget(target, source, options);

      for (j = 0; j < bones.length; ++j) {
        name = options.names[bones[j].name] || bones[j].name;
        boneTo = this.getBoneByName(name, source.skeleton);

        if (boneTo) {
          bone = bones[j];
          boneData = boneDatas[j] = boneDatas[j] || {
            bone: bone
          };

          if (options.hip === name) {
            if (!boneData.pos) {
              boneData.pos = {
                times: new Float32Array(numFrames),
                values: new Float32Array(numFrames * 3)
              };
            }

            if (options.useFirstFramePosition) {
              if (i === 0) {
                positionOffset = bone.position.clone();
              }

              bone.position.sub(positionOffset);
            }

            boneData.pos.times[i] = time;
            bone.position.toArray(boneData.pos.values, i * 3);
          }

          if (!boneData.quat) {
            boneData.quat = {
              times: new Float32Array(numFrames),
              values: new Float32Array(numFrames * 4)
            };
          }

          boneData.quat.times[i] = time;
          bone.quaternion.toArray(boneData.quat.values, i * 4);
        }
      }

      mixer.update(delta);
      source.updateMatrixWorld();
    }

    for (i = 0; i < boneDatas.length; ++i) {
      boneData = boneDatas[i];

      if (boneData) {
        if (boneData.pos) {
          convertedTracks.push(new VectorKeyframeTrack(".bones[" + boneData.bone.name + "].position", boneData.pos.times, boneData.pos.values));
        }

        convertedTracks.push(new QuaternionKeyframeTrack(".bones[" + boneData.bone.name + "].quaternion", boneData.quat.times, boneData.quat.values));
      }
    }

    mixer.uncacheAction(clip);
    return new AnimationClip(clip.name, -1, convertedTracks);
  },
  getHelperFromSkeleton: function getHelperFromSkeleton(skeleton) {
    var source = new SkeletonHelper(skeleton.bones[0]);
    source.skeleton = skeleton;
    return source;
  },
  getSkeletonOffsets: function () {
    var targetParentPos = new Vector3(),
        targetPos = new Vector3(),
        sourceParentPos = new Vector3(),
        sourcePos = new Vector3(),
        targetDir = new Vector2(),
        sourceDir = new Vector2();
    return function (target, source, options) {
      options = options || {};
      options.hip = options.hip !== undefined ? options.hip : "hip";
      options.names = options.names || {};

      if (!source.isObject3D) {
        source = this.getHelperFromSkeleton(source);
      }

      var nameKeys = _Object$keys(options.names),
          nameValues = _Object$values(options.names),
          sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source),
          bones = target.isObject3D ? target.skeleton.bones : this.getBones(target),
          offsets = [],
          bone,
          boneTo,
          name,
          i;

      target.skeleton.pose();

      for (i = 0; i < bones.length; ++i) {
        bone = bones[i];
        name = options.names[bone.name] || bone.name;
        boneTo = this.getBoneByName(name, sourceBones);

        if (boneTo && name !== options.hip) {
          var boneParent = this.getNearestBone(bone.parent, nameKeys),
              boneToParent = this.getNearestBone(boneTo.parent, nameValues);
          boneParent.updateMatrixWorld();
          boneToParent.updateMatrixWorld();
          targetParentPos.setFromMatrixPosition(boneParent.matrixWorld);
          targetPos.setFromMatrixPosition(bone.matrixWorld);
          sourceParentPos.setFromMatrixPosition(boneToParent.matrixWorld);
          sourcePos.setFromMatrixPosition(boneTo.matrixWorld);
          targetDir.subVectors(new Vector2(targetPos.x, targetPos.y), new Vector2(targetParentPos.x, targetParentPos.y)).normalize();
          sourceDir.subVectors(new Vector2(sourcePos.x, sourcePos.y), new Vector2(sourceParentPos.x, sourceParentPos.y)).normalize();
          var laterialAngle = targetDir.angle() - sourceDir.angle();
          var offset = new Matrix4().makeRotationFromEuler(new Euler(0, 0, laterialAngle));
          bone.matrix.multiply(offset);
          bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
          bone.updateMatrixWorld();
          offsets[name] = offset;
        }
      }

      return offsets;
    };
  }(),
  renameBones: function renameBones(skeleton, names) {
    var bones = this.getBones(skeleton);

    for (var i = 0; i < bones.length; ++i) {
      var bone = bones[i];

      if (names[bone.name]) {
        bone.name = names[bone.name];
      }
    }

    return this;
  },
  getBones: function getBones(skeleton) {
    return _Array$isArray(skeleton) ? skeleton : skeleton.bones;
  },
  getBoneByName: function getBoneByName(name, skeleton) {
    for (var i = 0, bones = this.getBones(skeleton); i < bones.length; i++) {
      if (name === bones[i].name) return bones[i];
    }
  },
  getNearestBone: function getNearestBone(bone, names) {
    while (bone.isBone) {
      if (names.indexOf(bone.name) !== -1) {
        return bone;
      }

      bone = bone.parent;
    }
  },
  findBoneTrackData: function findBoneTrackData(name, tracks) {
    var regexp = /\[(.*)\]\.(.*)/,
        result = {
      name: name
    };

    for (var i = 0; i < tracks.length; ++i) {
      // 1 is track name
      // 2 is track type
      var trackData = regexp.exec(tracks[i].name);

      if (trackData && name === trackData[1]) {
        result[trackData[2]] = i;
      }
    }

    return result;
  },
  getEqualsBonesNames: function getEqualsBonesNames(skeleton, targetSkeleton) {
    var sourceBones = this.getBones(skeleton),
        targetBones = this.getBones(targetSkeleton),
        bones = [];

    search: for (var i = 0; i < sourceBones.length; i++) {
      var boneName = sourceBones[i].name;

      for (var j = 0; j < targetBones.length; j++) {
        if (boneName === targetBones[j].name) {
          bones.push(boneName);
          continue search;
        }
      }
    }

    return bones;
  },
  clone: function clone(source) {
    var sourceLookup = new _Map();
    var cloneLookup = new _Map();
    var clone = source.clone();
    parallelTraverse(source, clone, function (sourceNode, clonedNode) {
      sourceLookup.set(clonedNode, sourceNode);
      cloneLookup.set(sourceNode, clonedNode);
    });
    clone.traverse(function (node) {
      if (!node.isSkinnedMesh) return;
      var clonedMesh = node;
      var sourceMesh = sourceLookup.get(node);
      var sourceBones = sourceMesh.skeleton.bones;
      clonedMesh.skeleton = sourceMesh.skeleton.clone();
      clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
      clonedMesh.skeleton.bones = sourceBones.map(function (bone) {
        return cloneLookup.get(bone);
      });
      clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
    });
    return clone;
  }
};

function parallelTraverse(a, b, callback) {
  callback(a, b);

  for (var i = 0; i < a.children.length; i++) {
    parallelTraverse(a.children[i], b.children[i], callback);
  }
}

export { SkeletonUtils };