three-stdlib 2.22.7 → 2.22.9

package/dist/_polyfill/CompressedArrayTexture.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class CompressedArrayTexture extends THREE.CompressedTexture {
+  constructor(mipmaps, width, height, depth, format, type) {
+    super(mipmaps, width, height, format, type);
+    this.isCompressedArrayTexture = true;
+    this.image.depth = depth;
+    this.wrapR = THREE.ClampToEdgeWrapping;
+  }
+}
+exports.CompressedArrayTexture = CompressedArrayTexture;

package/dist/_polyfill/CompressedArrayTexture.mjs

@@ -0,0 +1,12 @@
+import { CompressedTexture, ClampToEdgeWrapping } from "three";
+class CompressedArrayTexture extends CompressedTexture {
+  constructor(mipmaps, width, height, depth, format, type) {
+    super(mipmaps, width, height, format, type);
+    this.isCompressedArrayTexture = true;
+    this.image.depth = depth;
+    this.wrapR = ClampToEdgeWrapping;
+  }
+}
+export {
+  CompressedArrayTexture
+};

package/dist/_polyfill/Data3DTexture.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class Data3DTexture extends THREE.Texture {
+  constructor(data = null, width = 1, height = 1, depth = 1) {
+    super(null);
+    this.isData3DTexture = true;
+    this.image = { data, width, height, depth };
+    this.magFilter = THREE.NearestFilter;
+    this.minFilter = THREE.NearestFilter;
+    this.wrapR = THREE.ClampToEdgeWrapping;
+    this.generateMipmaps = false;
+    this.flipY = false;
+    this.unpackAlignment = 1;
+  }
+}
+exports.Data3DTexture = Data3DTexture;

package/dist/_polyfill/Data3DTexture.mjs

@@ -0,0 +1,17 @@
+import { Texture, NearestFilter, ClampToEdgeWrapping } from "three";
+class Data3DTexture extends Texture {
+  constructor(data = null, width = 1, height = 1, depth = 1) {
+    super(null);
+    this.isData3DTexture = true;
+    this.image = { data, width, height, depth };
+    this.magFilter = NearestFilter;
+    this.minFilter = NearestFilter;
+    this.wrapR = ClampToEdgeWrapping;
+    this.generateMipmaps = false;
+    this.flipY = false;
+    this.unpackAlignment = 1;
+  }
+}
+export {
+  Data3DTexture
+};

package/dist/animation/AnimationClipCreator.d.ts

@@ -0,0 +1,12 @@
+import { AnimationClip, Vector3 } from 'three'
+
+export interface AnimationClipCreator {
+  CreateRotationAnimation(period: number, axis: string): AnimationClip
+  CreateScaleAxisAnimation(period: number, axis: string): AnimationClip
+  CreateShakeAnimation(duration: number, shakeScale: Vector3): AnimationClip
+  CreatePulsationAnimation(duration: number, pulseScale: number): AnimationClip
+  CreateVisibilityAnimation(duration: number): AnimationClip
+  CreateMaterialColorAnimation(duration: number, colors: number[]): AnimationClip
+}
+
+export const AnimationClipCreator: AnimationClipCreator

package/dist/animation/AnimationClipCreator.js

@@ -0,0 +1,57 @@
+"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);
+  }
+  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);
+  }
+  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]);
+  }
+  const trackName = ".material[0].color";
+  const track = new THREE.ColorKeyframeTrack(trackName, times, values);
+  return new THREE.AnimationClip(null, duration, [track]);
+};
+exports.AnimationClipCreator = AnimationClipCreator;

package/dist/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/dist/animation/CCDIKSolver.d.ts

@@ -0,0 +1,25 @@
+import { Object3D, SkinnedMesh } from 'three'
+
+// tslint:disable-next-line:interface-name
+export interface IKS {
+  effector: number
+  iteration: number
+  links: {
+    enabled: boolean
+    index: number
+  }
+  maxAngle: number
+  target: number
+}
+
+export class CCDIKSolver {
+  constructor(mesh: SkinnedMesh, iks: IKS[])
+
+  update(): this
+  updateOne(iks: IKS): this
+  createHelper(): CCDIKHelper
+}
+
+export class CCDIKHelper extends Object3D {
+  constructor(mesh: SkinnedMesh, iks: IKS[])
+}

package/dist/animation/CCDIKSolver.js

