three-stdlib 2.15.0 → 2.15.2

package/animation/AnimationClipCreator.js

@@ -1,77 +1,57 @@
-import { NumberKeyframeTrack, AnimationClip, Vector3, VectorKeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack } from 'three';
-
-const AnimationClipCreator = () => {};
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const AnimationClipCreator = () => {
+};
 AnimationClipCreator.CreateRotationAnimation = (period, axis) => {
-  const times = [0, period],
-        values = [0, 360];
-  axis = axis || 'x';
+  const times = [0, period], values = [0, 360];
+  axis = axis || "x";
   const trackName = `.rotation[${axis}]`;
-  const track = new NumberKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, period, [track]);
+  const track = new THREE.NumberKeyframeTrack(trackName, times, values);
+  return new THREE.AnimationClip(null, period, [track]);
 };
-
 AnimationClipCreator.CreateScaleAxisAnimation = (period, axis) => {
-  const times = [0, period],
-        values = [0, 1];
-  axis = axis || 'x';
+  const times = [0, period], values = [0, 1];
+  axis = axis || "x";
   const trackName = `.scale[${axis}]`;
-  const track = new NumberKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, period, [track]);
+  const track = new THREE.NumberKeyframeTrack(trackName, times, values);
+  return new THREE.AnimationClip(null, period, [track]);
 };
-
 AnimationClipCreator.CreateShakeAnimation = (duration, shakeScale) => {
-  const times = [],
-        values = [],
-        tmp = new Vector3();
-
+  const times = [], values = [], tmp = new THREE.Vector3();
   for (let i = 0; i < duration * 10; i++) {
     times.push(i / 10);
-    tmp.set(Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0).multiply(shakeScale).toArray(values, values.length);
+    tmp.set(Math.random() * 2 - 1, Math.random() * 2 - 1, Math.random() * 2 - 1).multiply(shakeScale).toArray(values, values.length);
   }
-
-  const trackName = '.position';
-  const track = new VectorKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
+  const trackName = ".position";
+  const track = new THREE.VectorKeyframeTrack(trackName, times, values);
+  return new THREE.AnimationClip(null, duration, [track]);
 };
-
 AnimationClipCreator.CreatePulsationAnimation = (duration, pulseScale) => {
-  const times = [],
-        values = [],
-        tmp = new Vector3();
-
+  const times = [], values = [], tmp = new THREE.Vector3();
   for (let i = 0; i < duration * 10; i++) {
     times.push(i / 10);
     const scaleFactor = Math.random() * pulseScale;
     tmp.set(scaleFactor, scaleFactor, scaleFactor).toArray(values, values.length);
   }
-
-  const trackName = '.scale';
-  const track = new VectorKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
+  const trackName = ".scale";
+  const track = new THREE.VectorKeyframeTrack(trackName, times, values);
+  return new THREE.AnimationClip(null, duration, [track]);
 };
