@zephyr3d/scene 0.9.4 → 0.9.6

package/dist/animation/ik/ik_pole_constraint.js

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

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

@@ -1 +0,0 @@
-{"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_track.js

@@ -1,96 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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_postprocessor.js

@@ -1,71 +0,0 @@
-import { SkeletonPostProcessor } from './skeleton_postprocessor.js';
-
-/**
- * Post-processor wrapper for IK solvers.
- *
- * Integrates IK solving into the skeleton post-processing pipeline.
- * The IK solver is executed each frame and results are blended with the base animation.
- *
- * @example
- * ```typescript
- * const ikChain = new IKChain([joint1, joint2, joint3]);
- * const ikSolver = new FABRIKSolver(ikChain);
- * const targetPos = new Vector3(1, 2, 3);
- * const processor = new IKPostProcessor(ikSolver, targetPos, 1.0);
- * skeleton.addPostProcessor(processor);
- * ```
- *
- * @public
- */ class IKPostProcessor extends SkeletonPostProcessor {
-    _solver;
-    _target;
-    /**
-   * Create an IK post-processor.
-   *
-   * @param solver - The IK solver to integrate
-   * @param target - Target position for the end effector
-   * @param weight - Blend weight [0-1] (default: 1.0)
-   * @param priority - Priority for ordering (default: 50)
-   */ constructor(solver, target, weight = 1.0, priority = 50){
-        super(weight, priority);
-        this._solver = solver;
-        this._target = target.clone();
-    }
-    /**
-   * Get the IK solver.
-   */ get solver() {
-        return this._solver;
-    }
-    /**
-   * Get the current target position.
-   */ get target() {
-        return this._target.clone();
-    }
-    /**
-   * Set the target position for the end effector.
-   *
-   * @param target - New target position (will be cloned)
-   */ setTarget(target) {
-        this._target.set(target);
-    }
-    /**
-   * Apply IK solving to skeleton joints.
-   */ apply(_skeleton, _deltaTime) {
-        if (!this._enabled || this._weight <= 0) {
-            return;
-        }
-        // Solve IK
-        this._solver.solve(this._target);
-        // Apply to nodes with blending
-        this._solver.applyToNodes(this._weight);
-    }
-    /**
-   * Reset the IK solver to initial state.
-   */ reset() {
-    // IK solvers typically don't need explicit reset
-    // as they solve based on current joint positions
-    }
-}
-
-export { IKPostProcessor };
-//# sourceMappingURL=ik_postprocessor.js.map

package/dist/animation/ik_postprocessor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ik_postprocessor.js","sources":["../../src/animation/ik_postprocessor.ts"],"sourcesContent":["import { SkeletonPostProcessor } from './skeleton_postprocessor';\r\nimport type { Skeleton } from './skeleton';\r\nimport type { IKSolver } from './ik/ik_solver';\r\nimport type { Vector3 } from '@zephyr3d/base';\r\n\r\n/**\r\n * Post-processor wrapper for IK solvers.\r\n *\r\n * Integrates IK solving into the skeleton post-processing pipeline.\r\n * The IK solver is executed each frame and results are blended with the base animation.\r\n *\r\n * @example\r\n * ```typescript\r\n * const ikChain = new IKChain([joint1, joint2, joint3]);\r\n * const ikSolver = new FABRIKSolver(ikChain);\r\n * const targetPos = new Vector3(1, 2, 3);\r\n * const processor = new IKPostProcessor(ikSolver, targetPos, 1.0);\r\n * skeleton.addPostProcessor(processor);\r\n * ```\r\n *\r\n * @public\r\n */\r\nexport class IKPostProcessor<Solver extends IKSolver = IKSolver> extends SkeletonPostProcessor {\r\n  private _solver: Solver;\r\n  private _target: Vector3;\r\n\r\n  /**\r\n   * Create an IK post-processor.\r\n   *\r\n   * @param solver - The IK solver to integrate\r\n   * @param target - Target position for the end effector\r\n   * @param weight - Blend weight [0-1] (default: 1.0)\r\n   * @param priority - Priority for ordering (default: 50)\r\n   */\r\n  constructor(solver: Solver, target: Vector3, weight: number = 1.0, priority: number = 50) {\r\n    super(weight, priority);\r\n    this._solver = solver;\r\n    this._target = target.clone();\r\n  }\r\n\r\n  /**\r\n   * Get the IK solver.\r\n   */\r\n  get solver(): Solver {\r\n    return this._solver;\r\n  }\r\n\r\n  /**\r\n   * Get the current target position.\r\n   */\r\n  get target(): Vector3 {\r\n    return this._target.clone();\r\n  }\r\n\r\n  /**\r\n   * Set the target position for the end effector.\r\n   *\r\n   * @param target - New target position (will be cloned)\r\n   */\r\n  setTarget(target: Vector3): void {\r\n    this._target.set(target);\r\n  }\r\n\r\n  /**\r\n   * Apply IK solving to skeleton joints.\r\n   */\r\n  apply(_skeleton: Skeleton, _deltaTime: number): void {\r\n    if (!this._enabled || this._weight <= 0) {\r\n      return;\r\n    }\r\n\r\n    // Solve IK\r\n    this._solver.solve(this._target);\r\n\r\n    // Apply to nodes with blending\r\n    this._solver.applyToNodes(this._weight);\r\n  }\r\n\r\n  /**\r\n   * Reset the IK solver to initial state.\r\n   */\r\n  reset(): void {\r\n    // IK solvers typically don't need explicit reset\r\n    // as they solve based on current joint positions\r\n  }\r\n}\r\n"],"names":["IKPostProcessor","SkeletonPostProcessor","_solver","_target","solver","target","weight","priority","clone","setTarget","set","apply","_skeleton","_deltaTime","_enabled","_weight","solve","applyToNodes","reset"],"mappings":";;AAKA;;;;;;;;;;;;;;;;IAiBO,MAAMA,eAA4DC,SAAAA,qBAAAA,CAAAA;IAC/DC,OAAgB;IAChBC,OAAiB;AAEzB;;;;;;;MAQA,WAAA,CAAYC,MAAc,EAAEC,MAAe,EAAEC,SAAiB,GAAG,EAAEC,QAAmB,GAAA,EAAE,CAAE;AACxF,QAAA,KAAK,CAACD,MAAQC,EAAAA,QAAAA,CAAAA;QACd,IAAI,CAACL,OAAO,GAAGE,MAAAA;AACf,QAAA,IAAI,CAACD,OAAO,GAAGE,MAAAA,CAAOG,KAAK,EAAA;AAC7B;AAEA;;AAEC,MACD,IAAIJ,MAAiB,GAAA;QACnB,OAAO,IAAI,CAACF,OAAO;AACrB;AAEA;;AAEC,MACD,IAAIG,MAAkB,GAAA;AACpB,QAAA,OAAO,IAAI,CAACF,OAAO,CAACK,KAAK,EAAA;AAC3B;AAEA;;;;MAKAC,SAAAA,CAAUJ,MAAe,EAAQ;AAC/B,QAAA,IAAI,CAACF,OAAO,CAACO,GAAG,CAACL,MAAAA,CAAAA;AACnB;AAEA;;AAEC,MACDM,KAAMC,CAAAA,SAAmB,EAAEC,UAAkB,EAAQ;QACnD,IAAI,CAAC,IAAI,CAACC,QAAQ,IAAI,IAAI,CAACC,OAAO,IAAI,CAAG,EAAA;AACvC,YAAA;AACF;;AAGA,QAAA,IAAI,CAACb,OAAO,CAACc,KAAK,CAAC,IAAI,CAACb,OAAO,CAAA;;AAG/B,QAAA,IAAI,CAACD,OAAO,CAACe,YAAY,CAAC,IAAI,CAACF,OAAO,CAAA;AACxC;AAEA;;AAEC,MACDG,KAAc,GAAA;;;AAGd;AACF;;;;"}

package/dist/animation/joint_dynamics/math.js

@@ -1,16 +0,0 @@
-// spcr-joint-dynamics — math adapter layer
-// Wraps base/vector.ts (class-based) with plain-object API for backward compatibility
-// ── Utility ──
-function clamp(v, min, max) {
-    return v < min ? min : v > max ? max : v;
-}
-function clamp01(v) {
-    return v < 0 ? 0 : v > 1 ? 1 : v;
-}
-function smoothStep(from, to, t) {
-    const c = clamp01((t - from) / (to - from));
-    return c * c * (3 - 2 * c);
-}
-
-export { clamp, clamp01, smoothStep };
-//# sourceMappingURL=math.js.map

package/dist/animation/joint_dynamics/math.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"math.js","sources":["../../../src/animation/joint_dynamics/math.ts"],"sourcesContent":["// spcr-joint-dynamics — math adapter layer\r\n// Wraps base/vector.ts (class-based) with plain-object API for backward compatibility\r\n\r\n// ── Utility ──\r\n\r\nexport function clamp(v: number, min: number, max: number): number {\r\n  return v < min ? min : v > max ? max : v;\r\n}\r\n\r\nexport function clamp01(v: number): number {\r\n  return v < 0 ? 0 : v > 1 ? 1 : v;\r\n}\r\n\r\nexport function smoothStep(from: number, to: number, t: number): number {\r\n  const c = clamp01((t - from) / (to - from));\r\n  return c * c * (3 - 2 * c);\r\n}\r\n"],"names":["clamp","v","min","max","clamp01","smoothStep","from","to","t","c"],"mappings":"AAAA;AACA;AAEA;AAEO,SAASA,KAAMC,CAAAA,CAAS,EAAEC,GAAW,EAAEC,GAAW,EAAA;AACvD,IAAA,OAAOF,CAAIC,GAAAA,GAAAA,GAAMA,GAAMD,GAAAA,CAAAA,GAAIE,MAAMA,GAAMF,GAAAA,CAAAA;AACzC;AAEO,SAASG,QAAQH,CAAS,EAAA;AAC/B,IAAA,OAAOA,CAAI,GAAA,CAAA,GAAI,CAAIA,GAAAA,CAAAA,GAAI,IAAI,CAAIA,GAAAA,CAAAA;AACjC;AAEO,SAASI,UAAWC,CAAAA,IAAY,EAAEC,EAAU,EAAEC,CAAS,EAAA;IAC5D,MAAMC,CAAAA,GAAIL,QAAQ,CAACI,IAAIF,IAAG,KAAMC,EAAAA,GAAKD,IAAG,CAAA,CAAA;AACxC,IAAA,OAAOG,CAAIA,GAAAA,CAAAA,IAAK,CAAA,GAAI,IAAIA,CAAAA,CAAAA;AAC1B;;;;"}

package/dist/animation/manual_transform_processor.js

@@ -1,156 +0,0 @@
-import { Vector3, Quaternion } from '@zephyr3d/base';
-import { SkeletonPostProcessor } from './skeleton_postprocessor.js';
-
-/**
- * Post-processor for manual joint transform control.
- *
- * Allows setting custom transforms for specific joints that blend with
- * the base animation/bind pose layer.
- *
- * @example
- * ```typescript
- * const processor = new ManualTransformProcessor();
- * processor.setJointPosition(5, new Vector3(1, 2, 3));
- * processor.setJointRotation(5, Quaternion.fromEuler(0, Math.PI / 2, 0));
- * skeleton.addPostProcessor(processor);
- * ```
- *
- * @public
- */ class ManualTransformProcessor extends SkeletonPostProcessor {
-    /** Map of joint index to transform overrides */ _overrides;
-    constructor(weight = 1.0, priority = 100){
-        super(weight, priority);
-        this._overrides = new Map();
-    }
-    /**
-   * Set position override for a joint.
-   *
-   * @param jointIndex - Index of the joint in the skeleton
-   * @param position - New local position (will be cloned)
-   */ setJointPosition(jointIndex, position) {
-        let override = this._overrides.get(jointIndex);
-        if (!override) {
-            override = {};
-            this._overrides.set(jointIndex, override);
-        }
-        override.position = position.clone();
-    }
-    /**
-   * Set rotation override for a joint.
-   *
-   * @param jointIndex - Index of the joint in the skeleton
-   * @param rotation - New local rotation (will be cloned)
-   */ setJointRotation(jointIndex, rotation) {
-        let override = this._overrides.get(jointIndex);
-        if (!override) {
-            override = {};
-            this._overrides.set(jointIndex, override);
-        }
-        override.rotation = rotation.clone();
-    }
-    /**
-   * Set scale override for a joint.
-   *
-   * @param jointIndex - Index of the joint in the skeleton
-   * @param scale - New local scale (will be cloned)
-   */ setJointScale(jointIndex, scale) {
-        let override = this._overrides.get(jointIndex);
-        if (!override) {
-            override = {};
-            this._overrides.set(jointIndex, override);
-        }
-        override.scale = scale.clone();
-    }
-    /**
-   * Set full transform override for a joint.
-   *
-   * @param jointIndex - Index of the joint in the skeleton
-   * @param position - New local position (optional)
-   * @param rotation - New local rotation (optional)
-   * @param scale - New local scale (optional)
-   */ setJointTransform(jointIndex, position, rotation, scale) {
-        const override = {};
-        if (position) {
-            override.position = position.clone();
-        }
-        if (rotation) {
-            override.rotation = rotation.clone();
-        }
-        if (scale) {
-            override.scale = scale.clone();
-        }
-        this._overrides.set(jointIndex, override);
-    }
-    /**
-   * Clear override for a specific joint.
-   *
-   * @param jointIndex - Index of the joint to clear
-   */ clearJoint(jointIndex) {
-        this._overrides.delete(jointIndex);
-    }
-    /**
-   * Clear all joint overrides.
-   */ clearAll() {
-        this._overrides.clear();
-    }
-    /**
-   * Check if a joint has any overrides.
-   *
-   * @param jointIndex - Index of the joint to check
-   * @returns True if the joint has overrides
-   */ hasOverride(jointIndex) {
-        return this._overrides.has(jointIndex);
-    }
-    /**
-   * Get the number of joints with overrides.
-   */ get overrideCount() {
-        return this._overrides.size;
-    }
-    /**
-   * Apply manual transform overrides to skeleton joints.
-   */ apply(skeleton, _deltaTime) {
-        if (!this._enabled || this._overrides.size === 0 || this._weight <= 0) {
-            return;
-        }
-        const joints = skeleton.joints;
-        const weight = this._weight;
-        this._overrides.forEach((override, jointIndex)=>{
-            if (jointIndex < 0 || jointIndex >= joints.length) {
-                return;
-            }
-            const joint = joints[jointIndex];
-            // Blend position
-            if (override.position) {
-                if (weight >= 1) {
-                    joint.position = override.position;
-                } else {
-                    joint.position = Vector3.combine(joint.position, override.position, weight, 1 - weight);
-                }
-            }
-            // Blend rotation
-            if (override.rotation) {
-                if (weight >= 1) {
-                    joint.rotation = override.rotation;
-                } else {
-                    joint.rotation = Quaternion.slerp(joint.rotation, override.rotation, weight);
-                }
-            }
-            // Blend scale
-            if (override.scale) {
-                if (weight >= 1) {
-                    joint.scale = override.scale;
-                } else {
-                    joint.scale = Vector3.combine(joint.scale, override.scale, weight, 1 - weight);
-                }
-            }
-        });
-    }
-    /**
-   * Reset the processor (clears all overrides).
-   */ reset() {
-        this._overrides.clear();
-    }
-}
-
-export { ManualTransformProcessor };
-//# sourceMappingURL=manual_transform_processor.js.map

package/dist/animation/manual_transform_processor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"manual_transform_processor.js","sources":["../../src/animation/manual_transform_processor.ts"],"sourcesContent":["import { Vector3, Quaternion } from '@zephyr3d/base';\r\nimport { SkeletonPostProcessor } from './skeleton_postprocessor';\r\nimport type { Skeleton } from './skeleton';\r\n\r\n/**\r\n * Manual transform override for specific joints.\r\n *\r\n * Stores position, rotation, and scale overrides for joints and blends them\r\n * with the base animation layer.\r\n */\r\ninterface JointOverride {\r\n  position?: Vector3;\r\n  rotation?: Quaternion;\r\n  scale?: Vector3;\r\n}\r\n\r\n/**\r\n * Post-processor for manual joint transform control.\r\n *\r\n * Allows setting custom transforms for specific joints that blend with\r\n * the base animation/bind pose layer.\r\n *\r\n * @example\r\n * ```typescript\r\n * const processor = new ManualTransformProcessor();\r\n * processor.setJointPosition(5, new Vector3(1, 2, 3));\r\n * processor.setJointRotation(5, Quaternion.fromEuler(0, Math.PI / 2, 0));\r\n * skeleton.addPostProcessor(processor);\r\n * ```\r\n *\r\n * @public\r\n */\r\nexport class ManualTransformProcessor extends SkeletonPostProcessor {\r\n  /** Map of joint index to transform overrides */\r\n  private _overrides: Map<number, JointOverride>;\r\n\r\n  constructor(weight: number = 1.0, priority: number = 100) {\r\n    super(weight, priority);\r\n    this._overrides = new Map();\r\n  }\r\n\r\n  /**\r\n   * Set position override for a joint.\r\n   *\r\n   * @param jointIndex - Index of the joint in the skeleton\r\n   * @param position - New local position (will be cloned)\r\n   */\r\n  setJointPosition(jointIndex: number, position: Vector3): void {\r\n    let override = this._overrides.get(jointIndex);\r\n    if (!override) {\r\n      override = {};\r\n      this._overrides.set(jointIndex, override);\r\n    }\r\n    override.position = position.clone();\r\n  }\r\n\r\n  /**\r\n   * Set rotation override for a joint.\r\n   *\r\n   * @param jointIndex - Index of the joint in the skeleton\r\n   * @param rotation - New local rotation (will be cloned)\r\n   */\r\n  setJointRotation(jointIndex: number, rotation: Quaternion): void {\r\n    let override = this._overrides.get(jointIndex);\r\n    if (!override) {\r\n      override = {};\r\n      this._overrides.set(jointIndex, override);\r\n    }\r\n    override.rotation = rotation.clone();\r\n  }\r\n\r\n  /**\r\n   * Set scale override for a joint.\r\n   *\r\n   * @param jointIndex - Index of the joint in the skeleton\r\n   * @param scale - New local scale (will be cloned)\r\n   */\r\n  setJointScale(jointIndex: number, scale: Vector3): void {\r\n    let override = this._overrides.get(jointIndex);\r\n    if (!override) {\r\n      override = {};\r\n      this._overrides.set(jointIndex, override);\r\n    }\r\n    override.scale = scale.clone();\r\n  }\r\n\r\n  /**\r\n   * Set full transform override for a joint.\r\n   *\r\n   * @param jointIndex - Index of the joint in the skeleton\r\n   * @param position - New local position (optional)\r\n   * @param rotation - New local rotation (optional)\r\n   * @param scale - New local scale (optional)\r\n   */\r\n  setJointTransform(jointIndex: number, position?: Vector3, rotation?: Quaternion, scale?: Vector3): void {\r\n    const override: JointOverride = {};\r\n    if (position) {\r\n      override.position = position.clone();\r\n    }\r\n    if (rotation) {\r\n      override.rotation = rotation.clone();\r\n    }\r\n    if (scale) {\r\n      override.scale = scale.clone();\r\n    }\r\n    this._overrides.set(jointIndex, override);\r\n  }\r\n\r\n  /**\r\n   * Clear override for a specific joint.\r\n   *\r\n   * @param jointIndex - Index of the joint to clear\r\n   */\r\n  clearJoint(jointIndex: number): void {\r\n    this._overrides.delete(jointIndex);\r\n  }\r\n\r\n  /**\r\n   * Clear all joint overrides.\r\n   */\r\n  clearAll(): void {\r\n    this._overrides.clear();\r\n  }\r\n\r\n  /**\r\n   * Check if a joint has any overrides.\r\n   *\r\n   * @param jointIndex - Index of the joint to check\r\n   * @returns True if the joint has overrides\r\n   */\r\n  hasOverride(jointIndex: number): boolean {\r\n    return this._overrides.has(jointIndex);\r\n  }\r\n\r\n  /**\r\n   * Get the number of joints with overrides.\r\n   */\r\n  get overrideCount(): number {\r\n    return this._overrides.size;\r\n  }\r\n\r\n  /**\r\n   * Apply manual transform overrides to skeleton joints.\r\n   */\r\n  apply(skeleton: Skeleton, _deltaTime: number): void {\r\n    if (!this._enabled || this._overrides.size === 0 || this._weight <= 0) {\r\n      return;\r\n    }\r\n\r\n    const joints = skeleton.joints;\r\n    const weight = this._weight;\r\n\r\n    this._overrides.forEach((override, jointIndex) => {\r\n      if (jointIndex < 0 || jointIndex >= joints.length) {\r\n        return;\r\n      }\r\n\r\n      const joint = joints[jointIndex];\r\n\r\n      // Blend position\r\n      if (override.position) {\r\n        if (weight >= 1) {\r\n          joint.position = override.position;\r\n        } else {\r\n          joint.position = Vector3.combine(joint.position, override.position, weight, 1 - weight);\r\n        }\r\n      }\r\n\r\n      // Blend rotation\r\n      if (override.rotation) {\r\n        if (weight >= 1) {\r\n          joint.rotation = override.rotation;\r\n        } else {\r\n          joint.rotation = Quaternion.slerp(joint.rotation, override.rotation, weight);\r\n        }\r\n      }\r\n\r\n      // Blend scale\r\n      if (override.scale) {\r\n        if (weight >= 1) {\r\n          joint.scale = override.scale;\r\n        } else {\r\n          joint.scale = Vector3.combine(joint.scale, override.scale, weight, 1 - weight);\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Reset the processor (clears all overrides).\r\n   */\r\n  reset(): void {\r\n    this._overrides.clear();\r\n  }\r\n}\r\n"],"names":["ManualTransformProcessor","SkeletonPostProcessor","weight","priority","_overrides","Map","setJointPosition","jointIndex","position","override","get","set","clone","setJointRotation","rotation","setJointScale","scale","setJointTransform","clearJoint","delete","clearAll","clear","hasOverride","has","overrideCount","size","apply","skeleton","_deltaTime","_enabled","_weight","joints","forEach","length","joint","Vector3","combine","Quaternion","slerp","reset"],"mappings":"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"}

package/dist/animation/skeleton_postprocessor.js

@@ -1,50 +0,0 @@
-/**
- * Abstract base class for skeleton post-processors.
- *
- * Post-processors are applied after the base animation/bind pose layer,
- * allowing procedural modifications like IK, spring physics, or manual overrides.
- *
- * @public
- */ class SkeletonPostProcessor {
-    /** Blend weight for this processor [0-1] */ _weight;
-    /** Whether this processor is enabled */ _enabled;
-    /** Priority for ordering (higher = applied later) */ _priority;
-    constructor(weight = 1.0, priority = 0){
-        this._weight = Math.max(0, Math.min(1, weight));
-        this._enabled = true;
-        this._priority = priority;
-    }
-    /**
-   * Get the blend weight [0-1]
-   */ get weight() {
-        return this._weight;
-    }
-    /**
-   * Set the blend weight [0-1]
-   */ set weight(value) {
-        this._weight = Math.max(0, Math.min(1, value));
-    }
-    /**
-   * Get whether this processor is enabled
-   */ get enabled() {
-        return this._enabled;
-    }
-    /**
-   * Set whether this processor is enabled
-   */ set enabled(value) {
-        this._enabled = value;
-    }
-    /**
-   * Get the priority (higher = applied later)
-   */ get priority() {
-        return this._priority;
-    }
-    /**
-   * Set the priority (higher = applied later)
-   */ set priority(value) {
-        this._priority = value;
-    }
-}
-
-export { SkeletonPostProcessor };
-//# sourceMappingURL=skeleton_postprocessor.js.map

package/dist/animation/skeleton_postprocessor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skeleton_postprocessor.js","sources":["../../src/animation/skeleton_postprocessor.ts"],"sourcesContent":["import type { Skeleton } from './skeleton';\r\n\r\n/**\r\n * Abstract base class for skeleton post-processors.\r\n *\r\n * Post-processors are applied after the base animation/bind pose layer,\r\n * allowing procedural modifications like IK, spring physics, or manual overrides.\r\n *\r\n * @public\r\n */\r\nexport abstract class SkeletonPostProcessor {\r\n  /** Blend weight for this processor [0-1] */\r\n  protected _weight: number;\r\n  /** Whether this processor is enabled */\r\n  protected _enabled: boolean;\r\n  /** Priority for ordering (higher = applied later) */\r\n  protected _priority: number;\r\n\r\n  constructor(weight: number = 1.0, priority: number = 0) {\r\n    this._weight = Math.max(0, Math.min(1, weight));\r\n    this._enabled = true;\r\n    this._priority = priority;\r\n  }\r\n\r\n  /**\r\n   * Get the blend weight [0-1]\r\n   */\r\n  get weight(): number {\r\n    return this._weight;\r\n  }\r\n\r\n  /**\r\n   * Set the blend 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   * Get whether this processor is enabled\r\n   */\r\n  get enabled(): boolean {\r\n    return this._enabled;\r\n  }\r\n\r\n  /**\r\n   * Set whether this processor is enabled\r\n   */\r\n  set enabled(value: boolean) {\r\n    this._enabled = value;\r\n  }\r\n\r\n  /**\r\n   * Get the priority (higher = applied later)\r\n   */\r\n  get priority(): number {\r\n    return this._priority;\r\n  }\r\n\r\n  /**\r\n   * Set the priority (higher = applied later)\r\n   */\r\n  set priority(value: number) {\r\n    this._priority = value;\r\n  }\r\n\r\n  /**\r\n   * Apply post-processing to skeleton joints.\r\n   *\r\n   * This method is called after the base animation/bind pose has been applied.\r\n   * Implementations should modify joint transforms and blend with the current state\r\n   * using the processor's weight.\r\n   *\r\n   * @param skeleton - The skeleton to process\r\n   * @param deltaTime - Time elapsed since last frame (in seconds)\r\n   */\r\n  abstract apply(skeleton: Skeleton, deltaTime: number): void;\r\n\r\n  /**\r\n   * Reset the processor to its initial state.\r\n   *\r\n   * Called when the skeleton or animation state changes significantly.\r\n   */\r\n  abstract reset(): void;\r\n}\r\n"],"names":["SkeletonPostProcessor","weight","priority","_weight","Math","max","min","_enabled","_priority","value","enabled"],"mappings":"AAEA;;;;;;;AAOC,IACM,MAAeA,qBAAAA,CAAAA;iDAEpB,OAA0B;6CAE1B,QAA4B;0DAE5B,SAA4B;AAE5B,IAAA,WAAA,CAAYC,MAAiB,GAAA,GAAG,EAAEC,QAAAA,GAAmB,CAAC,CAAE;QACtD,IAAI,CAACC,OAAO,GAAGC,IAAKC,CAAAA,GAAG,CAAC,CAAGD,EAAAA,IAAAA,CAAKE,GAAG,CAAC,CAAGL,EAAAA,MAAAA,CAAAA,CAAAA;QACvC,IAAI,CAACM,QAAQ,GAAG,IAAA;QAChB,IAAI,CAACC,SAAS,GAAGN,QAAAA;AACnB;AAEA;;AAEC,MACD,IAAID,MAAiB,GAAA;QACnB,OAAO,IAAI,CAACE,OAAO;AACrB;AAEA;;MAGA,IAAIF,MAAOQ,CAAAA,KAAa,EAAE;QACxB,IAAI,CAACN,OAAO,GAAGC,IAAKC,CAAAA,GAAG,CAAC,CAAGD,EAAAA,IAAAA,CAAKE,GAAG,CAAC,CAAGG,EAAAA,KAAAA,CAAAA,CAAAA;AACzC;AAEA;;AAEC,MACD,IAAIC,OAAmB,GAAA;QACrB,OAAO,IAAI,CAACH,QAAQ;AACtB;AAEA;;MAGA,IAAIG,OAAQD,CAAAA,KAAc,EAAE;QAC1B,IAAI,CAACF,QAAQ,GAAGE,KAAAA;AAClB;AAEA;;AAEC,MACD,IAAIP,QAAmB,GAAA;QACrB,OAAO,IAAI,CAACM,SAAS;AACvB;AAEA;;MAGA,IAAIN,QAASO,CAAAA,KAAa,EAAE;QAC1B,IAAI,CAACD,SAAS,GAAGC,KAAAA;AACnB;AAoBF;;;;"}