three-stdlib 2.22.9 → 2.22.10

package/dist/animation/AnimationClipCreator.js

@@ -1,57 +1,56 @@
 "use strict";
 Object.defineProperty(exports, 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 trackName = `.rotation[${axis}]`;
-  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 trackName = `.scale[${axis}]`;
-  const track = new THREE.NumberKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, period, [track]);
-};
-AnimationClipCreator.CreateShakeAnimation = (duration, shakeScale) => {
-  const times = [], values = [], tmp = new THREE.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);
+class AnimationClipCreator {
+  static CreateRotationAnimation(period, axis = "x") {
+    const times = [0, period], values = [0, 360];
+    const trackName = ".rotation[" + axis + "]";
+    const track = new THREE.NumberKeyframeTrack(trackName, times, values);
+    return new THREE.AnimationClip(null, period, [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 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);
+  static CreateScaleAxisAnimation(period, axis = "x") {
+    const times = [0, period], values = [0, 1];
+    const trackName = ".scale[" + axis + "]";
+    const track = new THREE.NumberKeyframeTrack(trackName, times, values);
+    return new THREE.AnimationClip(null, period, [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 THREE.BooleanKeyframeTrack(trackName, times, values);
-  return new THREE.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]);
+  static CreateShakeAnimation(duration, shakeScale) {
+    const times = [], values = [], tmp = new THREE.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 THREE.VectorKeyframeTrack(trackName, times, values);
+    return new THREE.AnimationClip(null, duration, [track]);
   }
-  const trackName = ".material[0].color";
-  const track = new THREE.ColorKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, duration, [track]);
-};
+  static CreatePulsationAnimation(duration, pulseScale) {
+    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 THREE.VectorKeyframeTrack(trackName, times, values);
+    return new THREE.AnimationClip(null, duration, [track]);
+  }
+  static 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]);
+  }
+  static CreateMaterialColorAnimation(duration, colors) {
+    const times = [], values = [], timeStep = duration / colors.length;
+    for (let i = 0; i < colors.length; i++) {
+      times.push(i * timeStep);
+      const color = colors[i];
+      values.push(color.r, color.g, color.b);
+    }
+    const trackName = ".material.color";
+    const track = new THREE.ColorKeyframeTrack(trackName, times, values);
+    return new THREE.AnimationClip(null, duration, [track]);
+  }
+}
 exports.AnimationClipCreator = AnimationClipCreator;

package/dist/animation/AnimationClipCreator.mjs

@@ -1,57 +1,56 @@
 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);
+class AnimationClipCreator {
+  static CreateRotationAnimation(period, axis = "x") {
+    const times = [0, period], values = [0, 360];
+    const trackName = ".rotation[" + axis + "]";
+    const track = new NumberKeyframeTrack(trackName, times, values);
+    return new AnimationClip(null, period, [track]);
   }
-  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);
+  static CreateScaleAxisAnimation(period, axis = "x") {
+    const times = [0, period], values = [0, 1];
+    const trackName = ".scale[" + axis + "]";
+    const track = new NumberKeyframeTrack(trackName, times, values);
+    return new AnimationClip(null, period, [track]);
   }
-  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]);
+  static 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]);
   }
-  const trackName = ".material[0].color";
-  const track = new ColorKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
-};
+  static 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]);
+  }
+  static 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]);
+  }
+  static CreateMaterialColorAnimation(duration, colors) {
+    const times = [], values = [], timeStep = duration / colors.length;
+    for (let i = 0; i < colors.length; i++) {
+      times.push(i * timeStep);
+      const color = colors[i];
+      values.push(color.r, color.g, color.b);
+    }
+    const trackName = ".material.color";
+    const track = new ColorKeyframeTrack(trackName, times, values);
+    return new AnimationClip(null, duration, [track]);
+  }
+}
 export {
   AnimationClipCreator
 };

package/dist/animation/CCDIKSolver.d.ts

@@ -1,13 +1,17 @@
-import { Object3D, SkinnedMesh } from 'three'
+import { Object3D, SkinnedMesh, Vector3 } from 'three'
 
 // tslint:disable-next-line:interface-name
 export interface IKS {
   effector: number
   iteration: number
-  links: {
+  links: Array<{
     enabled: boolean
     index: number
-  }
+    limitation?: Vector3
+    rotationMin?: Vector3
+    rotationMax?: Vector3
+  }>
+  minAngle: number
   maxAngle: number
   target: number
 }
