@zephyr3d/scene 0.7.1 → 0.8.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"ik_pole_constraint.js","sources":["../../../src/animation/ik/ik_pole_constraint.ts"],"sourcesContent":["import { Vector3 } from '@zephyr3d/base';\r\nimport { IKConstraint } from './ik_constraint';\r\nimport type { IKJoint } from './ik_joint';\r\n\r\n/**\r\n * Pole vector constraint for IK chains.\r\n *\r\n * Controls the twist/rotation of a joint chain by ensuring the middle joint\r\n * bends toward a specified pole vector position.\r\n *\r\n * @remarks\r\n * This is commonly used for arms and legs to control which direction\r\n * the elbow or knee points. For example, ensuring an elbow points\r\n * backward or a knee points forward.\r\n *\r\n * The pole vector defines a plane, and the middle joint is constrained\r\n * to lie on this plane.\r\n *\r\n * @public\r\n */\r\nexport class IKPoleVectorConstraint extends IKConstraint {\r\n  /** The pole vector position in world space */\r\n  private _poleVector: Vector3;\r\n  /** Weight of the constraint (0 = no effect, 1 = full effect) */\r\n  private _weight: number;\r\n\r\n  /**\r\n   * Create a pole vector constraint.\r\n   *\r\n   * @param jointIndex - Index of the middle joint to constrain (typically elbow or knee)\r\n   * @param poleVector - Position in world space that the joint should point toward\r\n   * @param weight - Constraint weight (0-1, default: 1)\r\n   */\r\n  constructor(jointIndex: number, poleVector: Vector3, weight = 1) {\r\n    super(jointIndex);\r\n    this._poleVector = poleVector.clone();\r\n    this._weight = Math.max(0, Math.min(1, weight));\r\n  }\r\n\r\n  /**\r\n   * Get the pole vector position.\r\n   */\r\n  get poleVector(): Vector3 {\r\n    return this._poleVector;\r\n  }\r\n\r\n  /**\r\n   * Set the pole vector position.\r\n   */\r\n  set poleVector(value: Vector3) {\r\n    this._poleVector.set(value);\r\n  }\r\n\r\n  /**\r\n   * Get the constraint weight.\r\n   */\r\n  get weight(): number {\r\n    return this._weight;\r\n  }\r\n\r\n  /**\r\n   * Set the constraint weight (0-1).\r\n   */\r\n  set weight(value: number) {\r\n    this._weight = Math.max(0, Math.min(1, value));\r\n  }\r\n\r\n  /**\r\n   * Apply the pole vector constraint.\r\n   *\r\n   * This adjusts the middle joint position to align with the pole vector\r\n   * while maintaining bone lengths.\r\n   */\r\n  apply(joints: IKJoint[]): void {\r\n    const index = this._jointIndex;\r\n\r\n    // Need at least 3 joints (parent, this, child)\r\n    if (index < 1 || index >= joints.length - 1) {\r\n      return;\r\n    }\r\n\r\n    if (this._weight < 0.001) {\r\n      return; // No effect\r\n    }\r\n\r\n    const parentJoint = joints[index - 1];\r\n    const currentJoint = joints[index];\r\n    const childJoint = joints[index + 1];\r\n\r\n    // Calculate the plane defined by parent, child, and pole vector\r\n    const parentPos = parentJoint.position;\r\n    const childPos = childJoint.position;\r\n    const currentPos = currentJoint.position;\r\n\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    projectionPoint.addBy(parentPos);\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(this._poleVector, parentPos, new Vector3());\r\n    const poleProjectionLength = Vector3.dot(parentToPole, lineDir);\r\n    const poleProjectionPoint = Vector3.scale(lineDir, poleProjectionLength, new Vector3());\r\n    poleProjectionPoint.addBy(parentPos);\r\n\r\n    // Direction from projection to pole (perpendicular to line)\r\n    const poleDirection = Vector3.sub(this._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 (this._weight < 0.999) {\r\n      // Manual lerp: result = a + (b - a) * t\r\n      const blended = new Vector3();\r\n      blended.x = currentPos.x + (newPosition.x - currentPos.x) * this._weight;\r\n      blended.y = currentPos.y + (newPosition.y - currentPos.y) * this._weight;\r\n      blended.z = currentPos.z + (newPosition.z - currentPos.z) * this._weight;\r\n      currentJoint.position.set(blended);\r\n    } else {\r\n      currentJoint.position.set(newPosition);\r\n    }\r\n  }\r\n}\r\n"],"names":["IKPoleVectorConstraint","IKConstraint","jointIndex","poleVector","weight","_poleVector","clone","_weight","Math","max","min","value","set","apply","joints","index","_jointIndex","length","parentJoint","currentJoint","childJoint","parentPos","position","childPos","currentPos","parentToChild","Vector3","sub","lineLength","magnitude","lineDir","scale","parentToCurrent","projectionLength","dot","projectionPoint","addBy","perpendicular","perpLength","parentToPole","poleProjectionLength","poleProjectionPoint","poleDirection","poleDirLength","scaleBy","desiredPerpendicular","newPosition","add","blended","x","y","z"],"mappings":"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"}

package/dist/animation/ik/ik_solver.js

