@zephyr3d/scene 0.7.0 → 0.8.0

package/dist/animation/ik/ccd_solver.js

@@ -0,0 +1,372 @@
+import { Vector3, Quaternion } from '@zephyr3d/base';
+import { IKSolver } from './ik_solver.js';
+import { IKUtils } from './ik_utils.js';
+
+/**
+ * CCD (Cyclic Coordinate Descent) IK solver.
+ *
+ * @remarks
+ * CCD is an iterative IK algorithm that works by:
+ * 1. Starting from the joint closest to the end effector
+ * 2. Rotating each joint to point the end effector toward the target
+ * 3. Moving backward through the chain to the root
+ * 4. Repeating until convergence or max iterations
+ *
+ * CCD is generally faster than FABRIK and works well for chains of any length.
+ * It's particularly good for tentacles, tails, and other flexible chains.
+ *
+ * Supports multiple pole vectors to control the bending direction of different joints.
+ *
+ * @public
+ */ class CCDSolver extends IKSolver {
+    /** Map of joint index to pole vector configuration */ _poleVectors;
+    /** Twist constraints for each joint (indexed by joint index) */ _twistConstraints;
+    /**
+   * Create a CCD solver.
+   *
+   * @param chain - The IK chain to solve
+   * @param maxIterations - Maximum number of iterations (default: 10)
+   * @param tolerance - Convergence tolerance in world units (default: 0.001)
+   */ constructor(chain, maxIterations = 10, tolerance = 0.001){
+        super(chain, maxIterations, tolerance);
+        this._poleVectors = new Map();
+        this._twistConstraints = new Map();
+        // Set default twist constraints for all joints
+        for(let i = 0; i < chain.joints.length - 1; i++){
+            // Middle joints have more restrictive twist limits
+            const isMiddleJoint = i > 0 && i < chain.joints.length - 2;
+            this._twistConstraints.set(i, {
+                minTwist: isMiddleJoint ? -Math.PI * 0.2 : -Math.PI * 0.3,
+                maxTwist: isMiddleJoint ? Math.PI * 0.2 : Math.PI * 0.3,
+                smoothFactor: 0.3
+            });
+        }
+    }
+    /**
+   * Set twist constraint for a specific joint.
+   *
+   * @param jointIndex - Index of the joint
+   * @param minTwist - Minimum twist angle in radians
+   * @param maxTwist - Maximum twist angle in radians
+   * @param smoothFactor - Smoothing factor [0-1] (default: 0.3)
+   */ setTwistConstraint(jointIndex, minTwist, maxTwist, smoothFactor = 0.3) {
+        if (jointIndex < 0 || jointIndex >= this._chain.joints.length - 1) {
+            throw new Error(`Invalid joint index: ${jointIndex}`);
+        }
+        this._twistConstraints.set(jointIndex, {
+            minTwist,
+            maxTwist,
+            smoothFactor: Math.max(0, Math.min(1, smoothFactor))
+        });
+    }
+    /**
+   * Get twist constraint for a specific joint.
+   *
+   * @param jointIndex - Index of the joint
+   * @returns Twist constraint or undefined if not set
+   */ getTwistConstraint(jointIndex) {
+        return this._twistConstraints.get(jointIndex);
+    }
+    /**
+   * Remove twist constraint for a specific joint.
+   *
+   * @param jointIndex - Index of the joint
+   * @returns True if a constraint was removed
+   */ removeTwistConstraint(jointIndex) {
+        return this._twistConstraints.delete(jointIndex);
+    }
+    /**
+   * Clear all twist constraints.
+   */ clearTwistConstraints() {
+        this._twistConstraints.clear();
+    }
+    /**
+   * Set pole vector for a specific joint.
+   *
+   * @param jointIndex - Index of the joint to apply pole vector to
+   * @param poleVector - Pole vector position in world space
+   * @param weight - Weight of the pole vector constraint (0-1, default: 1)
+   */ setPoleVector(jointIndex, poleVector, weight = 1) {
+        if (jointIndex < 0 || jointIndex >= this._chain.joints.length) {
+            throw new Error(`Invalid joint index: ${jointIndex}`);
+        }
+        this._poleVectors.set(jointIndex, {
+            position: poleVector.clone(),
+            weight: Math.max(0, Math.min(1, weight))
+        });
+    }
+    /**
+   * Remove pole vector for a specific joint.
+   *
+   * @param jointIndex - Index of the joint to remove pole vector from
+   * @returns True if a pole vector was removed, false if none existed
+   */ removePoleVector(jointIndex) {
+        return this._poleVectors.delete(jointIndex);
+    }
+    /**
+   * Clear all pole vectors.
+   */ clearPoleVectors() {
+        this._poleVectors.clear();
+    }
+    /**
+   * Get pole vector configuration for a specific joint.
+   *
+   * @param jointIndex - Index of the joint
+   * @returns Pole vector configuration or undefined if not set
+   */ getPoleVector(jointIndex) {
+        const config = this._poleVectors.get(jointIndex);
+        if (config) {
+            return {
+                position: config.position.clone(),
+                weight: config.weight
+            };
+        }
+        return undefined;
+    }
+    /**
+   * Check if a joint has a pole vector.
+   *
+   * @param jointIndex - Index of the joint
+   * @returns True if the joint has a pole vector
+   */ hasPoleVector(jointIndex) {
+        return this._poleVectors.has(jointIndex);
+    }
+    /**
+   * Solve the IK chain to reach the target position using CCD algorithm.
+   *
+   * @param target - Target position for the end effector
+   * @returns True if converged within tolerance, false otherwise
+   */ solve(target) {
+        const joints = this._chain.joints;
+        // Update joint positions from scene nodes before solving
+        this._chain.updateFromNodes();
+        // Store original positions
+        this._chain.storeOriginalPositions();
+        let converged = false;
+        for(let iteration = 0; iteration < this._maxIterations; iteration++){
+            // Check convergence
+            const endEffector = joints[joints.length - 1];
+            const distToTarget = Vector3.distance(endEffector.position, target);
+            if (distToTarget < this._tolerance) {
+                converged = true;
+                break;
+            }
+            // Iterate backward through joints (from second-to-last to root)
+            // We skip the end effector itself since it doesn't have a child to rotate toward
+            for(let i = joints.length - 2; i >= 0; i--){
+                const joint = joints[i];
+                // Vector from current joint to end effector
+                const toEnd = Vector3.sub(endEffector.position, joint.position, new Vector3());
+                const toEndDist = toEnd.magnitude;
+                // Vector from current joint to target
+                const toTarget = Vector3.sub(target, joint.position, new Vector3());
+                const toTargetDist = toTarget.magnitude;
+                // Skip if either vector is too small
+                if (toEndDist < 0.000001 || toTargetDist < 0.000001) {
+                    continue;
+                }
+                // Normalize vectors
+                const toEndDir = Vector3.scale(toEnd, 1 / toEndDist, new Vector3());
+                const toTargetDir = Vector3.scale(toTarget, 1 / toTargetDist, new Vector3());
+                // Calculate rotation needed to align end effector toward target
+                let rotation = new Quaternion();
+                IKUtils.fromToRotation(toEndDir, toTargetDir, rotation);
+                // Apply rotation to all joints from current to end effector
+                this._rotateJointsFromIndex(i, rotation, joint.position);
+                // Apply constraints after rotating this joint
+                this._applyConstraintsForJoint(i);
+            }
+            // Apply all pole vector constraints after each full iteration
+            // This is more stable than applying them during the CCD loop
+            this._applyAllPoleVectors();
+        }
+        return converged;
+    }
+    /**
+   * Rotate all joints from the given index to the end effector around a pivot point.
+   *
+   * @param startIndex - Index of the joint to start rotating from
+   * @param rotation - Rotation to apply
+   * @param pivot - Pivot point for rotation (position of the joint being adjusted)
+   */ _rotateJointsFromIndex(startIndex, rotation, pivot) {
+        const joints = this._chain.joints;
+        // Rotate all joints from startIndex+1 to end effector
+        for(let i = startIndex + 1; i < joints.length; i++){
+            const joint = joints[i];
+            // Translate to pivot
+            const offset = Vector3.sub(joint.position, pivot, new Vector3());
+            // Rotate around pivot
+            const rotated = rotation.transform(offset, new Vector3());
+            // Translate back
+            joint.position.set(Vector3.add(pivot, rotated, new Vector3()));
+        }
+    }
+    /**
+   * Apply all pole vector constraints.
+   *
+   * @remarks
+   * This method applies all configured pole vectors to their respective joints.
+   * Pole vectors are applied in reverse order (from end to root) to minimize
+   * interference between multiple pole vectors. This ensures that pole vectors
+   * closer to the end effector are not affected by pole vectors closer to the root.
+   */ _applyAllPoleVectors() {
+        if (this._poleVectors.size === 0) {
+            return;
+        }
+        // Apply pole vectors in reverse order (from end to root)
+        // This prevents earlier pole vectors from affecting later ones
+        const sortedIndices = Array.from(this._poleVectors.keys()).sort((a, b)=>b - a);
+        for (const jointIndex of sortedIndices){
+            const config = this._poleVectors.get(jointIndex);
+            if (config && config.weight > 0.001) {
+                this._applyPoleVectorTwist(jointIndex, config.position, config.weight);
+            }
+        }
+    }
+    /**
+   * Apply pole vector twist to a specific joint.
+   *
+   * @remarks
+   * This method is called after the base CCD rotation has been applied.
+   * It adds an additional twist rotation around the joint-to-end axis
+   * to make the next joint (child) bend toward the pole vector.
+   *
+   * @param jointIndex - Index of the pole joint
+   * @param poleVector - Pole vector position in world space
+   * @param weight - Weight of the pole vector constraint (0-1)
+   */ _applyPoleVectorTwist(jointIndex, poleVector, weight) {
+        const joints = this._chain.joints;
+        // We need at least 3 joints to apply pole vector (parent, pole joint, child)
+        if (jointIndex < 1 || jointIndex >= joints.length - 1) {
+            return;
+        }
+        const parentJoint = joints[jointIndex - 1];
+        const currentJoint = joints[jointIndex];
+        const childJoint = joints[jointIndex + 1];
+        const parentPos = parentJoint.position;
+        const currentPos = currentJoint.position;
+        const childPos = childJoint.position;
+        // Calculate the plane defined by parent, child, and pole vector
+        // Vector from parent to child (the "line" we're bending around)
+        const parentToChild = Vector3.sub(childPos, parentPos, new Vector3());
+        const lineLength = parentToChild.magnitude;
+        if (lineLength < 0.000001) {
+            return; // Parent and child are at same position
+        }
+        const lineDir = Vector3.scale(parentToChild, 1 / lineLength, new Vector3());
+        // Project current joint onto the parent-child line
+        const parentToCurrent = Vector3.sub(currentPos, parentPos, new Vector3());
+        const projectionLength = Vector3.dot(parentToCurrent, lineDir);
+        const projectionPoint = Vector3.scale(lineDir, projectionLength, new Vector3());
+        Vector3.add(parentPos, projectionPoint, projectionPoint);
+        // Vector from projection point to current joint (perpendicular to line)
+        const perpendicular = Vector3.sub(currentPos, projectionPoint, new Vector3());
+        const perpLength = perpendicular.magnitude;
+        if (perpLength < 0.000001) {
+            return; // Current joint is on the line
+        }
+        // Calculate desired direction toward pole vector
+        const parentToPole = Vector3.sub(poleVector, parentPos, new Vector3());
+        const poleProjectionLength = Vector3.dot(parentToPole, lineDir);
+        const poleProjectionPoint = Vector3.scale(lineDir, poleProjectionLength, new Vector3());
+        Vector3.add(parentPos, poleProjectionPoint, poleProjectionPoint);
+        // Direction from projection to pole (perpendicular to line)
+        const poleDirection = Vector3.sub(poleVector, poleProjectionPoint, new Vector3());
+        const poleDirLength = poleDirection.magnitude;
+        if (poleDirLength < 0.000001) {
+            return; // Pole is on the line
+        }
+        poleDirection.scaleBy(1 / poleDirLength);
+        // Calculate new position for current joint
+        // Keep the same distance from the line, but rotate toward pole direction
+        const desiredPerpendicular = Vector3.scale(poleDirection, perpLength, new Vector3());
+        const newPosition = Vector3.add(projectionPoint, desiredPerpendicular, new Vector3());
+        // Apply weight (blend between original and constrained position)
+        if (weight < 0.999) {
+            const blended = new Vector3();
+            blended.x = currentPos.x + (newPosition.x - currentPos.x) * weight;
+            blended.y = currentPos.y + (newPosition.y - currentPos.y) * weight;
+            blended.z = currentPos.z + (newPosition.z - currentPos.z) * weight;
+            currentJoint.position.set(blended);
+        } else {
+            currentJoint.position.set(newPosition);
+        }
+    }
+    /**
+   * Apply constraints for a specific joint.
+   *
+   * @param jointIndex - Index of the joint to apply constraints to
+   */ _applyConstraintsForJoint(jointIndex) {
+        const constraints = this._chain.constraints;
+        for (const constraint of constraints){
+            if (constraint.jointIndex === jointIndex) {
+                constraint.apply(this._chain.joints);
+            }
+        }
+    }
+    /**
+   * Apply the solved joint positions to scene nodes as rotations.
+   *
+   * @param weight - Blend weight (0 = original, 1 = full IK, default: 1)
+   */ applyToNodes(weight = 1) {
+        const joints = this._chain.joints;
+        // Apply rotation for all joints except the end effector
+        for(let i = 0; i < joints.length - 1; i++){
+            const joint = joints[i];
+            const nextJoint = joints[i + 1];
+            // Calculate direction from current joint to next joint in world space
+            const originalDir = Vector3.sub(nextJoint.originalPosition, joint.originalPosition, new Vector3());
+            const newDir = Vector3.sub(nextJoint.position, joint.position, new Vector3());
+            const originalDirNorm = Vector3.normalize(originalDir, new Vector3());
+            const newDirNorm = Vector3.normalize(newDir, new Vector3());
+            // Calculate basic rotation
+            const deltaRotation = new Quaternion();
+            IKUtils.fromToRotation(originalDirNorm, newDirNorm, deltaRotation);
+            // Calculate new world rotation
+            let worldRotation = Quaternion.multiply(deltaRotation, joint.originalRotation, new Quaternion());
+            // Apply swing-twist constraint to prevent over-rotation
+            const swing = new Quaternion();
+            const twist = new Quaternion();
+            IKUtils.decomposeSwingTwist(worldRotation, newDirNorm, swing, twist);
+            // Get twist angle
+            let twistAngle = IKUtils.getTwistAngle(twist, newDirNorm);
+            // Get twist constraint for this joint
+            const constraint = this._twistConstraints.get(i);
+            if (constraint) {
+                // Clamp and smooth twist
+                twistAngle = IKUtils.clampAndSmoothTwist(twistAngle, joint.previousTwist, constraint.minTwist, constraint.maxTwist, constraint.smoothFactor);
+            }
+            // Store for next frame
+            joint.previousTwist = twistAngle;
+            // Reconstruct rotation from clamped twist: Q = Twist * Swing
+            const clampedTwist = new Quaternion();
+            IKUtils.createTwist(twistAngle, newDirNorm, clampedTwist);
+            worldRotation = Quaternion.multiply(clampedTwist, swing, worldRotation);
+            // Blend with original rotation based on weight
+            if (weight < 1) {
+                Quaternion.slerp(joint.originalRotation, worldRotation, weight, worldRotation);
+            }
+            // Store this frame's world rotation for next frame's twist continuity
+            if (!joint.previousIKRotation) {
+                joint.previousIKRotation = worldRotation.clone();
+            } else {
+                joint.previousIKRotation.set(worldRotation);
+            }
+            // Convert world rotation to local rotation (relative to parent)
+            if (joint.node.parent) {
+                const parentWorldRotation = new Quaternion();
+                joint.node.parent.worldMatrix.decompose(null, parentWorldRotation, null);
+                // localRotation = conjugate(parentWorldRotation) * worldRotation
+                const parentInvRotation = Quaternion.conjugate(parentWorldRotation, new Quaternion());
+                const localRotation = Quaternion.multiply(parentInvRotation, worldRotation, new Quaternion());
+                joint.node.rotation = localRotation;
+            } else {
+                // Root node has no parent, world rotation is local rotation
+                joint.node.rotation = worldRotation;
+            }
+        }
+    }
+}
+
+export { CCDSolver };
+//# sourceMappingURL=ccd_solver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ccd_solver.js","sources":["../../../src/animation/ik/ccd_solver.ts"],"sourcesContent":["import { Vector3, Quaternion } from '@zephyr3d/base';\r\nimport { IKSolver } from './ik_solver';\r\nimport type { IKChain } from './ik_chain';\r\nimport { IKUtils } from './ik_utils';\r\nimport type { TwistConstraint } from './ik_constraint';\r\n\r\n/**\r\n * Pole vector configuration for a specific joint.\r\n */\r\ninterface PoleVectorConfig {\r\n  /** Pole vector position in world space */\r\n  position: Vector3;\r\n  /** Weight of the pole vector constraint (0-1) */\r\n  weight: number;\r\n}\r\n\r\n/**\r\n * CCD (Cyclic Coordinate Descent) IK solver.\r\n *\r\n * @remarks\r\n * CCD is an iterative IK algorithm that works by:\r\n * 1. Starting from the joint closest to the end effector\r\n * 2. Rotating each joint to point the end effector toward the target\r\n * 3. Moving backward through the chain to the root\r\n * 4. Repeating until convergence or max iterations\r\n *\r\n * CCD is generally faster than FABRIK and works well for chains of any length.\r\n * It's particularly good for tentacles, tails, and other flexible chains.\r\n *\r\n * Supports multiple pole vectors to control the bending direction of different joints.\r\n *\r\n * @public\r\n */\r\nexport class CCDSolver extends IKSolver {\r\n  /** Map of joint index to pole vector configuration */\r\n  private _poleVectors: Map<number, PoleVectorConfig>;\r\n  /** Twist constraints for each joint (indexed by joint index) */\r\n  private _twistConstraints: Map<number, TwistConstraint>;\r\n\r\n  /**\r\n   * Create a CCD solver.\r\n   *\r\n   * @param chain - The IK chain to solve\r\n   * @param maxIterations - Maximum number of iterations (default: 10)\r\n   * @param tolerance - Convergence tolerance in world units (default: 0.001)\r\n   */\r\n  constructor(chain: IKChain, maxIterations = 10, tolerance = 0.001) {\r\n    super(chain, maxIterations, tolerance);\r\n    this._poleVectors = new Map();\r\n    this._twistConstraints = new Map();\r\n\r\n    // Set default twist constraints for all joints\r\n    for (let i = 0; i < chain.joints.length - 1; i++) {\r\n      // Middle joints have more restrictive twist limits\r\n      const isMiddleJoint = i > 0 && i < chain.joints.length - 2;\r\n      this._twistConstraints.set(i, {\r\n        minTwist: isMiddleJoint ? -Math.PI * 0.2 : -Math.PI * 0.3,\r\n        maxTwist: isMiddleJoint ? Math.PI * 0.2 : Math.PI * 0.3,\r\n        smoothFactor: 0.3\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Set twist constraint for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint\r\n   * @param minTwist - Minimum twist angle in radians\r\n   * @param maxTwist - Maximum twist angle in radians\r\n   * @param smoothFactor - Smoothing factor [0-1] (default: 0.3)\r\n   */\r\n  setTwistConstraint(\r\n    jointIndex: number,\r\n    minTwist: number,\r\n    maxTwist: number,\r\n    smoothFactor: number = 0.3\r\n  ): void {\r\n    if (jointIndex < 0 || jointIndex >= this._chain.joints.length - 1) {\r\n      throw new Error(`Invalid joint index: ${jointIndex}`);\r\n    }\r\n\r\n    this._twistConstraints.set(jointIndex, {\r\n      minTwist,\r\n      maxTwist,\r\n      smoothFactor: Math.max(0, Math.min(1, smoothFactor))\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get twist constraint for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint\r\n   * @returns Twist constraint or undefined if not set\r\n   */\r\n  getTwistConstraint(jointIndex: number): TwistConstraint | undefined {\r\n    return this._twistConstraints.get(jointIndex);\r\n  }\r\n\r\n  /**\r\n   * Remove twist constraint for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint\r\n   * @returns True if a constraint was removed\r\n   */\r\n  removeTwistConstraint(jointIndex: number): boolean {\r\n    return this._twistConstraints.delete(jointIndex);\r\n  }\r\n\r\n  /**\r\n   * Clear all twist constraints.\r\n   */\r\n  clearTwistConstraints(): void {\r\n    this._twistConstraints.clear();\r\n  }\r\n\r\n  /**\r\n   * Set pole vector for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint to apply pole vector to\r\n   * @param poleVector - Pole vector position in world space\r\n   * @param weight - Weight of the pole vector constraint (0-1, default: 1)\r\n   */\r\n  setPoleVector(jointIndex: number, poleVector: Vector3, weight = 1): void {\r\n    if (jointIndex < 0 || jointIndex >= this._chain.joints.length) {\r\n      throw new Error(`Invalid joint index: ${jointIndex}`);\r\n    }\r\n\r\n    this._poleVectors.set(jointIndex, {\r\n      position: poleVector.clone(),\r\n      weight: Math.max(0, Math.min(1, weight))\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Remove pole vector for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint to remove pole vector from\r\n   * @returns True if a pole vector was removed, false if none existed\r\n   */\r\n  removePoleVector(jointIndex: number): boolean {\r\n    return this._poleVectors.delete(jointIndex);\r\n  }\r\n\r\n  /**\r\n   * Clear all pole vectors.\r\n   */\r\n  clearPoleVectors(): void {\r\n    this._poleVectors.clear();\r\n  }\r\n\r\n  /**\r\n   * Get pole vector configuration for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint\r\n   * @returns Pole vector configuration or undefined if not set\r\n   */\r\n  getPoleVector(jointIndex: number): { position: Vector3; weight: number } | undefined {\r\n    const config = this._poleVectors.get(jointIndex);\r\n    if (config) {\r\n      return {\r\n        position: config.position.clone(),\r\n        weight: config.weight\r\n      };\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /**\r\n   * Check if a joint has a pole vector.\r\n   *\r\n   * @param jointIndex - Index of the joint\r\n   * @returns True if the joint has a pole vector\r\n   */\r\n  hasPoleVector(jointIndex: number): boolean {\r\n    return this._poleVectors.has(jointIndex);\r\n  }\r\n\r\n  /**\r\n   * Solve the IK chain to reach the target position using CCD algorithm.\r\n   *\r\n   * @param target - Target position for the end effector\r\n   * @returns True if converged within tolerance, false otherwise\r\n   */\r\n  solve(target: Vector3): boolean {\r\n    const joints = this._chain.joints;\r\n\r\n    // Update joint positions from scene nodes before solving\r\n    this._chain.updateFromNodes();\r\n\r\n    // Store original positions\r\n    this._chain.storeOriginalPositions();\r\n\r\n    let converged = false;\r\n\r\n    for (let iteration = 0; iteration < this._maxIterations; iteration++) {\r\n      // Check convergence\r\n      const endEffector = joints[joints.length - 1];\r\n      const distToTarget = Vector3.distance(endEffector.position, target);\r\n\r\n      if (distToTarget < this._tolerance) {\r\n        converged = true;\r\n        break;\r\n      }\r\n\r\n      // Iterate backward through joints (from second-to-last to root)\r\n      // We skip the end effector itself since it doesn't have a child to rotate toward\r\n      for (let i = joints.length - 2; i >= 0; i--) {\r\n        const joint = joints[i];\r\n\r\n        // Vector from current joint to end effector\r\n        const toEnd = Vector3.sub(endEffector.position, joint.position, new Vector3());\r\n        const toEndDist = toEnd.magnitude;\r\n\r\n        // Vector from current joint to target\r\n        const toTarget = Vector3.sub(target, joint.position, new Vector3());\r\n        const toTargetDist = toTarget.magnitude;\r\n\r\n        // Skip if either vector is too small\r\n        if (toEndDist < 0.000001 || toTargetDist < 0.000001) {\r\n          continue;\r\n        }\r\n\r\n        // Normalize vectors\r\n        const toEndDir = Vector3.scale(toEnd, 1 / toEndDist, new Vector3());\r\n        const toTargetDir = Vector3.scale(toTarget, 1 / toTargetDist, new Vector3());\r\n\r\n        // Calculate rotation needed to align end effector toward target\r\n        let rotation = new Quaternion();\r\n        IKUtils.fromToRotation(toEndDir, toTargetDir, rotation);\r\n\r\n        // Apply rotation to all joints from current to end effector\r\n        this._rotateJointsFromIndex(i, rotation, joint.position);\r\n\r\n        // Apply constraints after rotating this joint\r\n        this._applyConstraintsForJoint(i);\r\n      }\r\n\r\n      // Apply all pole vector constraints after each full iteration\r\n      // This is more stable than applying them during the CCD loop\r\n      this._applyAllPoleVectors();\r\n    }\r\n\r\n    return converged;\r\n  }\r\n\r\n  /**\r\n   * Rotate all joints from the given index to the end effector around a pivot point.\r\n   *\r\n   * @param startIndex - Index of the joint to start rotating from\r\n   * @param rotation - Rotation to apply\r\n   * @param pivot - Pivot point for rotation (position of the joint being adjusted)\r\n   */\r\n  private _rotateJointsFromIndex(startIndex: number, rotation: Quaternion, pivot: Vector3): void {\r\n    const joints = this._chain.joints;\r\n\r\n    // Rotate all joints from startIndex+1 to end effector\r\n    for (let i = startIndex + 1; i < joints.length; i++) {\r\n      const joint = joints[i];\r\n\r\n      // Translate to pivot\r\n      const offset = Vector3.sub(joint.position, pivot, new Vector3());\r\n\r\n      // Rotate around pivot\r\n      const rotated = rotation.transform(offset, new Vector3());\r\n\r\n      // Translate back\r\n      joint.position.set(Vector3.add(pivot, rotated, new Vector3()));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Apply all pole vector constraints.\r\n   *\r\n   * @remarks\r\n   * This method applies all configured pole vectors to their respective joints.\r\n   * Pole vectors are applied in reverse order (from end to root) to minimize\r\n   * interference between multiple pole vectors. This ensures that pole vectors\r\n   * closer to the end effector are not affected by pole vectors closer to the root.\r\n   */\r\n  private _applyAllPoleVectors(): void {\r\n    if (this._poleVectors.size === 0) {\r\n      return;\r\n    }\r\n\r\n    // Apply pole vectors in reverse order (from end to root)\r\n    // This prevents earlier pole vectors from affecting later ones\r\n    const sortedIndices = Array.from(this._poleVectors.keys()).sort((a, b) => b - a);\r\n\r\n    for (const jointIndex of sortedIndices) {\r\n      const config = this._poleVectors.get(jointIndex);\r\n      if (config && config.weight > 0.001) {\r\n        this._applyPoleVectorTwist(jointIndex, config.position, config.weight);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Apply pole vector twist to a specific joint.\r\n   *\r\n   * @remarks\r\n   * This method is called after the base CCD rotation has been applied.\r\n   * It adds an additional twist rotation around the joint-to-end axis\r\n   * to make the next joint (child) bend toward the pole vector.\r\n   *\r\n   * @param jointIndex - Index of the pole joint\r\n   * @param poleVector - Pole vector position in world space\r\n   * @param weight - Weight of the pole vector constraint (0-1)\r\n   */\r\n  private _applyPoleVectorTwist(jointIndex: number, poleVector: Vector3, weight: number): void {\r\n    const joints = this._chain.joints;\r\n\r\n    // We need at least 3 joints to apply pole vector (parent, pole joint, child)\r\n    if (jointIndex < 1 || jointIndex >= joints.length - 1) {\r\n      return;\r\n    }\r\n\r\n    const parentJoint = joints[jointIndex - 1];\r\n    const currentJoint = joints[jointIndex];\r\n    const childJoint = joints[jointIndex + 1];\r\n\r\n    const parentPos = parentJoint.position;\r\n    const currentPos = currentJoint.position;\r\n    const childPos = childJoint.position;\r\n\r\n    // Calculate the plane defined by parent, child, and pole vector\r\n    // Vector from parent to child (the \"line\" we're bending around)\r\n    const parentToChild = Vector3.sub(childPos, parentPos, new Vector3());\r\n    const lineLength = parentToChild.magnitude;\r\n\r\n    if (lineLength < 0.000001) {\r\n      return; // Parent and child are at same position\r\n    }\r\n\r\n    const lineDir = Vector3.scale(parentToChild, 1 / lineLength, new Vector3());\r\n\r\n    // Project current joint onto the parent-child line\r\n    const parentToCurrent = Vector3.sub(currentPos, parentPos, new Vector3());\r\n    const projectionLength = Vector3.dot(parentToCurrent, lineDir);\r\n    const projectionPoint = Vector3.scale(lineDir, projectionLength, new Vector3());\r\n    Vector3.add(parentPos, projectionPoint, projectionPoint);\r\n\r\n    // Vector from projection point to current joint (perpendicular to line)\r\n    const perpendicular = Vector3.sub(currentPos, projectionPoint, new Vector3());\r\n    const perpLength = perpendicular.magnitude;\r\n\r\n    if (perpLength < 0.000001) {\r\n      return; // Current joint is on the line\r\n    }\r\n\r\n    // Calculate desired direction toward pole vector\r\n    const parentToPole = Vector3.sub(poleVector, parentPos, new Vector3());\r\n    const poleProjectionLength = Vector3.dot(parentToPole, lineDir);\r\n    const poleProjectionPoint = Vector3.scale(lineDir, poleProjectionLength, new Vector3());\r\n    Vector3.add(parentPos, poleProjectionPoint, poleProjectionPoint);\r\n\r\n    // Direction from projection to pole (perpendicular to line)\r\n    const poleDirection = Vector3.sub(poleVector, poleProjectionPoint, new Vector3());\r\n    const poleDirLength = poleDirection.magnitude;\r\n\r\n    if (poleDirLength < 0.000001) {\r\n      return; // Pole is on the line\r\n    }\r\n\r\n    poleDirection.scaleBy(1 / poleDirLength);\r\n\r\n    // Calculate new position for current joint\r\n    // Keep the same distance from the line, but rotate toward pole direction\r\n    const desiredPerpendicular = Vector3.scale(poleDirection, perpLength, new Vector3());\r\n    const newPosition = Vector3.add(projectionPoint, desiredPerpendicular, new Vector3());\r\n\r\n    // Apply weight (blend between original and constrained position)\r\n    if (weight < 0.999) {\r\n      const blended = new Vector3();\r\n      blended.x = currentPos.x + (newPosition.x - currentPos.x) * weight;\r\n      blended.y = currentPos.y + (newPosition.y - currentPos.y) * weight;\r\n      blended.z = currentPos.z + (newPosition.z - currentPos.z) * weight;\r\n      currentJoint.position.set(blended);\r\n    } else {\r\n      currentJoint.position.set(newPosition);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Apply constraints for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint to apply constraints to\r\n   */\r\n  private _applyConstraintsForJoint(jointIndex: number): void {\r\n    const constraints = this._chain.constraints;\r\n    for (const constraint of constraints) {\r\n      if (constraint.jointIndex === jointIndex) {\r\n        constraint.apply(this._chain.joints);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Apply the solved joint positions to scene nodes as rotations.\r\n   *\r\n   * @param weight - Blend weight (0 = original, 1 = full IK, default: 1)\r\n   */\r\n  applyToNodes(weight = 1): void {\r\n    const joints = this._chain.joints;\r\n\r\n    // Apply rotation for all joints except the end effector\r\n    for (let i = 0; i < joints.length - 1; i++) {\r\n      const joint = joints[i];\r\n      const nextJoint = joints[i + 1];\r\n\r\n      // Calculate direction from current joint to next joint in world space\r\n      const originalDir = Vector3.sub(nextJoint.originalPosition, joint.originalPosition, new Vector3());\r\n      const newDir = Vector3.sub(nextJoint.position, joint.position, new Vector3());\r\n\r\n      const originalDirNorm = Vector3.normalize(originalDir, new Vector3());\r\n      const newDirNorm = Vector3.normalize(newDir, new Vector3());\r\n\r\n      // Calculate basic rotation\r\n      const deltaRotation = new Quaternion();\r\n      IKUtils.fromToRotation(originalDirNorm, newDirNorm, deltaRotation);\r\n\r\n      // Calculate new world rotation\r\n      let worldRotation = Quaternion.multiply(deltaRotation, joint.originalRotation, new Quaternion());\r\n\r\n      // Apply swing-twist constraint to prevent over-rotation\r\n      const swing = new Quaternion();\r\n      const twist = new Quaternion();\r\n      IKUtils.decomposeSwingTwist(worldRotation, newDirNorm, swing, twist);\r\n\r\n      // Get twist angle\r\n      let twistAngle = IKUtils.getTwistAngle(twist, newDirNorm);\r\n\r\n      // Get twist constraint for this joint\r\n      const constraint = this._twistConstraints.get(i);\r\n      if (constraint) {\r\n        // Clamp and smooth twist\r\n        twistAngle = IKUtils.clampAndSmoothTwist(\r\n          twistAngle,\r\n          joint.previousTwist,\r\n          constraint.minTwist,\r\n          constraint.maxTwist,\r\n          constraint.smoothFactor\r\n        );\r\n      }\r\n\r\n      // Store for next frame\r\n      joint.previousTwist = twistAngle;\r\n\r\n      // Reconstruct rotation from clamped twist: Q = Twist * Swing\r\n      const clampedTwist = new Quaternion();\r\n      IKUtils.createTwist(twistAngle, newDirNorm, clampedTwist);\r\n      worldRotation = Quaternion.multiply(clampedTwist, swing, worldRotation);\r\n\r\n      // Blend with original rotation based on weight\r\n      if (weight < 1) {\r\n        Quaternion.slerp(joint.originalRotation, worldRotation, weight, worldRotation);\r\n      }\r\n\r\n      // Store this frame's world rotation for next frame's twist continuity\r\n      if (!joint.previousIKRotation) {\r\n        joint.previousIKRotation = worldRotation.clone();\r\n      } else {\r\n        joint.previousIKRotation.set(worldRotation);\r\n      }\r\n\r\n      // Convert world rotation to local rotation (relative to parent)\r\n      if (joint.node.parent) {\r\n        const parentWorldRotation = new Quaternion();\r\n        joint.node.parent.worldMatrix.decompose(null, parentWorldRotation, null);\r\n\r\n        // localRotation = conjugate(parentWorldRotation) * worldRotation\r\n        const parentInvRotation = Quaternion.conjugate(parentWorldRotation, new Quaternion());\r\n        const localRotation = Quaternion.multiply(parentInvRotation, worldRotation, new Quaternion());\r\n\r\n        joint.node.rotation = localRotation;\r\n      } else {\r\n        // Root node has no parent, world rotation is local rotation\r\n        joint.node.rotation = worldRotation;\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"names":["CCDSolver","IKSolver","chain","maxIterations","tolerance","_poleVectors","Map","_twistConstraints","i","joints","length","isMiddleJoint","set","minTwist","Math","PI","maxTwist","smoothFactor","setTwistConstraint","jointIndex","_chain","Error","max","min","getTwistConstraint","get","removeTwistConstraint","delete","clearTwistConstraints","clear","setPoleVector","poleVector","weight","position","clone","removePoleVector","clearPoleVectors","getPoleVector","config","undefined","hasPoleVector","has","solve","target","updateFromNodes","storeOriginalPositions","converged","iteration","_maxIterations","endEffector","distToTarget","Vector3","distance","_tolerance","joint","toEnd","sub","toEndDist","magnitude","toTarget","toTargetDist","toEndDir","scale","toTargetDir","rotation","Quaternion","IKUtils","fromToRotation","_rotateJointsFromIndex","_applyConstraintsForJoint","_applyAllPoleVectors","startIndex","pivot","offset","rotated","transform","add","size","sortedIndices","Array","from","keys","sort","a","b","_applyPoleVectorTwist","parentJoint","currentJoint","childJoint","parentPos","currentPos","childPos","parentToChild","lineLength","lineDir","parentToCurrent","projectionLength","dot","projectionPoint","perpendicular","perpLength","parentToPole","poleProjectionLength","poleProjectionPoint","poleDirection","poleDirLength","scaleBy","desiredPerpendicular","newPosition","blended","x","y","z","constraints","constraint","apply","applyToNodes","nextJoint","originalDir","originalPosition","newDir","originalDirNorm","normalize","newDirNorm","deltaRotation","worldRotation","multiply","originalRotation","swing","twist","decomposeSwingTwist","twistAngle","getTwistAngle","clampAndSmoothTwist","previousTwist","clampedTwist","createTwist","slerp","previousIKRotation","node","parent","parentWorldRotation","worldMatrix","decompose","parentInvRotation","conjugate","localRotation"],"mappings":"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"}