@@ -21,5 +25,6 @@ export class CCDIKSolver {
 }
 
 export class CCDIKHelper extends Object3D {
-  constructor(mesh: SkinnedMesh, iks: IKS[])
+  constructor(mesh: SkinnedMesh, iks?: IKS[], sphereSize?: number)
+  dispose(): void
 }

package/dist/animation/CCDIKSolver.js

@@ -1,17 +1,151 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
+const _q = /* @__PURE__ */ new THREE.Quaternion();
+const _targetPos = /* @__PURE__ */ new THREE.Vector3();
+const _targetVec = /* @__PURE__ */ new THREE.Vector3();
+const _effectorPos = /* @__PURE__ */ new THREE.Vector3();
+const _effectorVec = /* @__PURE__ */ new THREE.Vector3();
+const _linkPos = /* @__PURE__ */ new THREE.Vector3();
+const _invLinkQ = /* @__PURE__ */ new THREE.Quaternion();
+const _linkScale = /* @__PURE__ */ new THREE.Vector3();
+const _axis = /* @__PURE__ */ new THREE.Vector3();
+const _vector = /* @__PURE__ */ new THREE.Vector3();
+const _matrix = /* @__PURE__ */ new THREE.Matrix4();
+class CCDIKSolver {
+  /**
+   * @param {THREE.SkinnedMesh} mesh
+   * @param {Array<Object>} iks
+   */
+  constructor(mesh, iks = []) {
+    this.mesh = mesh;
+    this.iks = iks;
+    this._valid();
+  }
+  /**
+   * Update all IK bones.
+   *
+   * @return {CCDIKSolver}
+   */
+  update() {
+    const iks = this.iks;
+    for (let i = 0, il = iks.length; i < il; i++) {
+      this.updateOne(iks[i]);
+    }
+    return this;
+  }
+  /**
+   * Update one IK bone
+   *
+   * @param {Object} ik parameter
+   * @return {CCDIKSolver}
+   */
+  updateOne(ik) {
+    const bones = this.mesh.skeleton.bones;
+    const math = Math;
+    const effector = bones[ik.effector];
+    const target = bones[ik.target];
+    _targetPos.setFromMatrixPosition(target.matrixWorld);
+    const links = ik.links;
+    const iteration = ik.iteration !== void 0 ? ik.iteration : 1;
+    for (let i = 0; i < iteration; i++) {
+      let rotated = false;
+      for (let j = 0, jl = links.length; j < jl; j++) {
+        const link = bones[links[j].index];
+        if (links[j].enabled === false)
+          break;
+        const limitation = links[j].limitation;
+        const rotationMin = links[j].rotationMin;
+        const rotationMax = links[j].rotationMax;
+        link.matrixWorld.decompose(_linkPos, _invLinkQ, _linkScale);
+        _invLinkQ.invert();
+        _effectorPos.setFromMatrixPosition(effector.matrixWorld);
+        _effectorVec.subVectors(_effectorPos, _linkPos);
+        _effectorVec.applyQuaternion(_invLinkQ);
+        _effectorVec.normalize();
+        _targetVec.subVectors(_targetPos, _linkPos);
+        _targetVec.applyQuaternion(_invLinkQ);
+        _targetVec.normalize();
+        let angle = _targetVec.dot(_effectorVec);
+        if (angle > 1) {
+          angle = 1;
+        } else if (angle < -1) {
+          angle = -1;
+        }
+        angle = math.acos(angle);
+        if (angle < 1e-5)
+          continue;
+        if (ik.minAngle !== void 0 && angle < ik.minAngle) {
+          angle = ik.minAngle;
+        }
+        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);
+        if (limitation !== void 0) {
+          let c = link.quaternion.w;
+          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 !== void 0) {
+          link.rotation.setFromVector3(_vector.setFromEuler(link.rotation).max(rotationMin));
+        }
+        if (rotationMax !== void 0) {
+          link.rotation.setFromVector3(_vector.setFromEuler(link.rotation).min(rotationMax));
+        }
+        link.updateMatrixWorld(true);
+        rotated = true;
+      }
+      if (!rotated)
+        break;
+    }
+    return this;
+  }
+  /**
+   * Creates Helper
+   *
+   * @return {CCDIKHelper}
+   */
+  createHelper() {
+    return new CCDIKHelper(this.mesh, this.iks);
+  }
+  // private methods
+  _valid() {
+    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;
+      }
+    }
+  }
+}
+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;
+}
 class CCDIKHelper extends THREE.Object3D {
   constructor(mesh, iks = [], sphereSize = 0.25) {
     super();
-    __publicField(this, "_m", new THREE.Matrix4());
-    __publicField(this, "_v", new THREE.Vector3());
     this.root = mesh;
     this.iks = iks;
     this.matrix.copy(mesh.matrixWorld);
@@ -41,73 +175,40 @@ class CCDIKHelper extends THREE.Object3D {
       depthWrite: false,
       transparent: true
     });
-    function createLineGeometry(ik) {
-      const geometry = new THREE.BufferGeometry();
-      const vertices = new Float32Array((2 + ik.links.length) * 3);
-      geometry.setAttribute("position", new THREE.BufferAttribute(vertices, 3));
-      return geometry;
-    }
-    const scope = this;
-    function createTargetMesh() {
-      return new THREE.Mesh(scope.sphereGeometry, scope.targetSphereMaterial);
-    }
-    function createEffectorMesh() {
-      return new THREE.Mesh(scope.sphereGeometry, scope.effectorSphereMaterial);
-    }
-    function createLinkMesh() {
-      return new THREE.Mesh(scope.sphereGeometry, scope.linkSphereMaterial);
-    }
-    function createLine(ik) {
-      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));
-    }
-  }
-  _getPosition(bone, matrixWorldInv) {
-    return this._v.setFromMatrixPosition(bone.matrixWorld).applyMatrix4(matrixWorldInv);
-  }
-  _setPositionOfBoneToAttributeArray(array, index, bone, matrixWorldInv) {
-    const v = this._getPosition(bone, matrixWorldInv);
-    array[index * 3 + 0] = v.x;
-    array[index * 3 + 1] = v.y;
-    array[index * 3 + 2] = v.z;
+    this._init();
   }
