@zephyr3d/scene 0.7.1 → 0.8.1

package/dist/animation/ik_modifier.js

@@ -0,0 +1,61 @@
+import { SkeletonModifier } from './skeleton_modifier.js';
+
+/**
+ * Skeleton modifier 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.
+ *
+ * @public
+ */ class IKModifier extends SkeletonModifier {
+    _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)
+   */ constructor(solver, target, weight = 1.0){
+        super(weight);
+        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 { IKModifier };
+//# sourceMappingURL=ik_modifier.js.map

package/dist/animation/ik_modifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ik_modifier.js","sources":["../../src/animation/ik_modifier.ts"],"sourcesContent":["import { SkeletonModifier } from './skeleton_modifier';\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 * Skeleton modifier 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 * @public\r\n */\r\nexport class IKModifier<Solver extends IKSolver = IKSolver> extends SkeletonModifier {\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   */\r\n  constructor(solver: Solver, target: Vector3, weight: number = 1.0) {\r\n    super(weight);\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":["IKModifier","SkeletonModifier","_solver","_target","solver","target","weight","clone","setTarget","set","apply","_skeleton","_deltaTime","_enabled","_weight","solve","applyToNodes","reset"],"mappings":";;AAKA;;;;;;;IAQO,MAAMA,UAAuDC,SAAAA,gBAAAA,CAAAA;IAC1DC,OAAgB;IAChBC,OAAiB;AAEzB;;;;;;AAMC,MACD,YAAYC,MAAc,EAAEC,MAAe,EAAEC,MAAAA,GAAiB,GAAG,CAAE;AACjE,QAAA,KAAK,CAACA,MAAAA,CAAAA;QACN,IAAI,CAACJ,OAAO,GAAGE,MAAAA;AACf,QAAA,IAAI,CAACD,OAAO,GAAGE,MAAAA,CAAOE,KAAK,EAAA;AAC7B;AAEA;;AAEC,MACD,IAAIH,MAAiB,GAAA;QACnB,OAAO,IAAI,CAACF,OAAO;AACrB;AAEA;;AAEC,MACD,IAAIG,MAAkB,GAAA;AACpB,QAAA,OAAO,IAAI,CAACF,OAAO,CAACI,KAAK,EAAA;AAC3B;AAEA;;;;MAKAC,SAAAA,CAAUH,MAAe,EAAQ;AAC/B,QAAA,IAAI,CAACF,OAAO,CAACM,GAAG,CAACJ,MAAAA,CAAAA;AACnB;AAEA;;AAEC,MACDK,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,CAACZ,OAAO,CAACa,KAAK,CAAC,IAAI,CAACZ,OAAO,CAAA;;AAG/B,QAAA,IAAI,CAACD,OAAO,CAACc,YAAY,CAAC,IAAI,CAACF,OAAO,CAAA;AACxC;AAEA;;AAEC,MACDG,KAAc,GAAA;;;AAGd;AACF;;;;"}

package/dist/animation/ik_postprocessor.js

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

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

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

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

@@ -32,42 +32,32 @@ const tmpV3 = new Vector3();
     /** @internal */ _id;
     /** @internal */ _joints;
     /** @internal */ _inverseBindMatrices;
-    /** @internal */ _bindPoseMatrices;
+    /** @internal */ _bindPose;
     /** @internal */ _jointMatrices;
-    /** @internal */ _jointTransforms;
     /** @internal */ _jointOffsets;
     /** @internal */ _jointMatrixArray;
     /** @internal */ _jointTexture;
     /** @internal */ _playing;
+    /** @internal */ _modifiers;
+    /** @internal */ _lastUpdateTime;
     /**
    * Create a skeleton instance.
    *
    * @param joints - Joint scene nodes (one per joint), ordered to match skin data.
    * @param inverseBindMatrices - Inverse bind matrices for each joint.
    * @param bindPoseMatrices - Bind pose matrices for each joint (model-space).
-   */ constructor(joints, inverseBindMatrices, bindPoseMatrices, jointTransforms){
+   */ constructor(joints, inverseBindMatrices, bindPose){
         super();
         this._id = randomUUID();
         this._joints = joints;
         this._inverseBindMatrices = inverseBindMatrices;
-        this._bindPoseMatrices = bindPoseMatrices;
+        this._bindPose = bindPose;
         this._jointTexture = new DRef();
         this._playing = false;
-        if (jointTransforms) {
-            this._jointTransforms = jointTransforms;
-            for(let i = 0; i < jointTransforms.length; i++){
-                this._joints[i].scale = jointTransforms[i].scale;
-                this._joints[i].rotation = jointTransforms[i].rotation;
-                this._joints[i].position = jointTransforms[i].position;
-            }
-        } else {
-            this._jointTransforms = this._joints.map((joint)=>({
-                    scale: joint.scale.clone(),
-                    rotation: joint.rotation.clone(),
-                    position: joint.position.clone()
-                }));
-        }
-        this.updateJointMatrices();
+        this._modifiers = [];
+        this._lastUpdateTime = 0;
+        this.computeBindPose();
+        this.updateJointMatrices(0);
         Skeleton._registry.set(this._id, new DWeakRef(this));
     }
     /**
@@ -87,14 +77,11 @@ const tmpV3 = new Vector3();
     /** @internal */ get joints() {
         return this._joints;
     }
-    /** @internal */ get jointTransforms() {
-        return this._jointTransforms;
-    }
     /** @internal */ get inverseBindMatrices() {
         return this._inverseBindMatrices;
     }
-    /** @internal */ get bindPoseMatrices() {
-        return this._bindPoseMatrices;
+    /** @internal */ get bindPose() {
+        return this._bindPose;
     }
     /** @internal */ get playing() {
         return this._playing;
@@ -124,6 +111,20 @@ const tmpV3 = new Vector3();
         return this._jointTexture.get();
     }
     /**
+   * Get joint index by joint node
+   * @param joint - joint node
+   * @returns The index of the joint
+   */ getJointIndex(joint) {
+        return this._joints.indexOf(joint);
+    }
+    /**
+   * Get joint index by joint name
+   * @param jointName - joint name
+   * @returns The index of the joint
+   */ getJointIndexByName(jointName) {
+        return this._joints.findIndex((joint)=>joint.name === jointName);
+    }
+    /**
    * Update joint matrices from either provided transforms or the joints' world matrices.
    *
    * - Lazily creates the joint texture and its backing arrays on first call.
@@ -138,7 +139,8 @@ const tmpV3 = new Vector3();
    * @param jointTransforms - Optional per-joint transforms to use instead of node world matrices.
    * @param worldMatrix - Optional world-to-model transform applied before inverse bind.
    * @internal
-   */ updateJointMatrices(jointTransforms, worldMatrix) {
+   */ updateJointMatrices(deltaTime) {
+        this.applyModifiers(deltaTime);
         if (!this._jointTexture.get()) {
             this._createJointTexture();
         }
@@ -150,48 +152,50 @@ const tmpV3 = new Vector3();
             this._jointOffsets[0] = this._joints.length - this._jointOffsets[0] + 2;
         }
         for(let i = 0; i < this._joints.length; i++){
-            const mat = this._jointMatrices[i + this._jointOffsets[0] - 1];
-            const jointTransform = jointTransforms ? jointTransforms[i] : this._joints[i].worldMatrix;
-            if (worldMatrix) {
-                Matrix4x4.multiplyAffine(worldMatrix, jointTransform, mat);
-                Matrix4x4.multiply(mat, this._inverseBindMatrices[i], mat);
-            } else {
-                Matrix4x4.multiply(jointTransform, this._inverseBindMatrices[i], mat);
-            }
+            Matrix4x4.multiply(this._joints[i].worldMatrix, this._inverseBindMatrices[i], this._jointMatrices[i + this._jointOffsets[0] - 1]);
         }
     }
     /**
-   * Compute and upload the bind pose matrices to the joint texture for a given model.
-   *
-   * - Fills the "current" ring buffer slot with bind pose transforms.
-   * - Uploads the entire matrix array to the GPU texture.
+   * Reset skeleton to bind pose
    *
-   * @param model - The model node whose world matrix provides the reference space.
    * @internal
-   */ computeBindPose(model) {
-        this.updateJointMatrices(this._bindPoseMatrices, model.worldMatrix);
-        this._jointOffsets[1] = this._jointOffsets[0];
-        const tex = this.jointTexture;
-        tex.update(this._jointMatrixArray, 0, 0, tex.width, tex.height);
+   */ computeBindPose() {
+        for(let i = 0; i < this._joints.length; i++){
+            const joint = this._joints[i];
+            const bindpose = this._bindPose[i];
+            joint.position.set(bindpose.position);
+            joint.rotation.set(bindpose.rotation);
+            joint.scale.set(bindpose.scale);
+        }
     }
     /**
    * Compute current joint matrices from the nodes and upload them to the joint texture.
    *
    * @internal
-   */ computeJoints() {
-        this.updateJointMatrices();
+   */ apply(deltaTime) {
+        this.updateJointMatrices(deltaTime);
         const tex = this.jointTexture;
         tex.update(this._jointMatrixArray, 0, 0, tex.width, tex.height);
     }
     /**
-   * Apply current skeleton state to all meshes:
-   * - Updates joint matrices and uploads to the texture.
-   * - Computes animated bounding boxes per mesh in model space.
-   * - Binds the joint texture to each mesh for GPU skinning.
+   * Apply all enabled modifiers.
+   *
+   * Modifiers are applied after the base animation/bind pose layer,
+   * allowing procedural modifications like IK, spring physics, or manual overrides.
    *
+   * @param deltaTime - Time elapsed since last frame (in seconds)
    * @internal
-   */ apply() {
-        this.computeJoints();
+   */ applyModifiers(deltaTime) {
+        for (const modifier of this._modifiers){
+            modifier.apply(this, deltaTime);
+        }
+    }
+    /**
+   * Get all modifiers attached to this skeleton.
+   *
+   * @public
+   */ get modifiers() {
+        return this._modifiers;
     }
     /**
    * Reset all meshes to an unskinned state and clear animated bounds.