@zephyr3d/scene 0.7.0 → 0.8.0

package/dist/animation/spring/spring_system.js

@@ -0,0 +1,526 @@
+import { Vector3, Quaternion } from '@zephyr3d/base';
+import { IKUtils } from '../ik/ik_utils.js';
+import { updateColliderFromNode, resolvePlaneCollision, resolveCapsuleCollision, resolveSphereCollision } from './spring_collider.js';
+
+/**
+ * Physics engine for spring-based particle simulation
+ * Uses Verlet integration and iterative constraint solving
+ *
+ * @public
+ */ class SpringSystem {
+    _chain;
+    _iterations;
+    _gravity;
+    _wind;
+    _enableInertialForces;
+    _centrifugalScale;
+    _coriolisScale;
+    _colliders;
+    _solver;
+    constructor(chain, options){
+        this._chain = chain;
+        this._iterations = options?.iterations ?? 5;
+        this._gravity = options?.gravity?.clone() ?? new Vector3(0, -9.8, 0);
+        this._wind = options?.wind?.clone() ?? new Vector3(0, 0, 0);
+        this._enableInertialForces = options?.enableInertialForces ?? true;
+        this._centrifugalScale = options?.centrifugalScale ?? 1.0;
+        this._coriolisScale = options?.coriolisScale ?? 1.0;
+        this._colliders = [];
+        this._solver = options?.solver ?? 'verlet';
+    }
+    /**
+   * Updates the physics simulation
+   * @param deltaTime - Time step in seconds
+   */ update(deltaTime) {
+        // Clamp deltaTime to prevent instability
+        const dt = Math.min(deltaTime, 0.033); // Max 30 FPS
+        // Step 1: Save all particle positions before updating
+        if (this._enableInertialForces) {
+            for (const p of this._chain.particles){
+                p.lastFramePosition.set(p.position);
+            }
+        }
+        // Step 2: Update fixed particles from their scene nodes
+        this.updateFixedParticles();
+        // Step 3: Calculate global rotation parameters
+        let rotationCenter = null;
+        let angularVelocity = null;
+        if (this._enableInertialForces && dt > 0.0001) {
+            const result = this.calculateGlobalRotation(dt);
+            rotationCenter = result.center;
+            angularVelocity = result.omega;
+        }
+        // Step 4: Verlet integration with inertial forces
+        for(let i = 0; i < this._chain.particles.length; i++){
+            const p = this._chain.particles[i];
+            if (p.fixed) {
+                continue;
+            }
+            // Calculate velocity (implicit in Verlet)
+            const velocity = Vector3.sub(p.position, p.prevPosition, new Vector3());
+            velocity.scaleBy(p.damping);
+            // Apply external forces (gravity + wind)
+            const acceleration = Vector3.add(this._gravity, this._wind, new Vector3());
+            // Apply inertial forces from rotating reference frame
+            if (this._enableInertialForces && rotationCenter && angularVelocity) {
+                const inertialAccel = this.calculateInertialAcceleration(p, rotationCenter, angularVelocity, velocity, this._centrifugalScale, this._coriolisScale);
+                Vector3.add(acceleration, inertialAccel, acceleration);
+            }
+            const positionDelta = Vector3.scale(acceleration, dt * dt, new Vector3());
+            Vector3.add(velocity, positionDelta, velocity);
+            // Update position
+            p.prevPosition.set(p.position);
+            Vector3.add(p.position, velocity, p.position);
+        }
+        // Step 5: Iteratively solve constraints
+        if (this._solver === 'xpbd') {
+            // Reset Lagrange multipliers at the start of each time step
+            for (const constraint of this._chain.constraints){
+                constraint.lambda = 0;
+            }
+        }
+        for(let iter = 0; iter < this._iterations; iter++){
+            for (const constraint of this._chain.constraints){
+                if (this._solver === 'xpbd') {
+                    this.solveConstraintXPBD(constraint, dt);
+                } else {
+                    this.solveConstraint(constraint);
+                }
+            }
+            // Apply collision constraints
+            this.solveCollisions();
+        }
+    }
+    /**
+   * Updates fixed particles to match their scene node positions
+   */ updateFixedParticles() {
+        for (const particle of this._chain.particles){
+            if (particle.node && particle.fixed) {
+                const worldMatrix = particle.node.worldMatrix;
+                const worldPos = new Vector3(worldMatrix.m03, worldMatrix.m13, worldMatrix.m23);
+                particle.position.set(worldPos);
+                particle.prevPosition.set(worldPos);
+                // Maintain position history for rotation center estimation
+                if (this._enableInertialForces) {
+                    if (!particle.positionHistory) {
+                        particle.positionHistory = [];
+                    }
+                    particle.positionHistory.push(worldPos.clone());
+                    // Keep only last 5 frames
+                    if (particle.positionHistory.length > 5) {
+                        particle.positionHistory.shift();
+                    }
+                }
+            }
+        }
+    }
+    /**
+   * Calculates global rotation parameters from fixed particle movements
+   * Uses position history to estimate rotation center
+   */ calculateGlobalRotation(dt) {
+        // Collect fixed particles with movement
+        const fixedParticles = [];
+        const velocities = [];
+        for (const p of this._chain.particles){
+            if (!p.fixed) {
+                continue;
+            }
+            const velocity = Vector3.sub(p.position, p.lastFramePosition, new Vector3());
+            velocity.scaleBy(1.0 / dt);
+            if (velocity.magnitudeSq > 0.001) {
+                fixedParticles.push(p);
+                velocities.push(velocity);
+            }
+        }
+        if (fixedParticles.length === 0) {
+            return {
+                center: new Vector3(0, 0, 0),
+                omega: new Vector3(0, 0, 0)
+            };
+        }
+        // Estimate rotation center using position history
+        let center;
+        if (fixedParticles.length === 1) {
+            // Single fixed particle: use position history to estimate rotation center
+            center = this.estimateRotationCenterFromHistory(fixedParticles[0], velocities[0]);
+        } else {
+            // Multiple fixed particles: use their average position
+            center = new Vector3(0, 0, 0);
+            for (const p of fixedParticles){
+                Vector3.add(center, p.position, center);
+            }
+            center.scaleBy(1.0 / fixedParticles.length);
+        }
+        // Estimate angular velocity
+        let sumOmega = new Vector3(0, 0, 0);
+        let count = 0;
+        for(let i = 0; i < fixedParticles.length; i++){
+            const r = Vector3.sub(fixedParticles[i].position, center, new Vector3());
+            const v = velocities[i];
+            const rLengthSq = r.magnitudeSq;
+            if (rLengthSq > 0.0001) {
+                // ω = (r × v) / |r|²
+                const omega = Vector3.cross(r, v, new Vector3());
+                omega.scaleBy(1.0 / rLengthSq);
+                Vector3.add(sumOmega, omega, sumOmega);
+                count++;
+            }
+        }
+        if (count > 0) {
+            sumOmega.scaleBy(1.0 / count);
+        }
+        return {
+            center,
+            omega: sumOmega
+        };
+    }
+    /**
+   * Estimates rotation center from a single particle's position history
+   * Uses circular motion fitting
+   */ estimateRotationCenterFromHistory(particle, currentVelocity) {
+        const history = particle.positionHistory;
+        if (!history || history.length < 3) {
+            // Not enough history: estimate using velocity perpendicular direction
+            // Assume rotation center is perpendicular to velocity
+            // Use a default radius based on velocity magnitude
+            const speed = currentVelocity.magnitude;
+            if (speed < 0.001) {
+                return particle.position.clone();
+            }
+            // Estimate radius: for typical character rotation, assume ~0.5-1.0m radius
+            const estimatedRadius = Math.max(0.5, speed * 0.5);
+            // Direction perpendicular to velocity (in the plane of motion)
+            // We need to guess which perpendicular direction - use cross product with up vector
+            const up = new Vector3(0, 1, 0);
+            const perpDir = Vector3.cross(currentVelocity, up, new Vector3());
+            if (perpDir.magnitudeSq < 0.0001) {
+                // Velocity is vertical, use another perpendicular
+                perpDir.set(new Vector3(1, 0, 0));
+            } else {
+                perpDir.inplaceNormalize();
+            }
+            // Rotation center is perpendicular to velocity
+            const center = Vector3.add(particle.position, Vector3.scale(perpDir, estimatedRadius, new Vector3()), new Vector3());
+            return center;
+        }
+        // Fit a circle through the last 3 positions
+        // Use positions at indices: 0 (oldest), middle, last (newest)
+        const p1 = history[0];
+        const p2 = history[Math.floor(history.length / 2)];
+        const p3 = history[history.length - 1];
+        // Calculate circle center from 3 points
+        const center = this.calculateCircleCenter(p1, p2, p3);
+        return center;
+    }
+    /**
+   * Calculates the center of a circle passing through 3 points
+   * Uses perpendicular bisector method
+   */ calculateCircleCenter(p1, p2, p3) {
+        // Midpoints
+        const mid12 = Vector3.scale(Vector3.add(p1, p2, new Vector3()), 0.5, new Vector3());
+        const mid23 = Vector3.scale(Vector3.add(p2, p3, new Vector3()), 0.5, new Vector3());
+        // Direction vectors
+        const dir12 = Vector3.sub(p2, p1, new Vector3());
+        const dir23 = Vector3.sub(p3, p2, new Vector3());
+        // Normal vectors (perpendicular bisectors)
+        // For 3D, we need to find perpendiculars in the plane of the three points
+        const normal = Vector3.cross(dir12, dir23, new Vector3());
+        if (normal.magnitudeSq < 0.0001) {
+            // Points are collinear, return midpoint
+            return Vector3.scale(Vector3.add(Vector3.add(p1, p2, new Vector3()), p3, new Vector3()), 1.0 / 3.0, new Vector3());
+        }
+        normal.inplaceNormalize();
+        // Perpendicular to dir12 in the plane
+        const perp12 = Vector3.cross(dir12, normal, new Vector3()).inplaceNormalize();
+        // Perpendicular to dir23 in the plane
+        const perp23 = Vector3.cross(dir23, normal, new Vector3()).inplaceNormalize();
+        // Find intersection of two lines:
+        // Line 1: mid12 + t * perp12
+        // Line 2: mid23 + s * perp23
+        // Solve: mid12 + t * perp12 = mid23 + s * perp23
+        const diff = Vector3.sub(mid23, mid12, new Vector3());
+        // Use 2D projection for simplicity (project onto plane perpendicular to normal)
+        // Solve in the plane: t * perp12 - s * perp23 = diff
+        // Use least squares or pick the dominant components
+        const det = perp12.x * perp23.y - perp12.y * perp23.x;
+        if (Math.abs(det) > 0.0001) {
+            const t = (diff.x * perp23.y - diff.y * perp23.x) / det;
+            const center = Vector3.add(mid12, Vector3.scale(perp12, t, new Vector3()), new Vector3());
+            return center;
+        }
+        // Fallback: use centroid
+        return Vector3.scale(Vector3.add(Vector3.add(p1, p2, new Vector3()), p3, new Vector3()), 1.0 / 3.0, new Vector3());
+    }
+    /**
+   * Calculates inertial acceleration for a particle in a rotating reference frame
+   */ calculateInertialAcceleration(particle, rotationCenter, angularVelocity, particleVelocity, centrifugalScale, coriolisScale) {
+        // Vector from rotation center to particle
+        const r = Vector3.sub(particle.position, rotationCenter, new Vector3());
+        // Centrifugal acceleration: a_centrifugal = ω × (ω × r)
+        const omegaCrossR = Vector3.cross(angularVelocity, r, new Vector3());
+        const centrifugalAccel = Vector3.cross(angularVelocity, omegaCrossR, new Vector3());
+        centrifugalAccel.scaleBy(centrifugalScale);
+        // Coriolis acceleration: a_coriolis = -2ω × v_relative
+        // v_relative is the particle's velocity in the rotating frame
+        // Use the velocity passed in (already calculated from prevPosition)
+        const coriolisAccel = Vector3.cross(angularVelocity, particleVelocity, new Vector3());
+        coriolisAccel.scaleBy(-2 * coriolisScale);
+        // Total inertial acceleration
+        const totalAccel = Vector3.add(centrifugalAccel, coriolisAccel, new Vector3());
+        return totalAccel;
+    }
+    /**
+   * Solves a single spring constraint using XPBD (Extended Position-Based Dynamics).
+   *
+   * Reference: Müller et al., "Detailed Rigid Body Simulation with Extended Position Based Dynamics", 2020.
+   *
+   * The XPBD correction for a distance constraint C(x) = |x_b - x_a| - L is:
+   *   α̃ = compliance / dt²          (scaled compliance)
+   *   Δλ = (-C - α̃·λ) / (w_a + w_b + α̃)
+   *   λ  += Δλ
+   *   Δx_a = -w_a · Δλ · n̂
+   *   Δx_b = +w_b · Δλ · n̂
+   * where w = 1/mass (0 for fixed particles), n̂ = unit vector from a to b.
+   */ solveConstraintXPBD(constraint, dt) {
+        const pA = this._chain.particles[constraint.particleA];
+        const pB = this._chain.particles[constraint.particleB];
+        const wA = pA.fixed ? 0 : 1.0 / pA.mass;
+        const wB = pB.fixed ? 0 : 1.0 / pB.mass;
+        const wSum = wA + wB;
+        if (wSum < 1e-10) {
+            return;
+        }
+        const delta = Vector3.sub(pB.position, pA.position, new Vector3());
+        const currentLength = delta.magnitude;
+        if (currentLength < 0.0001) {
+            return;
+        }
+        // Constraint value C = currentLength - restLength
+        const C = currentLength - constraint.restLength;
+        // Scaled compliance: α̃ = compliance / dt²
+        const alphaTilde = constraint.compliance / (dt * dt);
+        // XPBD Lagrange multiplier update
+        const deltaLambda = (-C - alphaTilde * constraint.lambda) / (wSum + alphaTilde);
+        constraint.lambda += deltaLambda;
+        // Correction direction (unit vector from A to B)
+        const n = Vector3.scale(delta, 1.0 / currentLength, new Vector3());
+        if (!pA.fixed) {
+            // Δx_a = -w_a · Δλ · n̂
+            Vector3.add(pA.position, Vector3.scale(n, -wA * deltaLambda, new Vector3()), pA.position);
+        }
+        if (!pB.fixed) {
+            // Δx_b = +w_b · Δλ · n̂
+            Vector3.add(pB.position, Vector3.scale(n, wB * deltaLambda, new Vector3()), pB.position);
+        }
+    }
+    /**
+   * Solves a single spring constraint (Verlet / PBD)
+   */ solveConstraint(constraint) {
+        const pA = this._chain.particles[constraint.particleA];
+        const pB = this._chain.particles[constraint.particleB];
+        // Calculate current distance
+        const delta = Vector3.sub(pB.position, pA.position, new Vector3());
+        const currentLength = delta.magnitude;
+        if (currentLength < 0.0001) {
+            return;
+        } // Avoid division by zero
+        // Calculate correction
+        const diff = (currentLength - constraint.restLength) / currentLength;
+        const correction = Vector3.scale(delta, diff * constraint.stiffness * 0.5, new Vector3());
+        // Apply correction (considering mass and fixed state)
+        if (!pA.fixed) {
+            Vector3.add(pA.position, correction, pA.position);
+        }
+        if (!pB.fixed) {
+            Vector3.sub(pB.position, correction, pB.position);
+        }
+    }
+    /**
+   * Solves collisions for all particles
+   */ solveCollisions() {
+        // Update dynamic colliders from their nodes
+        for (const collider of this._colliders){
+            if (collider.node) {
+                updateColliderFromNode(collider);
+            }
+        }
+        // Check each particle against all colliders
+        for (const particle of this._chain.particles){
+            if (particle.fixed) {
+                continue; // Skip fixed particles
+            }
+            for (const collider of this._colliders){
+                if (!collider.enabled) {
+                    continue;
+                }
+                switch(collider.type){
+                    case 'sphere':
+                        resolveSphereCollision(particle.position, collider);
+                        break;
+                    case 'capsule':
+                        resolveCapsuleCollision(particle.position, collider);
+                        break;
+                    case 'plane':
+                        resolvePlaneCollision(particle.position, collider);
+                        break;
+                }
+            }
+        }
+    }
+    /**
+   * Applies simulation results to scene nodes
+   * @param weight - Blend weight [0-1] (default: 1.0)
+   */ applyToNodes(weight = 1.0) {
+        for(let i = 0; i < this._chain.particles.length - 1; i++){
+            const particle = this._chain.particles[i];
+            const nextParticle = this._chain.particles[i + 1];
+            const node = particle.node;
+            // Skip if no node
+            if (!node) {
+                continue;
+            }
+            // Get current bone direction from node's world matrix (before physics)
+            // This reflects the current animation/skeleton state
+            const currentBonePos = new Vector3(node.worldMatrix.m03, node.worldMatrix.m13, node.worldMatrix.m23);
+            const nextNode = nextParticle.node;
+            if (!nextNode) {
+                continue;
+            }
+            const nextBonePos = new Vector3(nextNode.worldMatrix.m03, nextNode.worldMatrix.m13, nextNode.worldMatrix.m23);
+            const originalDir = Vector3.sub(nextBonePos, currentBonePos, new Vector3());
+            // Get current bone rotation from node's world matrix
+            const currentBoneRotation = new Quaternion();
+            node.worldMatrix.decompose(null, currentBoneRotation, null);
+            // Calculate new direction from physics simulation
+            const newDir = Vector3.sub(nextParticle.position, particle.position, new Vector3());
+            // Calculate rotation needed to align original direction to new direction
+            const deltaRotation = new Quaternion();
+            IKUtils.fromToRotation(originalDir, newDir, deltaRotation);
+            // Calculate new world rotation
+            let worldRotation = Quaternion.multiply(deltaRotation, currentBoneRotation, new Quaternion());
+            // Blend with current rotation based on weight
+            if (weight < 1) {
+                Quaternion.slerp(currentBoneRotation, worldRotation, weight, worldRotation);
+            }
+            // Convert world rotation to local rotation (relative to parent)
+            const parent = node.parent;
+            if (parent) {
+                const parentWorldRotation = new Quaternion();
+                parent.worldMatrix.decompose(null, parentWorldRotation, null);
+                // localRotation = conjugate(parentWorldRotation) * worldRotation
+                const parentInvRotation = Quaternion.conjugate(parentWorldRotation, new Quaternion());
+                const localRotation = Quaternion.multiply(parentInvRotation, worldRotation, new Quaternion());
+                node.rotation = localRotation;
+            } else {
+                // Root node has no parent, world rotation is local rotation
+                node.rotation = worldRotation;
+            }
+        }
+    }
+    /**
+   * Resets the simulation to initial state
+   */ reset() {
+        this._chain.reset();
+    }
+    /**
+   * Gets the spring chain
+   */ get chain() {
+        return this._chain;
+    }
+    /**
+   * Gets the current gravity
+   */ get gravity() {
+        return this._gravity;
+    }
+    set gravity(gravity) {
+        this._gravity.set(gravity);
+    }
+    /**
+   * Gets the current wind
+   */ get wind() {
+        return this._wind;
+    }
+    set wind(wind) {
+        this._wind.set(wind);
+    }
+    /**
+   * Gets the number of iterations
+   */ get iterations() {
+        return this._iterations;
+    }
+    set iterations(count) {
+        this._iterations = Math.max(1, count);
+    }
+    /**
+   * Gets whether inertial forces are enabled
+   */ get enableInertialForces() {
+        return this._enableInertialForces;
+    }
+    set enableInertialForces(enabled) {
+        this._enableInertialForces = enabled;
+    }
+    /**
+   * Gets the centrifugal force scale
+   */ get centrifugalScale() {
+        return this._centrifugalScale;
+    }
+    set centrifugalScale(scale) {
+        this._centrifugalScale = Math.max(0, scale);
+    }
+    /**
+   * Gets the Coriolis force scale
+   */ get coriolisScale() {
+        return this._coriolisScale;
+    }
+    /**
+   * Sets the Coriolis force scale
+   */ set coriolisScale(scale) {
+        this._coriolisScale = Math.max(0, scale);
+    }
+    /**
+   * Gets the constraint solver type
+   */ get solver() {
+        return this._solver;
+    }
+    /**
+   * Sets the constraint solver type.
+   * Switching to 'xpbd' resets all Lagrange multipliers.
+   */ set solver(type) {
+        if (this._solver !== type) {
+            this._solver = type;
+            if (type === 'xpbd') {
+                for (const c of this._chain.constraints){
+                    c.lambda = 0;
+                }
+            }
+        }
+    }
+    /**
+   * Adds a collider to the system
+   */ addCollider(collider) {
+        this._colliders.push(collider);
+    }
+    /**
+   * Removes a collider from the system
+   */ removeCollider(collider) {
+        const index = this._colliders.indexOf(collider);
+        if (index >= 0) {
+            this._colliders.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+   * Clears all colliders
+   */ clearColliders() {
+        this._colliders = [];
+    }
+    /**
+   * Gets all colliders
+   */ get colliders() {
+        return this._colliders;
+    }
+}
+
+export { SpringSystem };
+//# sourceMappingURL=spring_system.js.map

package/dist/animation/spring/spring_system.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring_system.js","sources":["../../../src/animation/spring/spring_system.ts"],"sourcesContent":["import { Vector3, Quaternion } from '@zephyr3d/base';\r\nimport type { SpringChain } from './spring_chain';\r\nimport { IKUtils } from '../ik/ik_utils';\r\nimport type { SpringCollider } from './spring_collider';\r\nimport {\r\n  resolveSphereCollision,\r\n  resolveCapsuleCollision,\r\n  resolvePlaneCollision,\r\n  updateColliderFromNode\r\n} from './spring_collider';\r\n\r\n/**\r\n * Options for creating a SpringSystem\r\n *\r\n * @public\r\n */\r\nexport interface SpringSystemOptions {\r\n  /** Number of constraint solver iterations (default: 5) */\r\n  iterations?: number;\r\n  /** Gravity force vector (default: (0, -9.8, 0)) */\r\n  gravity?: Vector3;\r\n  /** Wind force vector (default: (0, 0, 0)) */\r\n  wind?: Vector3;\r\n  /** Enable inertial forces (centrifugal/Coriolis) when root rotates (default: true) */\r\n  enableInertialForces?: boolean;\r\n  /** Centrifugal force multiplier (default: 1.0) */\r\n  centrifugalScale?: number;\r\n  /** Coriolis force multiplier (default: 1.0) */\r\n  coriolisScale?: number;\r\n  /**\r\n   * Constraint solver type (default: 'verlet').\r\n   * - 'verlet': Classic Verlet integration with iterative position correction.\r\n   *   stiffness [0-1] controls correction strength per iteration.\r\n   * - 'xpbd': Extended Position-Based Dynamics (Müller et al. 2020).\r\n   *   Uses compliance (inverse stiffness in m/N) for physically correct,\r\n   *   iteration-count-independent constraint solving.\r\n   */\r\n  solver?: 'verlet' | 'xpbd';\r\n}\r\n\r\n/**\r\n * Physics engine for spring-based particle simulation\r\n * Uses Verlet integration and iterative constraint solving\r\n *\r\n * @public\r\n */\r\nexport class SpringSystem {\r\n  private _chain: SpringChain;\r\n  private _iterations: number;\r\n  private _gravity: Vector3;\r\n  private _wind: Vector3;\r\n  private _enableInertialForces: boolean;\r\n  private _centrifugalScale: number;\r\n  private _coriolisScale: number;\r\n  private _colliders: SpringCollider[];\r\n  private _solver: 'verlet' | 'xpbd';\r\n\r\n  constructor(chain: SpringChain, options?: SpringSystemOptions) {\r\n    this._chain = chain;\r\n    this._iterations = options?.iterations ?? 5;\r\n    this._gravity = options?.gravity?.clone() ?? new Vector3(0, -9.8, 0);\r\n    this._wind = options?.wind?.clone() ?? new Vector3(0, 0, 0);\r\n    this._enableInertialForces = options?.enableInertialForces ?? true;\r\n    this._centrifugalScale = options?.centrifugalScale ?? 1.0;\r\n    this._coriolisScale = options?.coriolisScale ?? 1.0;\r\n    this._colliders = [];\r\n    this._solver = options?.solver ?? 'verlet';\r\n  }\r\n\r\n  /**\r\n   * Updates the physics simulation\r\n   * @param deltaTime - Time step in seconds\r\n   */\r\n  update(deltaTime: number): void {\r\n    // Clamp deltaTime to prevent instability\r\n    const dt = Math.min(deltaTime, 0.033); // Max 30 FPS\r\n\r\n    // Step 1: Save all particle positions before updating\r\n    if (this._enableInertialForces) {\r\n      for (const p of this._chain.particles) {\r\n        p.lastFramePosition.set(p.position);\r\n      }\r\n    }\r\n\r\n    // Step 2: Update fixed particles from their scene nodes\r\n    this.updateFixedParticles();\r\n\r\n    // Step 3: Calculate global rotation parameters\r\n    let rotationCenter: Vector3 | null = null;\r\n    let angularVelocity: Vector3 | null = null;\r\n\r\n    if (this._enableInertialForces && dt > 0.0001) {\r\n      const result = this.calculateGlobalRotation(dt);\r\n      rotationCenter = result.center;\r\n      angularVelocity = result.omega;\r\n    }\r\n\r\n    // Step 4: Verlet integration with inertial forces\r\n    for (let i = 0; i < this._chain.particles.length; i++) {\r\n      const p = this._chain.particles[i];\r\n      if (p.fixed) {\r\n        continue;\r\n      }\r\n\r\n      // Calculate velocity (implicit in Verlet)\r\n      const velocity = Vector3.sub(p.position, p.prevPosition, new Vector3());\r\n      velocity.scaleBy(p.damping);\r\n\r\n      // Apply external forces (gravity + wind)\r\n      const acceleration = Vector3.add(this._gravity, this._wind, new Vector3());\r\n\r\n      // Apply inertial forces from rotating reference frame\r\n      if (this._enableInertialForces && rotationCenter && angularVelocity) {\r\n        const inertialAccel = this.calculateInertialAcceleration(\r\n          p,\r\n          rotationCenter,\r\n          angularVelocity,\r\n          velocity,\r\n          this._centrifugalScale,\r\n          this._coriolisScale\r\n        );\r\n        Vector3.add(acceleration, inertialAccel, acceleration);\r\n      }\r\n\r\n      const positionDelta = Vector3.scale(acceleration, dt * dt, new Vector3());\r\n      Vector3.add(velocity, positionDelta, velocity);\r\n\r\n      // Update position\r\n      p.prevPosition.set(p.position);\r\n      Vector3.add(p.position, velocity, p.position);\r\n    }\r\n\r\n    // Step 5: Iteratively solve constraints\r\n    if (this._solver === 'xpbd') {\r\n      // Reset Lagrange multipliers at the start of each time step\r\n      for (const constraint of this._chain.constraints) {\r\n        constraint.lambda = 0;\r\n      }\r\n    }\r\n    for (let iter = 0; iter < this._iterations; iter++) {\r\n      for (const constraint of this._chain.constraints) {\r\n        if (this._solver === 'xpbd') {\r\n          this.solveConstraintXPBD(constraint, dt);\r\n        } else {\r\n          this.solveConstraint(constraint);\r\n        }\r\n      }\r\n\r\n      // Apply collision constraints\r\n      this.solveCollisions();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Updates fixed particles to match their scene node positions\r\n   */\r\n  private updateFixedParticles(): void {\r\n    for (const particle of this._chain.particles) {\r\n      if (particle.node && particle.fixed) {\r\n        const worldMatrix = particle.node.worldMatrix;\r\n        const worldPos = new Vector3(worldMatrix.m03, worldMatrix.m13, worldMatrix.m23);\r\n        particle.position.set(worldPos);\r\n        particle.prevPosition.set(worldPos);\r\n\r\n        // Maintain position history for rotation center estimation\r\n        if (this._enableInertialForces) {\r\n          if (!particle.positionHistory) {\r\n            particle.positionHistory = [];\r\n          }\r\n          particle.positionHistory.push(worldPos.clone());\r\n          // Keep only last 5 frames\r\n          if (particle.positionHistory.length > 5) {\r\n            particle.positionHistory.shift();\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Calculates global rotation parameters from fixed particle movements\r\n   * Uses position history to estimate rotation center\r\n   */\r\n  private calculateGlobalRotation(dt: number): { center: Vector3; omega: Vector3 } {\r\n    // Collect fixed particles with movement\r\n    const fixedParticles: any[] = [];\r\n    const velocities: Vector3[] = [];\r\n\r\n    for (const p of this._chain.particles) {\r\n      if (!p.fixed) {\r\n        continue;\r\n      }\r\n\r\n      const velocity = Vector3.sub(p.position, p.lastFramePosition, new Vector3());\r\n      velocity.scaleBy(1.0 / dt);\r\n\r\n      if (velocity.magnitudeSq > 0.001) {\r\n        fixedParticles.push(p);\r\n        velocities.push(velocity);\r\n      }\r\n    }\r\n\r\n    if (fixedParticles.length === 0) {\r\n      return { center: new Vector3(0, 0, 0), omega: new Vector3(0, 0, 0) };\r\n    }\r\n\r\n    // Estimate rotation center using position history\r\n    let center: Vector3;\r\n\r\n    if (fixedParticles.length === 1) {\r\n      // Single fixed particle: use position history to estimate rotation center\r\n      center = this.estimateRotationCenterFromHistory(fixedParticles[0], velocities[0]);\r\n    } else {\r\n      // Multiple fixed particles: use their average position\r\n      center = new Vector3(0, 0, 0);\r\n      for (const p of fixedParticles) {\r\n        Vector3.add(center, p.position, center);\r\n      }\r\n      center.scaleBy(1.0 / fixedParticles.length);\r\n    }\r\n\r\n    // Estimate angular velocity\r\n    let sumOmega = new Vector3(0, 0, 0);\r\n    let count = 0;\r\n\r\n    for (let i = 0; i < fixedParticles.length; i++) {\r\n      const r = Vector3.sub(fixedParticles[i].position, center, new Vector3());\r\n      const v = velocities[i];\r\n      const rLengthSq = r.magnitudeSq;\r\n\r\n      if (rLengthSq > 0.0001) {\r\n        // ω = (r × v) / |r|²\r\n        const omega = Vector3.cross(r, v, new Vector3());\r\n        omega.scaleBy(1.0 / rLengthSq);\r\n        Vector3.add(sumOmega, omega, sumOmega);\r\n        count++;\r\n      }\r\n    }\r\n\r\n    if (count > 0) {\r\n      sumOmega.scaleBy(1.0 / count);\r\n    }\r\n\r\n    return { center, omega: sumOmega };\r\n  }\r\n\r\n  /**\r\n   * Estimates rotation center from a single particle's position history\r\n   * Uses circular motion fitting\r\n   */\r\n  private estimateRotationCenterFromHistory(particle: any, currentVelocity: Vector3): Vector3 {\r\n    const history = particle.positionHistory;\r\n    if (!history || history.length < 3) {\r\n      // Not enough history: estimate using velocity perpendicular direction\r\n      // Assume rotation center is perpendicular to velocity\r\n      // Use a default radius based on velocity magnitude\r\n      const speed = currentVelocity.magnitude;\r\n      if (speed < 0.001) {\r\n        return particle.position.clone();\r\n      }\r\n\r\n      // Estimate radius: for typical character rotation, assume ~0.5-1.0m radius\r\n      const estimatedRadius = Math.max(0.5, speed * 0.5);\r\n\r\n      // Direction perpendicular to velocity (in the plane of motion)\r\n      // We need to guess which perpendicular direction - use cross product with up vector\r\n      const up = new Vector3(0, 1, 0);\r\n      const perpDir = Vector3.cross(currentVelocity, up, new Vector3());\r\n\r\n      if (perpDir.magnitudeSq < 0.0001) {\r\n        // Velocity is vertical, use another perpendicular\r\n        perpDir.set(new Vector3(1, 0, 0));\r\n      } else {\r\n        perpDir.inplaceNormalize();\r\n      }\r\n\r\n      // Rotation center is perpendicular to velocity\r\n      const center = Vector3.add(\r\n        particle.position,\r\n        Vector3.scale(perpDir, estimatedRadius, new Vector3()),\r\n        new Vector3()\r\n      );\r\n      return center;\r\n    }\r\n\r\n    // Fit a circle through the last 3 positions\r\n    // Use positions at indices: 0 (oldest), middle, last (newest)\r\n    const p1 = history[0];\r\n    const p2 = history[Math.floor(history.length / 2)];\r\n    const p3 = history[history.length - 1];\r\n\r\n    // Calculate circle center from 3 points\r\n    const center = this.calculateCircleCenter(p1, p2, p3);\r\n    return center;\r\n  }\r\n\r\n  /**\r\n   * Calculates the center of a circle passing through 3 points\r\n   * Uses perpendicular bisector method\r\n   */\r\n  private calculateCircleCenter(p1: Vector3, p2: Vector3, p3: Vector3): Vector3 {\r\n    // Midpoints\r\n    const mid12 = Vector3.scale(Vector3.add(p1, p2, new Vector3()), 0.5, new Vector3());\r\n    const mid23 = Vector3.scale(Vector3.add(p2, p3, new Vector3()), 0.5, new Vector3());\r\n\r\n    // Direction vectors\r\n    const dir12 = Vector3.sub(p2, p1, new Vector3());\r\n    const dir23 = Vector3.sub(p3, p2, new Vector3());\r\n\r\n    // Normal vectors (perpendicular bisectors)\r\n    // For 3D, we need to find perpendiculars in the plane of the three points\r\n    const normal = Vector3.cross(dir12, dir23, new Vector3());\r\n\r\n    if (normal.magnitudeSq < 0.0001) {\r\n      // Points are collinear, return midpoint\r\n      return Vector3.scale(\r\n        Vector3.add(Vector3.add(p1, p2, new Vector3()), p3, new Vector3()),\r\n        1.0 / 3.0,\r\n        new Vector3()\r\n      );\r\n    }\r\n\r\n    normal.inplaceNormalize();\r\n\r\n    // Perpendicular to dir12 in the plane\r\n    const perp12 = Vector3.cross(dir12, normal, new Vector3()).inplaceNormalize();\r\n\r\n    // Perpendicular to dir23 in the plane\r\n    const perp23 = Vector3.cross(dir23, normal, new Vector3()).inplaceNormalize();\r\n\r\n    // Find intersection of two lines:\r\n    // Line 1: mid12 + t * perp12\r\n    // Line 2: mid23 + s * perp23\r\n    // Solve: mid12 + t * perp12 = mid23 + s * perp23\r\n\r\n    const diff = Vector3.sub(mid23, mid12, new Vector3());\r\n\r\n    // Use 2D projection for simplicity (project onto plane perpendicular to normal)\r\n    // Solve in the plane: t * perp12 - s * perp23 = diff\r\n    // Use least squares or pick the dominant components\r\n\r\n    const det = perp12.x * perp23.y - perp12.y * perp23.x;\r\n\r\n    if (Math.abs(det) > 0.0001) {\r\n      const t = (diff.x * perp23.y - diff.y * perp23.x) / det;\r\n      const center = Vector3.add(mid12, Vector3.scale(perp12, t, new Vector3()), new Vector3());\r\n      return center;\r\n    }\r\n\r\n    // Fallback: use centroid\r\n    return Vector3.scale(\r\n      Vector3.add(Vector3.add(p1, p2, new Vector3()), p3, new Vector3()),\r\n      1.0 / 3.0,\r\n      new Vector3()\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Calculates inertial acceleration for a particle in a rotating reference frame\r\n   */\r\n  private calculateInertialAcceleration(\r\n    particle: any,\r\n    rotationCenter: Vector3,\r\n    angularVelocity: Vector3,\r\n    particleVelocity: Vector3,\r\n    centrifugalScale: number,\r\n    coriolisScale: number\r\n  ): Vector3 {\r\n    // Vector from rotation center to particle\r\n    const r = Vector3.sub(particle.position, rotationCenter, new Vector3());\r\n\r\n    // Centrifugal acceleration: a_centrifugal = ω × (ω × r)\r\n    const omegaCrossR = Vector3.cross(angularVelocity, r, new Vector3());\r\n    const centrifugalAccel = Vector3.cross(angularVelocity, omegaCrossR, new Vector3());\r\n    centrifugalAccel.scaleBy(centrifugalScale);\r\n\r\n    // Coriolis acceleration: a_coriolis = -2ω × v_relative\r\n    // v_relative is the particle's velocity in the rotating frame\r\n    // Use the velocity passed in (already calculated from prevPosition)\r\n    const coriolisAccel = Vector3.cross(angularVelocity, particleVelocity, new Vector3());\r\n    coriolisAccel.scaleBy(-2.0 * coriolisScale);\r\n\r\n    // Total inertial acceleration\r\n    const totalAccel = Vector3.add(centrifugalAccel, coriolisAccel, new Vector3());\r\n    return totalAccel;\r\n  }\r\n\r\n  /**\r\n   * Solves a single spring constraint using XPBD (Extended Position-Based Dynamics).\r\n   *\r\n   * Reference: Müller et al., \"Detailed Rigid Body Simulation with Extended Position Based Dynamics\", 2020.\r\n   *\r\n   * The XPBD correction for a distance constraint C(x) = |x_b - x_a| - L is:\r\n   *   α̃ = compliance / dt²          (scaled compliance)\r\n   *   Δλ = (-C - α̃·λ) / (w_a + w_b + α̃)\r\n   *   λ  += Δλ\r\n   *   Δx_a = -w_a · Δλ · n̂\r\n   *   Δx_b = +w_b · Δλ · n̂\r\n   * where w = 1/mass (0 for fixed particles), n̂ = unit vector from a to b.\r\n   */\r\n  private solveConstraintXPBD(constraint: any, dt: number): void {\r\n    const pA = this._chain.particles[constraint.particleA];\r\n    const pB = this._chain.particles[constraint.particleB];\r\n\r\n    const wA = pA.fixed ? 0 : 1.0 / pA.mass;\r\n    const wB = pB.fixed ? 0 : 1.0 / pB.mass;\r\n    const wSum = wA + wB;\r\n    if (wSum < 1e-10) {\r\n      return;\r\n    }\r\n\r\n    const delta = Vector3.sub(pB.position, pA.position, new Vector3());\r\n    const currentLength = delta.magnitude;\r\n    if (currentLength < 0.0001) {\r\n      return;\r\n    }\r\n\r\n    // Constraint value C = currentLength - restLength\r\n    const C = currentLength - constraint.restLength;\r\n\r\n    // Scaled compliance: α̃ = compliance / dt²\r\n    const alphaTilde = constraint.compliance / (dt * dt);\r\n\r\n    // XPBD Lagrange multiplier update\r\n    const deltaLambda = (-C - alphaTilde * constraint.lambda) / (wSum + alphaTilde);\r\n    constraint.lambda += deltaLambda;\r\n\r\n    // Correction direction (unit vector from A to B)\r\n    const n = Vector3.scale(delta, 1.0 / currentLength, new Vector3());\r\n\r\n    if (!pA.fixed) {\r\n      // Δx_a = -w_a · Δλ · n̂\r\n      Vector3.add(pA.position, Vector3.scale(n, -wA * deltaLambda, new Vector3()), pA.position);\r\n    }\r\n    if (!pB.fixed) {\r\n      // Δx_b = +w_b · Δλ · n̂\r\n      Vector3.add(pB.position, Vector3.scale(n, wB * deltaLambda, new Vector3()), pB.position);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Solves a single spring constraint (Verlet / PBD)\r\n   */\r\n  private solveConstraint(constraint: any): void {\r\n    const pA = this._chain.particles[constraint.particleA];\r\n    const pB = this._chain.particles[constraint.particleB];\r\n\r\n    // Calculate current distance\r\n    const delta = Vector3.sub(pB.position, pA.position, new Vector3());\r\n    const currentLength = delta.magnitude;\r\n\r\n    if (currentLength < 0.0001) {\r\n      return;\r\n    } // Avoid division by zero\r\n\r\n    // Calculate correction\r\n    const diff = (currentLength - constraint.restLength) / currentLength;\r\n    const correction = Vector3.scale(delta, diff * constraint.stiffness * 0.5, new Vector3());\r\n\r\n    // Apply correction (considering mass and fixed state)\r\n    if (!pA.fixed) {\r\n      Vector3.add(pA.position, correction, pA.position);\r\n    }\r\n    if (!pB.fixed) {\r\n      Vector3.sub(pB.position, correction, pB.position);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Solves collisions for all particles\r\n   */\r\n  private solveCollisions(): void {\r\n    // Update dynamic colliders from their nodes\r\n    for (const collider of this._colliders) {\r\n      if (collider.node) {\r\n        updateColliderFromNode(collider);\r\n      }\r\n    }\r\n\r\n    // Check each particle against all colliders\r\n    for (const particle of this._chain.particles) {\r\n      if (particle.fixed) {\r\n        continue; // Skip fixed particles\r\n      }\r\n\r\n      for (const collider of this._colliders) {\r\n        if (!collider.enabled) {\r\n          continue;\r\n        }\r\n\r\n        switch (collider.type) {\r\n          case 'sphere':\r\n            resolveSphereCollision(particle.position, collider as any);\r\n            break;\r\n          case 'capsule':\r\n            resolveCapsuleCollision(particle.position, collider as any);\r\n            break;\r\n          case 'plane':\r\n            resolvePlaneCollision(particle.position, collider as any);\r\n            break;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Applies simulation results to scene nodes\r\n   * @param weight - Blend weight [0-1] (default: 1.0)\r\n   */\r\n  applyToNodes(weight: number = 1.0): void {\r\n    for (let i = 0; i < this._chain.particles.length - 1; i++) {\r\n      const particle = this._chain.particles[i];\r\n      const nextParticle = this._chain.particles[i + 1];\r\n      const node = particle.node;\r\n\r\n      // Skip if no node\r\n      if (!node) {\r\n        continue;\r\n      }\r\n\r\n      // Get current bone direction from node's world matrix (before physics)\r\n      // This reflects the current animation/skeleton state\r\n      const currentBonePos = new Vector3(node.worldMatrix.m03, node.worldMatrix.m13, node.worldMatrix.m23);\r\n\r\n      const nextNode = nextParticle.node;\r\n      if (!nextNode) {\r\n        continue;\r\n      }\r\n\r\n      const nextBonePos = new Vector3(\r\n        nextNode.worldMatrix.m03,\r\n        nextNode.worldMatrix.m13,\r\n        nextNode.worldMatrix.m23\r\n      );\r\n      const originalDir = Vector3.sub(nextBonePos, currentBonePos, new Vector3());\r\n\r\n      // Get current bone rotation from node's world matrix\r\n      const currentBoneRotation = new Quaternion();\r\n      node.worldMatrix.decompose(null, currentBoneRotation, null);\r\n\r\n      // Calculate new direction from physics simulation\r\n      const newDir = Vector3.sub(nextParticle.position, particle.position, new Vector3());\r\n\r\n      // Calculate rotation needed to align original direction to new direction\r\n      const deltaRotation = new Quaternion();\r\n      IKUtils.fromToRotation(originalDir, newDir, deltaRotation);\r\n\r\n      // Calculate new world rotation\r\n      let worldRotation = Quaternion.multiply(deltaRotation, currentBoneRotation, new Quaternion());\r\n\r\n      // Blend with current rotation based on weight\r\n      if (weight < 1) {\r\n        Quaternion.slerp(currentBoneRotation, worldRotation, weight, worldRotation);\r\n      }\r\n\r\n      // Convert world rotation to local rotation (relative to parent)\r\n      const parent = node.parent;\r\n      if (parent) {\r\n        const parentWorldRotation = new Quaternion();\r\n        parent.worldMatrix.decompose(null, parentWorldRotation, null);\r\n\r\n        // localRotation = conjugate(parentWorldRotation) * worldRotation\r\n        const parentInvRotation = Quaternion.conjugate(parentWorldRotation, new Quaternion());\r\n        const localRotation = Quaternion.multiply(parentInvRotation, worldRotation, new Quaternion());\r\n\r\n        node.rotation = localRotation;\r\n      } else {\r\n        // Root node has no parent, world rotation is local rotation\r\n        node.rotation = worldRotation;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Resets the simulation to initial state\r\n   */\r\n  reset(): void {\r\n    this._chain.reset();\r\n  }\r\n\r\n  /**\r\n   * Gets the spring chain\r\n   */\r\n  get chain(): SpringChain {\r\n    return this._chain;\r\n  }\r\n\r\n  /**\r\n   * Gets the current gravity\r\n   */\r\n  get gravity(): Vector3 {\r\n    return this._gravity;\r\n  }\r\n\r\n  set gravity(gravity: Vector3) {\r\n    this._gravity.set(gravity);\r\n  }\r\n\r\n  /**\r\n   * Gets the current wind\r\n   */\r\n  get wind(): Vector3 {\r\n    return this._wind;\r\n  }\r\n\r\n  set wind(wind: Vector3) {\r\n    this._wind.set(wind);\r\n  }\r\n\r\n  /**\r\n   * Gets the number of iterations\r\n   */\r\n  get iterations(): number {\r\n    return this._iterations;\r\n  }\r\n\r\n  set iterations(count: number) {\r\n    this._iterations = Math.max(1, count);\r\n  }\r\n\r\n  /**\r\n   * Gets whether inertial forces are enabled\r\n   */\r\n  get enableInertialForces(): boolean {\r\n    return this._enableInertialForces;\r\n  }\r\n\r\n  set enableInertialForces(enabled: boolean) {\r\n    this._enableInertialForces = enabled;\r\n  }\r\n\r\n  /**\r\n   * Gets the centrifugal force scale\r\n   */\r\n  get centrifugalScale(): number {\r\n    return this._centrifugalScale;\r\n  }\r\n\r\n  set centrifugalScale(scale: number) {\r\n    this._centrifugalScale = Math.max(0, scale);\r\n  }\r\n\r\n  /**\r\n   * Gets the Coriolis force scale\r\n   */\r\n  get coriolisScale(): number {\r\n    return this._coriolisScale;\r\n  }\r\n\r\n  /**\r\n   * Sets the Coriolis force scale\r\n   */\r\n  set coriolisScale(scale: number) {\r\n    this._coriolisScale = Math.max(0, scale);\r\n  }\r\n\r\n  /**\r\n   * Gets the constraint solver type\r\n   */\r\n  get solver(): 'verlet' | 'xpbd' {\r\n    return this._solver;\r\n  }\r\n\r\n  /**\r\n   * Sets the constraint solver type.\r\n   * Switching to 'xpbd' resets all Lagrange multipliers.\r\n   */\r\n  set solver(type: 'verlet' | 'xpbd') {\r\n    if (this._solver !== type) {\r\n      this._solver = type;\r\n      if (type === 'xpbd') {\r\n        for (const c of this._chain.constraints) {\r\n          c.lambda = 0;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Adds a collider to the system\r\n   */\r\n  addCollider(collider: SpringCollider): void {\r\n    this._colliders.push(collider);\r\n  }\r\n\r\n  /**\r\n   * Removes a collider from the system\r\n   */\r\n  removeCollider(collider: SpringCollider): boolean {\r\n    const index = this._colliders.indexOf(collider);\r\n    if (index >= 0) {\r\n      this._colliders.splice(index, 1);\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Clears all colliders\r\n   */\r\n  clearColliders(): void {\r\n    this._colliders = [];\r\n  }\r\n\r\n  /**\r\n   * Gets all colliders\r\n   */\r\n  get colliders(): SpringCollider[] {\r\n    return this._colliders;\r\n  }\r\n}\r\n"],"names":["SpringSystem","_chain","_iterations","_gravity","_wind","_enableInertialForces","_centrifugalScale","_coriolisScale","_colliders","_solver","chain","options","iterations","gravity","clone","Vector3","wind","enableInertialForces","centrifugalScale","coriolisScale","solver","update","deltaTime","dt","Math","min","p","particles","lastFramePosition","set","position","updateFixedParticles","rotationCenter","angularVelocity","result","calculateGlobalRotation","center","omega","i","length","fixed","velocity","sub","prevPosition","scaleBy","damping","acceleration","add","inertialAccel","calculateInertialAcceleration","positionDelta","scale","constraint","constraints","lambda","iter","solveConstraintXPBD","solveConstraint","solveCollisions","particle","node","worldMatrix","worldPos","m03","m13","m23","positionHistory","push","shift","fixedParticles","velocities","magnitudeSq","estimateRotationCenterFromHistory","sumOmega","count","r","v","rLengthSq","cross","currentVelocity","history","speed","magnitude","estimatedRadius","max","up","perpDir","inplaceNormalize","p1","p2","floor","p3","calculateCircleCenter","mid12","mid23","dir12","dir23","normal","perp12","perp23","diff","det","x","y","abs","t","particleVelocity","omegaCrossR","centrifugalAccel","coriolisAccel","totalAccel","pA","particleA","pB","particleB","wA","mass","wB","wSum","delta","currentLength","C","restLength","alphaTilde","compliance","deltaLambda","n","correction","stiffness","collider","updateColliderFromNode","enabled","type","resolveSphereCollision","resolveCapsuleCollision","resolvePlaneCollision","applyToNodes","weight","nextParticle","currentBonePos","nextNode","nextBonePos","originalDir","currentBoneRotation","Quaternion","decompose","newDir","deltaRotation","IKUtils","fromToRotation","worldRotation","multiply","slerp","parent","parentWorldRotation","parentInvRotation","conjugate","localRotation","rotation","reset","c","addCollider","removeCollider","index","indexOf","splice","clearColliders","colliders"],"mappings":"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"}

package/dist/animation/spring_modifier.js

@@ -0,0 +1,45 @@
+import { SkeletonModifier } from './skeleton_modifier.js';
+
+/**
+ * Post-processor wrapper for spring physics systems.
+ *
+ * Integrates spring-based physics simulation into the skeleton post-processing pipeline.
+ * The spring system is updated each frame and results are blended with the base animation.
+ *
+ * @public
+ */ class SpringModifier extends SkeletonModifier {
+    _springSystem;
+    /**
+   * Create a spring post-processor.
+   *
+   * @param springSystem - The spring system to integrate
+   * @param weight - Blend weight [0-1] (default: 1.0)
+   */ constructor(springSystem, weight = 1.0){
+        super(weight);
+        this._springSystem = springSystem;
+    }
+    /**
+   * Get the spring system.
+   */ get springSystem() {
+        return this._springSystem;
+    }
+    /**
+   * Apply spring physics to skeleton joints.
+   */ apply(_skeleton, deltaTime) {
+        if (!this._enabled || this._weight <= 0) {
+            return;
+        }
+        // Update spring physics simulation
+        this._springSystem.update(deltaTime);
+        // Apply results to scene nodes with blending
+        this._springSystem.applyToNodes(this._weight);
+    }
+    /**
+   * Reset the spring system to initial state.
+   */ reset() {
+        this._springSystem.reset();
+    }
+}
+
+export { SpringModifier };
+//# sourceMappingURL=spring_modifier.js.map