@zephyr3d/scene 0.7.0 → 0.8.0

package/dist/animation/ik/ik_track.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ik_track.js","sources":["../../../src/animation/ik/ik_track.ts"],"sourcesContent":["import { Quaternion } from '@zephyr3d/base';\r\nimport { AnimationTrack } from '../animationtrack';\r\nimport type { FABRIKSolver } from './fabrik_solver';\r\n\r\n/**\r\n * IK animation track state.\r\n *\r\n * Represents the rotations of all joints in an IK chain at a specific time.\r\n */\r\ninterface IKState {\r\n  /** Array of joint rotations (one per joint, excluding end effector) */\r\n  rotations: Quaternion[];\r\n}\r\n\r\n/**\r\n * Animation track that applies IK solving.\r\n *\r\n * @remarks\r\n * This track integrates IK solving into the animation system, allowing\r\n * IK to be blended with other animations. The track solves the IK chain\r\n * each frame and produces joint rotations that can be mixed with other\r\n * animation tracks.\r\n *\r\n * @public\r\n */\r\nexport class IKTrack extends AnimationTrack<IKState> {\r\n  /** The IK solver */\r\n  private _solver: FABRIKSolver;\r\n  /** Cached state for reuse */\r\n  private _state: IKState;\r\n  /** Duration of the track (can be infinite for procedural IK) */\r\n  private _duration: number;\r\n\r\n  /**\r\n   * Create an IK animation track.\r\n   *\r\n   * @param solver - The FABRIK solver to use\r\n   * @param duration - Duration of the track in seconds (default: Infinity for procedural)\r\n   */\r\n  constructor(solver: FABRIKSolver, duration = Infinity) {\r\n    super(false);\r\n    this._solver = solver;\r\n    this._duration = duration;\r\n\r\n    // Initialize state with identity rotations\r\n    const numJoints = solver.chain.joints.length - 1; // Exclude end effector\r\n    this._state = {\r\n      rotations: Array.from({ length: numJoints }, () => new Quaternion())\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Get the IK solver.\r\n   */\r\n  get solver(): FABRIKSolver {\r\n    return this._solver;\r\n  }\r\n\r\n  /**\r\n   * Set the duration of the track.\r\n   */\r\n  setDuration(duration: number): void {\r\n    this._duration = Math.max(0, duration);\r\n  }\r\n\r\n  /**\r\n   * Calculate IK state at the given time.\r\n   *\r\n   * @remarks\r\n   * For procedural IK, the time parameter is typically ignored.\r\n   * The solver uses the current target position set externally.\r\n   */\r\n  calculateState(_target: object, _currentTime: number): IKState {\r\n    const joints = this._solver.chain.joints;\r\n\r\n    // Store current rotations as the calculated state\r\n    for (let i = 0; i < joints.length - 1; i++) {\r\n      this._state.rotations[i].set(joints[i].rotation);\r\n    }\r\n\r\n    return this._state;\r\n  }\r\n\r\n  /**\r\n   * Apply IK state to the target scene nodes.\r\n   */\r\n  applyState(_target: object, state: IKState): void {\r\n    const joints = this._solver.chain.joints;\r\n\r\n    // Apply rotations to scene nodes\r\n    for (let i = 0; i < state.rotations.length && i < joints.length - 1; i++) {\r\n      joints[i].node.rotation = state.rotations[i];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Mix two IK states using spherical interpolation.\r\n   */\r\n  mixState(a: IKState, b: IKState, t: number): IKState {\r\n    const result: IKState = {\r\n      rotations: []\r\n    };\r\n\r\n    const count = Math.min(a.rotations.length, b.rotations.length);\r\n    for (let i = 0; i < count; i++) {\r\n      result.rotations.push(Quaternion.slerp(a.rotations[i], b.rotations[i], t));\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Get the blend identifier for this track.\r\n   *\r\n   * IK tracks with the same root joint can be blended together.\r\n   */\r\n  getBlendId(): string {\r\n    const rootNode = this._solver.chain.root.node;\r\n    return `ik-chain-${rootNode.runtimeId}`;\r\n  }\r\n\r\n  /**\r\n   * Get the duration of this track.\r\n   */\r\n  getDuration(): number {\r\n    return this._duration;\r\n  }\r\n}\r\n"],"names":["IKTrack","AnimationTrack","solver","duration","Infinity","_solver","_duration","numJoints","chain","joints","length","_state","rotations","Array","from","Quaternion","setDuration","Math","max","calculateState","_target","_currentTime","i","set","rotation","applyState","state","node","mixState","a","b","t","result","count","min","push","slerp","getBlendId","rootNode","root","runtimeId","getDuration"],"mappings":"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"}

package/dist/animation/ik/ik_utils.js

@@ -0,0 +1,270 @@
+import { Vector3, Quaternion } from '@zephyr3d/base';
+
+/**
+ * Utility functions for IK calculations.
+ *
+ * @internal
+ */ class IKUtils {
+    /**
+   * Calculate the rotation needed to align 'from' direction to 'to' direction.
+   *
+   * @param from - Starting direction vector
+   * @param to - Target direction vector
+   * @param result - Output quaternion
+   * @returns The rotation quaternion
+   */ static fromToRotation(from, to, result) {
+        const fromNorm = Vector3.normalize(from, new Vector3());
+        const toNorm = Vector3.normalize(to, new Vector3());
+        const dot = Vector3.dot(fromNorm, toNorm);
+        // Vectors are parallel
+        if (dot >= 0.999999) {
+            return result.identity();
+        }
+        // Vectors are opposite
+        if (dot <= -0.999999) {
+            // Find an orthogonal axis
+            let axis = Vector3.cross(Vector3.axisPX(), fromNorm, new Vector3());
+            const lenSq = axis.x * axis.x + axis.y * axis.y + axis.z * axis.z;
+            if (lenSq < 0.000001) {
+                axis = Vector3.cross(Vector3.axisPY(), fromNorm, new Vector3());
+            }
+            axis.inplaceNormalize();
+            return result.fromAxisAngle(axis, Math.PI);
+        }
+        // General case
+        const axis = Vector3.cross(fromNorm, toNorm).inplaceNormalize();
+        const angle = Math.acos(dot);
+        return result.fromAxisAngle(axis, angle);
+    }
+    /**
+   * Calculate bone length between two positions.
+   *
+   * @param start - Start position
+   * @param end - End position
+   * @returns Distance between positions
+   */ static calculateBoneLength(start, end) {
+        return Vector3.distance(start, end);
+    }
+    /**
+   * Decompose a quaternion into swing and twist components around a given axis.
+   *
+   * @remarks
+   * Given a rotation Q and an axis A, decompose Q into:
+   * - Twist: rotation around A
+   * - Swing: rotation perpendicular to A
+   * Such that Q = Twist * Swing
+   *
+   * Algorithm:
+   * 1. Project Q's imaginary part onto axis to get twist component
+   * 2. Normalize to get pure twist rotation
+   * 3. Calculate swing = twist^-1 * Q
+   *
+   * @param q - The quaternion to decompose
+   * @param axis - The twist axis (must be normalized)
+   * @param outSwing - Output swing rotation
+   * @param outTwist - Output twist rotation
+   */ static decomposeSwingTwist(q, axis, outSwing, outTwist) {
+        // Project quaternion's imaginary part (xyz) onto twist axis
+        // twist quaternion = (w, (xyz · axis) * axis)
+        const dot = q.x * axis.x + q.y * axis.y + q.z * axis.z;
+        outTwist.x = axis.x * dot;
+        outTwist.y = axis.y * dot;
+        outTwist.z = axis.z * dot;
+        outTwist.w = q.w;
+        // Normalize twist quaternion
+        const twistLen = Math.sqrt(outTwist.x * outTwist.x + outTwist.y * outTwist.y + outTwist.z * outTwist.z + outTwist.w * outTwist.w);
+        if (twistLen < 0.000001) {
+            // No rotation or rotation perpendicular to axis
+            outTwist.identity();
+            outSwing.set(q);
+            return;
+        }
+        outTwist.x /= twistLen;
+        outTwist.y /= twistLen;
+        outTwist.z /= twistLen;
+        outTwist.w /= twistLen;
+        // Calculate swing: Q = Twist * Swing => Swing = Twist^-1 * Q
+        const twistInv = Quaternion.conjugate(outTwist, new Quaternion());
+        Quaternion.multiply(twistInv, q, outSwing);
+    }
+    /**
+   * Get the twist angle (in radians) from a twist quaternion around an axis.
+   *
+   * @param twist - The twist quaternion
+   * @param axis - The twist axis (must be normalized)
+   * @returns Twist angle in radians, range [-PI, PI]
+   */ static getTwistAngle(twist, axis) {
+        // For a twist quaternion around axis: twist = (cos(θ/2), sin(θ/2) * axis)
+        // We can extract the angle from the quaternion components
+        // Ensure twist is normalized
+        const len = Math.sqrt(twist.x * twist.x + twist.y * twist.y + twist.z * twist.z + twist.w * twist.w);
+        if (len < 0.000001) {
+            return 0;
+        }
+        const w = twist.w / len;
+        const halfAngle = Math.acos(Math.max(-1, Math.min(1, w)));
+        // Determine sign based on axis direction
+        const dot = twist.x * axis.x + twist.y * axis.y + twist.z * axis.z;
+        const sign = dot >= 0 ? 1 : -1;
+        return sign * 2 * halfAngle;
+    }
+    /**
+   * Create a twist quaternion from an angle and axis.
+   *
+   * @param angle - Twist angle in radians
+   * @param axis - The twist axis (must be normalized)
+   * @param result - Output quaternion
+   * @returns The twist quaternion
+   */ static createTwist(angle, axis, result) {
+        const halfAngle = angle * 0.5;
+        const s = Math.sin(halfAngle);
+        result.x = axis.x * s;
+        result.y = axis.y * s;
+        result.z = axis.z * s;
+        result.w = Math.cos(halfAngle);
+        return result;
+    }
+    /**
+   * Clamp twist angle and optionally smooth with previous twist.
+   *
+   * @param currentTwist - Current twist angle in radians
+   * @param previousTwist - Previous frame's twist angle in radians (optional)
+   * @param minTwist - Minimum allowed twist angle in radians
+   * @param maxTwist - Maximum allowed twist angle in radians
+   * @param smoothFactor - Smoothing factor [0-1], 0 = no smoothing, 1 = full smoothing
+   * @returns Clamped and smoothed twist angle
+   */ static clampAndSmoothTwist(currentTwist, previousTwist, minTwist, maxTwist, smoothFactor = 0.5) {
+        // Clamp to range
+        let clampedTwist = Math.max(minTwist, Math.min(maxTwist, currentTwist));
+        // Smooth with previous frame if available
+        if (previousTwist !== undefined && smoothFactor > 0.001) {
+            // Normalize angle difference to [-PI, PI]
+            let diff = clampedTwist - previousTwist;
+            while(diff > Math.PI){
+                diff -= 2 * Math.PI;
+            }
+            while(diff < -Math.PI){
+                diff += 2 * Math.PI;
+            }
+            // Lerp
+            clampedTwist = previousTwist + diff * (1 - smoothFactor);
+        }
+        return clampedTwist;
+    }
+    /**
+   * Calculate a look-at rotation with twist constraint using a pole vector.
+   *
+   * @remarks
+   * This creates a rotation that:
+   * 1. Aligns 'forward' direction to 'targetDir'
+   * 2. Keeps the perpendicular plane aligned with 'poleDir'
+   *
+   * This prevents unwanted twist around the bone axis by using an external
+   * reference direction (pole vector) rather than relying on previous rotations.
+   *
+   * @param forward - Current forward direction (will be aligned to targetDir)
+   * @param targetDir - Desired forward direction
+   * @param poleDir - Direction that should be in the "up" hemisphere (from joint position)
+   * @param result - Output quaternion
+   * @returns The rotation quaternion
+   */ static lookAtRotationWithPole(forward, targetDir, poleDir, result) {
+        const forwardNorm = Vector3.normalize(forward, new Vector3());
+        const targetDirNorm = Vector3.normalize(targetDir, new Vector3());
+        const poleDirNorm = Vector3.normalize(poleDir, new Vector3());
+        // First, align forward to targetDir (swing rotation)
+        const swingRotation = new Quaternion();
+        this.fromToRotation(forwardNorm, targetDirNorm, swingRotation);
+        // Calculate the "right" vector perpendicular to targetDir and poleDir
+        // This defines the plane that the bone should bend in
+        const right = Vector3.cross(targetDirNorm, poleDirNorm, new Vector3());
+        const rightLenSq = right.x * right.x + right.y * right.y + right.z * right.z;
+        // If pole is parallel to target direction, no twist correction possible
+        if (rightLenSq < 0.000001) {
+            result.set(swingRotation);
+            return result;
+        }
+        right.scaleBy(1 / Math.sqrt(rightLenSq));
+        // Calculate the "up" vector perpendicular to targetDir in the pole plane
+        const up = Vector3.cross(right, targetDirNorm, new Vector3()).inplaceNormalize();
+        // Now we need to find the twist rotation around targetDir
+        // We want the local "up" axis to align with the calculated "up" vector
+        // Get a perpendicular vector to forward in the original space
+        let originalUp = Vector3.cross(forwardNorm, Vector3.axisPY(), new Vector3());
+        const originalUpLenSq = originalUp.x * originalUp.x + originalUp.y * originalUp.y + originalUp.z * originalUp.z;
+        if (originalUpLenSq < 0.000001) {
+            originalUp = Vector3.cross(forwardNorm, Vector3.axisPX(), new Vector3());
+        }
+        originalUp.inplaceNormalize();
+        // Rotate originalUp by swing rotation to see where it ends up
+        const rotatedUp = swingRotation.transform(originalUp, new Vector3());
+        // Project rotatedUp onto the plane perpendicular to targetDir
+        const rotatedUpDot = Vector3.dot(rotatedUp, targetDirNorm);
+        const rotatedUpProj = Vector3.scale(targetDirNorm, rotatedUpDot, new Vector3());
+        const rotatedUpPerp = Vector3.sub(rotatedUp, rotatedUpProj, new Vector3());
+        const rotatedUpPerpLen = rotatedUpPerp.magnitude;
+        if (rotatedUpPerpLen < 0.000001) {
+            result.set(swingRotation);
+            return result;
+        }
+        rotatedUpPerp.scaleBy(1 / rotatedUpPerpLen);
+        // Calculate twist rotation to align rotatedUpPerp with up
+        const twistRotation = new Quaternion();
+        this.fromToRotation(rotatedUpPerp, up, twistRotation);
+        // Combine swing and twist
+        return Quaternion.multiply(twistRotation, swingRotation, result);
+    }
+    /**
+   * Calculate a look-at rotation with twist constraint.
+   *
+   * @remarks
+   * This creates a rotation that:
+   * 1. Aligns 'forward' direction to 'targetDir'
+   * 2. Keeps 'up' direction as close as possible to 'targetUp'
+   *
+   * This prevents unwanted twist around the bone axis.
+   *
+   * @param forward - Current forward direction (will be aligned to targetDir)
+   * @param targetDir - Desired forward direction
+   * @param up - Current up direction (perpendicular to forward)
+   * @param targetUp - Desired up direction (will be projected perpendicular to targetDir)
+   * @param result - Output quaternion
+   * @returns The rotation quaternion
+   */ static lookAtRotation(forward, targetDir, up, targetUp, result) {
+        const forwardNorm = Vector3.normalize(forward, new Vector3());
+        const targetDirNorm = Vector3.normalize(targetDir, new Vector3());
+        // First, align forward to targetDir (swing rotation)
+        const swingRotation = new Quaternion();
+        this.fromToRotation(forwardNorm, targetDirNorm, swingRotation);
+        // Rotate the up vector by swing rotation
+        const rotatedUp = swingRotation.transform(up, new Vector3());
+        // Project targetUp onto plane perpendicular to targetDir
+        const dot = Vector3.dot(targetUp, targetDirNorm);
+        const projection = Vector3.scale(targetDirNorm, dot, new Vector3());
+        const targetUpPerp = Vector3.sub(targetUp, projection, new Vector3());
+        const targetUpPerpLen = targetUpPerp.magnitude;
+        // If targetUp is parallel to targetDir, no twist correction needed
+        if (targetUpPerpLen < 0.000001) {
+            result.set(swingRotation);
+            return result;
+        }
+        targetUpPerp.scaleBy(1 / targetUpPerpLen);
+        // Project rotatedUp onto the same plane
+        const rotatedUpDot = Vector3.dot(rotatedUp, targetDirNorm);
+        const rotatedUpProj = Vector3.scale(targetDirNorm, rotatedUpDot, new Vector3());
+        const rotatedUpPerp = Vector3.sub(rotatedUp, rotatedUpProj, new Vector3());
+        const rotatedUpPerpLen = rotatedUpPerp.magnitude;
+        if (rotatedUpPerpLen < 0.000001) {
+            result.set(swingRotation);
+            return result;
+        }
+        rotatedUpPerp.scaleBy(1 / rotatedUpPerpLen);
+        // Calculate twist rotation around targetDir
+        const twistRotation = new Quaternion();
+        this.fromToRotation(rotatedUpPerp, targetUpPerp, twistRotation);
+        // Combine swing and twist
+        return Quaternion.multiply(twistRotation, swingRotation, result);
+    }
+}
+
+export { IKUtils };
+//# sourceMappingURL=ik_utils.js.map

package/dist/animation/ik/ik_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ik_utils.js","sources":["../../../src/animation/ik/ik_utils.ts"],"sourcesContent":["import { Vector3, Quaternion } from '@zephyr3d/base';\r\n\r\n/**\r\n * Utility functions for IK calculations.\r\n *\r\n * @internal\r\n */\r\nexport class IKUtils {\r\n  /**\r\n   * Calculate the rotation needed to align 'from' direction to 'to' direction.\r\n   *\r\n   * @param from - Starting direction vector\r\n   * @param to - Target direction vector\r\n   * @param result - Output quaternion\r\n   * @returns The rotation quaternion\r\n   */\r\n  static fromToRotation(from: Vector3, to: Vector3, result: Quaternion): Quaternion {\r\n    const fromNorm = Vector3.normalize(from, new Vector3());\r\n    const toNorm = Vector3.normalize(to, new Vector3());\r\n\r\n    const dot = Vector3.dot(fromNorm, toNorm);\r\n\r\n    // Vectors are parallel\r\n    if (dot >= 0.999999) {\r\n      return result.identity();\r\n    }\r\n\r\n    // Vectors are opposite\r\n    if (dot <= -0.999999) {\r\n      // Find an orthogonal axis\r\n      let axis = Vector3.cross(Vector3.axisPX(), fromNorm, new Vector3());\r\n      const lenSq = axis.x * axis.x + axis.y * axis.y + axis.z * axis.z;\r\n      if (lenSq < 0.000001) {\r\n        axis = Vector3.cross(Vector3.axisPY(), fromNorm, new Vector3());\r\n      }\r\n      axis.inplaceNormalize();\r\n      return result.fromAxisAngle(axis, Math.PI);\r\n    }\r\n\r\n    // General case\r\n    const axis = Vector3.cross(fromNorm, toNorm).inplaceNormalize();\r\n    const angle = Math.acos(dot);\r\n    return result.fromAxisAngle(axis, angle);\r\n  }\r\n\r\n  /**\r\n   * Calculate bone length between two positions.\r\n   *\r\n   * @param start - Start position\r\n   * @param end - End position\r\n   * @returns Distance between positions\r\n   */\r\n  static calculateBoneLength(start: Vector3, end: Vector3): number {\r\n    return Vector3.distance(start, end);\r\n  }\r\n\r\n  /**\r\n   * Decompose a quaternion into swing and twist components around a given axis.\r\n   *\r\n   * @remarks\r\n   * Given a rotation Q and an axis A, decompose Q into:\r\n   * - Twist: rotation around A\r\n   * - Swing: rotation perpendicular to A\r\n   * Such that Q = Twist * Swing\r\n   *\r\n   * Algorithm:\r\n   * 1. Project Q's imaginary part onto axis to get twist component\r\n   * 2. Normalize to get pure twist rotation\r\n   * 3. Calculate swing = twist^-1 * Q\r\n   *\r\n   * @param q - The quaternion to decompose\r\n   * @param axis - The twist axis (must be normalized)\r\n   * @param outSwing - Output swing rotation\r\n   * @param outTwist - Output twist rotation\r\n   */\r\n  static decomposeSwingTwist(q: Quaternion, axis: Vector3, outSwing: Quaternion, outTwist: Quaternion): void {\r\n    // Project quaternion's imaginary part (xyz) onto twist axis\r\n    // twist quaternion = (w, (xyz · axis) * axis)\r\n    const dot = q.x * axis.x + q.y * axis.y + q.z * axis.z;\r\n\r\n    outTwist.x = axis.x * dot;\r\n    outTwist.y = axis.y * dot;\r\n    outTwist.z = axis.z * dot;\r\n    outTwist.w = q.w;\r\n\r\n    // Normalize twist quaternion\r\n    const twistLen = Math.sqrt(\r\n      outTwist.x * outTwist.x + outTwist.y * outTwist.y + outTwist.z * outTwist.z + outTwist.w * outTwist.w\r\n    );\r\n\r\n    if (twistLen < 0.000001) {\r\n      // No rotation or rotation perpendicular to axis\r\n      outTwist.identity();\r\n      outSwing.set(q);\r\n      return;\r\n    }\r\n\r\n    outTwist.x /= twistLen;\r\n    outTwist.y /= twistLen;\r\n    outTwist.z /= twistLen;\r\n    outTwist.w /= twistLen;\r\n\r\n    // Calculate swing: Q = Twist * Swing => Swing = Twist^-1 * Q\r\n    const twistInv = Quaternion.conjugate(outTwist, new Quaternion());\r\n    Quaternion.multiply(twistInv, q, outSwing);\r\n  }\r\n\r\n  /**\r\n   * Get the twist angle (in radians) from a twist quaternion around an axis.\r\n   *\r\n   * @param twist - The twist quaternion\r\n   * @param axis - The twist axis (must be normalized)\r\n   * @returns Twist angle in radians, range [-PI, PI]\r\n   */\r\n  static getTwistAngle(twist: Quaternion, axis: Vector3): number {\r\n    // For a twist quaternion around axis: twist = (cos(θ/2), sin(θ/2) * axis)\r\n    // We can extract the angle from the quaternion components\r\n\r\n    // Ensure twist is normalized\r\n    const len = Math.sqrt(twist.x * twist.x + twist.y * twist.y + twist.z * twist.z + twist.w * twist.w);\r\n    if (len < 0.000001) {\r\n      return 0;\r\n    }\r\n\r\n    const w = twist.w / len;\r\n    const halfAngle = Math.acos(Math.max(-1, Math.min(1, w)));\r\n\r\n    // Determine sign based on axis direction\r\n    const dot = twist.x * axis.x + twist.y * axis.y + twist.z * axis.z;\r\n    const sign = dot >= 0 ? 1 : -1;\r\n\r\n    return sign * 2 * halfAngle;\r\n  }\r\n\r\n  /**\r\n   * Create a twist quaternion from an angle and axis.\r\n   *\r\n   * @param angle - Twist angle in radians\r\n   * @param axis - The twist axis (must be normalized)\r\n   * @param result - Output quaternion\r\n   * @returns The twist quaternion\r\n   */\r\n  static createTwist(angle: number, axis: Vector3, result: Quaternion): Quaternion {\r\n    const halfAngle = angle * 0.5;\r\n    const s = Math.sin(halfAngle);\r\n    result.x = axis.x * s;\r\n    result.y = axis.y * s;\r\n    result.z = axis.z * s;\r\n    result.w = Math.cos(halfAngle);\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Clamp twist angle and optionally smooth with previous twist.\r\n   *\r\n   * @param currentTwist - Current twist angle in radians\r\n   * @param previousTwist - Previous frame's twist angle in radians (optional)\r\n   * @param minTwist - Minimum allowed twist angle in radians\r\n   * @param maxTwist - Maximum allowed twist angle in radians\r\n   * @param smoothFactor - Smoothing factor [0-1], 0 = no smoothing, 1 = full smoothing\r\n   * @returns Clamped and smoothed twist angle\r\n   */\r\n  static clampAndSmoothTwist(\r\n    currentTwist: number,\r\n    previousTwist: number | undefined,\r\n    minTwist: number,\r\n    maxTwist: number,\r\n    smoothFactor: number = 0.5\r\n  ): number {\r\n    // Clamp to range\r\n    let clampedTwist = Math.max(minTwist, Math.min(maxTwist, currentTwist));\r\n\r\n    // Smooth with previous frame if available\r\n    if (previousTwist !== undefined && smoothFactor > 0.001) {\r\n      // Normalize angle difference to [-PI, PI]\r\n      let diff = clampedTwist - previousTwist;\r\n      while (diff > Math.PI) {\r\n        diff -= 2 * Math.PI;\r\n      }\r\n      while (diff < -Math.PI) {\r\n        diff += 2 * Math.PI;\r\n      }\r\n\r\n      // Lerp\r\n      clampedTwist = previousTwist + diff * (1 - smoothFactor);\r\n    }\r\n\r\n    return clampedTwist;\r\n  }\r\n\r\n  /**\r\n   * Calculate a look-at rotation with twist constraint using a pole vector.\r\n   *\r\n   * @remarks\r\n   * This creates a rotation that:\r\n   * 1. Aligns 'forward' direction to 'targetDir'\r\n   * 2. Keeps the perpendicular plane aligned with 'poleDir'\r\n   *\r\n   * This prevents unwanted twist around the bone axis by using an external\r\n   * reference direction (pole vector) rather than relying on previous rotations.\r\n   *\r\n   * @param forward - Current forward direction (will be aligned to targetDir)\r\n   * @param targetDir - Desired forward direction\r\n   * @param poleDir - Direction that should be in the \"up\" hemisphere (from joint position)\r\n   * @param result - Output quaternion\r\n   * @returns The rotation quaternion\r\n   */\r\n  static lookAtRotationWithPole(\r\n    forward: Vector3,\r\n    targetDir: Vector3,\r\n    poleDir: Vector3,\r\n    result: Quaternion\r\n  ): Quaternion {\r\n    const forwardNorm = Vector3.normalize(forward, new Vector3());\r\n    const targetDirNorm = Vector3.normalize(targetDir, new Vector3());\r\n    const poleDirNorm = Vector3.normalize(poleDir, new Vector3());\r\n\r\n    // First, align forward to targetDir (swing rotation)\r\n    const swingRotation = new Quaternion();\r\n    this.fromToRotation(forwardNorm, targetDirNorm, swingRotation);\r\n\r\n    // Calculate the \"right\" vector perpendicular to targetDir and poleDir\r\n    // This defines the plane that the bone should bend in\r\n    const right = Vector3.cross(targetDirNorm, poleDirNorm, new Vector3());\r\n    const rightLenSq = right.x * right.x + right.y * right.y + right.z * right.z;\r\n\r\n    // If pole is parallel to target direction, no twist correction possible\r\n    if (rightLenSq < 0.000001) {\r\n      result.set(swingRotation);\r\n      return result;\r\n    }\r\n\r\n    right.scaleBy(1 / Math.sqrt(rightLenSq));\r\n\r\n    // Calculate the \"up\" vector perpendicular to targetDir in the pole plane\r\n    const up = Vector3.cross(right, targetDirNorm, new Vector3()).inplaceNormalize();\r\n\r\n    // Now we need to find the twist rotation around targetDir\r\n    // We want the local \"up\" axis to align with the calculated \"up\" vector\r\n\r\n    // Get a perpendicular vector to forward in the original space\r\n    let originalUp = Vector3.cross(forwardNorm, Vector3.axisPY(), new Vector3());\r\n    const originalUpLenSq =\r\n      originalUp.x * originalUp.x + originalUp.y * originalUp.y + originalUp.z * originalUp.z;\r\n    if (originalUpLenSq < 0.000001) {\r\n      originalUp = Vector3.cross(forwardNorm, Vector3.axisPX(), new Vector3());\r\n    }\r\n    originalUp.inplaceNormalize();\r\n\r\n    // Rotate originalUp by swing rotation to see where it ends up\r\n    const rotatedUp = swingRotation.transform(originalUp, new Vector3());\r\n\r\n    // Project rotatedUp onto the plane perpendicular to targetDir\r\n    const rotatedUpDot = Vector3.dot(rotatedUp, targetDirNorm);\r\n    const rotatedUpProj = Vector3.scale(targetDirNorm, rotatedUpDot, new Vector3());\r\n    const rotatedUpPerp = Vector3.sub(rotatedUp, rotatedUpProj, new Vector3());\r\n    const rotatedUpPerpLen = rotatedUpPerp.magnitude;\r\n\r\n    if (rotatedUpPerpLen < 0.000001) {\r\n      result.set(swingRotation);\r\n      return result;\r\n    }\r\n\r\n    rotatedUpPerp.scaleBy(1 / rotatedUpPerpLen);\r\n\r\n    // Calculate twist rotation to align rotatedUpPerp with up\r\n    const twistRotation = new Quaternion();\r\n    this.fromToRotation(rotatedUpPerp, up, twistRotation);\r\n\r\n    // Combine swing and twist\r\n    return Quaternion.multiply(twistRotation, swingRotation, result);\r\n  }\r\n\r\n  /**\r\n   * Calculate a look-at rotation with twist constraint.\r\n   *\r\n   * @remarks\r\n   * This creates a rotation that:\r\n   * 1. Aligns 'forward' direction to 'targetDir'\r\n   * 2. Keeps 'up' direction as close as possible to 'targetUp'\r\n   *\r\n   * This prevents unwanted twist around the bone axis.\r\n   *\r\n   * @param forward - Current forward direction (will be aligned to targetDir)\r\n   * @param targetDir - Desired forward direction\r\n   * @param up - Current up direction (perpendicular to forward)\r\n   * @param targetUp - Desired up direction (will be projected perpendicular to targetDir)\r\n   * @param result - Output quaternion\r\n   * @returns The rotation quaternion\r\n   */\r\n  static lookAtRotation(\r\n    forward: Vector3,\r\n    targetDir: Vector3,\r\n    up: Vector3,\r\n    targetUp: Vector3,\r\n    result: Quaternion\r\n  ): Quaternion {\r\n    const forwardNorm = Vector3.normalize(forward, new Vector3());\r\n    const targetDirNorm = Vector3.normalize(targetDir, new Vector3());\r\n\r\n    // First, align forward to targetDir (swing rotation)\r\n    const swingRotation = new Quaternion();\r\n    this.fromToRotation(forwardNorm, targetDirNorm, swingRotation);\r\n\r\n    // Rotate the up vector by swing rotation\r\n    const rotatedUp = swingRotation.transform(up, new Vector3());\r\n\r\n    // Project targetUp onto plane perpendicular to targetDir\r\n    const dot = Vector3.dot(targetUp, targetDirNorm);\r\n    const projection = Vector3.scale(targetDirNorm, dot, new Vector3());\r\n    const targetUpPerp = Vector3.sub(targetUp, projection, new Vector3());\r\n    const targetUpPerpLen = targetUpPerp.magnitude;\r\n\r\n    // If targetUp is parallel to targetDir, no twist correction needed\r\n    if (targetUpPerpLen < 0.000001) {\r\n      result.set(swingRotation);\r\n      return result;\r\n    }\r\n\r\n    targetUpPerp.scaleBy(1 / targetUpPerpLen);\r\n\r\n    // Project rotatedUp onto the same plane\r\n    const rotatedUpDot = Vector3.dot(rotatedUp, targetDirNorm);\r\n    const rotatedUpProj = Vector3.scale(targetDirNorm, rotatedUpDot, new Vector3());\r\n    const rotatedUpPerp = Vector3.sub(rotatedUp, rotatedUpProj, new Vector3());\r\n    const rotatedUpPerpLen = rotatedUpPerp.magnitude;\r\n\r\n    if (rotatedUpPerpLen < 0.000001) {\r\n      result.set(swingRotation);\r\n      return result;\r\n    }\r\n\r\n    rotatedUpPerp.scaleBy(1 / rotatedUpPerpLen);\r\n\r\n    // Calculate twist rotation around targetDir\r\n    const twistRotation = new Quaternion();\r\n    this.fromToRotation(rotatedUpPerp, targetUpPerp, twistRotation);\r\n\r\n    // Combine swing and twist\r\n    return Quaternion.multiply(twistRotation, swingRotation, result);\r\n  }\r\n}\r\n"],"names":["IKUtils","fromToRotation","from","to","result","fromNorm","Vector3","normalize","toNorm","dot","identity","axis","cross","axisPX","lenSq","x","y","z","axisPY","inplaceNormalize","fromAxisAngle","Math","PI","angle","acos","calculateBoneLength","start","end","distance","decomposeSwingTwist","q","outSwing","outTwist","w","twistLen","sqrt","set","twistInv","Quaternion","conjugate","multiply","getTwistAngle","twist","len","halfAngle","max","min","sign","createTwist","s","sin","cos","clampAndSmoothTwist","currentTwist","previousTwist","minTwist","maxTwist","smoothFactor","clampedTwist","undefined","diff","lookAtRotationWithPole","forward","targetDir","poleDir","forwardNorm","targetDirNorm","poleDirNorm","swingRotation","right","rightLenSq","scaleBy","up","originalUp","originalUpLenSq","rotatedUp","transform","rotatedUpDot","rotatedUpProj","scale","rotatedUpPerp","sub","rotatedUpPerpLen","magnitude","twistRotation","lookAtRotation","targetUp","projection","targetUpPerp","targetUpPerpLen"],"mappings":"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"}