+  /**
+   * Updates IK bones visualization.
+   */
   updateMatrixWorld(force) {
     const mesh = this.root;
     if (this.visible) {
       let offset = 0;
       const iks = this.iks;
       const bones = mesh.skeleton.bones;
-      this._m.copy(mesh.matrixWorld).invert();
+      _matrix.copy(mesh.matrixWorld).invert();
       for (let i = 0, il = iks.length; i < il; i++) {
         const ik = iks[i];
         const targetBone = bones[ik.target];
         const effectorBone = bones[ik.effector];
         const targetMesh = this.children[offset++];
         const effectorMesh = this.children[offset++];
-        targetMesh.position.copy(this._getPosition(targetBone, this._m));
-        effectorMesh.position.copy(this._getPosition(effectorBone, this._m));
+        targetMesh.position.copy(getPosition(targetBone, _matrix));
+        effectorMesh.position.copy(getPosition(effectorBone, _matrix));
         for (let j = 0, jl = ik.links.length; j < jl; j++) {
           const link = ik.links[j];
           const linkBone = bones[link.index];
           const linkMesh = this.children[offset++];
-          linkMesh.position.copy(this._getPosition(linkBone, this._m));
+          linkMesh.position.copy(getPosition(linkBone, _matrix));
         }
         const line = this.children[offset++];
         const array = line.geometry.attributes.position.array;
-        this._setPositionOfBoneToAttributeArray(array, 0, targetBone, this._m);
-        this._setPositionOfBoneToAttributeArray(array, 1, effectorBone, this._m);
+        setPositionOfBoneToAttributeArray(array, 0, targetBone, _matrix);
+        setPositionOfBoneToAttributeArray(array, 1, effectorBone, _matrix);
         for (let j = 0, jl = ik.links.length; j < jl; j++) {
           const link = ik.links[j];
           const linkBone = bones[link.index];
-          this._setPositionOfBoneToAttributeArray(array, j + 2, linkBone, this._m);
+          setPositionOfBoneToAttributeArray(array, j + 2, linkBone, _matrix);
         }
         line.geometry.attributes.position.needsUpdate = true;
       }
@@ -115,109 +216,53 @@ class CCDIKHelper extends THREE.Object3D {
     this.matrix.copy(mesh.matrixWorld);
     super.updateMatrixWorld(force);
   }
-}
-class CCDIKSolver {
-  constructor(mesh, iks) {
-    __publicField(this, "q", new THREE.Quaternion());
-    __publicField(this, "targetPos", new THREE.Vector3());
-    __publicField(this, "targetVec", new THREE.Vector3());
-    __publicField(this, "effectorPos", new THREE.Vector3());
-    __publicField(this, "effectorVec", new THREE.Vector3());
-    __publicField(this, "linkPos", new THREE.Vector3());
-    __publicField(this, "invLinkQ", new THREE.Quaternion());
-    __publicField(this, "linkScale", new THREE.Vector3());
-    __publicField(this, "axis", new THREE.Vector3());
-    __publicField(this, "vector", new THREE.Vector3());
-    this.mesh = mesh;
-    this.iks = iks;
-    const bones = this.mesh.skeleton.bones;
-    for (let i = 0, il = this.iks.length; i < il; i++) {
-      const ik = this.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;
-      }
+  /**
+   * Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+   */
+  dispose() {
+    this.sphereGeometry.dispose();
+    this.targetSphereMaterial.dispose();
+    this.effectorSphereMaterial.dispose();
+    this.linkSphereMaterial.dispose();
+    this.lineMaterial.dispose();
+    const children = this.children;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.isLine)
+        child.geometry.dispose();
     }
   }
-  update() {
-    const bones = this.mesh.skeleton.bones;
+  // private method
+  _init() {
+    const scope = this;
     const iks = this.iks;
-    const math = Math;
+    function createLineGeometry(ik) {
+      const geometry = new THREE.BufferGeometry();
+      const vertices = new Float32Array((2 + ik.links.length) * 3);
+      geometry.setAttribute("position", new THREE.BufferAttribute(vertices, 3));
+      return geometry;
+    }
+    function createTargetMesh() {
+      return new THREE.Mesh(scope.sphereGeometry, scope.targetSphereMaterial);
+    }
+    function createEffectorMesh() {
+      return new THREE.Mesh(scope.sphereGeometry, scope.effectorSphereMaterial);
+    }
+    function createLinkMesh() {
+      return new THREE.Mesh(scope.sphereGeometry, scope.linkSphereMaterial);
+    }
+    function createLine(ik) {
+      return new THREE.Line(createLineGeometry(ik), scope.lineMaterial);
+    }
     for (let i = 0, il = iks.length; i < il; i++) {
       const ik = iks[i];
-      const effector = bones[ik.effector];
-      const target = bones[ik.target];
-      this.targetPos.setFromMatrixPosition(target.matrixWorld);
-      const links = ik.links;
-      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];
-          if (links[k].enabled === false)
-            break;
-          const limitation = links[k].limitation;
-          const rotationMin = links[k].rotationMin;
-          const rotationMax = links[k].rotationMax;
-          link.matrixWorld.decompose(this.linkPos, this.invLinkQ, this.linkScale);
-          this.invLinkQ.invert();
-          this.effectorPos.setFromMatrixPosition(effector.matrixWorld);
-          this.effectorVec.subVectors(this.effectorPos, this.linkPos);
-          this.effectorVec.applyQuaternion(this.invLinkQ);
-          this.effectorVec.normalize();
-          this.targetVec.subVectors(this.targetPos, this.linkPos);
-          this.targetVec.applyQuaternion(this.invLinkQ);
-          this.targetVec.normalize();
-          let angle = this.targetVec.dot(this.effectorVec);
-          if (angle > 1) {
-            angle = 1;
-          } else if (angle < -1) {
-            angle = -1;
-          }
-          angle = math.acos(angle);
-          if (angle < 1e-5)
-            continue;
-          if (ik.minAngle !== void 0 && angle < ik.minAngle) {
-            angle = ik.minAngle;
-          }
-          if (ik.maxAngle !== void 0 && angle > ik.maxAngle) {
-            angle = ik.maxAngle;
-          }
-          this.axis.crossVectors(this.effectorVec, this.targetVec);
-          this.axis.normalize();
-          this.q.setFromAxisAngle(this.axis, angle);
-          link.quaternion.multiply(this.q);
-          if (limitation !== void 0) {
-            let c = link.quaternion.w;
-            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 !== void 0) {
-            link.rotation.setFromVector3(this.vector.setFromEuler(link.rotation).max(rotationMin));
-          }
-          if (rotationMax !== void 0) {
-            link.rotation.setFromVector3(this.vector.setFromEuler(link.rotation).min(rotationMax));
-          }
-          link.updateMatrixWorld(true);
-          rotated = true;
-        }
-        if (!rotated)
-          break;
+      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 this;
-  }
-  createHelper() {
-    return new CCDIKHelper(this.mesh, this.mesh.geometry.userData.MMD.iks);
   }
 }
 exports.CCDIKHelper = CCDIKHelper;