@zephyr3d/scene 0.7.1 → 0.8.1

package/dist/animation/ik/fabrik_solver.js

@@ -0,0 +1,398 @@
+import { Vector3, Quaternion } from '@zephyr3d/base';
+import { IKSolver } from './ik_solver.js';
+import { IKUtils } from './ik_utils.js';
+
+/**
+ * FABRIK (Forward And Backward Reaching Inverse Kinematics) solver.
+ *
+ * @remarks
+ * FABRIK is an iterative IK algorithm that alternates between:
+ * 1. Forward pass: Move from end effector to root, pulling joints toward target
+ * 2. Backward pass: Move from root to end effector, restoring root position
+ *
+ * Supports multiple pole vectors to control the bending direction of different joints.
+ *
+ * @public
+ */ class FABRIKSolver extends IKSolver {
+    /** Map of joint index to pole vector configuration */ _poleVectors;
+    /** Twist constraints for each joint (indexed by joint index) */ _twistConstraints;
+    /**
+   * Create a FABRIK solver.
+   *
+   * @param chain - The IK chain to solve
+   * @param maxIterations - Maximum number of iterations (default: 15)
+   * @param tolerance - Convergence tolerance in world units (default: 0.001)
+   */ constructor(chain, maxIterations = 15, 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 FABRIK 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();
+        const rootPos = joints[0].originalPosition.clone();
+        // Check if target is reachable
+        const distToTarget = Vector3.distance(rootPos, target);
+        if (distToTarget > this._chain.totalLength) {
+            // Target unreachable - stretch chain toward target
+            this._stretchToward(target);
+            return false;
+        }
+        let converged = false;
+        for(let iteration = 0; iteration < this._maxIterations; iteration++){
+            // Check convergence
+            const distToEnd = Vector3.distance(joints[joints.length - 1].position, target);
+            if (distToEnd < this._tolerance) {
+                converged = true;
+                break;
+            }
+            // Forward pass: end effector to root
+            this._forwardPass(target);
+            // Backward pass: root to end effector (constraints are applied within the pass)
+            this._backwardPass(rootPos);
+        }
+        return converged;
+    }
+    /**
+   * 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;
+        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();
+            worldRotation.decomposeSwingTwist(newDirNorm, swing, twist);
+            // Get twist angle
+            let twistAngle = twist.getTwistAngle(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 = Quaternion.fromAxisAngle(newDirNorm, twistAngle);
+            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
+            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;
+            }
+        }
+    }
+    /**
+   * Forward pass: move from end effector toward root.
+   * Each joint is pulled toward its child, maintaining bone length.
+   * Constraints are applied immediately after each joint adjustment.
+   *
+   * @param target - Target position for end effector
+   */ _forwardPass(target) {
+        const joints = this._chain.joints;
+        // Set end effector to target
+        joints[joints.length - 1].position.set(target);
+        // Move backward through chain
+        for(let i = joints.length - 2; i >= 0; i--){
+            const joint = joints[i];
+            const childJoint = joints[i + 1];
+            // Calculate direction from child to current joint
+            const direction = Vector3.sub(joint.position, childJoint.position, new Vector3());
+            const distance = direction.magnitude;
+            if (distance > 0.000001) {
+                direction.scaleBy(1 / distance);
+                // Place joint at correct distance from child
+                Vector3.scale(direction, joint.boneLength, direction);
+                Vector3.add(childJoint.position, direction, joint.position);
+            }
+            // Apply constraints immediately after adjusting this joint
+            // This ensures constraints are integrated into the FABRIK algorithm
+            if (i > 0) {
+                // Apply constraints for joint i (not for root joint)
+                this._applyConstraintsForJoint(i);
+            }
+        }
+    }
+    /**
+   * Backward pass: move from root toward end effector.
+   * Each joint is pulled toward its parent, maintaining bone length.
+   * Constraints are applied immediately after each joint adjustment.
+   *
+   * @param rootPos - Original root position to restore
+   */ _backwardPass(rootPos) {
+        const joints = this._chain.joints;
+        // Restore root position
+        joints[0].position.set(rootPos);
+        // Move forward through chain
+        for(let i = 0; i < joints.length - 1; i++){
+            const joint = joints[i];
+            const childJoint = joints[i + 1];
+            // Calculate direction from current joint to child
+            const direction = Vector3.sub(childJoint.position, joint.position, new Vector3());
+            const distance = direction.magnitude;
+            if (distance > 0.000001) {
+                direction.scaleBy(1 / distance);
+                // Place child at correct distance from current joint
+                Vector3.scale(direction, joint.boneLength, direction);
+                Vector3.add(joint.position, direction, childJoint.position);
+            }
+            // Apply constraints immediately after adjusting this joint
+            // This ensures constraints are integrated into the FABRIK algorithm
+            this._applyConstraintsForJoint(i + 1);
+        }
+    }
+    /**
+   * Apply constraints for a specific joint.
+   * This is called during the FABRIK passes to integrate constraints into the algorithm.
+   *
+   * @param jointIndex - Index of the joint to apply constraints to
+   */ _applyConstraintsForJoint(jointIndex) {
+        const constraints = this._chain.constraints;
+        // Apply non-pole-vector constraints
+        // IKPoleVectorConstraint is deprecated and ignored in favor of built-in pole vectors
+        for (const constraint of constraints){
+            if (constraint.jointIndex === jointIndex) {
+                // Skip IKPoleVectorConstraint - use built-in pole vectors instead
+                if (constraint.constructor.name === 'IKPoleVectorConstraint') {
+                    continue;
+                }
+                constraint.apply(this._chain.joints);
+            }
+        }
+        // Apply built-in pole vector if configured for this joint
+        const poleConfig = this._poleVectors.get(jointIndex);
+        if (poleConfig && poleConfig.weight > 0.001) {
+            this._applyPoleVectorTwist(jointIndex, poleConfig.position, poleConfig.weight);
+        }
+    }
+    /**
+   * Apply pole vector twist to a specific joint.
+   *
+   * @remarks
+   * This method adjusts the joint position to align with the pole vector.
+   * It uses the same algorithm as IKPoleVectorConstraint but is integrated
+   * into the solver for better performance and control.
+   *
+   * @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);
+        }
+    }
+    /**
+   * Stretch the chain toward an unreachable target.
+   * All joints are aligned in a straight line toward the target.
+   *
+   * @param target - Unreachable target position
+   */ _stretchToward(target) {
+        const joints = this._chain.joints;
+        const rootPos = joints[0].originalPosition;
+        // Calculate direction from root to target
+        const direction = Vector3.sub(target, rootPos, new Vector3()).inplaceNormalize();
+        // Place each joint along the direction at its bone length
+        let currentPos = rootPos.clone();
+        for(let i = 0; i < joints.length; i++){
+            joints[i].position.set(currentPos);
+            if (i < joints.length - 1) {
+                const offset = Vector3.scale(direction, joints[i].boneLength, new Vector3());
+                currentPos.addBy(offset);
+            }
+        }
+    }
+}
+
+export { FABRIKSolver };
+//# sourceMappingURL=fabrik_solver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fabrik_solver.js","sources":["../../../src/animation/ik/fabrik_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 * FABRIK (Forward And Backward Reaching Inverse Kinematics) solver.\r\n *\r\n * @remarks\r\n * FABRIK is an iterative IK algorithm that alternates between:\r\n * 1. Forward pass: Move from end effector to root, pulling joints toward target\r\n * 2. Backward pass: Move from root to end effector, restoring root position\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 FABRIKSolver 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 FABRIK solver.\r\n   *\r\n   * @param chain - The IK chain to solve\r\n   * @param maxIterations - Maximum number of iterations (default: 15)\r\n   * @param tolerance - Convergence tolerance in world units (default: 0.001)\r\n   */\r\n  constructor(chain: IKChain, maxIterations = 15, 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 FABRIK 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    const rootPos = joints[0].originalPosition.clone();\r\n\r\n    // Check if target is reachable\r\n    const distToTarget = Vector3.distance(rootPos, target);\r\n    if (distToTarget > this._chain.totalLength) {\r\n      // Target unreachable - stretch chain toward target\r\n      this._stretchToward(target);\r\n      return false;\r\n    }\r\n\r\n    let converged = false;\r\n    for (let iteration = 0; iteration < this._maxIterations; iteration++) {\r\n      // Check convergence\r\n      const distToEnd = Vector3.distance(joints[joints.length - 1].position, target);\r\n      if (distToEnd < this._tolerance) {\r\n        converged = true;\r\n        break;\r\n      }\r\n\r\n      // Forward pass: end effector to root\r\n      this._forwardPass(target);\r\n\r\n      // Backward pass: root to end effector (constraints are applied within the pass)\r\n      this._backwardPass(rootPos);\r\n    }\r\n\r\n    return converged;\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    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      worldRotation.decomposeSwingTwist(newDirNorm, swing, twist);\r\n\r\n      // Get twist angle\r\n      let twistAngle = twist.getTwistAngle(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 = Quaternion.fromAxisAngle(newDirNorm, twistAngle);\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\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  /**\r\n   * Forward pass: move from end effector toward root.\r\n   * Each joint is pulled toward its child, maintaining bone length.\r\n   * Constraints are applied immediately after each joint adjustment.\r\n   *\r\n   * @param target - Target position for end effector\r\n   */\r\n  private _forwardPass(target: Vector3): void {\r\n    const joints = this._chain.joints;\r\n\r\n    // Set end effector to target\r\n    joints[joints.length - 1].position.set(target);\r\n\r\n    // Move backward through chain\r\n    for (let i = joints.length - 2; i >= 0; i--) {\r\n      const joint = joints[i];\r\n      const childJoint = joints[i + 1];\r\n\r\n      // Calculate direction from child to current joint\r\n      const direction = Vector3.sub(joint.position, childJoint.position, new Vector3());\r\n      const distance = direction.magnitude;\r\n\r\n      if (distance > 0.000001) {\r\n        direction.scaleBy(1 / distance);\r\n        // Place joint at correct distance from child\r\n        Vector3.scale(direction, joint.boneLength, direction);\r\n        Vector3.add(childJoint.position, direction, joint.position);\r\n      }\r\n\r\n      // Apply constraints immediately after adjusting this joint\r\n      // This ensures constraints are integrated into the FABRIK algorithm\r\n      if (i > 0) {\r\n        // Apply constraints for joint i (not for root joint)\r\n        this._applyConstraintsForJoint(i);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Backward pass: move from root toward end effector.\r\n   * Each joint is pulled toward its parent, maintaining bone length.\r\n   * Constraints are applied immediately after each joint adjustment.\r\n   *\r\n   * @param rootPos - Original root position to restore\r\n   */\r\n  private _backwardPass(rootPos: Vector3): void {\r\n    const joints = this._chain.joints;\r\n\r\n    // Restore root position\r\n    joints[0].position.set(rootPos);\r\n\r\n    // Move forward through chain\r\n    for (let i = 0; i < joints.length - 1; i++) {\r\n      const joint = joints[i];\r\n      const childJoint = joints[i + 1];\r\n\r\n      // Calculate direction from current joint to child\r\n      const direction = Vector3.sub(childJoint.position, joint.position, new Vector3());\r\n      const distance = direction.magnitude;\r\n\r\n      if (distance > 0.000001) {\r\n        direction.scaleBy(1 / distance);\r\n        // Place child at correct distance from current joint\r\n        Vector3.scale(direction, joint.boneLength, direction);\r\n        Vector3.add(joint.position, direction, childJoint.position);\r\n      }\r\n\r\n      // Apply constraints immediately after adjusting this joint\r\n      // This ensures constraints are integrated into the FABRIK algorithm\r\n      this._applyConstraintsForJoint(i + 1);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Apply constraints for a specific joint.\r\n   * This is called during the FABRIK passes to integrate constraints into the algorithm.\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\r\n    // Apply non-pole-vector constraints\r\n    // IKPoleVectorConstraint is deprecated and ignored in favor of built-in pole vectors\r\n    for (const constraint of constraints) {\r\n      if (constraint.jointIndex === jointIndex) {\r\n        // Skip IKPoleVectorConstraint - use built-in pole vectors instead\r\n        if (constraint.constructor.name === 'IKPoleVectorConstraint') {\r\n          continue;\r\n        }\r\n        constraint.apply(this._chain.joints);\r\n      }\r\n    }\r\n\r\n    // Apply built-in pole vector if configured for this joint\r\n    const poleConfig = this._poleVectors.get(jointIndex);\r\n    if (poleConfig && poleConfig.weight > 0.001) {\r\n      this._applyPoleVectorTwist(jointIndex, poleConfig.position, poleConfig.weight);\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 adjusts the joint position to align with the pole vector.\r\n   * It uses the same algorithm as IKPoleVectorConstraint but is integrated\r\n   * into the solver for better performance and control.\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   * Stretch the chain toward an unreachable target.\r\n   * All joints are aligned in a straight line toward the target.\r\n   *\r\n   * @param target - Unreachable target position\r\n   */\r\n  private _stretchToward(target: Vector3): void {\r\n    const joints = this._chain.joints;\r\n    const rootPos = joints[0].originalPosition;\r\n\r\n    // Calculate direction from root to target\r\n    const direction = Vector3.sub(target, rootPos, new Vector3()).inplaceNormalize();\r\n\r\n    // Place each joint along the direction at its bone length\r\n    let currentPos = rootPos.clone();\r\n    for (let i = 0; i < joints.length; i++) {\r\n      joints[i].position.set(currentPos);\r\n      if (i < joints.length - 1) {\r\n        const offset = Vector3.scale(direction, joints[i].boneLength, new Vector3());\r\n        currentPos.addBy(offset);\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"names":["FABRIKSolver","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","rootPos","originalPosition","distToTarget","Vector3","distance","totalLength","_stretchToward","converged","iteration","_maxIterations","distToEnd","_tolerance","_forwardPass","_backwardPass","applyToNodes","joint","nextJoint","originalDir","sub","newDir","originalDirNorm","normalize","newDirNorm","deltaRotation","Quaternion","IKUtils","fromToRotation","worldRotation","multiply","originalRotation","swing","twist","decomposeSwingTwist","twistAngle","getTwistAngle","constraint","clampAndSmoothTwist","previousTwist","clampedTwist","fromAxisAngle","slerp","previousIKRotation","node","parent","parentWorldRotation","worldMatrix","decompose","parentInvRotation","conjugate","localRotation","rotation","childJoint","direction","magnitude","scaleBy","scale","boneLength","add","_applyConstraintsForJoint","constraints","name","apply","poleConfig","_applyPoleVectorTwist","parentJoint","currentJoint","parentPos","currentPos","childPos","parentToChild","lineLength","lineDir","parentToCurrent","projectionLength","dot","projectionPoint","perpendicular","perpLength","parentToPole","poleProjectionLength","poleProjectionPoint","poleDirection","poleDirLength","desiredPerpendicular","newPosition","blended","x","y","z","inplaceNormalize","offset","addBy"],"mappings":"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"}

