@pixiv/three-vrm-springbone 2.1.1 → 3.0.0-beta.0

package/lib/three-vrm-springbone.cjs

@@ -0,0 +1,1135 @@
+/*!
+ * @pixiv/three-vrm-springbone v3.0.0-beta.0
+ * Spring bone module for @pixiv/three-vrm
+ *
+ * Copyright (c) 2019-2024 pixiv Inc.
+ * @pixiv/three-vrm-springbone is distributed under MIT License
+ * https://github.com/pixiv/three-vrm/blob/release/LICENSE
+ */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  VRMSpringBoneCollider: () => VRMSpringBoneCollider,
+  VRMSpringBoneColliderHelper: () => VRMSpringBoneColliderHelper,
+  VRMSpringBoneColliderShape: () => VRMSpringBoneColliderShape,
+  VRMSpringBoneColliderShapeCapsule: () => VRMSpringBoneColliderShapeCapsule,
+  VRMSpringBoneColliderShapeSphere: () => VRMSpringBoneColliderShapeSphere,
+  VRMSpringBoneJoint: () => VRMSpringBoneJoint,
+  VRMSpringBoneJointHelper: () => VRMSpringBoneJointHelper,
+  VRMSpringBoneLoaderPlugin: () => VRMSpringBoneLoaderPlugin,
+  VRMSpringBoneManager: () => VRMSpringBoneManager
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/helpers/VRMSpringBoneColliderHelper.ts
+var THREE5 = __toESM(require("three"), 1);
+
+// src/VRMSpringBoneColliderShapeCapsule.ts
+var THREE = __toESM(require("three"), 1);
+
+// src/VRMSpringBoneColliderShape.ts
+var VRMSpringBoneColliderShape = class {
+};
+
+// src/VRMSpringBoneColliderShapeCapsule.ts
+var _v3A = new THREE.Vector3();
+var _v3B = new THREE.Vector3();
+var VRMSpringBoneColliderShapeCapsule = class extends VRMSpringBoneColliderShape {
+  get type() {
+    return "capsule";
+  }
+  constructor(params) {
+    var _a, _b, _c;
+    super();
+    this.offset = (_a = params == null ? void 0 : params.offset) != null ? _a : new THREE.Vector3(0, 0, 0);
+    this.tail = (_b = params == null ? void 0 : params.tail) != null ? _b : new THREE.Vector3(0, 0, 0);
+    this.radius = (_c = params == null ? void 0 : params.radius) != null ? _c : 0;
+  }
+  calculateCollision(colliderMatrix, objectPosition, objectRadius, target) {
+    _v3A.copy(this.offset).applyMatrix4(colliderMatrix);
+    _v3B.copy(this.tail).applyMatrix4(colliderMatrix);
+    _v3B.sub(_v3A);
+    const lengthSqCapsule = _v3B.lengthSq();
+    target.copy(objectPosition).sub(_v3A);
+    const dot = _v3B.dot(target);
+    if (dot <= 0) {
+    } else if (lengthSqCapsule <= dot) {
+      target.sub(_v3B);
+    } else {
+      _v3B.multiplyScalar(dot / lengthSqCapsule);
+      target.sub(_v3B);
+    }
+    const radius = objectRadius + this.radius;
+    const distance = target.length() - radius;
+    target.normalize();
+    return distance;
+  }
+};
+
+// src/VRMSpringBoneColliderShapeSphere.ts
+var THREE2 = __toESM(require("three"), 1);
+var VRMSpringBoneColliderShapeSphere = class extends VRMSpringBoneColliderShape {
+  get type() {
+    return "sphere";
+  }
+  constructor(params) {
+    var _a, _b;
+    super();
+    this.offset = (_a = params == null ? void 0 : params.offset) != null ? _a : new THREE2.Vector3(0, 0, 0);
+    this.radius = (_b = params == null ? void 0 : params.radius) != null ? _b : 0;
+  }
+  calculateCollision(colliderMatrix, objectPosition, objectRadius, target) {
+    target.copy(this.offset).applyMatrix4(colliderMatrix);
+    target.negate().add(objectPosition);
+    const radius = objectRadius + this.radius;
+    const distance = target.length() - radius;
+    target.normalize();
+    return distance;
+  }
+};
+
+// src/helpers/utils/ColliderShapeCapsuleBufferGeometry.ts
+var THREE3 = __toESM(require("three"), 1);
+var _v3A2 = new THREE3.Vector3();
+var ColliderShapeCapsuleBufferGeometry = class extends THREE3.BufferGeometry {
+  constructor(shape) {
+    super();
+    this.worldScale = 1;
+    this._currentRadius = 0;
+    this._currentOffset = new THREE3.Vector3();
+    this._currentTail = new THREE3.Vector3();
+    this._shape = shape;
+    this._attrPos = new THREE3.BufferAttribute(new Float32Array(396), 3);
+    this.setAttribute("position", this._attrPos);
+    this._attrIndex = new THREE3.BufferAttribute(new Uint16Array(264), 1);
+    this.setIndex(this._attrIndex);
+    this._buildIndex();
+    this.update();
+  }
+  update() {
+    let shouldUpdateGeometry = false;
+    const radius = this._shape.radius / this.worldScale;
+    if (this._currentRadius !== radius) {
+      this._currentRadius = radius;
+      shouldUpdateGeometry = true;
+    }
+    if (!this._currentOffset.equals(this._shape.offset)) {
+      this._currentOffset.copy(this._shape.offset);
+      shouldUpdateGeometry = true;
+    }
+    const tail = _v3A2.copy(this._shape.tail).divideScalar(this.worldScale);
+    if (this._currentTail.distanceToSquared(tail) > 1e-10) {
+      this._currentTail.copy(tail);
+      shouldUpdateGeometry = true;
+    }
+    if (shouldUpdateGeometry) {
+      this._buildPosition();
+    }
+  }
+  _buildPosition() {
+    _v3A2.copy(this._currentTail).sub(this._currentOffset);
+    const l = _v3A2.length() / this._currentRadius;
+    for (let i = 0; i <= 16; i++) {
+      const t = i / 16 * Math.PI;
+      this._attrPos.setXYZ(i, -Math.sin(t), -Math.cos(t), 0);
+      this._attrPos.setXYZ(17 + i, l + Math.sin(t), Math.cos(t), 0);
+      this._attrPos.setXYZ(34 + i, -Math.sin(t), 0, -Math.cos(t));
+      this._attrPos.setXYZ(51 + i, l + Math.sin(t), 0, Math.cos(t));
+    }
+    for (let i = 0; i < 32; i++) {
+      const t = i / 16 * Math.PI;
+      this._attrPos.setXYZ(68 + i, 0, Math.sin(t), Math.cos(t));
+      this._attrPos.setXYZ(100 + i, l, Math.sin(t), Math.cos(t));
+    }
+    const theta = Math.atan2(_v3A2.y, Math.sqrt(_v3A2.x * _v3A2.x + _v3A2.z * _v3A2.z));
+    const phi = -Math.atan2(_v3A2.z, _v3A2.x);
+    this.rotateZ(theta);
+    this.rotateY(phi);
+    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);
+    this.translate(this._currentOffset.x, this._currentOffset.y, this._currentOffset.z);
+    this._attrPos.needsUpdate = true;
+  }
+  _buildIndex() {
+    for (let i = 0; i < 34; i++) {
+      const i1 = (i + 1) % 34;
+      this._attrIndex.setXY(i * 2, i, i1);
+      this._attrIndex.setXY(68 + i * 2, 34 + i, 34 + i1);
+    }
+    for (let i = 0; i < 32; i++) {
+      const i1 = (i + 1) % 32;
+      this._attrIndex.setXY(136 + i * 2, 68 + i, 68 + i1);
+      this._attrIndex.setXY(200 + i * 2, 100 + i, 100 + i1);
+    }
+    this._attrIndex.needsUpdate = true;
+  }
+};
+
+// src/helpers/utils/ColliderShapeSphereBufferGeometry.ts
+var THREE4 = __toESM(require("three"), 1);
+var ColliderShapeSphereBufferGeometry = class extends THREE4.BufferGeometry {
+  constructor(shape) {
+    super();
+    this.worldScale = 1;
+    this._currentRadius = 0;
+    this._currentOffset = new THREE4.Vector3();
+    this._shape = shape;
+    this._attrPos = new THREE4.BufferAttribute(new Float32Array(32 * 3 * 3), 3);
+    this.setAttribute("position", this._attrPos);
+    this._attrIndex = new THREE4.BufferAttribute(new Uint16Array(64 * 3), 1);
+    this.setIndex(this._attrIndex);
+    this._buildIndex();
+    this.update();
+  }
+  update() {
+    let shouldUpdateGeometry = false;
+    const radius = this._shape.radius / this.worldScale;
+    if (this._currentRadius !== radius) {
+      this._currentRadius = radius;
+      shouldUpdateGeometry = true;
+    }
+    if (!this._currentOffset.equals(this._shape.offset)) {
+      this._currentOffset.copy(this._shape.offset);
+      shouldUpdateGeometry = true;
+    }
+    if (shouldUpdateGeometry) {
+      this._buildPosition();
+    }
+  }
+  _buildPosition() {
+    for (let i = 0; i < 32; i++) {
+      const t = i / 16 * Math.PI;
+      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0);
+      this._attrPos.setXYZ(32 + i, 0, Math.cos(t), Math.sin(t));
+      this._attrPos.setXYZ(64 + i, Math.sin(t), 0, Math.cos(t));
+    }
+    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);
+    this.translate(this._currentOffset.x, this._currentOffset.y, this._currentOffset.z);
+    this._attrPos.needsUpdate = true;
+  }
+  _buildIndex() {
+    for (let i = 0; i < 32; i++) {
+      const i1 = (i + 1) % 32;
+      this._attrIndex.setXY(i * 2, i, i1);
+      this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);
+      this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);
+    }
+    this._attrIndex.needsUpdate = true;
+  }
+};
+
+// src/helpers/VRMSpringBoneColliderHelper.ts
+var _v3A3 = new THREE5.Vector3();
+var VRMSpringBoneColliderHelper = class extends THREE5.Group {
+  constructor(collider) {
+    super();
+    this.matrixAutoUpdate = false;
+    this.collider = collider;
+    if (this.collider.shape instanceof VRMSpringBoneColliderShapeSphere) {
+      this._geometry = new ColliderShapeSphereBufferGeometry(this.collider.shape);
+    } else if (this.collider.shape instanceof VRMSpringBoneColliderShapeCapsule) {
+      this._geometry = new ColliderShapeCapsuleBufferGeometry(this.collider.shape);
+    } else {
+      throw new Error("VRMSpringBoneColliderHelper: Unknown collider shape type detected");
+    }
+    const material = new THREE5.LineBasicMaterial({
+      color: 16711935,
+      depthTest: false,
+      depthWrite: false
+    });
+    this._line = new THREE5.LineSegments(this._geometry, material);
+    this.add(this._line);
+  }
+  dispose() {
+    this._geometry.dispose();
+  }
+  updateMatrixWorld(force) {
+    this.collider.updateWorldMatrix(true, false);
+    this.matrix.copy(this.collider.matrixWorld);
+    const matrixWorldElements = this.matrix.elements;
+    this._geometry.worldScale = _v3A3.set(matrixWorldElements[0], matrixWorldElements[1], matrixWorldElements[2]).length();
+    this._geometry.update();
+    super.updateMatrixWorld(force);
+  }
+};
+
+// src/helpers/VRMSpringBoneJointHelper.ts
+var THREE7 = __toESM(require("three"), 1);
+
+// src/helpers/utils/SpringBoneBufferGeometry.ts
+var THREE6 = __toESM(require("three"), 1);
+var SpringBoneBufferGeometry = class extends THREE6.BufferGeometry {
+  constructor(springBone) {
+    super();
+    this.worldScale = 1;
+    this._currentRadius = 0;
+    this._currentTail = new THREE6.Vector3();
+    this._springBone = springBone;
+    this._attrPos = new THREE6.BufferAttribute(new Float32Array(294), 3);
+    this.setAttribute("position", this._attrPos);
+    this._attrIndex = new THREE6.BufferAttribute(new Uint16Array(194), 1);
+    this.setIndex(this._attrIndex);
+    this._buildIndex();
+    this.update();
+  }
+  update() {
+    let shouldUpdateGeometry = false;
+    const radius = this._springBone.settings.hitRadius / this.worldScale;
+    if (this._currentRadius !== radius) {
+      this._currentRadius = radius;
+      shouldUpdateGeometry = true;
+    }
+    if (!this._currentTail.equals(this._springBone.initialLocalChildPosition)) {
+      this._currentTail.copy(this._springBone.initialLocalChildPosition);
+      shouldUpdateGeometry = true;
+    }
+    if (shouldUpdateGeometry) {
+      this._buildPosition();
+    }
+  }
+  _buildPosition() {
+    for (let i = 0; i < 32; i++) {
+      const t = i / 16 * Math.PI;
+      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0);
+      this._attrPos.setXYZ(32 + i, 0, Math.cos(t), Math.sin(t));
+      this._attrPos.setXYZ(64 + i, Math.sin(t), 0, Math.cos(t));
+    }
+    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);
+    this.translate(this._currentTail.x, this._currentTail.y, this._currentTail.z);
+    this._attrPos.setXYZ(96, 0, 0, 0);
+    this._attrPos.setXYZ(97, this._currentTail.x, this._currentTail.y, this._currentTail.z);
+    this._attrPos.needsUpdate = true;
+  }
+  _buildIndex() {
+    for (let i = 0; i < 32; i++) {
+      const i1 = (i + 1) % 32;
+      this._attrIndex.setXY(i * 2, i, i1);
+      this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);
+      this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);
+    }
+    this._attrIndex.setXY(192, 96, 97);
+    this._attrIndex.needsUpdate = true;
+  }
+};
+
+// src/helpers/VRMSpringBoneJointHelper.ts
+var _v3A4 = new THREE7.Vector3();
+var VRMSpringBoneJointHelper = class extends THREE7.Group {
+  constructor(springBone) {
+    super();
+    this.matrixAutoUpdate = false;
+    this.springBone = springBone;
+    this._geometry = new SpringBoneBufferGeometry(this.springBone);
+    const material = new THREE7.LineBasicMaterial({
+      color: 16776960,
+      depthTest: false,
+      depthWrite: false
+    });
+    this._line = new THREE7.LineSegments(this._geometry, material);
+    this.add(this._line);
+  }
+  dispose() {
+    this._geometry.dispose();
+  }
+  updateMatrixWorld(force) {
+    this.springBone.bone.updateWorldMatrix(true, false);
+    this.matrix.copy(this.springBone.bone.matrixWorld);
+    const matrixWorldElements = this.matrix.elements;
+    this._geometry.worldScale = _v3A4.set(matrixWorldElements[0], matrixWorldElements[1], matrixWorldElements[2]).length();
+    this._geometry.update();
+    super.updateMatrixWorld(force);
+  }
+};
+
+// src/VRMSpringBoneCollider.ts
+var THREE8 = __toESM(require("three"), 1);
+var VRMSpringBoneCollider = class extends THREE8.Object3D {
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+};
+
+// src/VRMSpringBoneJoint.ts
+var THREE11 = __toESM(require("three"), 1);
+
+// src/utils/mat4InvertCompat.ts
+var THREE9 = __toESM(require("three"), 1);
+var _matA = new THREE9.Matrix4();
+function mat4InvertCompat(target) {
+  if (target.invert) {
+    target.invert();
+  } else {
+    target.getInverse(_matA.copy(target));
+  }
+  return target;
+}
+
+// src/utils/Matrix4InverseCache.ts
+var THREE10 = __toESM(require("three"), 1);
+var Matrix4InverseCache = class {
+  constructor(matrix) {
+    /**
+     * A cache of inverse of current matrix.
+     */
+    this._inverseCache = new THREE10.Matrix4();
+    /**
+     * A flag that makes it want to recalculate its {@link _inverseCache}.
+     * Will be set `true` when `elements` are mutated and be used in `getInverse`.
+     */
+    this._shouldUpdateInverse = true;
+    this.matrix = matrix;
+    const handler = {
+      set: (obj, prop, newVal) => {
+        this._shouldUpdateInverse = true;
+        obj[prop] = newVal;
+        return true;
+      }
+    };
+    this._originalElements = matrix.elements;
+    matrix.elements = new Proxy(matrix.elements, handler);
+  }
+  /**
+   * Inverse of given matrix.
+   * Note that it will return its internal private instance.
+   * Make sure copying this before mutate this.
+   */
+  get inverse() {
+    if (this._shouldUpdateInverse) {
+      this._inverseCache.copy(this.matrix);
+      mat4InvertCompat(this._inverseCache);
+      this._shouldUpdateInverse = false;
+    }
+    return this._inverseCache;
+  }
+  revert() {
+    this.matrix.elements = this._originalElements;
+  }
+};
+
+// src/VRMSpringBoneJoint.ts
+var IDENTITY_MATRIX4 = new THREE11.Matrix4();
+var _v3A5 = new THREE11.Vector3();
+var _v3B2 = new THREE11.Vector3();
+var _v3C = new THREE11.Vector3();
+var _worldSpacePosition = new THREE11.Vector3();
+var _centerSpacePosition = new THREE11.Vector3();
+var _nextTail = new THREE11.Vector3();
+var _quatA = new THREE11.Quaternion();
+var _matA2 = new THREE11.Matrix4();
+var _matB = new THREE11.Matrix4();
+var VRMSpringBoneJoint = class {
+  /**
+   * Create a new VRMSpringBone.
+   *
+   * @param bone An Object3D that will be attached to this bone
+   * @param child An Object3D that will be used as a tail of this spring bone. It can be null when the spring bone is imported from VRM 0.0
+   * @param settings Several parameters related to behavior of the spring bone
+   * @param colliderGroups Collider groups that will be collided with this spring bone
+   */
+  constructor(bone, child, settings = {}, colliderGroups = []) {
+    /**
+     * Current position of child tail, in center unit. Will be used for verlet integration.
+     */
+    this._currentTail = new THREE11.Vector3();
+    /**
+     * Previous position of child tail, in center unit. Will be used for verlet integration.
+     */
+    this._prevTail = new THREE11.Vector3();
+    /**
+     * Initial axis of the bone, in local unit.
+     */
+    this._boneAxis = new THREE11.Vector3();
+    /**
+     * Length of the bone in world unit.
+     * Will be used for normalization in update loop, will be updated by {@link _calcWorldSpaceBoneLength}.
+     *
+     * It's same as local unit length unless there are scale transformations in the world space.
+     */
+    this._worldSpaceBoneLength = 0;
+    /**
+     * This springbone will be calculated based on the space relative from this object.
+     * If this is `null`, springbone will be calculated in world space.
+     */
+    this._center = null;
+    /**
+     * Initial state of the local matrix of the bone.
+     */
+    this._initialLocalMatrix = new THREE11.Matrix4();
+    /**
+     * Initial state of the rotation of the bone.
+     */
+    this._initialLocalRotation = new THREE11.Quaternion();
+    /**
+     * Initial state of the position of its child.
+     */
+    this._initialLocalChildPosition = new THREE11.Vector3();
+    var _a, _b, _c, _d, _e, _f;
+    this.bone = bone;
+    this.bone.matrixAutoUpdate = false;
+    this.child = child;
+    this.settings = {
+      hitRadius: (_a = settings.hitRadius) != null ? _a : 0,
+      stiffness: (_b = settings.stiffness) != null ? _b : 1,
+      gravityPower: (_c = settings.gravityPower) != null ? _c : 0,
+      gravityDir: (_e = (_d = settings.gravityDir) == null ? void 0 : _d.clone()) != null ? _e : new THREE11.Vector3(0, -1, 0),
+      dragForce: (_f = settings.dragForce) != null ? _f : 0.4
+    };
+    this.colliderGroups = colliderGroups;
+  }
+  get center() {
+    return this._center;
+  }
+  set center(center) {
+    var _a;
+    if ((_a = this._center) == null ? void 0 : _a.userData.inverseCacheProxy) {
+      this._center.userData.inverseCacheProxy.revert();
+      delete this._center.userData.inverseCacheProxy;
+    }
+    this._center = center;
+    if (this._center) {
+      if (!this._center.userData.inverseCacheProxy) {
+        this._center.userData.inverseCacheProxy = new Matrix4InverseCache(this._center.matrixWorld);
+      }
+    }
+  }
+  get initialLocalChildPosition() {
+    return this._initialLocalChildPosition;
+  }
+  /**
+   * Returns the world matrix of its parent object.
+   * Note that it returns a reference to the matrix. Don't mutate this directly!
+   */
+  get _parentMatrixWorld() {
+    return this.bone.parent ? this.bone.parent.matrixWorld : IDENTITY_MATRIX4;
+  }
+  /**
+   * Set the initial state of this spring bone.
+   * You might want to call {@link VRMSpringBoneManager.setInitState} instead.
+   */
+  setInitState() {
+    this._initialLocalMatrix.copy(this.bone.matrix);
+    this._initialLocalRotation.copy(this.bone.quaternion);
+    if (this.child) {
+      this._initialLocalChildPosition.copy(this.child.position);
+    } else {
+      this._initialLocalChildPosition.copy(this.bone.position).normalize().multiplyScalar(0.07);
+    }
+    const matrixWorldToCenter = this._getMatrixWorldToCenter(_matA2);
+    this.bone.localToWorld(this._currentTail.copy(this._initialLocalChildPosition)).applyMatrix4(matrixWorldToCenter);
+    this._prevTail.copy(this._currentTail);
+    this._boneAxis.copy(this._initialLocalChildPosition).normalize();
+  }
+  /**
+   * Reset the state of this bone.
+   * You might want to call [[VRMSpringBoneManager.reset]] instead.
+   */
+  reset() {
+    this.bone.quaternion.copy(this._initialLocalRotation);
+    this.bone.updateMatrix();
+    this.bone.matrixWorld.multiplyMatrices(this._parentMatrixWorld, this.bone.matrix);
+    const matrixWorldToCenter = this._getMatrixWorldToCenter(_matA2);
+    this.bone.localToWorld(this._currentTail.copy(this._initialLocalChildPosition)).applyMatrix4(matrixWorldToCenter);
+    this._prevTail.copy(this._currentTail);
+  }
+  /**
+   * Update the state of this bone.
+   * You might want to call [[VRMSpringBoneManager.update]] instead.
+   *
+   * @param delta deltaTime
+   */
+  update(delta) {
+    if (delta <= 0) return;
+    this._calcWorldSpaceBoneLength();
+    _worldSpacePosition.setFromMatrixPosition(this.bone.matrixWorld);
+    let matrixWorldToCenter = this._getMatrixWorldToCenter(_matA2);
+    _centerSpacePosition.copy(_worldSpacePosition).applyMatrix4(matrixWorldToCenter);
+    const quatWorldToCenter = _quatA.setFromRotationMatrix(matrixWorldToCenter);
+    const centerSpaceParentMatrix = _matB.copy(matrixWorldToCenter).multiply(this._parentMatrixWorld);
+    const centerSpaceBoneAxis = _v3B2.copy(this._boneAxis).applyMatrix4(this._initialLocalMatrix).applyMatrix4(centerSpaceParentMatrix).sub(_centerSpacePosition).normalize();
+    const centerSpaceGravity = _v3C.copy(this.settings.gravityDir).applyQuaternion(quatWorldToCenter).normalize();
+    const matrixCenterToWorld = this._getMatrixCenterToWorld(_matA2);
+    _nextTail.copy(this._currentTail).add(
+      _v3A5.copy(this._currentTail).sub(this._prevTail).multiplyScalar(1 - this.settings.dragForce)
+    ).add(_v3A5.copy(centerSpaceBoneAxis).multiplyScalar(this.settings.stiffness * delta)).add(_v3A5.copy(centerSpaceGravity).multiplyScalar(this.settings.gravityPower * delta)).applyMatrix4(matrixCenterToWorld);
+    _nextTail.sub(_worldSpacePosition).normalize().multiplyScalar(this._worldSpaceBoneLength).add(_worldSpacePosition);
+    this._collision(_nextTail);
+    matrixWorldToCenter = this._getMatrixWorldToCenter(_matA2);
+    this._prevTail.copy(this._currentTail);
+    this._currentTail.copy(_v3A5.copy(_nextTail).applyMatrix4(matrixWorldToCenter));
+    const worldSpaceInitialMatrixInv = mat4InvertCompat(
+      _matA2.copy(this._parentMatrixWorld).multiply(this._initialLocalMatrix)
+    );
+    const applyRotation = _quatA.setFromUnitVectors(
+      this._boneAxis,
+      _v3A5.copy(_nextTail).applyMatrix4(worldSpaceInitialMatrixInv).normalize()
+    );
+    this.bone.quaternion.copy(this._initialLocalRotation).multiply(applyRotation);
+    this.bone.updateMatrix();
+    this.bone.matrixWorld.multiplyMatrices(this._parentMatrixWorld, this.bone.matrix);
+  }
+  /**
+   * Do collision math against every colliders attached to this bone.
+   *
+   * @param tail The tail you want to process
+   */
+  _collision(tail) {
+    this.colliderGroups.forEach((colliderGroup) => {
+      colliderGroup.colliders.forEach((collider) => {
+        const dist = collider.shape.calculateCollision(collider.matrixWorld, tail, this.settings.hitRadius, _v3A5);
+        if (dist < 0) {
+          tail.add(_v3A5.multiplyScalar(-dist));
+          tail.sub(_worldSpacePosition).normalize().multiplyScalar(this._worldSpaceBoneLength).add(_worldSpacePosition);
+        }
+      });
+    });
+  }
+  /**
+   * Calculate the {@link _worldSpaceBoneLength}.
+   * Intended to be used in {@link update}.
+   */
+  _calcWorldSpaceBoneLength() {
+    _v3A5.setFromMatrixPosition(this.bone.matrixWorld);
+    if (this.child) {
+      _v3B2.setFromMatrixPosition(this.child.matrixWorld);
+    } else {
+      _v3B2.copy(this._initialLocalChildPosition);
+      _v3B2.applyMatrix4(this.bone.matrixWorld);
+    }
+    this._worldSpaceBoneLength = _v3A5.sub(_v3B2).length();
+  }
+  /**
+   * Create a matrix that converts center space into world space.
+   * @param target Target matrix
+   */
+  _getMatrixCenterToWorld(target) {
+    if (this._center) {
+      target.copy(this._center.matrixWorld);
+    } else {
+      target.identity();
+    }
+    return target;
+  }
+  /**
+   * Create a matrix that converts world space into center space.
+   * @param target Target matrix
+   */
+  _getMatrixWorldToCenter(target) {
+    if (this._center) {
+      target.copy(this._center.userData.inverseCacheProxy.inverse);
+    } else {
+      target.identity();
+    }
+    return target;
+  }
+};
+
+// src/VRMSpringBoneLoaderPlugin.ts
+var THREE12 = __toESM(require("three"), 1);
+
+// src/utils/traverseAncestorsFromRoot.ts
+function traverseAncestorsFromRoot(object, callback) {
+  const ancestors = [];
+  let head = object;
+  while (head !== null) {
+    ancestors.unshift(head);
+    head = head.parent;
+  }
+  ancestors.forEach((ancestor) => {
+    callback(ancestor);
+  });
+}
+
+// src/utils/traverseChildrenUntilConditionMet.ts
+function traverseChildrenUntilConditionMet(object, callback) {
+  object.children.forEach((child) => {
+    const result = callback(child);
+    if (!result) {
+      traverseChildrenUntilConditionMet(child, callback);
+    }
+  });
+}
+
+// src/VRMSpringBoneManager.ts
+var VRMSpringBoneManager = class {
+  constructor() {
+    this._joints = /* @__PURE__ */ new Set();
+    this._objectSpringBonesMap = /* @__PURE__ */ new Map();
+  }
+  get joints() {
+    return this._joints;
+  }
+  /**
+   * @deprecated Use {@link joints} instead.
+   */
+  get springBones() {
+    console.warn("VRMSpringBoneManager: springBones is deprecated. use joints instead.");
+    return this._joints;
+  }
+  get colliderGroups() {
+    const set = /* @__PURE__ */ new Set();
+    this._joints.forEach((springBone) => {
+      springBone.colliderGroups.forEach((colliderGroup) => {
+        set.add(colliderGroup);
+      });
+    });
+    return Array.from(set);
+  }
+  get colliders() {
+    const set = /* @__PURE__ */ new Set();
+    this.colliderGroups.forEach((colliderGroup) => {
+      colliderGroup.colliders.forEach((collider) => {
+        set.add(collider);
+      });
+    });
+    return Array.from(set);
+  }
+  addJoint(joint) {
+    this._joints.add(joint);
+    let objectSet = this._objectSpringBonesMap.get(joint.bone);
+    if (objectSet == null) {
+      objectSet = /* @__PURE__ */ new Set();
+      this._objectSpringBonesMap.set(joint.bone, objectSet);
+    }
+    objectSet.add(joint);
+  }
+  /**
+   * @deprecated Use {@link addJoint} instead.
+   */
+  addSpringBone(joint) {
+    console.warn("VRMSpringBoneManager: addSpringBone() is deprecated. use addJoint() instead.");
+    this.addJoint(joint);
+  }
+  deleteJoint(joint) {
+    this._joints.delete(joint);
+    const objectSet = this._objectSpringBonesMap.get(joint.bone);
+    objectSet.delete(joint);
+  }
+  /**
+   * @deprecated Use {@link deleteJoint} instead.
+   */
+  deleteSpringBone(joint) {
+    console.warn("VRMSpringBoneManager: deleteSpringBone() is deprecated. use deleteJoint() instead.");
+    this.deleteJoint(joint);
+  }
+  setInitState() {
+    const springBonesTried = /* @__PURE__ */ new Set();
+    const springBonesDone = /* @__PURE__ */ new Set();
+    const objectUpdated = /* @__PURE__ */ new Set();
+    for (const springBone of this._joints) {
+      this._processSpringBone(
+        springBone,
+        springBonesTried,
+        springBonesDone,
+        objectUpdated,
+        (springBone2) => springBone2.setInitState()
+      );
+    }
+  }
+  reset() {
+    const springBonesTried = /* @__PURE__ */ new Set();
+    const springBonesDone = /* @__PURE__ */ new Set();
+    const objectUpdated = /* @__PURE__ */ new Set();
+    for (const springBone of this._joints) {
+      this._processSpringBone(
+        springBone,
+        springBonesTried,
+        springBonesDone,
+        objectUpdated,
+        (springBone2) => springBone2.reset()
+      );
+    }
+  }
+  update(delta) {
+    const springBonesTried = /* @__PURE__ */ new Set();
+    const springBonesDone = /* @__PURE__ */ new Set();
+    const objectUpdated = /* @__PURE__ */ new Set();
+    for (const springBone of this._joints) {
+      this._processSpringBone(
+        springBone,
+        springBonesTried,
+        springBonesDone,
+        objectUpdated,
+        (springBone2) => springBone2.update(delta)
+      );
+      traverseChildrenUntilConditionMet(springBone.bone, (object) => {
+        var _a, _b;
+        if (((_b = (_a = this._objectSpringBonesMap.get(object)) == null ? void 0 : _a.size) != null ? _b : 0) > 0) {
+          return true;
+        }
+        object.updateWorldMatrix(false, false);
+        return false;
+      });
+    }
+  }
+  /**
+   * Update a spring bone.
+   * If there are other spring bone that are dependant, it will try to update them recursively.
+   * It updates matrixWorld of all ancestors and myself.
+   * It might throw an error if there are circular dependencies.
+   *
+   * Intended to be used in {@link update} and {@link _processSpringBone} itself recursively.
+   *
+   * @param springBone A springBone you want to update
+   * @param springBonesTried Set of springBones that are already tried to be updated
+   * @param springBonesDone Set of springBones that are already up to date
+   * @param objectUpdated Set of object3D whose matrixWorld is updated
+   */
+  _processSpringBone(springBone, springBonesTried, springBonesDone, objectUpdated, callback) {
+    if (springBonesDone.has(springBone)) {
+      return;
+    }
+    if (springBonesTried.has(springBone)) {
+      throw new Error("VRMSpringBoneManager: Circular dependency detected while updating springbones");
+    }
+    springBonesTried.add(springBone);
+    const depObjects = this._getDependencies(springBone);
+    for (const depObject of depObjects) {
+      traverseAncestorsFromRoot(depObject, (depObjectAncestor) => {
+        const objectSet = this._objectSpringBonesMap.get(depObjectAncestor);
+        if (objectSet) {
+          for (const depSpringBone of objectSet) {
+            this._processSpringBone(depSpringBone, springBonesTried, springBonesDone, objectUpdated, callback);
+          }
+        } else if (!objectUpdated.has(depObjectAncestor)) {
+          depObjectAncestor.updateWorldMatrix(false, false);
+          objectUpdated.add(depObjectAncestor);
+        }
+      });
+    }
+    springBone.bone.updateMatrix();
+    springBone.bone.updateWorldMatrix(false, false);
+    callback(springBone);
+    objectUpdated.add(springBone.bone);
+    springBonesDone.add(springBone);
+  }
+  /**
+   * Return a set of objects that are dependant of given spring bone.
+   * @param springBone A spring bone
+   * @return A set of objects that are dependant of given spring bone
+   */
+  _getDependencies(springBone) {
+    const set = /* @__PURE__ */ new Set();
+    const parent = springBone.bone.parent;
+    if (parent) {
+      set.add(parent);
+    }
+    springBone.colliderGroups.forEach((colliderGroup) => {
+      colliderGroup.colliders.forEach((collider) => {
+        set.add(collider);
+      });
+    });
+    return set;
+  }
+};
+
+// src/VRMSpringBoneLoaderPlugin.ts
+var POSSIBLE_SPEC_VERSIONS = /* @__PURE__ */ new Set(["1.0", "1.0-beta"]);
+var _VRMSpringBoneLoaderPlugin = class _VRMSpringBoneLoaderPlugin {
+  get name() {
+    return _VRMSpringBoneLoaderPlugin.EXTENSION_NAME;
+  }
+  constructor(parser, options) {
+    this.parser = parser;
+    this.jointHelperRoot = options == null ? void 0 : options.jointHelperRoot;
+    this.colliderHelperRoot = options == null ? void 0 : options.colliderHelperRoot;
+  }
+  afterRoot(gltf) {
+    return __async(this, null, function* () {
+      gltf.userData.vrmSpringBoneManager = yield this._import(gltf);
+    });
+  }
+  /**
+   * Import spring bones from a GLTF and return a {@link VRMSpringBoneManager}.
+   * It might return `null` instead when it does not need to be created or something go wrong.
+   *
+   * @param gltf A parsed result of GLTF taken from GLTFLoader
+   */
+  _import(gltf) {
+    return __async(this, null, function* () {
+      const v1Result = yield this._v1Import(gltf);
+      if (v1Result != null) {
+        return v1Result;
+      }
+      const v0Result = yield this._v0Import(gltf);
+      if (v0Result != null) {
+        return v0Result;
+      }
+      return null;
+    });
+  }
+  _v1Import(gltf) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      const json = gltf.parser.json;
+      const isSpringBoneUsed = ((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf(_VRMSpringBoneLoaderPlugin.EXTENSION_NAME)) !== -1;
+      if (!isSpringBoneUsed) {
+        return null;
+      }
+      const manager = new VRMSpringBoneManager();
+      const threeNodes = yield gltf.parser.getDependencies("node");
+      const extension = (_b = json.extensions) == null ? void 0 : _b[_VRMSpringBoneLoaderPlugin.EXTENSION_NAME];
+      if (!extension) {
+        return null;
+      }
+      const specVersion = extension.specVersion;
+      if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {
+        console.warn(
+          `VRMSpringBoneLoaderPlugin: Unknown ${_VRMSpringBoneLoaderPlugin.EXTENSION_NAME} specVersion "${specVersion}"`
+        );
+        return null;
+      }
+      const colliders = (_c = extension.colliders) == null ? void 0 : _c.map((schemaCollider, iCollider) => {
+        var _a2, _b2, _c2, _d2, _e2;
+        const node = threeNodes[schemaCollider.node];
+        const schemaShape = schemaCollider.shape;
+        if (schemaShape.sphere) {
+          return this._importSphereCollider(node, {
+            offset: new THREE12.Vector3().fromArray((_a2 = schemaShape.sphere.offset) != null ? _a2 : [0, 0, 0]),
+            radius: (_b2 = schemaShape.sphere.radius) != null ? _b2 : 0
+          });
+        } else if (schemaShape.capsule) {
+          return this._importCapsuleCollider(node, {
+            offset: new THREE12.Vector3().fromArray((_c2 = schemaShape.capsule.offset) != null ? _c2 : [0, 0, 0]),
+            radius: (_d2 = schemaShape.capsule.radius) != null ? _d2 : 0,
+            tail: new THREE12.Vector3().fromArray((_e2 = schemaShape.capsule.tail) != null ? _e2 : [0, 0, 0])
+          });
+        }
+        throw new Error(`VRMSpringBoneLoaderPlugin: The collider #${iCollider} has no valid shape`);
+      });
+      const colliderGroups = (_d = extension.colliderGroups) == null ? void 0 : _d.map(
+        (schemaColliderGroup, iColliderGroup) => {
+          var _a2;
+          const cols = ((_a2 = schemaColliderGroup.colliders) != null ? _a2 : []).map((iCollider) => {
+            const col = colliders == null ? void 0 : colliders[iCollider];
+            if (col == null) {
+              throw new Error(
+                `VRMSpringBoneLoaderPlugin: The colliderGroup #${iColliderGroup} attempted to use a collider #${iCollider} but not found`
+              );
+            }
+            return col;
+          });
+          return {
+            colliders: cols,
+            name: schemaColliderGroup.name
+          };
+        }
+      );
+      (_e = extension.springs) == null ? void 0 : _e.forEach((schemaSpring, iSpring) => {
+        var _a2;
+        const schemaJoints = schemaSpring.joints;
+        const colliderGroupsForSpring = (_a2 = schemaSpring.colliderGroups) == null ? void 0 : _a2.map((iColliderGroup) => {
+          const group = colliderGroups == null ? void 0 : colliderGroups[iColliderGroup];
+          if (group == null) {
+            throw new Error(
+              `VRMSpringBoneLoaderPlugin: The spring #${iSpring} attempted to use a colliderGroup ${iColliderGroup} but not found`
+            );
+          }
+          return group;
+        });
+        const center = schemaSpring.center != null ? threeNodes[schemaSpring.center] : void 0;
+        let prevSchemaJoint;
+        schemaJoints.forEach((schemaJoint) => {
+          if (prevSchemaJoint) {
+            const nodeIndex = prevSchemaJoint.node;
+            const node = threeNodes[nodeIndex];
+            const childIndex = schemaJoint.node;
+            const child = threeNodes[childIndex];
+            const setting = {
+              hitRadius: prevSchemaJoint.hitRadius,
+              dragForce: prevSchemaJoint.dragForce,
+              gravityPower: prevSchemaJoint.gravityPower,
+              stiffness: prevSchemaJoint.stiffness,
+              gravityDir: prevSchemaJoint.gravityDir != null ? new THREE12.Vector3().fromArray(prevSchemaJoint.gravityDir) : void 0
+            };
+            const joint = this._importJoint(node, child, setting, colliderGroupsForSpring);
+            if (center) {
+              joint.center = center;
+            }
+            manager.addJoint(joint);
+          }
+          prevSchemaJoint = schemaJoint;
+        });
+      });
+      manager.setInitState();
+      return manager;
+    });
+  }
+  _v0Import(gltf) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const json = gltf.parser.json;
+      const isVRMUsed = ((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf("VRM")) !== -1;
+      if (!isVRMUsed) {
+        return null;
+      }
+      const extension = (_b = json.extensions) == null ? void 0 : _b["VRM"];
+      const schemaSecondaryAnimation = extension == null ? void 0 : extension.secondaryAnimation;
+      if (!schemaSecondaryAnimation) {
+        return null;
+      }
+      const schemaBoneGroups = schemaSecondaryAnimation == null ? void 0 : schemaSecondaryAnimation.boneGroups;
+      if (!schemaBoneGroups) {
+        return null;
+      }
+      const manager = new VRMSpringBoneManager();
+      const threeNodes = yield gltf.parser.getDependencies("node");
+      const colliderGroups = (_c = schemaSecondaryAnimation.colliderGroups) == null ? void 0 : _c.map(
+        (schemaColliderGroup) => {
+          var _a2;
+          const node = threeNodes[schemaColliderGroup.node];
+          const colliders = ((_a2 = schemaColliderGroup.colliders) != null ? _a2 : []).map((schemaCollider, iCollider) => {
+            var _a3, _b2, _c2;
+            const offset = new THREE12.Vector3(0, 0, 0);
+            if (schemaCollider.offset) {
+              offset.set(
+                (_a3 = schemaCollider.offset.x) != null ? _a3 : 0,
+                (_b2 = schemaCollider.offset.y) != null ? _b2 : 0,
+                schemaCollider.offset.z ? -schemaCollider.offset.z : 0
+                // z is opposite in VRM0.0
+              );
+            }
+            return this._importSphereCollider(node, {
+              offset,
+              radius: (_c2 = schemaCollider.radius) != null ? _c2 : 0
+            });
+          });
+          return { colliders };
+        }
+      );
+      schemaBoneGroups == null ? void 0 : schemaBoneGroups.forEach((schemaBoneGroup, iBoneGroup) => {
+        const rootIndices = schemaBoneGroup.bones;
+        if (!rootIndices) {
+          return;
+        }
+        rootIndices.forEach((rootIndex) => {
+          var _a2, _b2, _c2, _d;
+          const root = threeNodes[rootIndex];
+          const gravityDir = new THREE12.Vector3();
+          if (schemaBoneGroup.gravityDir) {
+            gravityDir.set(
+              (_a2 = schemaBoneGroup.gravityDir.x) != null ? _a2 : 0,
+              (_b2 = schemaBoneGroup.gravityDir.y) != null ? _b2 : 0,
+              (_c2 = schemaBoneGroup.gravityDir.z) != null ? _c2 : 0
+            );
+          } else {
+            gravityDir.set(0, -1, 0);
+          }
+          const center = schemaBoneGroup.center != null ? threeNodes[schemaBoneGroup.center] : void 0;
+          const setting = {
+            hitRadius: schemaBoneGroup.hitRadius,
+            dragForce: schemaBoneGroup.dragForce,
+            gravityPower: schemaBoneGroup.gravityPower,
+            stiffness: schemaBoneGroup.stiffiness,
+            gravityDir
+          };
+          const colliderGroupsForSpring = (_d = schemaBoneGroup.colliderGroups) == null ? void 0 : _d.map((iColliderGroup) => {
+            const group = colliderGroups == null ? void 0 : colliderGroups[iColliderGroup];
+            if (group == null) {
+              throw new Error(
+                `VRMSpringBoneLoaderPlugin: The spring #${iBoneGroup} attempted to use a colliderGroup ${iColliderGroup} but not found`
+              );
+            }
+            return group;
+          });
+          root.traverse((node) => {
+            var _a3;
+            const child = (_a3 = node.children[0]) != null ? _a3 : null;
+            const joint = this._importJoint(node, child, setting, colliderGroupsForSpring);
+            if (center) {
+              joint.center = center;
+            }
+            manager.addJoint(joint);
+          });
+        });
+      });
+      gltf.scene.updateMatrixWorld();
+      manager.setInitState();
+      return manager;
+    });
+  }
+  _importJoint(node, child, setting, colliderGroupsForSpring) {
+    const springBone = new VRMSpringBoneJoint(node, child, setting, colliderGroupsForSpring);
+    if (this.jointHelperRoot) {
+      const helper = new VRMSpringBoneJointHelper(springBone);
+      this.jointHelperRoot.add(helper);
+      helper.renderOrder = this.jointHelperRoot.renderOrder;
+    }
+    return springBone;
+  }
+  _importSphereCollider(destination, params) {
+    const { offset, radius } = params;
+    const shape = new VRMSpringBoneColliderShapeSphere({ offset, radius });
+    const collider = new VRMSpringBoneCollider(shape);
+    destination.add(collider);
+    if (this.colliderHelperRoot) {
+      const helper = new VRMSpringBoneColliderHelper(collider);
+      this.colliderHelperRoot.add(helper);
+      helper.renderOrder = this.colliderHelperRoot.renderOrder;
+    }
+    return collider;
+  }
+  _importCapsuleCollider(destination, params) {
+    const { offset, radius, tail } = params;
+    const shape = new VRMSpringBoneColliderShapeCapsule({ offset, radius, tail });
+    const collider = new VRMSpringBoneCollider(shape);
+    destination.add(collider);
+    if (this.colliderHelperRoot) {
+      const helper = new VRMSpringBoneColliderHelper(collider);
+      this.colliderHelperRoot.add(helper);
+      helper.renderOrder = this.colliderHelperRoot.renderOrder;
+    }
+    return collider;
+  }
+};
+_VRMSpringBoneLoaderPlugin.EXTENSION_NAME = "VRMC_springBone";
+var VRMSpringBoneLoaderPlugin = _VRMSpringBoneLoaderPlugin;
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/helpers/VRMSpringBoneColliderHelper.ts", "../src/VRMSpringBoneColliderShapeCapsule.ts", "../src/VRMSpringBoneColliderShape.ts", "../src/VRMSpringBoneColliderShapeSphere.ts", "../src/helpers/utils/ColliderShapeCapsuleBufferGeometry.ts", "../src/helpers/utils/ColliderShapeSphereBufferGeometry.ts", "../src/helpers/VRMSpringBoneJointHelper.ts", "../src/helpers/utils/SpringBoneBufferGeometry.ts", "../src/VRMSpringBoneCollider.ts", "../src/VRMSpringBoneJoint.ts", "../src/utils/mat4InvertCompat.ts", "../src/utils/Matrix4InverseCache.ts", "../src/VRMSpringBoneLoaderPlugin.ts", "../src/utils/traverseAncestorsFromRoot.ts", "../src/utils/traverseChildrenUntilConditionMet.ts", "../src/VRMSpringBoneManager.ts"],
  "sourcesContent": ["export * from './helpers';\nexport * from './VRMSpringBoneCollider';\nexport * from './VRMSpringBoneColliderGroup';\nexport * from './VRMSpringBoneColliderShape';\nexport * from './VRMSpringBoneColliderShapeCapsule';\nexport * from './VRMSpringBoneColliderShapeSphere';\nexport * from './VRMSpringBoneJoint';\nexport * from './VRMSpringBoneLoaderPlugin';\nexport * from './VRMSpringBoneManager';\nexport * from './VRMSpringBoneJointSettings';\n", "import * as THREE from 'three';\nimport { VRMSpringBoneCollider } from '../VRMSpringBoneCollider';\nimport { VRMSpringBoneColliderShapeCapsule } from '../VRMSpringBoneColliderShapeCapsule';\nimport { VRMSpringBoneColliderShapeSphere } from '../VRMSpringBoneColliderShapeSphere';\nimport { ColliderShapeBufferGeometry } from './utils/ColliderShapeBufferGeometry';\nimport { ColliderShapeCapsuleBufferGeometry } from './utils/ColliderShapeCapsuleBufferGeometry';\nimport { ColliderShapeSphereBufferGeometry } from './utils/ColliderShapeSphereBufferGeometry';\n\nconst _v3A = new THREE.Vector3();\n\nexport class VRMSpringBoneColliderHelper extends THREE.Group {\n  public readonly collider: VRMSpringBoneCollider;\n  private readonly _geometry: ColliderShapeBufferGeometry;\n  private readonly _line: THREE.LineSegments;\n\n  public constructor(collider: VRMSpringBoneCollider) {\n    super();\n    this.matrixAutoUpdate = false;\n\n    this.collider = collider;\n\n    if (this.collider.shape instanceof VRMSpringBoneColliderShapeSphere) {\n      this._geometry = new ColliderShapeSphereBufferGeometry(this.collider.shape);\n    } else if (this.collider.shape instanceof VRMSpringBoneColliderShapeCapsule) {\n      this._geometry = new ColliderShapeCapsuleBufferGeometry(this.collider.shape);\n    } else {\n      throw new Error('VRMSpringBoneColliderHelper: Unknown collider shape type detected');\n    }\n\n    const material = new THREE.LineBasicMaterial({\n      color: 0xff00ff,\n      depthTest: false,\n      depthWrite: false,\n    });\n\n    this._line = new THREE.LineSegments(this._geometry, material);\n    this.add(this._line);\n  }\n\n  public dispose(): void {\n    this._geometry.dispose();\n  }\n\n  public updateMatrixWorld(force: boolean): void {\n    this.collider.updateWorldMatrix(true, false);\n\n    this.matrix.copy(this.collider.matrixWorld);\n\n    const matrixWorldElements = this.matrix.elements;\n    this._geometry.worldScale = _v3A\n      .set(matrixWorldElements[0], matrixWorldElements[1], matrixWorldElements[2])\n      .length(); // calculate scale of x component\n\n    this._geometry.update();\n\n    super.updateMatrixWorld(force);\n  }\n}\n", "import * as THREE from 'three';\nimport { VRMSpringBoneColliderShape } from './VRMSpringBoneColliderShape';\n\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\n\nexport class VRMSpringBoneColliderShapeCapsule extends VRMSpringBoneColliderShape {\n  public get type(): 'capsule' {\n    return 'capsule';\n  }\n\n  /**\n   * The offset of the head from the origin.\n   */\n  public offset: THREE.Vector3;\n\n  /**\n   * The offset of the tail from the origin.\n   */\n  public tail: THREE.Vector3;\n\n  /**\n   * The radius.\n   */\n  public radius: number;\n\n  public constructor(params?: { radius?: number; offset?: THREE.Vector3; tail?: THREE.Vector3 }) {\n    super();\n\n    this.offset = params?.offset ?? new THREE.Vector3(0.0, 0.0, 0.0);\n    this.tail = params?.tail ?? new THREE.Vector3(0.0, 0.0, 0.0);\n    this.radius = params?.radius ?? 0.0;\n  }\n\n  public calculateCollision(\n    colliderMatrix: THREE.Matrix4,\n    objectPosition: THREE.Vector3,\n    objectRadius: number,\n    target: THREE.Vector3,\n  ): number {\n    _v3A.copy(this.offset).applyMatrix4(colliderMatrix); // transformed head\n    _v3B.copy(this.tail).applyMatrix4(colliderMatrix); // transformed tail\n    _v3B.sub(_v3A); // from head to tail\n    const lengthSqCapsule = _v3B.lengthSq();\n\n    target.copy(objectPosition).sub(_v3A); // from head to object\n    const dot = _v3B.dot(target); // dot product of offsetToTail and offsetToObject\n\n    if (dot <= 0.0) {\n      // if object is near from the head\n      // do nothing, use the current value directly\n    } else if (lengthSqCapsule <= dot) {\n      // if object is near from the tail\n      target.sub(_v3B); // from tail to object\n    } else {\n      // if object is between two ends\n      _v3B.multiplyScalar(dot / lengthSqCapsule); // from head to the nearest point of the shaft\n      target.sub(_v3B); // from the shaft point to object\n    }\n\n    const radius = objectRadius + this.radius;\n    const distance = target.length() - radius;\n    target.normalize();\n    return distance;\n  }\n}\n", "import type * as THREE from 'three';\n\n/**\n * Represents a shape of a collider.\n */\nexport abstract class VRMSpringBoneColliderShape {\n  /**\n   * The type of the shape.\n   */\n  public abstract get type(): string;\n\n  /**\n   * Calculate a distance and a direction from the collider to a target object.\n   * It's hit if the distance is negative.\n   * The direction will be contained in the given target vector.\n   *\n   * @param colliderMatrix A matrix represents the transform of the collider\n   * @param objectPosition A vector represents the position of the target object\n   * @param objectRadius The radius of the object\n   * @param target The result direction will be contained in this vector\n   */\n  public abstract calculateCollision(\n    colliderMatrix: THREE.Matrix4,\n    objectPosition: THREE.Vector3,\n    objectRadius: number,\n    target: THREE.Vector3,\n  ): number;\n}\n", "import * as THREE from 'three';\nimport { VRMSpringBoneColliderShape } from './VRMSpringBoneColliderShape';\n\nexport class VRMSpringBoneColliderShapeSphere extends VRMSpringBoneColliderShape {\n  public get type(): 'sphere' {\n    return 'sphere';\n  }\n\n  /**\n   * The offset from the origin.\n   */\n  public offset: THREE.Vector3;\n\n  /**\n   * The radius.\n   */\n  public radius: number;\n\n  public constructor(params?: { radius?: number; offset?: THREE.Vector3 }) {\n    super();\n\n    this.offset = params?.offset ?? new THREE.Vector3(0.0, 0.0, 0.0);\n    this.radius = params?.radius ?? 0.0;\n  }\n\n  public calculateCollision(\n    colliderMatrix: THREE.Matrix4,\n    objectPosition: THREE.Vector3,\n    objectRadius: number,\n    target: THREE.Vector3,\n  ): number {\n    target.copy(this.offset).applyMatrix4(colliderMatrix); // transformed offset\n    target.negate().add(objectPosition); // a vector from collider center to object position\n    const radius = objectRadius + this.radius;\n    const distance = target.length() - radius;\n    target.normalize();\n    return distance;\n  }\n}\n", "import * as THREE from 'three';\nimport { VRMSpringBoneColliderShapeCapsule } from '../../VRMSpringBoneColliderShapeCapsule';\nimport { ColliderShapeBufferGeometry } from './ColliderShapeBufferGeometry';\n\nconst _v3A = new THREE.Vector3();\n\nexport class ColliderShapeCapsuleBufferGeometry extends THREE.BufferGeometry implements ColliderShapeBufferGeometry {\n  public worldScale = 1.0;\n\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n  private readonly _shape: VRMSpringBoneColliderShapeCapsule;\n  private _currentRadius = 0;\n  private readonly _currentOffset = new THREE.Vector3();\n  private readonly _currentTail = new THREE.Vector3();\n\n  public constructor(shape: VRMSpringBoneColliderShapeCapsule) {\n    super();\n\n    this._shape = shape;\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(396), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(264), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    const radius = this._shape.radius / this.worldScale;\n    if (this._currentRadius !== radius) {\n      this._currentRadius = radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (!this._currentOffset.equals(this._shape.offset)) {\n      this._currentOffset.copy(this._shape.offset);\n      shouldUpdateGeometry = true;\n    }\n\n    const tail = _v3A.copy(this._shape.tail).divideScalar(this.worldScale);\n    if (this._currentTail.distanceToSquared(tail) > 1e-10) {\n      this._currentTail.copy(tail);\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    _v3A.copy(this._currentTail).sub(this._currentOffset);\n    const l = _v3A.length() / this._currentRadius;\n\n    for (let i = 0; i <= 16; i++) {\n      const t = (i / 16.0) * Math.PI;\n\n      this._attrPos.setXYZ(i, -Math.sin(t), -Math.cos(t), 0.0);\n      this._attrPos.setXYZ(17 + i, l + Math.sin(t), Math.cos(t), 0.0);\n      this._attrPos.setXYZ(34 + i, -Math.sin(t), 0.0, -Math.cos(t));\n      this._attrPos.setXYZ(51 + i, l + Math.sin(t), 0.0, Math.cos(t));\n    }\n\n    for (let i = 0; i < 32; i++) {\n      const t = (i / 16.0) * Math.PI;\n      this._attrPos.setXYZ(68 + i, 0.0, Math.sin(t), Math.cos(t));\n      this._attrPos.setXYZ(100 + i, l, Math.sin(t), Math.cos(t));\n    }\n\n    const theta = Math.atan2(_v3A.y, Math.sqrt(_v3A.x * _v3A.x + _v3A.z * _v3A.z));\n    const phi = -Math.atan2(_v3A.z, _v3A.x);\n\n    this.rotateZ(theta);\n    this.rotateY(phi);\n    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);\n    this.translate(this._currentOffset.x, this._currentOffset.y, this._currentOffset.z);\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 34; i++) {\n      const i1 = (i + 1) % 34;\n\n      this._attrIndex.setXY(i * 2, i, i1);\n      this._attrIndex.setXY(68 + i * 2, 34 + i, 34 + i1);\n    }\n\n    for (let i = 0; i < 32; i++) {\n      const i1 = (i + 1) % 32;\n\n      this._attrIndex.setXY(136 + i * 2, 68 + i, 68 + i1);\n      this._attrIndex.setXY(200 + i * 2, 100 + i, 100 + i1);\n    }\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n", "import * as THREE from 'three';\nimport { VRMSpringBoneColliderShapeSphere } from '../../VRMSpringBoneColliderShapeSphere';\nimport { ColliderShapeBufferGeometry } from './ColliderShapeBufferGeometry';\n\nexport class ColliderShapeSphereBufferGeometry extends THREE.BufferGeometry implements ColliderShapeBufferGeometry {\n  public worldScale = 1.0;\n\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n  private readonly _shape: VRMSpringBoneColliderShapeSphere;\n  private _currentRadius = 0;\n  private readonly _currentOffset = new THREE.Vector3();\n\n  public constructor(shape: VRMSpringBoneColliderShapeSphere) {\n    super();\n\n    this._shape = shape;\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(32 * 3 * 3), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(64 * 3), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    const radius = this._shape.radius / this.worldScale;\n    if (this._currentRadius !== radius) {\n      this._currentRadius = radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (!this._currentOffset.equals(this._shape.offset)) {\n      this._currentOffset.copy(this._shape.offset);\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    for (let i = 0; i < 32; i++) {\n      const t = (i / 16.0) * Math.PI;\n\n      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0.0);\n      this._attrPos.setXYZ(32 + i, 0.0, Math.cos(t), Math.sin(t));\n      this._attrPos.setXYZ(64 + i, Math.sin(t), 0.0, Math.cos(t));\n    }\n\n    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);\n    this.translate(this._currentOffset.x, this._currentOffset.y, this._currentOffset.z);\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 32; i++) {\n      const i1 = (i + 1) % 32;\n\n      this._attrIndex.setXY(i * 2, i, i1);\n      this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);\n      this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);\n    }\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n", "import * as THREE from 'three';\nimport { VRMSpringBoneJoint } from '../VRMSpringBoneJoint';\nimport { SpringBoneBufferGeometry } from './utils/SpringBoneBufferGeometry';\n\nconst _v3A = new THREE.Vector3();\n\nexport class VRMSpringBoneJointHelper extends THREE.Group {\n  public readonly springBone: VRMSpringBoneJoint;\n  private readonly _geometry: SpringBoneBufferGeometry;\n  private readonly _line: THREE.LineSegments;\n\n  public constructor(springBone: VRMSpringBoneJoint) {\n    super();\n    this.matrixAutoUpdate = false;\n\n    this.springBone = springBone;\n\n    this._geometry = new SpringBoneBufferGeometry(this.springBone);\n\n    const material = new THREE.LineBasicMaterial({\n      color: 0xffff00,\n      depthTest: false,\n      depthWrite: false,\n    });\n\n    this._line = new THREE.LineSegments(this._geometry, material);\n    this.add(this._line);\n  }\n\n  public dispose(): void {\n    this._geometry.dispose();\n  }\n\n  public updateMatrixWorld(force: boolean): void {\n    this.springBone.bone.updateWorldMatrix(true, false);\n\n    this.matrix.copy(this.springBone.bone.matrixWorld);\n\n    const matrixWorldElements = this.matrix.elements;\n    this._geometry.worldScale = _v3A\n      .set(matrixWorldElements[0], matrixWorldElements[1], matrixWorldElements[2])\n      .length(); // calculate scale of x component\n\n    this._geometry.update();\n\n    super.updateMatrixWorld(force);\n  }\n}\n", "import * as THREE from 'three';\nimport { VRMSpringBoneJoint } from '../../VRMSpringBoneJoint';\n\nexport class SpringBoneBufferGeometry extends THREE.BufferGeometry {\n  public worldScale = 1.0;\n\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n  private readonly _springBone: VRMSpringBoneJoint;\n  private _currentRadius = 0;\n  private readonly _currentTail = new THREE.Vector3();\n\n  public constructor(springBone: VRMSpringBoneJoint) {\n    super();\n\n    this._springBone = springBone;\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(294), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(194), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    const radius = this._springBone.settings.hitRadius / this.worldScale;\n    if (this._currentRadius !== radius) {\n      this._currentRadius = radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (!this._currentTail.equals(this._springBone.initialLocalChildPosition)) {\n      this._currentTail.copy(this._springBone.initialLocalChildPosition);\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    for (let i = 0; i < 32; i++) {\n      const t = (i / 16.0) * Math.PI;\n\n      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0.0);\n      this._attrPos.setXYZ(32 + i, 0.0, Math.cos(t), Math.sin(t));\n      this._attrPos.setXYZ(64 + i, Math.sin(t), 0.0, Math.cos(t));\n    }\n\n    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);\n    this.translate(this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.setXYZ(96, 0, 0, 0);\n    this._attrPos.setXYZ(97, this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 32; i++) {\n      const i1 = (i + 1) % 32;\n\n      this._attrIndex.setXY(i * 2, i, i1);\n      this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);\n      this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);\n    }\n    this._attrIndex.setXY(192, 96, 97);\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n", "import * as THREE from 'three';\nimport type { VRMSpringBoneColliderShape } from './VRMSpringBoneColliderShape';\n\n/**\n * Represents a collider of a VRM.\n */\nexport class VRMSpringBoneCollider extends THREE.Object3D {\n  /**\n   * The shape of the collider.\n   */\n  public readonly shape: VRMSpringBoneColliderShape;\n\n  public constructor(shape: VRMSpringBoneColliderShape) {\n    super();\n\n    this.shape = shape;\n  }\n}\n", "import * as THREE from 'three';\nimport { mat4InvertCompat } from './utils/mat4InvertCompat';\nimport { Matrix4InverseCache } from './utils/Matrix4InverseCache';\nimport type { VRMSpringBoneColliderGroup } from './VRMSpringBoneColliderGroup';\nimport type { VRMSpringBoneJointSettings } from './VRMSpringBoneJointSettings';\n\n// based on\n// http://rocketjump.skr.jp/unity3d/109/\n// https://github.com/dwango/UniVRM/blob/master/Scripts/SpringBone/VRMSpringBone.cs\n\nconst IDENTITY_MATRIX4 = new THREE.Matrix4();\n\n// \u8A08\u7B97\u4E2D\u306E\u4E00\u6642\u4FDD\u5B58\u7528\u5909\u6570\uFF08\u4E00\u5EA6\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u3092\u4F5C\u3063\u305F\u3089\u3042\u3068\u306F\u4F7F\u3044\u56DE\u3059\uFF09\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _v3C = new THREE.Vector3();\n\n/**\n * A temporary variable which is used in `update`\n */\nconst _worldSpacePosition = new THREE.Vector3();\n\n/**\n * A temporary variable which is used in `update`\n */\nconst _centerSpacePosition = new THREE.Vector3();\n\n/**\n * A temporary variable which is used in `update`\n */\nconst _nextTail = new THREE.Vector3();\n\nconst _quatA = new THREE.Quaternion();\nconst _matA = new THREE.Matrix4();\nconst _matB = new THREE.Matrix4();\n\n/**\n * A class represents a single joint of a spring bone.\n * It should be managed by a [[VRMSpringBoneManager]].\n */\nexport class VRMSpringBoneJoint {\n  /**\n   * Settings of the bone.\n   */\n  public settings: VRMSpringBoneJointSettings;\n\n  /**\n   * Collider groups attached to this bone.\n   */\n  public colliderGroups: VRMSpringBoneColliderGroup[];\n\n  /**\n   * An Object3D attached to this bone.\n   */\n  public readonly bone: THREE.Object3D;\n\n  /**\n   * An Object3D that will be used as a tail of this spring bone.\n   * It can be null when the spring bone is imported from VRM 0.0.\n   */\n  public readonly child: THREE.Object3D | null;\n\n  /**\n   * Current position of child tail, in center unit. Will be used for verlet integration.\n   */\n  private _currentTail = new THREE.Vector3();\n\n  /**\n   * Previous position of child tail, in center unit. Will be used for verlet integration.\n   */\n  private _prevTail = new THREE.Vector3();\n\n  /**\n   * Initial axis of the bone, in local unit.\n   */\n  private _boneAxis = new THREE.Vector3();\n\n  /**\n   * Length of the bone in world unit.\n   * Will be used for normalization in update loop, will be updated by {@link _calcWorldSpaceBoneLength}.\n   *\n   * It's same as local unit length unless there are scale transformations in the world space.\n   */\n  private _worldSpaceBoneLength = 0.0;\n\n  /**\n   * This springbone will be calculated based on the space relative from this object.\n   * If this is `null`, springbone will be calculated in world space.\n   */\n  private _center: THREE.Object3D | null = null;\n  public get center(): THREE.Object3D | null {\n    return this._center;\n  }\n  public set center(center: THREE.Object3D | null) {\n    // uninstall inverse cache\n    if (this._center?.userData.inverseCacheProxy) {\n      (this._center.userData.inverseCacheProxy as Matrix4InverseCache).revert();\n      delete this._center.userData.inverseCacheProxy;\n    }\n\n    // change the center\n    this._center = center;\n\n    // install inverse cache\n    if (this._center) {\n      if (!this._center.userData.inverseCacheProxy) {\n        this._center.userData.inverseCacheProxy = new Matrix4InverseCache(this._center.matrixWorld);\n      }\n    }\n  }\n\n  /**\n   * Initial state of the local matrix of the bone.\n   */\n  private _initialLocalMatrix = new THREE.Matrix4();\n\n  /**\n   * Initial state of the rotation of the bone.\n   */\n  private _initialLocalRotation = new THREE.Quaternion();\n\n  /**\n   * Initial state of the position of its child.\n   */\n  private _initialLocalChildPosition = new THREE.Vector3();\n  public get initialLocalChildPosition(): THREE.Vector3 {\n    return this._initialLocalChildPosition;\n  }\n\n  /**\n   * Returns the world matrix of its parent object.\n   * Note that it returns a reference to the matrix. Don't mutate this directly!\n   */\n  private get _parentMatrixWorld(): THREE.Matrix4 {\n    return this.bone.parent ? this.bone.parent.matrixWorld : IDENTITY_MATRIX4;\n  }\n\n  /**\n   * Create a new VRMSpringBone.\n   *\n   * @param bone An Object3D that will be attached to this bone\n   * @param child An Object3D that will be used as a tail of this spring bone. It can be null when the spring bone is imported from VRM 0.0\n   * @param settings Several parameters related to behavior of the spring bone\n   * @param colliderGroups Collider groups that will be collided with this spring bone\n   */\n  constructor(\n    bone: THREE.Object3D,\n    child: THREE.Object3D | null,\n    settings: Partial<VRMSpringBoneJointSettings> = {},\n    colliderGroups: VRMSpringBoneColliderGroup[] = [],\n  ) {\n    this.bone = bone; // uniVRM\u3067\u306E parent\n    this.bone.matrixAutoUpdate = false; // update\u306B\u3088\u308A\u8A08\u7B97\u3055\u308C\u308B\u306E\u3067three.js\u5185\u3067\u306E\u81EA\u52D5\u51E6\u7406\u306F\u4E0D\u8981\n\n    this.child = child;\n\n    this.settings = {\n      hitRadius: settings.hitRadius ?? 0.0,\n      stiffness: settings.stiffness ?? 1.0,\n      gravityPower: settings.gravityPower ?? 0.0,\n      gravityDir: settings.gravityDir?.clone() ?? new THREE.Vector3(0.0, -1.0, 0.0),\n      dragForce: settings.dragForce ?? 0.4,\n    };\n\n    this.colliderGroups = colliderGroups;\n  }\n\n  /**\n   * Set the initial state of this spring bone.\n   * You might want to call {@link VRMSpringBoneManager.setInitState} instead.\n   */\n  public setInitState(): void {\n    // remember initial position of itself\n    this._initialLocalMatrix.copy(this.bone.matrix);\n    this._initialLocalRotation.copy(this.bone.quaternion);\n\n    // see initial position of its local child\n    if (this.child) {\n      this._initialLocalChildPosition.copy(this.child.position);\n    } else {\n      // vrm0 requires a 7cm fixed bone length for the final node in a chain\n      // See: https://github.com/vrm-c/vrm-specification/tree/master/specification/VRMC_springBone-1.0#about-spring-configuration\n      this._initialLocalChildPosition.copy(this.bone.position).normalize().multiplyScalar(0.07);\n    }\n\n    // copy the child position to tails\n    const matrixWorldToCenter = this._getMatrixWorldToCenter(_matA);\n    this.bone.localToWorld(this._currentTail.copy(this._initialLocalChildPosition)).applyMatrix4(matrixWorldToCenter);\n    this._prevTail.copy(this._currentTail);\n\n    // set initial states that are related to local child position\n    this._boneAxis.copy(this._initialLocalChildPosition).normalize();\n  }\n\n  /**\n   * Reset the state of this bone.\n   * You might want to call [[VRMSpringBoneManager.reset]] instead.\n   */\n  public reset(): void {\n    this.bone.quaternion.copy(this._initialLocalRotation);\n\n    // We need to update its matrixWorld manually, since we tweaked the bone by our hand\n    this.bone.updateMatrix();\n    this.bone.matrixWorld.multiplyMatrices(this._parentMatrixWorld, this.bone.matrix);\n\n    // Apply updated position to tail states\n    const matrixWorldToCenter = this._getMatrixWorldToCenter(_matA);\n    this.bone.localToWorld(this._currentTail.copy(this._initialLocalChildPosition)).applyMatrix4(matrixWorldToCenter);\n    this._prevTail.copy(this._currentTail);\n  }\n\n  /**\n   * Update the state of this bone.\n   * You might want to call [[VRMSpringBoneManager.update]] instead.\n   *\n   * @param delta deltaTime\n   */\n  public update(delta: number): void {\n    if (delta <= 0) return;\n\n    // Update the _worldSpaceBoneLength\n    this._calcWorldSpaceBoneLength();\n\n    // Get bone position in center space\n    _worldSpacePosition.setFromMatrixPosition(this.bone.matrixWorld);\n    let matrixWorldToCenter = this._getMatrixWorldToCenter(_matA);\n    _centerSpacePosition.copy(_worldSpacePosition).applyMatrix4(matrixWorldToCenter);\n    const quatWorldToCenter = _quatA.setFromRotationMatrix(matrixWorldToCenter);\n\n    // Get parent matrix in center space\n    const centerSpaceParentMatrix = _matB.copy(matrixWorldToCenter).multiply(this._parentMatrixWorld);\n\n    // Get boneAxis in center space\n    const centerSpaceBoneAxis = _v3B\n      .copy(this._boneAxis)\n      .applyMatrix4(this._initialLocalMatrix)\n      .applyMatrix4(centerSpaceParentMatrix)\n      .sub(_centerSpacePosition)\n      .normalize();\n\n    // gravity in center space\n    const centerSpaceGravity = _v3C.copy(this.settings.gravityDir).applyQuaternion(quatWorldToCenter).normalize();\n\n    const matrixCenterToWorld = this._getMatrixCenterToWorld(_matA);\n\n    // verlet\u7A4D\u5206\u3067\u6B21\u306E\u4F4D\u7F6E\u3092\u8A08\u7B97\n    _nextTail\n      .copy(this._currentTail)\n      .add(\n        _v3A\n          .copy(this._currentTail)\n          .sub(this._prevTail)\n          .multiplyScalar(1 - this.settings.dragForce),\n      ) // \u524D\u30D5\u30EC\u30FC\u30E0\u306E\u79FB\u52D5\u3092\u7D99\u7D9A\u3059\u308B(\u6E1B\u8870\u3082\u3042\u308B\u3088)\n      .add(_v3A.copy(centerSpaceBoneAxis).multiplyScalar(this.settings.stiffness * delta)) // \u89AA\u306E\u56DE\u8EE2\u306B\u3088\u308B\u5B50\u30DC\u30FC\u30F3\u306E\u79FB\u52D5\u76EE\u6A19\n      .add(_v3A.copy(centerSpaceGravity).multiplyScalar(this.settings.gravityPower * delta)) // \u5916\u529B\u306B\u3088\u308B\u79FB\u52D5\u91CF\n      .applyMatrix4(matrixCenterToWorld); // tail\u3092world space\u306B\u623B\u3059\n\n    // normalize bone length\n    _nextTail.sub(_worldSpacePosition).normalize().multiplyScalar(this._worldSpaceBoneLength).add(_worldSpacePosition);\n\n    // Collision\u3067\u79FB\u52D5\n    this._collision(_nextTail);\n\n    // update prevTail and currentTail\n    matrixWorldToCenter = this._getMatrixWorldToCenter(_matA);\n\n    this._prevTail.copy(this._currentTail);\n    this._currentTail.copy(_v3A.copy(_nextTail).applyMatrix4(matrixWorldToCenter));\n\n    // Apply rotation, convert vector3 thing into actual quaternion\n    // Original UniVRM is doing center unit calculus at here but we're gonna do this on local unit\n    const worldSpaceInitialMatrixInv = mat4InvertCompat(\n      _matA.copy(this._parentMatrixWorld).multiply(this._initialLocalMatrix),\n    );\n    const applyRotation = _quatA.setFromUnitVectors(\n      this._boneAxis,\n      _v3A.copy(_nextTail).applyMatrix4(worldSpaceInitialMatrixInv).normalize(),\n    );\n\n    this.bone.quaternion.copy(this._initialLocalRotation).multiply(applyRotation);\n\n    // We need to update its matrixWorld manually, since we tweaked the bone by our hand\n    this.bone.updateMatrix();\n    this.bone.matrixWorld.multiplyMatrices(this._parentMatrixWorld, this.bone.matrix);\n  }\n\n  /**\n   * Do collision math against every colliders attached to this bone.\n   *\n   * @param tail The tail you want to process\n   */\n  private _collision(tail: THREE.Vector3): void {\n    this.colliderGroups.forEach((colliderGroup) => {\n      colliderGroup.colliders.forEach((collider) => {\n        const dist = collider.shape.calculateCollision(collider.matrixWorld, tail, this.settings.hitRadius, _v3A);\n\n        if (dist < 0.0) {\n          // hit\n          tail.add(_v3A.multiplyScalar(-dist));\n\n          // normalize bone length\n          tail.sub(_worldSpacePosition).normalize().multiplyScalar(this._worldSpaceBoneLength).add(_worldSpacePosition);\n        }\n      });\n    });\n  }\n\n  /**\n   * Calculate the {@link _worldSpaceBoneLength}.\n   * Intended to be used in {@link update}.\n   */\n  private _calcWorldSpaceBoneLength(): void {\n    _v3A.setFromMatrixPosition(this.bone.matrixWorld); // get world position of this.bone\n\n    if (this.child) {\n      _v3B.setFromMatrixPosition(this.child.matrixWorld); // get world position of this.child\n    } else {\n      _v3B.copy(this._initialLocalChildPosition);\n      _v3B.applyMatrix4(this.bone.matrixWorld);\n    }\n\n    this._worldSpaceBoneLength = _v3A.sub(_v3B).length();\n  }\n\n  /**\n   * Create a matrix that converts center space into world space.\n   * @param target Target matrix\n   */\n  private _getMatrixCenterToWorld(target: THREE.Matrix4): THREE.Matrix4 {\n    if (this._center) {\n      target.copy(this._center.matrixWorld);\n    } else {\n      target.identity();\n    }\n\n    return target;\n  }\n\n  /**\n   * Create a matrix that converts world space into center space.\n   * @param target Target matrix\n   */\n  private _getMatrixWorldToCenter(target: THREE.Matrix4): THREE.Matrix4 {\n    if (this._center) {\n      target.copy((this._center.userData.inverseCacheProxy as Matrix4InverseCache).inverse);\n    } else {\n      target.identity();\n    }\n\n    return target;\n  }\n}\n", "import * as THREE from 'three';\n\nconst _matA = new THREE.Matrix4();\n\n/**\n * A compat function for `Matrix4.invert()` / `Matrix4.getInverse()`.\n * `Matrix4.invert()` is introduced in r123 and `Matrix4.getInverse()` emits a warning.\n * We are going to use this compat for a while.\n * @param target A target matrix\n */\nexport function mat4InvertCompat<T extends THREE.Matrix4>(target: T): T {\n  if ((target as any).invert) {\n    target.invert();\n  } else {\n    (target as any).getInverse(_matA.copy(target));\n  }\n\n  return target;\n}\n", "import * as THREE from 'three';\nimport { mat4InvertCompat } from './mat4InvertCompat';\n\nexport class Matrix4InverseCache {\n  /**\n   * The target matrix.\n   */\n  public readonly matrix: THREE.Matrix4;\n\n  /**\n   * A cache of inverse of current matrix.\n   */\n  private readonly _inverseCache = new THREE.Matrix4();\n\n  /**\n   * A flag that makes it want to recalculate its {@link _inverseCache}.\n   * Will be set `true` when `elements` are mutated and be used in `getInverse`.\n   */\n  private _shouldUpdateInverse = true;\n\n  /**\n   * The original of `matrix.elements`\n   */\n  private readonly _originalElements: number[];\n\n  /**\n   * Inverse of given matrix.\n   * Note that it will return its internal private instance.\n   * Make sure copying this before mutate this.\n   */\n  public get inverse(): THREE.Matrix4 {\n    if (this._shouldUpdateInverse) {\n      this._inverseCache.copy(this.matrix);\n      mat4InvertCompat(this._inverseCache);\n      this._shouldUpdateInverse = false;\n    }\n\n    return this._inverseCache;\n  }\n\n  public constructor(matrix: THREE.Matrix4) {\n    this.matrix = matrix;\n\n    const handler: ProxyHandler<number[]> = {\n      set: (obj, prop: any, newVal) => {\n        this._shouldUpdateInverse = true;\n        obj[prop] = newVal;\n\n        return true;\n      },\n    };\n\n    this._originalElements = matrix.elements;\n    matrix.elements = new Proxy(matrix.elements, handler);\n  }\n\n  public revert(): void {\n    this.matrix.elements = this._originalElements;\n  }\n}\n", "import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1SpringBoneSchema from '@pixiv/types-vrmc-springbone-1.0';\nimport * as THREE from 'three';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { VRMSpringBoneColliderHelper, VRMSpringBoneJointHelper } from './helpers';\nimport { VRMSpringBoneCollider } from './VRMSpringBoneCollider';\nimport type { VRMSpringBoneColliderGroup } from './VRMSpringBoneColliderGroup';\nimport { VRMSpringBoneColliderShapeCapsule } from './VRMSpringBoneColliderShapeCapsule';\nimport { VRMSpringBoneColliderShapeSphere } from './VRMSpringBoneColliderShapeSphere';\nimport { VRMSpringBoneJoint } from './VRMSpringBoneJoint';\nimport type { VRMSpringBoneLoaderPluginOptions } from './VRMSpringBoneLoaderPluginOptions';\nimport { VRMSpringBoneManager } from './VRMSpringBoneManager';\nimport type { VRMSpringBoneJointSettings } from './VRMSpringBoneJointSettings';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\nexport class VRMSpringBoneLoaderPlugin implements GLTFLoaderPlugin {\n  public static readonly EXTENSION_NAME = 'VRMC_springBone';\n\n  /**\n   * Specify an Object3D to add {@link VRMSpringBoneJointHelper} s.\n   * If not specified, helper will not be created.\n   * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .\n   */\n  public jointHelperRoot?: THREE.Object3D;\n\n  /**\n   * Specify an Object3D to add {@link VRMSpringBoneJointHelper} s.\n   * If not specified, helper will not be created.\n   * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .\n   */\n  public colliderHelperRoot?: THREE.Object3D;\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    return VRMSpringBoneLoaderPlugin.EXTENSION_NAME;\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMSpringBoneLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.jointHelperRoot = options?.jointHelperRoot;\n    this.colliderHelperRoot = options?.colliderHelperRoot;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmSpringBoneManager = await this._import(gltf);\n  }\n\n  /**\n   * Import spring bones from a GLTF and return a {@link VRMSpringBoneManager}.\n   * It might return `null` instead when it does not need to be created or something go wrong.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  private async _import(gltf: GLTF): Promise<VRMSpringBoneManager | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result != null) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result != null) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRMSpringBoneManager | null> {\n    const json = gltf.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use spring bones\n    const isSpringBoneUsed = json.extensionsUsed?.indexOf(VRMSpringBoneLoaderPlugin.EXTENSION_NAME) !== -1;\n    if (!isSpringBoneUsed) {\n      return null;\n    }\n\n    const manager = new VRMSpringBoneManager();\n\n    const threeNodes: THREE.Object3D[] = await gltf.parser.getDependencies('node');\n\n    const extension = json.extensions?.[VRMSpringBoneLoaderPlugin.EXTENSION_NAME] as\n      | V1SpringBoneSchema.VRMCSpringBone\n      | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(\n        `VRMSpringBoneLoaderPlugin: Unknown ${VRMSpringBoneLoaderPlugin.EXTENSION_NAME} specVersion \"${specVersion}\"`,\n      );\n      return null;\n    }\n\n    const colliders = extension.colliders?.map((schemaCollider, iCollider) => {\n      const node = threeNodes[schemaCollider.node!];\n      const schemaShape = schemaCollider.shape!;\n\n      if (schemaShape.sphere) {\n        return this._importSphereCollider(node, {\n          offset: new THREE.Vector3().fromArray(schemaShape.sphere.offset ?? [0.0, 0.0, 0.0]),\n          radius: schemaShape.sphere.radius ?? 0.0,\n        });\n      } else if (schemaShape.capsule) {\n        return this._importCapsuleCollider(node, {\n          offset: new THREE.Vector3().fromArray(schemaShape.capsule.offset ?? [0.0, 0.0, 0.0]),\n          radius: schemaShape.capsule.radius ?? 0.0,\n          tail: new THREE.Vector3().fromArray(schemaShape.capsule.tail ?? [0.0, 0.0, 0.0]),\n        });\n      }\n\n      throw new Error(`VRMSpringBoneLoaderPlugin: The collider #${iCollider} has no valid shape`);\n    });\n\n    const colliderGroups = extension.colliderGroups?.map(\n      (schemaColliderGroup, iColliderGroup): VRMSpringBoneColliderGroup => {\n        const cols = (schemaColliderGroup.colliders ?? []).map((iCollider) => {\n          const col = colliders?.[iCollider];\n\n          if (col == null) {\n            throw new Error(\n              `VRMSpringBoneLoaderPlugin: The colliderGroup #${iColliderGroup} attempted to use a collider #${iCollider} but not found`,\n            );\n          }\n\n          return col;\n        });\n\n        return {\n          colliders: cols,\n          name: schemaColliderGroup.name,\n        };\n      },\n    );\n\n    extension.springs?.forEach((schemaSpring, iSpring) => {\n      const schemaJoints = schemaSpring.joints;\n\n      // prepare colliders\n      const colliderGroupsForSpring = schemaSpring.colliderGroups?.map((iColliderGroup) => {\n        const group = colliderGroups?.[iColliderGroup];\n\n        if (group == null) {\n          throw new Error(\n            `VRMSpringBoneLoaderPlugin: The spring #${iSpring} attempted to use a colliderGroup ${iColliderGroup} but not found`,\n          );\n        }\n\n        return group;\n      });\n\n      const center = schemaSpring.center != null ? threeNodes[schemaSpring.center] : undefined;\n\n      let prevSchemaJoint: V1SpringBoneSchema.SpringBoneJoint | undefined;\n      schemaJoints.forEach((schemaJoint) => {\n        if (prevSchemaJoint) {\n          // prepare node\n          const nodeIndex = prevSchemaJoint.node;\n          const node = threeNodes[nodeIndex];\n          const childIndex = schemaJoint.node;\n          const child = threeNodes[childIndex];\n\n          // prepare setting\n          const setting: Partial<VRMSpringBoneJointSettings> = {\n            hitRadius: prevSchemaJoint.hitRadius,\n            dragForce: prevSchemaJoint.dragForce,\n            gravityPower: prevSchemaJoint.gravityPower,\n            stiffness: prevSchemaJoint.stiffness,\n            gravityDir:\n              prevSchemaJoint.gravityDir != null\n                ? new THREE.Vector3().fromArray(prevSchemaJoint.gravityDir)\n                : undefined,\n          };\n\n          // create spring bones\n          const joint = this._importJoint(node, child, setting, colliderGroupsForSpring);\n          if (center) {\n            joint.center = center;\n          }\n\n          manager.addJoint(joint);\n        }\n\n        prevSchemaJoint = schemaJoint;\n      });\n    });\n\n    // init spring bones\n    manager.setInitState();\n\n    return manager;\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRMSpringBoneManager | null> {\n    const json = gltf.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRM') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    // early abort if it doesn't have bone groups\n    const extension = json.extensions?.['VRM'] as V0VRM.VRM | undefined;\n    const schemaSecondaryAnimation = extension?.secondaryAnimation;\n    if (!schemaSecondaryAnimation) {\n      return null;\n    }\n\n    const schemaBoneGroups = schemaSecondaryAnimation?.boneGroups;\n    if (!schemaBoneGroups) {\n      return null;\n    }\n\n    const manager = new VRMSpringBoneManager();\n\n    const threeNodes: THREE.Object3D[] = await gltf.parser.getDependencies('node');\n\n    const colliderGroups = schemaSecondaryAnimation.colliderGroups?.map(\n      (schemaColliderGroup): VRMSpringBoneColliderGroup => {\n        const node = threeNodes[schemaColliderGroup.node!];\n        const colliders = (schemaColliderGroup.colliders ?? []).map((schemaCollider, iCollider) => {\n          const offset = new THREE.Vector3(0.0, 0.0, 0.0);\n          if (schemaCollider.offset) {\n            offset.set(\n              schemaCollider.offset.x ?? 0.0,\n              schemaCollider.offset.y ?? 0.0,\n              schemaCollider.offset.z ? -schemaCollider.offset.z : 0.0, // z is opposite in VRM0.0\n            );\n          }\n\n          return this._importSphereCollider(node, {\n            offset,\n            radius: schemaCollider.radius ?? 0.0,\n          });\n        });\n\n        return { colliders };\n      },\n    );\n\n    // import spring bones for each spring bone groups\n    schemaBoneGroups?.forEach((schemaBoneGroup, iBoneGroup) => {\n      const rootIndices = schemaBoneGroup.bones;\n      if (!rootIndices) {\n        return;\n      }\n\n      rootIndices.forEach((rootIndex) => {\n        const root = threeNodes[rootIndex];\n\n        // prepare setting\n        const gravityDir = new THREE.Vector3();\n        if (schemaBoneGroup.gravityDir) {\n          gravityDir.set(\n            schemaBoneGroup.gravityDir.x ?? 0.0,\n            schemaBoneGroup.gravityDir.y ?? 0.0,\n            schemaBoneGroup.gravityDir.z ?? 0.0,\n          );\n        } else {\n          gravityDir.set(0.0, -1.0, 0.0);\n        }\n\n        const center = schemaBoneGroup.center != null ? threeNodes[schemaBoneGroup.center] : undefined;\n\n        const setting: Partial<VRMSpringBoneJointSettings> = {\n          hitRadius: schemaBoneGroup.hitRadius,\n          dragForce: schemaBoneGroup.dragForce,\n          gravityPower: schemaBoneGroup.gravityPower,\n          stiffness: schemaBoneGroup.stiffiness,\n          gravityDir,\n        };\n\n        // prepare colliders\n        const colliderGroupsForSpring = schemaBoneGroup.colliderGroups?.map((iColliderGroup) => {\n          const group = colliderGroups?.[iColliderGroup];\n\n          if (group == null) {\n            throw new Error(\n              `VRMSpringBoneLoaderPlugin: The spring #${iBoneGroup} attempted to use a colliderGroup ${iColliderGroup} but not found`,\n            );\n          }\n\n          return group;\n        });\n\n        // create spring bones\n        root.traverse((node) => {\n          const child: THREE.Object3D | null = node.children[0] ?? null;\n\n          const joint = this._importJoint(node, child, setting, colliderGroupsForSpring);\n          if (center) {\n            joint.center = center;\n          }\n\n          manager.addJoint(joint);\n        });\n      });\n    });\n\n    // init spring bones\n    gltf.scene.updateMatrixWorld();\n    manager.setInitState();\n\n    return manager;\n  }\n\n  private _importJoint(\n    node: THREE.Object3D,\n    child: THREE.Object3D,\n    setting?: Partial<VRMSpringBoneJointSettings>,\n    colliderGroupsForSpring?: VRMSpringBoneColliderGroup[],\n  ): VRMSpringBoneJoint {\n    const springBone = new VRMSpringBoneJoint(node, child, setting, colliderGroupsForSpring);\n\n    if (this.jointHelperRoot) {\n      const helper = new VRMSpringBoneJointHelper(springBone);\n      this.jointHelperRoot.add(helper);\n      helper.renderOrder = this.jointHelperRoot.renderOrder;\n    }\n\n    return springBone;\n  }\n\n  private _importSphereCollider(\n    destination: THREE.Object3D,\n    params: {\n      offset: THREE.Vector3;\n      radius: number;\n    },\n  ): VRMSpringBoneCollider {\n    const { offset, radius } = params;\n\n    const shape = new VRMSpringBoneColliderShapeSphere({ offset, radius });\n\n    const collider = new VRMSpringBoneCollider(shape);\n\n    destination.add(collider);\n\n    if (this.colliderHelperRoot) {\n      const helper = new VRMSpringBoneColliderHelper(collider);\n      this.colliderHelperRoot.add(helper);\n      helper.renderOrder = this.colliderHelperRoot.renderOrder;\n    }\n\n    return collider;\n  }\n\n  private _importCapsuleCollider(\n    destination: THREE.Object3D,\n    params: {\n      offset: THREE.Vector3;\n      radius: number;\n      tail: THREE.Vector3;\n    },\n  ): VRMSpringBoneCollider {\n    const { offset, radius, tail } = params;\n\n    const shape = new VRMSpringBoneColliderShapeCapsule({ offset, radius, tail });\n\n    const collider = new VRMSpringBoneCollider(shape);\n\n    destination.add(collider);\n\n    if (this.colliderHelperRoot) {\n      const helper = new VRMSpringBoneColliderHelper(collider);\n      this.colliderHelperRoot.add(helper);\n      helper.renderOrder = this.colliderHelperRoot.renderOrder;\n    }\n\n    return collider;\n  }\n}\n", "import type * as THREE from 'three';\n\nexport function traverseAncestorsFromRoot(object: THREE.Object3D, callback: (object: THREE.Object3D) => void): void {\n  const ancestors: THREE.Object3D[] = [];\n\n  let head: THREE.Object3D | null = object;\n  while (head !== null) {\n    ancestors.unshift(head);\n    head = head.parent;\n  }\n\n  ancestors.forEach((ancestor) => {\n    callback(ancestor);\n  });\n}\n", "import type * as THREE from 'three';\n\n/**\n * Traverse children of given object and execute given callback.\n * The given object itself wont be given to the callback.\n * If the return value of the callback is `true`, it will halt the traversal of its children.\n * @param object A root object\n * @param callback A callback function called for each children\n */\nexport function traverseChildrenUntilConditionMet(\n  object: THREE.Object3D,\n  callback: (object: THREE.Object3D) => boolean,\n): void {\n  object.children.forEach((child) => {\n    const result = callback(child);\n    if (!result) {\n      traverseChildrenUntilConditionMet(child, callback);\n    }\n  });\n}\n", "import type * as THREE from 'three';\nimport type { VRMSpringBoneJoint } from './VRMSpringBoneJoint';\nimport { traverseAncestorsFromRoot } from './utils/traverseAncestorsFromRoot';\nimport type { VRMSpringBoneCollider } from './VRMSpringBoneCollider';\nimport type { VRMSpringBoneColliderGroup } from './VRMSpringBoneColliderGroup';\nimport { traverseChildrenUntilConditionMet } from './utils/traverseChildrenUntilConditionMet';\n\nexport class VRMSpringBoneManager {\n  private _joints = new Set<VRMSpringBoneJoint>();\n  public get joints(): Set<VRMSpringBoneJoint> {\n    return this._joints;\n  }\n\n  /**\n   * @deprecated Use {@link joints} instead.\n   */\n  public get springBones(): Set<VRMSpringBoneJoint> {\n    console.warn('VRMSpringBoneManager: springBones is deprecated. use joints instead.');\n\n    return this._joints;\n  }\n\n  public get colliderGroups(): VRMSpringBoneColliderGroup[] {\n    const set = new Set<VRMSpringBoneColliderGroup>();\n    this._joints.forEach((springBone) => {\n      springBone.colliderGroups.forEach((colliderGroup) => {\n        set.add(colliderGroup);\n      });\n    });\n    return Array.from(set);\n  }\n\n  public get colliders(): VRMSpringBoneCollider[] {\n    const set = new Set<VRMSpringBoneCollider>();\n    this.colliderGroups.forEach((colliderGroup) => {\n      colliderGroup.colliders.forEach((collider) => {\n        set.add(collider);\n      });\n    });\n    return Array.from(set);\n  }\n\n  private _objectSpringBonesMap = new Map<THREE.Object3D, Set<VRMSpringBoneJoint>>();\n\n  public addJoint(joint: VRMSpringBoneJoint): void {\n    this._joints.add(joint);\n\n    let objectSet = this._objectSpringBonesMap.get(joint.bone);\n    if (objectSet == null) {\n      objectSet = new Set<VRMSpringBoneJoint>();\n      this._objectSpringBonesMap.set(joint.bone, objectSet);\n    }\n    objectSet.add(joint);\n  }\n\n  /**\n   * @deprecated Use {@link addJoint} instead.\n   */\n  public addSpringBone(joint: VRMSpringBoneJoint): void {\n    console.warn('VRMSpringBoneManager: addSpringBone() is deprecated. use addJoint() instead.');\n\n    this.addJoint(joint);\n  }\n\n  public deleteJoint(joint: VRMSpringBoneJoint): void {\n    this._joints.delete(joint);\n\n    const objectSet = this._objectSpringBonesMap.get(joint.bone)!;\n    objectSet.delete(joint);\n  }\n\n  /**\n   * @deprecated Use {@link deleteJoint} instead.\n   */\n  public deleteSpringBone(joint: VRMSpringBoneJoint): void {\n    console.warn('VRMSpringBoneManager: deleteSpringBone() is deprecated. use deleteJoint() instead.');\n\n    this.deleteJoint(joint);\n  }\n\n  public setInitState(): void {\n    const springBonesTried = new Set<VRMSpringBoneJoint>();\n    const springBonesDone = new Set<VRMSpringBoneJoint>();\n    const objectUpdated = new Set<THREE.Object3D>();\n\n    for (const springBone of this._joints) {\n      this._processSpringBone(springBone, springBonesTried, springBonesDone, objectUpdated, (springBone) =>\n        springBone.setInitState(),\n      );\n    }\n  }\n\n  public reset(): void {\n    const springBonesTried = new Set<VRMSpringBoneJoint>();\n    const springBonesDone = new Set<VRMSpringBoneJoint>();\n    const objectUpdated = new Set<THREE.Object3D>();\n\n    for (const springBone of this._joints) {\n      this._processSpringBone(springBone, springBonesTried, springBonesDone, objectUpdated, (springBone) =>\n        springBone.reset(),\n      );\n    }\n  }\n\n  public update(delta: number): void {\n    const springBonesTried = new Set<VRMSpringBoneJoint>();\n    const springBonesDone = new Set<VRMSpringBoneJoint>();\n    const objectUpdated = new Set<THREE.Object3D>();\n\n    for (const springBone of this._joints) {\n      // update the springbone\n      this._processSpringBone(springBone, springBonesTried, springBonesDone, objectUpdated, (springBone) =>\n        springBone.update(delta),\n      );\n\n      // update children world matrices\n      // it is required when the spring bone chain is sparse\n      traverseChildrenUntilConditionMet(springBone.bone, (object) => {\n        // if the object has attached springbone, halt the traversal\n        if ((this._objectSpringBonesMap.get(object)?.size ?? 0) > 0) {\n          return true;\n        }\n\n        // otherwise update its world matrix\n        object.updateWorldMatrix(false, false);\n        return false;\n      });\n    }\n  }\n\n  /**\n   * Update a spring bone.\n   * If there are other spring bone that are dependant, it will try to update them recursively.\n   * It updates matrixWorld of all ancestors and myself.\n   * It might throw an error if there are circular dependencies.\n   *\n   * Intended to be used in {@link update} and {@link _processSpringBone} itself recursively.\n   *\n   * @param springBone A springBone you want to update\n   * @param springBonesTried Set of springBones that are already tried to be updated\n   * @param springBonesDone Set of springBones that are already up to date\n   * @param objectUpdated Set of object3D whose matrixWorld is updated\n   */\n  private _processSpringBone(\n    springBone: VRMSpringBoneJoint,\n    springBonesTried: Set<VRMSpringBoneJoint>,\n    springBonesDone: Set<VRMSpringBoneJoint>,\n    objectUpdated: Set<THREE.Object3D>,\n    callback: (springBone: VRMSpringBoneJoint) => void,\n  ): void {\n    if (springBonesDone.has(springBone)) {\n      return;\n    }\n\n    if (springBonesTried.has(springBone)) {\n      throw new Error('VRMSpringBoneManager: Circular dependency detected while updating springbones');\n    }\n    springBonesTried.add(springBone);\n\n    const depObjects = this._getDependencies(springBone);\n    for (const depObject of depObjects) {\n      traverseAncestorsFromRoot(depObject, (depObjectAncestor) => {\n        const objectSet = this._objectSpringBonesMap.get(depObjectAncestor);\n        if (objectSet) {\n          for (const depSpringBone of objectSet) {\n            this._processSpringBone(depSpringBone, springBonesTried, springBonesDone, objectUpdated, callback);\n          }\n        } else if (!objectUpdated.has(depObjectAncestor)) {\n          // update matrix of non-springbone\n          depObjectAncestor.updateWorldMatrix(false, false);\n          objectUpdated.add(depObjectAncestor);\n        }\n      });\n    }\n\n    // update my matrix\n    springBone.bone.updateMatrix();\n    springBone.bone.updateWorldMatrix(false, false);\n\n    callback(springBone);\n\n    objectUpdated.add(springBone.bone);\n\n    springBonesDone.add(springBone);\n  }\n\n  /**\n   * Return a set of objects that are dependant of given spring bone.\n   * @param springBone A spring bone\n   * @return A set of objects that are dependant of given spring bone\n   */\n  private _getDependencies(springBone: VRMSpringBoneJoint): Set<THREE.Object3D> {\n    const set = new Set<THREE.Object3D>();\n\n    const parent = springBone.bone.parent;\n    if (parent) {\n      set.add(parent);\n    }\n\n    springBone.colliderGroups.forEach((colliderGroup) => {\n      colliderGroup.colliders.forEach((collider) => {\n        set.add(collider);\n      });\n    });\n\n    return set;\n  }\n}\n"],
  "mappings": "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",
  "names": ["THREE", "THREE", "THREE", "_v3A", "THREE", "_v3A", "THREE", "THREE", "_v3A", "THREE", "THREE", "THREE", "THREE", "_v3A", "_v3B", "_matA", "THREE", "springBone", "_a", "_b", "_c", "_d", "_e"]
}