@@ -0,0 +1,224 @@
+"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");
+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);
+    this.matrixAutoUpdate = false;
+    this.sphereGeometry = new THREE.SphereGeometry(sphereSize, 16, 8);
+    this.targetSphereMaterial = new THREE.MeshBasicMaterial({
+      color: new THREE.Color(16746632),
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    this.effectorSphereMaterial = new THREE.MeshBasicMaterial({
+      color: new THREE.Color(8978312),
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    this.linkSphereMaterial = new THREE.MeshBasicMaterial({
+      color: new THREE.Color(8947967),
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    this.lineMaterial = new THREE.LineBasicMaterial({
+      color: new THREE.Color(16711680),
+      depthTest: false,
+      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;
+  }
+  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();
+      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));
+        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));
+        }
+        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);
+        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);
+        }
+        line.geometry.attributes.position.needsUpdate = true;
+      }
+    }
+    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;
+      }
+    }
+  }
+  update() {
+    const bones = this.mesh.skeleton.bones;
+    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];
+      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;
+      }
+    }
+    return this;
+  }
+  createHelper() {
+    return new CCDIKHelper(this.mesh, this.mesh.geometry.userData.MMD.iks);
+  }
+}
+exports.CCDIKHelper = CCDIKHelper;
+exports.CCDIKSolver = CCDIKSolver;

package/dist/animation/CCDIKSolver.mjs

@@ -0,0 +1,224 @@
+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;
+};
+import { Object3D, Matrix4, Vector3, SphereGeometry, MeshBasicMaterial, Color, LineBasicMaterial, BufferGeometry, BufferAttribute, Mesh, Line, Quaternion } from "three";
+class CCDIKHelper extends Object3D {
+  constructor(mesh, iks = [], sphereSize = 0.25) {
+    super();
+    __publicField(this, "_m", new Matrix4());
+    __publicField(this, "_v", new Vector3());
+    this.root = mesh;
+    this.iks = iks;
+    this.matrix.copy(mesh.matrixWorld);
+    this.matrixAutoUpdate = false;
+    this.sphereGeometry = new SphereGeometry(sphereSize, 16, 8);
+    this.targetSphereMaterial = new MeshBasicMaterial({
+      color: new Color(16746632),
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    this.effectorSphereMaterial = new MeshBasicMaterial({
+      color: new Color(8978312),
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    this.linkSphereMaterial = new MeshBasicMaterial({
+      color: new Color(8947967),
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    this.lineMaterial = new LineBasicMaterial({
+      color: new Color(16711680),
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    function createLineGeometry(ik) {
+      const geometry = new BufferGeometry();
+      const vertices = new Float32Array((2 + ik.links.length) * 3);
+      geometry.setAttribute("position", new BufferAttribute(vertices, 3));
+      return geometry;
+    }
+    const scope = this;
+    function createTargetMesh() {
+      return new Mesh(scope.sphereGeometry, scope.targetSphereMaterial);
+    }
+    function createEffectorMesh() {
+      return new Mesh(scope.sphereGeometry, scope.effectorSphereMaterial);
+    }
+    function createLinkMesh() {
+      return new Mesh(scope.sphereGeometry, scope.linkSphereMaterial);
+    }
+    function createLine(ik) {
+      return new 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;
+  }
+  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();
+      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));
+        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));
+        }
+        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);
+        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);
+        }
+        line.geometry.attributes.position.needsUpdate = true;
+      }
+    }
+    this.matrix.copy(mesh.matrixWorld);
+    super.updateMatrixWorld(force);
+  }
+}
+class CCDIKSolver {
+  constructor(mesh, iks) {
+    __publicField(this, "q", new Quaternion());
+    __publicField(this, "targetPos", new Vector3());
+    __publicField(this, "targetVec", new Vector3());
+    __publicField(this, "effectorPos", new Vector3());
+    __publicField(this, "effectorVec", new Vector3());
+    __publicField(this, "linkPos", new Vector3());
+    __publicField(this, "invLinkQ", new Quaternion());
+    __publicField(this, "linkScale", new Vector3());
+    __publicField(this, "axis", new Vector3());
+    __publicField(this, "vector", new 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;
+      }
+    }
+  }
+  update() {
+    const bones = this.mesh.skeleton.bones;
+    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];
+      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;
+      }
+    }
+    return this;
+  }
+  createHelper() {
+    return new CCDIKHelper(this.mesh, this.mesh.geometry.userData.MMD.iks);
+  }
+}
+export {
+  CCDIKHelper,
+  CCDIKSolver
+};