@@ -0,0 +1,48 @@
+/**
+ * Base class for IK solvers.
+ *
+ * @public
+ */ class IKSolver {
+    /** The IK chain to solve */ _chain;
+    /** Maximum number of iterations */ _maxIterations;
+    /** Convergence tolerance (distance threshold) */ _tolerance;
+    /**
+   * Create an IK 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){
+        this._chain = chain;
+        this._maxIterations = maxIterations;
+        this._tolerance = tolerance;
+    }
+    /**
+   * Get the IK chain.
+   */ get chain() {
+        return this._chain;
+    }
+    /**
+   * Set maximum number of iterations.
+   */ setMaxIterations(value) {
+        this._maxIterations = Math.max(1, value);
+    }
+    /**
+   * Get maximum number of iterations.
+   */ getMaxIterations() {
+        return this._maxIterations;
+    }
+    /**
+   * Set convergence tolerance.
+   */ setTolerance(value) {
+        this._tolerance = Math.max(0, value);
+    }
+    /**
+   * Get convergence tolerance.
+   */ getTolerance() {
+        return this._tolerance;
+    }
+}
+
+export { IKSolver };
+//# sourceMappingURL=ik_solver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ik_solver.js","sources":["../../../src/animation/ik/ik_solver.ts"],"sourcesContent":["import type { Vector3 } from '@zephyr3d/base';\r\nimport type { IKChain } from './ik_chain';\r\n\r\n/**\r\n * Base class for IK solvers.\r\n *\r\n * @public\r\n */\r\nexport abstract class IKSolver {\r\n  /** The IK chain to solve */\r\n  protected _chain: IKChain;\r\n  /** Maximum number of iterations */\r\n  protected _maxIterations: number;\r\n  /** Convergence tolerance (distance threshold) */\r\n  protected _tolerance: number;\r\n\r\n  /**\r\n   * Create an IK 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    this._chain = chain;\r\n    this._maxIterations = maxIterations;\r\n    this._tolerance = tolerance;\r\n  }\r\n\r\n  /**\r\n   * Get the IK chain.\r\n   */\r\n  get chain(): IKChain {\r\n    return this._chain;\r\n  }\r\n\r\n  /**\r\n   * Set maximum number of iterations.\r\n   */\r\n  setMaxIterations(value: number): void {\r\n    this._maxIterations = Math.max(1, value);\r\n  }\r\n\r\n  /**\r\n   * Get maximum number of iterations.\r\n   */\r\n  getMaxIterations(): number {\r\n    return this._maxIterations;\r\n  }\r\n\r\n  /**\r\n   * Set convergence tolerance.\r\n   */\r\n  setTolerance(value: number): void {\r\n    this._tolerance = Math.max(0, value);\r\n  }\r\n\r\n  /**\r\n   * Get convergence tolerance.\r\n   */\r\n  getTolerance(): number {\r\n    return this._tolerance;\r\n  }\r\n\r\n  /**\r\n   * Solve the IK chain to reach the target position.\r\n   *\r\n   * @param target - Target position for the end effector\r\n   * @returns True if converged, false otherwise\r\n   */\r\n  abstract solve(target: Vector3): boolean;\r\n\r\n  /**\r\n   * Apply the solved positions to the scene nodes as rotations.\r\n   *\r\n   * @param weight - Blend weight (0 = original, 1 = full IK)\r\n   */\r\n  abstract applyToNodes(weight?: number): void;\r\n}\r\n"],"names":["IKSolver","chain","maxIterations","tolerance","_chain","_maxIterations","_tolerance","setMaxIterations","value","Math","max","getMaxIterations","setTolerance","getTolerance"],"mappings":"AAGA;;;;AAIC,IACM,MAAeA,QAAAA,CAAAA;iCAEpB,MAA0B;wCAE1B,cAAiC;sDAEjC,UAA6B;AAE7B;;;;;;MAOA,WAAA,CAAYC,KAAc,EAAEC,aAAAA,GAAgB,EAAE,EAAEC,SAAAA,GAAY,KAAK,CAAE;QACjE,IAAI,CAACC,MAAM,GAAGH,KAAAA;QACd,IAAI,CAACI,cAAc,GAAGH,aAAAA;QACtB,IAAI,CAACI,UAAU,GAAGH,SAAAA;AACpB;AAEA;;AAEC,MACD,IAAIF,KAAiB,GAAA;QACnB,OAAO,IAAI,CAACG,MAAM;AACpB;AAEA;;MAGAG,gBAAAA,CAAiBC,KAAa,EAAQ;AACpC,QAAA,IAAI,CAACH,cAAc,GAAGI,IAAKC,CAAAA,GAAG,CAAC,CAAGF,EAAAA,KAAAA,CAAAA;AACpC;AAEA;;AAEC,MACDG,gBAA2B,GAAA;QACzB,OAAO,IAAI,CAACN,cAAc;AAC5B;AAEA;;MAGAO,YAAAA,CAAaJ,KAAa,EAAQ;AAChC,QAAA,IAAI,CAACF,UAAU,GAAGG,IAAKC,CAAAA,GAAG,CAAC,CAAGF,EAAAA,KAAAA,CAAAA;AAChC;AAEA;;AAEC,MACDK,YAAuB,GAAA;QACrB,OAAO,IAAI,CAACP,UAAU;AACxB;AAgBF;;;;"}

package/dist/animation/ik/ik_track.js

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

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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"}