-
-AnimationClipCreator.CreateVisibilityAnimation = duration => {
-  const times = [0, duration / 2, duration],
-        values = [true, false, true];
-  const trackName = '.visible';
-  const track = new BooleanKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
+AnimationClipCreator.CreateVisibilityAnimation = (duration) => {
+  const times = [0, duration / 2, duration], values = [true, false, true];
+  const trackName = ".visible";
+  const track = new THREE.BooleanKeyframeTrack(trackName, times, values);
+  return new THREE.AnimationClip(null, duration, [track]);
 };
-
 AnimationClipCreator.CreateMaterialColorAnimation = (duration, colors) => {
-  const times = [],
-        values = [],
-        timeStep = duration / colors.length;
-
+  const times = [], values = [], timeStep = duration / colors.length;
   for (let i = 0; i <= colors.length; i++) {
     times.push(i * timeStep);
     values.push(colors[i % colors.length]);
   }
-
-  const trackName = '.material[0].color';
-  const track = new ColorKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
+  const trackName = ".material[0].color";
+  const track = new THREE.ColorKeyframeTrack(trackName, times, values);
+  return new THREE.AnimationClip(null, duration, [track]);
 };
-
-export { AnimationClipCreator };
+exports.AnimationClipCreator = AnimationClipCreator;

package/animation/AnimationClipCreator.mjs

@@ -0,0 +1,57 @@
+import { NumberKeyframeTrack, AnimationClip, Vector3, VectorKeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack } from "three";
+const AnimationClipCreator = () => {
+};
+AnimationClipCreator.CreateRotationAnimation = (period, axis) => {
+  const times = [0, period], values = [0, 360];
+  axis = axis || "x";
+  const trackName = `.rotation[${axis}]`;
+  const track = new NumberKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, period, [track]);
+};
+AnimationClipCreator.CreateScaleAxisAnimation = (period, axis) => {
+  const times = [0, period], values = [0, 1];
+  axis = axis || "x";
+  const trackName = `.scale[${axis}]`;
+  const track = new NumberKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, period, [track]);
+};
+AnimationClipCreator.CreateShakeAnimation = (duration, shakeScale) => {
+  const times = [], values = [], tmp = new Vector3();
+  for (let i = 0; i < duration * 10; i++) {
+    times.push(i / 10);
+    tmp.set(Math.random() * 2 - 1, Math.random() * 2 - 1, Math.random() * 2 - 1).multiply(shakeScale).toArray(values, values.length);
+  }
+  const trackName = ".position";
+  const track = new VectorKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
+};
+AnimationClipCreator.CreatePulsationAnimation = (duration, pulseScale) => {
+  const times = [], values = [], tmp = new Vector3();
+  for (let i = 0; i < duration * 10; i++) {
+    times.push(i / 10);
+    const scaleFactor = Math.random() * pulseScale;
+    tmp.set(scaleFactor, scaleFactor, scaleFactor).toArray(values, values.length);
+  }
+  const trackName = ".scale";
+  const track = new VectorKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
+};
+AnimationClipCreator.CreateVisibilityAnimation = (duration) => {
+  const times = [0, duration / 2, duration], values = [true, false, true];
+  const trackName = ".visible";
+  const track = new BooleanKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
+};
+AnimationClipCreator.CreateMaterialColorAnimation = (duration, colors) => {
+  const times = [], values = [], timeStep = duration / colors.length;
+  for (let i = 0; i <= colors.length; i++) {
+    times.push(i * timeStep);
+    values.push(colors[i % colors.length]);
+  }
+  const trackName = ".material[0].color";
+  const track = new ColorKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
+};
+export {
+  AnimationClipCreator
+};

package/animation/CCDIKSolver.js