package/dist/animation/ik/ik_angle_constraint.js

@@ -0,0 +1,181 @@
+import { Vector3 } from '@zephyr3d/base';
+import { IKConstraint } from './ik_constraint.js';
+
+/**
+ * Angle constraint for IK joints.
+ *
+ * Limits the angle between the bone from parent to this joint
+ * and the bone from this joint to child.
+ *
+ * @remarks
+ * This is useful for joints like elbows and knees that have
+ * limited range of motion.
+ *
+ * @public
+ */ class IKAngleConstraint extends IKConstraint {
+    /** Minimum angle in degrees */ _minAngle;
+    /** Maximum angle in degrees */ _maxAngle;
+    /**
+   * Create an angle constraint.
+   *
+   * @param jointIndex - Index of the joint in the chain
+   * @param minAngle - Minimum angle in degrees (0 = straight)
+   * @param maxAngle - Maximum angle in degrees (180 = fully bent)
+   */ constructor(jointIndex, minAngle, maxAngle){
+        super(jointIndex);
+        this._minAngle = Math.max(0, minAngle);
+        this._maxAngle = Math.min(180, maxAngle);
+        if (this._minAngle > this._maxAngle) {
+            throw new Error('IKAngleConstraint: minAngle must be <= maxAngle');
+        }
+    }
+    /**
+   * Get the minimum angle in degrees.
+   */ get minAngle() {
+        return this._minAngle;
+    }
+    /**
+   * Set the minimum angle in degrees.
+   */ set minAngle(value) {
+        this._minAngle = Math.max(0, Math.min(value, this._maxAngle));
+    }
+    /**
+   * Get the maximum angle in degrees.
+   */ get maxAngle() {
+        return this._maxAngle;
+    }
+    /**
+   * Set the maximum angle in degrees.
+   */ set maxAngle(value) {
+        this._maxAngle = Math.min(180, Math.max(value, this._minAngle));
+    }
+    /**
+   * Apply the angle constraint to limit joint bending.
+   */ apply(joints) {
+        const index = this._jointIndex;
+        // For end effector (last joint), we constrain the angle between the last two bones
+        // For other joints, we constrain the angle at the joint itself
+        if (index === joints.length - 1) {
+            // End effector: constrain angle between (parent-1 -> parent) and (parent -> this)
+            if (index < 2) {
+                return; // Need at least 3 joints total
+            }
+            this._applyEndEffectorConstraint(joints, index);
+        } else {
+            // Regular joint: constrain angle between (parent -> this) and (this -> child)
+            if (index < 1) {
+                return; // Root joint cannot be constrained this way
+            }
+            this._applyRegularConstraint(joints, index);
+        }
+    }
+    /**
+   * Apply constraint to end effector joint.
+   */ _applyEndEffectorConstraint(joints, index) {
+        const grandParentJoint = joints[index - 2];
+        const parentJoint = joints[index - 1];
+        const currentJoint = joints[index];
+        // Calculate bone vectors
+        const incomingBone = Vector3.sub(parentJoint.position, grandParentJoint.position, new Vector3());
+        const outgoingBone = Vector3.sub(currentJoint.position, parentJoint.position, new Vector3());
+        const incomingLen = incomingBone.magnitude;
+        const outgoingLen = outgoingBone.magnitude;
+        if (incomingLen < 0.000001 || outgoingLen < 0.000001) {
+            return;
+        }
+        // Normalize
+        const incomingNorm = Vector3.scale(incomingBone, 1 / incomingLen, new Vector3());
+        const outgoingNorm = Vector3.scale(outgoingBone, 1 / outgoingLen, new Vector3());
+        // Calculate current angle
+        const dot = Vector3.dot(incomingNorm, outgoingNorm);
+        const currentAngleDeg = Math.acos(Math.max(-1, Math.min(1, dot))) * (180 / Math.PI);
+        // Check if constraint is violated
+        let targetAngleDeg = currentAngleDeg;
+        if (currentAngleDeg < this._minAngle) {
+            targetAngleDeg = this._minAngle;
+        } else if (currentAngleDeg > this._maxAngle) {
+            targetAngleDeg = this._maxAngle;
+        } else {
+            return;
+        }
+        // Apply the same constraint logic as regular joints
+        this._adjustJointAngle(incomingNorm, outgoingNorm, currentAngleDeg, targetAngleDeg, parentJoint, currentJoint);
+    }
+    /**
+   * Apply constraint to regular joint.
+   */ _applyRegularConstraint(joints, index) {
+        const parentJoint = joints[index - 1];
+        const currentJoint = joints[index];
+        const childJoint = joints[index + 1];
+        // Calculate bone vectors: incoming bone (parent->current) and outgoing bone (current->child)
+        const incomingBone = Vector3.sub(currentJoint.position, parentJoint.position, new Vector3());
+        const outgoingBone = Vector3.sub(childJoint.position, currentJoint.position, new Vector3());
+        const incomingLen = incomingBone.magnitude;
+        const outgoingLen = outgoingBone.magnitude;
+        if (incomingLen < 0.000001 || outgoingLen < 0.000001) {
+            return;
+        }
+        // Normalize
+        const incomingNorm = Vector3.scale(incomingBone, 1 / incomingLen, new Vector3());
+        const outgoingNorm = Vector3.scale(outgoingBone, 1 / outgoingLen, new Vector3());
+        // Calculate current angle between incoming and outgoing bones (interior angle)
+        const dot = Vector3.dot(incomingNorm, outgoingNorm);
+        const currentAngleDeg = Math.acos(Math.max(-1, Math.min(1, dot))) * (180 / Math.PI);
+        // Check if constraint is violated
+        let targetAngleDeg = currentAngleDeg;
+        if (currentAngleDeg < this._minAngle) {
+            targetAngleDeg = this._minAngle;
+        } else if (currentAngleDeg > this._maxAngle) {
+            targetAngleDeg = this._maxAngle;
+        } else {
+            return;
+        }
+        // Apply the constraint
+        this._adjustJointAngle(incomingNorm, outgoingNorm, currentAngleDeg, targetAngleDeg, currentJoint, childJoint);
+    }
+    /**
+   * Adjust joint angle by rotating the outgoing bone.
+   */ _adjustJointAngle(incomingNorm, outgoingNorm, currentAngleDeg, targetAngleDeg, pivotJoint, targetJoint) {
+        // Add a dead zone to prevent oscillation
+        const angleDifference = Math.abs(targetAngleDeg - currentAngleDeg);
+        const isHardConstraint = Math.abs(this._maxAngle - this._minAngle) < 0.01;
+        const deadZone = isHardConstraint ? 0.2 : 0.1;
+        if (angleDifference < deadZone) {
+            return; // Too close to target, avoid over-correction
+        }
+        // Calculate rotation axis (perpendicular to both bone vectors)
+        const axis = Vector3.cross(incomingNorm, outgoingNorm, new Vector3());
+        const axisLen = axis.magnitude;
+        // Use a smaller threshold to allow constraint to work at small angles
+        if (axisLen < 0.0001) {
+            return; // Vectors are too close to parallel or anti-parallel
+        }
+        axis.scaleBy(1 / axisLen);
+        // Calculate the angle we need to rotate
+        const targetAngleRad = targetAngleDeg * (Math.PI / 180);
+        const currentAngleRad = currentAngleDeg * (Math.PI / 180);
+        let deltaAngle = targetAngleRad - currentAngleRad;
+        // Apply full correction without damping to ensure constraints are enforced
+        // This is necessary because FABRIK will try to undo the constraint in the next iteration
+        // So we need strong constraint enforcement
+        // Rotate the outgoing bone vector around the axis by deltaAngle
+        const cos = Math.cos(deltaAngle);
+        const sin = Math.sin(deltaAngle);
+        const oneMinusCos = 1 - cos;
+        // Rodrigues' rotation formula
+        const rotated = new Vector3();
+        rotated.x = outgoingNorm.x * (cos + axis.x * axis.x * oneMinusCos) + outgoingNorm.y * (axis.x * axis.y * oneMinusCos - axis.z * sin) + outgoingNorm.z * (axis.x * axis.z * oneMinusCos + axis.y * sin);
+        rotated.y = outgoingNorm.x * (axis.y * axis.x * oneMinusCos + axis.z * sin) + outgoingNorm.y * (cos + axis.y * axis.y * oneMinusCos) + outgoingNorm.z * (axis.y * axis.z * oneMinusCos - axis.x * sin);
+        rotated.z = outgoingNorm.x * (axis.z * axis.x * oneMinusCos - axis.y * sin) + outgoingNorm.y * (axis.z * axis.y * oneMinusCos + axis.x * sin) + outgoingNorm.z * (cos + axis.z * axis.z * oneMinusCos);
+        // Update target joint position using the rotated bone vector
+        const boneLength = pivotJoint.boneLength;
+        rotated.scaleBy(boneLength);
+        Vector3.add(pivotJoint.position, rotated, targetJoint.position);
+    // Note: We do NOT recursively update subsequent joints here.
+    // Instead, we let FABRIK algorithm handle the propagation in subsequent iterations.
+    // This ensures that each joint's constraint is properly applied.
+    }
+}
+
+export { IKAngleConstraint };
+//# sourceMappingURL=ik_angle_constraint.js.map