@@ -1,89 +1,48 @@
-import { Quaternion, Vector3, Object3D, SphereGeometry, MeshBasicMaterial, Color, LineBasicMaterial, Matrix4, Mesh, Line, BufferGeometry, BufferAttribute } from 'three';
-
-/**
- * CCD Algorithm
- *  - https://sites.google.com/site/auraliusproject/ccd-algorithm
- *
- * // ik parameter example
- * //
- * // target, effector, index in links are bone index in skeleton.bones.
- * // the bones relation should be
- * // <-- parent                                  child -->
- * // links[ n ], links[ n - 1 ], ..., links[ 0 ], effector
- * iks = [ {
- *	target: 1,
- *	effector: 2,
- *	links: [ { index: 5, limitation: new Vector3( 1, 0, 0 ) }, { index: 4, enabled: false }, { index : 3 } ],
- *	iteration: 10,
- *	minAngle: 0.0,
- *	maxAngle: 1.0,
- * } ];
- */
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 const CCDIKSolver = (() => {
-  /**
-   * @param {THREE.SkinnedMesh} mesh
-   * @param {Array<Object>} iks
-   */
-  function CCDIKSolver(mesh, iks) {
+  function CCDIKSolver2(mesh, iks) {
     this.mesh = mesh;
     this.iks = iks || [];
-
     this._valid();
   }
-
-  CCDIKSolver.prototype = {
-    constructor: CCDIKSolver,
-
-    /**
-     * Update IK bones.
-     *
-     * @return {CCDIKSolver}
-     */
+  CCDIKSolver2.prototype = {
+    constructor: CCDIKSolver2,
     update: (() => {
-      const q = new Quaternion();
-      const targetPos = new Vector3();
-      const targetVec = new Vector3();
-      const effectorPos = new Vector3();
-      const effectorVec = new Vector3();
-      const linkPos = new Vector3();
-      const invLinkQ = new Quaternion();
-      const linkScale = new Vector3();
-      const axis = new Vector3();
-      const vector = new Vector3();
+      const q = new THREE.Quaternion();
+      const targetPos = new THREE.Vector3();
+      const targetVec = new THREE.Vector3();
+      const effectorPos = new THREE.Vector3();
+      const effectorVec = new THREE.Vector3();
+      const linkPos = new THREE.Vector3();
+      const invLinkQ = new THREE.Quaternion();
+      const linkScale = new THREE.Vector3();
+      const axis = new THREE.Vector3();
+      const vector = new THREE.Vector3();
       return function update() {
         const bones = this.mesh.skeleton.bones;
-        const iks = this.iks; // for reference overhead reduction in loop
-
+        const iks = this.iks;
         const math = Math;
-
         for (let i = 0, il = iks.length; i < il; i++) {
           const ik = iks[i];
           const effector = bones[ik.effector];
-          const target = bones[ik.target]; // don't use getWorldPosition() here for the performance
-          // because it calls updateMatrixWorld( true ) inside.
-
+          const target = bones[ik.target];
           targetPos.setFromMatrixPosition(target.matrixWorld);
           const links = ik.links;
-          const iteration = ik.iteration !== undefined ? ik.iteration : 1;
-
+          const iteration = ik.iteration !== void 0 ? ik.iteration : 1;
           for (let j = 0; j < iteration; j++) {
             let rotated = false;
-
             for (let k = 0, kl = links.length; k < kl; k++) {
-              const link = bones[links[k].index]; // skip this link and following links.
-              // this skip is used for MMD performance optimization.
-
-              if (links[k].enabled === false) break;
+              const link = bones[links[k].index];
+              if (links[k].enabled === false)
+                break;
               const limitation = links[k].limitation;
               const rotationMin = links[k].rotationMin;
-              const rotationMax = links[k].rotationMax; // don't use getWorldPosition/Quaternion() here for the performance
-              // because they call updateMatrixWorld( true ) inside.
-
+              const rotationMax = links[k].rotationMax;
               link.matrixWorld.decompose(linkPos, invLinkQ, linkScale);
               invLinkQ.invert();
-              effectorPos.setFromMatrixPosition(effector.matrixWorld); // work in link world
-
+              effectorPos.setFromMatrixPosition(effector.matrixWorld);
               effectorVec.subVectors(effectorPos, linkPos);
               effectorVec.applyQuaternion(invLinkQ);
               effectorVec.normalize();
@@ -91,162 +50,123 @@ const CCDIKSolver = (() => {
               targetVec.applyQuaternion(invLinkQ);
               targetVec.normalize();
               let angle = targetVec.dot(effectorVec);
-
-              if (angle > 1.0) {
-                angle = 1.0;
-              } else if (angle < -1.0) {
-                angle = -1.0;
+              if (angle > 1) {
+                angle = 1;
+              } else if (angle < -1) {
+                angle = -1;
               }
-
-              angle = math.acos(angle); // skip if changing angle is too small to prevent vibration of bone
-              // Refer to http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mmd.three.js
-
-              if (angle < 1e-5) continue;
-
-              if (ik.minAngle !== undefined && angle < ik.minAngle) {
+              angle = math.acos(angle);
+              if (angle < 1e-5)
+                continue;
+              if (ik.minAngle !== void 0 && angle < ik.minAngle) {
                 angle = ik.minAngle;
               }
-
-              if (ik.maxAngle !== undefined && angle > ik.maxAngle) {
+              if (ik.maxAngle !== void 0 && angle > ik.maxAngle) {
                 angle = ik.maxAngle;
               }
-
               axis.crossVectors(effectorVec, targetVec);
               axis.normalize();
               q.setFromAxisAngle(axis, angle);
-              link.quaternion.multiply(q); // TODO: re-consider the limitation specification
-
-              if (limitation !== undefined) {
+              link.quaternion.multiply(q);
+              if (limitation !== void 0) {
                 let c = link.quaternion.w;
-                if (c > 1.0) c = 1.0;
+                if (c > 1)
+                  c = 1;
                 const c2 = math.sqrt(1 - c * c);
                 link.quaternion.set(limitation.x * c2, limitation.y * c2, limitation.z * c2, c);
               }
-
-              if (rotationMin !== undefined) {
+              if (rotationMin !== void 0) {
                 link.rotation.setFromVector3(link.rotation.toVector3(vector).max(rotationMin));
               }
-
-              if (rotationMax !== undefined) {
+              if (rotationMax !== void 0) {
                 link.rotation.setFromVector3(link.rotation.toVector3(vector).min(rotationMax));
               }
-
               link.updateMatrixWorld(true);
               rotated = true;
             }
-
-            if (!rotated) break;
+            if (!rotated)
+              break;
           }
         }
-
         return this;
       };
     })(),
-
-    /**
-     * Creates Helper
-     *
-     * @return {CCDIKHelper}
-     */
-    createHelper: function () {
+    createHelper: function() {
       return new CCDIKHelper(this.mesh, this.mesh.geometry.userData.MMD.iks);
     },
-    // private methods
-    _valid: function () {
+    _valid: function() {
       const iks = this.iks;
       const bones = this.mesh.skeleton.bones;
-
       for (let i = 0, il = iks.length; i < il; i++) {
         const ik = iks[i];
         const effector = bones[ik.effector];
         const links = ik.links;
         let link0, link1;
         link0 = effector;
-
         for (let j = 0, jl = links.length; j < jl; j++) {
           link1 = bones[links[j].index];
-
           if (link0.parent !== link1) {
             console.warn(`THREE.CCDIKSolver: bone ${link0.name} is not the child of bone ${link1.name}`);
           }
-
           link0 = link1;
         }
       }
     }
   };
-  /**
-   * Visualize IK bones
-   *
-   * @param {SkinnedMesh} mesh
-   * @param {Array<Object>} iks
-   */
-
   function CCDIKHelper(mesh, iks) {
-    Object3D.call(this);
+    THREE.Object3D.call(this);
     this.root = mesh;
     this.iks = iks || [];
     this.matrix.copy(mesh.matrixWorld);
     this.matrixAutoUpdate = false;
-    this.sphereGeometry = new SphereGeometry(0.25, 16, 8);
-    this.targetSphereMaterial = new MeshBasicMaterial({
-      color: new Color(0xff8888),
+    this.sphereGeometry = new THREE.SphereGeometry(0.25, 16, 8);
+    this.targetSphereMaterial = new THREE.MeshBasicMaterial({
+      color: new THREE.Color(16746632),
       depthTest: false,
       depthWrite: false,
       transparent: true
     });
-    this.effectorSphereMaterial = new MeshBasicMaterial({
-      color: new Color(0x88ff88),
+    this.effectorSphereMaterial = new THREE.MeshBasicMaterial({
+      color: new THREE.Color(8978312),
       depthTest: false,
       depthWrite: false,
       transparent: true
     });
-    this.linkSphereMaterial = new MeshBasicMaterial({
-      color: new Color(0x8888ff),
+    this.linkSphereMaterial = new THREE.MeshBasicMaterial({
+      color: new THREE.Color(8947967),
       depthTest: false,
       depthWrite: false,
       transparent: true
     });
-    this.lineMaterial = new LineBasicMaterial({
-      color: new Color(0xff0000),
+    this.lineMaterial = new THREE.LineBasicMaterial({
+      color: new THREE.Color(16711680),
       depthTest: false,
       depthWrite: false,
       transparent: true
     });
-
     this._init();
   }
-
-  CCDIKHelper.prototype = Object.assign(Object.create(Object3D.prototype), {
+  CCDIKHelper.prototype = Object.assign(Object.create(THREE.Object3D.prototype), {
     constructor: CCDIKHelper,
-
-    /**
-     * Updates IK bones visualization.
-     */
     updateMatrixWorld: (() => {
-      const matrix = new Matrix4();
-      const vector = new Vector3();
-
+      const matrix = new THREE.Matrix4();
+      const vector = new THREE.Vector3();
       function getPosition(bone, matrixWorldInv) {
         return vector.setFromMatrixPosition(bone.matrixWorld).applyMatrix4(matrixWorldInv);
       }
-
       function setPositionOfBoneToAttributeArray(array, index, bone, matrixWorldInv) {
         const v = getPosition(bone, matrixWorldInv);
         array[index * 3 + 0] = v.x;
         array[index * 3 + 1] = v.y;
         array[index * 3 + 2] = v.z;
       }
-
       return function updateMatrixWorld(force) {
         const mesh = this.root;
-
         if (this.visible) {
           let offset = 0;
           const iks = this.iks;
           const bones = mesh.skeleton.bones;
           matrix.copy(mesh.matrixWorld).invert();
-
           for (let i = 0, il = iks.length; i < il; i++) {
             const ik = iks[i];
             const targetBone = bones[ik.target];
@@ -255,75 +175,60 @@ const CCDIKSolver = (() => {
             const effectorMesh = this.children[offset++];
             targetMesh.position.copy(getPosition(targetBone, matrix));
             effectorMesh.position.copy(getPosition(effectorBone, matrix));
-
             for (let j = 0, jl = ik.links.length; j < jl; j++) {
               var link = ik.links[j];
               var linkBone = bones[link.index];
               const linkMesh = this.children[offset++];
               linkMesh.position.copy(getPosition(linkBone, matrix));
             }
-
             const line = this.children[offset++];
             const array = line.geometry.attributes.position.array;
             setPositionOfBoneToAttributeArray(array, 0, targetBone, matrix);
             setPositionOfBoneToAttributeArray(array, 1, effectorBone, matrix);
-
             for (let j = 0, jl = ik.links.length; j < jl; j++) {
               var link = ik.links[j];
               var linkBone = bones[link.index];
               setPositionOfBoneToAttributeArray(array, j + 2, linkBone, matrix);
             }
-
             line.geometry.attributes.position.needsUpdate = true;
           }
         }
-
         this.matrix.copy(mesh.matrixWorld);
-        Object3D.prototype.updateMatrixWorld.call(this, force);
+        THREE.Object3D.prototype.updateMatrixWorld.call(this, force);
       };
     })(),
-    // private method
-    _init: function () {
+    _init: function() {
       const scope = this;
       const iks = this.iks;
-
       function createLineGeometry(ik) {
-        const geometry = new BufferGeometry();
+        const geometry = new THREE.BufferGeometry();
         const vertices = new Float32Array((2 + ik.links.length) * 3);
-        geometry.setAttribute('position', new BufferAttribute(vertices, 3));
+        geometry.setAttribute("position", new THREE.BufferAttribute(vertices, 3));
         return geometry;
       }
-
       function createTargetMesh() {
-        return new Mesh(scope.sphereGeometry, scope.targetSphereMaterial);
+        return new THREE.Mesh(scope.sphereGeometry, scope.targetSphereMaterial);
       }
-
       function createEffectorMesh() {
-        return new Mesh(scope.sphereGeometry, scope.effectorSphereMaterial);
+        return new THREE.Mesh(scope.sphereGeometry, scope.effectorSphereMaterial);
       }
-
       function createLinkMesh() {
-        return new Mesh(scope.sphereGeometry, scope.linkSphereMaterial);
+        return new THREE.Mesh(scope.sphereGeometry, scope.linkSphereMaterial);
       }
-
       function createLine(ik) {
-        return new Line(createLineGeometry(ik), scope.lineMaterial);
+        return new THREE.Line(createLineGeometry(ik), scope.lineMaterial);
       }
-
       for (let i = 0, il = iks.length; i < il; i++) {
         const ik = iks[i];
         this.add(createTargetMesh());
         this.add(createEffectorMesh());
-
         for (let j = 0, jl = ik.links.length; j < jl; j++) {
           this.add(createLinkMesh());
         }
-
         this.add(createLine(ik));
       }
     }
   });
-  return CCDIKSolver;
+  return CCDIKSolver2;
 })();
-
-export { CCDIKSolver };
+exports.CCDIKSolver = CCDIKSolver;