@zephyr3d/scene 0.9.26 → 0.10.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"spring_solver.js","sources":["../../../src/animation/spring/spring_solver.ts"],"sourcesContent":["import { Quaternion, Vector3 } from '@zephyr3d/base';\r\nimport type { SpringParticle } from './spring_particle';\r\n\r\n/** Motion model used by the spring integration pipeline. */\r\nexport type SpringMotionModel = 'legacy' | 'kawaii';\r\n\r\nconst EPSILON = 1e-6;\r\nexport const INITIAL_COLLISION_PENETRATION_SLOP = 1e-4;\r\nexport const DEFAULT_INITIAL_COLLISION_PENETRATION_RELEASE_TIME = 0.25;\r\n\r\nexport function clampSpringRatio(value: number): number {\r\n  return Math.max(0, Math.min(1, Number(value) || 0));\r\n}\r\n\r\nexport function interpolateSpringValue(\r\n  root: number,\r\n  tip: number,\r\n  exponent: number,\r\n  index: number,\r\n  count: number\r\n) {\r\n  const t = Math.pow(index / Math.max(1, count - 1), Math.max(0.1, exponent));\r\n  return root + (tip - root) * t;\r\n}\r\n\r\n/**\r\n * Converts a user-facing per-step strength into a strength that can be applied\r\n * repeatedly without changing the effective response.\r\n */\r\nexport function getIterationStrength(strength: number, iterations: number): number {\r\n  const value = clampSpringRatio(strength);\r\n  return iterations > 1 ? 1 - Math.pow(1 - value, 1 / iterations) : value;\r\n}\r\n\r\n/** Smoothly releases startup collider overlap so particles reach the real surface after `duration`. */\r\nexport function getReleasedCollisionPenetration(\r\n  initialPenetration: number,\r\n  elapsed: number,\r\n  duration: number\r\n): number {\r\n  if (initialPenetration <= 0 || duration <= 0) {\r\n    return 0;\r\n  }\r\n  const t = Math.max(0, Math.min(1, elapsed / duration));\r\n  const progress = t * t * (3 - 2 * t);\r\n  return initialPenetration * (1 - progress);\r\n}\r\n\r\n/** Returns the Kawaii-style pose target relative to the simulated parent. */\r\nexport function getParentRelativePoseTarget(\r\n  particle: SpringParticle,\r\n  parent: SpringParticle | null,\r\n  result = new Vector3()\r\n): Vector3 {\r\n  if (!parent) {\r\n    result.set(particle.animPosition);\r\n    return result;\r\n  }\r\n  Vector3.sub(particle.animPosition, parent.animPosition, result);\r\n  return Vector3.add(parent.position, result, result);\r\n}\r\n\r\nexport interface SpringPoseTopologyEntry {\r\n  parent: SpringParticle | null;\r\n  nearestAnchor: SpringParticle | null;\r\n  normalizedDistance: number;\r\n}\r\n\r\n/** Builds a pose-follow direction and falloff measured from the nearest fixed particle. */\r\nexport function getSpringPoseTopology(particles: readonly SpringParticle[]): SpringPoseTopologyEntry[] {\r\n  const fixedIndices: number[] = [];\r\n  for (let i = 0; i < particles.length; i++) {\r\n    if (particles[i].fixed) {\r\n      fixedIndices.push(i);\r\n    }\r\n  }\r\n\r\n  if (fixedIndices.length === 0) {\r\n    const lastIndex = Math.max(1, particles.length - 1);\r\n    return particles.map((_, index) => ({\r\n      parent: index > 0 ? particles[index - 1] : null,\r\n      nearestAnchor: null,\r\n      normalizedDistance: index / lastIndex\r\n    }));\r\n  }\r\n\r\n  const nearestFixedIndices = new Array<number>(particles.length);\r\n  const distances = new Array<number>(particles.length);\r\n  let maxDistance = 1;\r\n  for (let i = 0; i < particles.length; i++) {\r\n    let nearestFixedIndex = fixedIndices[0];\r\n    let nearestDistance = Math.abs(i - nearestFixedIndex);\r\n    for (let j = 1; j < fixedIndices.length; j++) {\r\n      const distance = Math.abs(i - fixedIndices[j]);\r\n      if (distance < nearestDistance) {\r\n        nearestFixedIndex = fixedIndices[j];\r\n        nearestDistance = distance;\r\n      }\r\n    }\r\n    nearestFixedIndices[i] = nearestFixedIndex;\r\n    distances[i] = nearestDistance;\r\n    maxDistance = Math.max(maxDistance, nearestDistance);\r\n  }\r\n\r\n  return particles.map((_, index) => {\r\n    const nearestFixedIndex = nearestFixedIndices[index];\r\n    return {\r\n      parent: index > 0 ? particles[index - 1] : null,\r\n      nearestAnchor: particles[nearestFixedIndex],\r\n      normalizedDistance: distances[index] / maxDistance\r\n    };\r\n  });\r\n}\r\n\r\n/** Returns the Kawaii target, blending hierarchy shape with the nearest fixed anchor. */\r\nexport function getKawaiiPoseTarget(\r\n  particle: SpringParticle,\r\n  topology: SpringPoseTopologyEntry,\r\n  result = new Vector3()\r\n): Vector3 {\r\n  getParentRelativePoseTarget(particle, topology.parent, result);\r\n  if (!topology.nearestAnchor || topology.nearestAnchor === topology.parent) {\r\n    return result;\r\n  }\r\n  const anchorTarget = getParentRelativePoseTarget(particle, topology.nearestAnchor);\r\n  return Vector3.lerp(result, anchorTarget, 1 - topology.normalizedDistance, result);\r\n}\r\n\r\n/** Position-based distance projection with inverse-mass weighting. */\r\nexport function solveDistanceConstraint(\r\n  particleA: SpringParticle,\r\n  particleB: SpringParticle,\r\n  restLength: number,\r\n  stiffness: number\r\n): void {\r\n  const inverseMassA = particleA.fixed ? 0 : 1 / Math.max(particleA.mass, EPSILON);\r\n  const inverseMassB = particleB.fixed ? 0 : 1 / Math.max(particleB.mass, EPSILON);\r\n  const inverseMassSum = inverseMassA + inverseMassB;\r\n  if (inverseMassSum <= EPSILON) {\r\n    return;\r\n  }\r\n\r\n  const delta = Vector3.sub(particleB.position, particleA.position, new Vector3());\r\n  const length = delta.magnitude;\r\n  if (length <= EPSILON) {\r\n    return;\r\n  }\r\n\r\n  const correctionScale = ((length - restLength) / length) * clampSpringRatio(stiffness);\r\n  if (inverseMassA > 0) {\r\n    Vector3.add(\r\n      particleA.position,\r\n      Vector3.scale(delta, correctionScale * (inverseMassA / inverseMassSum), new Vector3()),\r\n      particleA.position\r\n    );\r\n  }\r\n  if (inverseMassB > 0) {\r\n    Vector3.sub(\r\n      particleB.position,\r\n      Vector3.scale(delta, correctionScale * (inverseMassB / inverseMassSum), new Vector3()),\r\n      particleB.position\r\n    );\r\n  }\r\n}\r\n\r\n/** Resolves a contact as an inelastic projection while preserving tangential Verlet velocity. */\r\nexport function resolveInelasticCollision<TCollider>(\r\n  particle: SpringParticle,\r\n  collider: TCollider,\r\n  resolveCollision: (position: Vector3, collider: TCollider, particleRadius?: number) => boolean,\r\n  allowedPenetration: number = 0\r\n): boolean {\r\n  const positionBeforeCollision = particle.position.clone();\r\n  const preservedDisplacement = Vector3.sub(positionBeforeCollision, particle.prevPosition, new Vector3());\r\n  if (!resolveCollision(particle.position, collider, particle.collisionRadius)) {\r\n    return false;\r\n  }\r\n\r\n  const correction = Vector3.sub(particle.position, positionBeforeCollision, new Vector3());\r\n  const correctionLength = correction.magnitude;\r\n  const excessPenetration = correctionLength - Math.max(0, allowedPenetration);\r\n  if (excessPenetration <= EPSILON) {\r\n    particle.position.set(positionBeforeCollision);\r\n    return false;\r\n  }\r\n\r\n  const outwardNormal = correction.scaleBy(1 / correctionLength);\r\n  Vector3.add(\r\n    positionBeforeCollision,\r\n    Vector3.scale(outwardNormal, excessPenetration, new Vector3()),\r\n    particle.position\r\n  );\r\n  if (correctionLength > EPSILON) {\r\n    const inwardDistance = Vector3.dot(preservedDisplacement, outwardNormal);\r\n    if (inwardDistance < 0) {\r\n      Vector3.sub(\r\n        preservedDisplacement,\r\n        Vector3.scale(outwardNormal, inwardDistance, new Vector3()),\r\n        preservedDisplacement\r\n      );\r\n    }\r\n  }\r\n  Vector3.sub(particle.position, preservedDisplacement, particle.prevPosition);\r\n  return true;\r\n}\r\n\r\n/** Returns how far a point is inside a collider according to its resolver. */\r\nexport function measureCollisionPenetration<TCollider>(\r\n  position: Vector3,\r\n  collider: TCollider,\r\n  resolveCollision: (position: Vector3, collider: TCollider, particleRadius?: number) => boolean,\r\n  particleRadius: number = 0\r\n): number {\r\n  const resolvedPosition = position.clone();\r\n  return resolveCollision(resolvedPosition, collider, particleRadius)\r\n    ? Vector3.distance(position, resolvedPosition)\r\n    : 0;\r\n}\r\n\r\nfunction getFallbackRotationAxis(direction: Vector3): Vector3 {\r\n  const reference = Math.abs(direction.x) < 0.8 ? Vector3.axisPX() : Vector3.axisPY();\r\n  return Vector3.cross(direction, reference, new Vector3()).inplaceNormalize();\r\n}\r\n\r\n/**\r\n * Limits a child direction around its current animated direction while\r\n * preserving the current simulated segment length.\r\n */\r\nexport function solveAngleLimit(\r\n  parent: SpringParticle,\r\n  child: SpringParticle,\r\n  maxAngleDegrees: number,\r\n  preserveVelocity: boolean\r\n): void {\r\n  if (maxAngleDegrees <= 0 || child.fixed) {\r\n    return;\r\n  }\r\n\r\n  const poseDirection = Vector3.sub(child.animPosition, parent.animPosition, new Vector3());\r\n  const simulatedDirection = Vector3.sub(child.position, parent.position, new Vector3());\r\n  const simulatedLength = simulatedDirection.magnitude;\r\n  if (poseDirection.magnitudeSq <= EPSILON || simulatedLength <= EPSILON) {\r\n    return;\r\n  }\r\n  poseDirection.inplaceNormalize();\r\n  simulatedDirection.scaleBy(1 / simulatedLength);\r\n\r\n  const dot = Math.max(-1, Math.min(1, Vector3.dot(poseDirection, simulatedDirection)));\r\n  const angle = Math.acos(dot);\r\n  const limit = (maxAngleDegrees * Math.PI) / 180;\r\n  if (angle <= limit) {\r\n    return;\r\n  }\r\n\r\n  let axis = Vector3.cross(poseDirection, simulatedDirection, new Vector3());\r\n  if (axis.magnitudeSq <= EPSILON) {\r\n    axis = getFallbackRotationAxis(poseDirection);\r\n  } else {\r\n    axis.inplaceNormalize();\r\n  }\r\n  const allowedDirection = Quaternion.fromAxisAngle(axis, limit).transform(poseDirection, new Vector3());\r\n  const previousPosition = child.position.clone();\r\n  Vector3.add(\r\n    parent.position,\r\n    Vector3.scale(allowedDirection, simulatedLength, allowedDirection),\r\n    child.position\r\n  );\r\n  if (preserveVelocity) {\r\n    Vector3.add(\r\n      child.prevPosition,\r\n      Vector3.sub(child.position, previousPosition, previousPosition),\r\n      child.prevPosition\r\n    );\r\n  }\r\n}\r\n"],"names":["EPSILON","INITIAL_COLLISION_PENETRATION_SLOP","DEFAULT_INITIAL_COLLISION_PENETRATION_RELEASE_TIME","clampSpringRatio","value","Math","max","min","Number","interpolateSpringValue","root","tip","exponent","index","count","t","pow","getIterationStrength","strength","iterations","getReleasedCollisionPenetration","initialPenetration","elapsed","duration","progress","getParentRelativePoseTarget","particle","parent","result","Vector3","set","animPosition","sub","add","position","getSpringPoseTopology","particles","fixedIndices","i","length","fixed","push","lastIndex","map","_","nearestAnchor","normalizedDistance","nearestFixedIndices","Array","distances","maxDistance","nearestFixedIndex","nearestDistance","abs","j","distance","getKawaiiPoseTarget","topology","anchorTarget","lerp","solveDistanceConstraint","particleA","particleB","restLength","stiffness","inverseMassA","mass","inverseMassB","inverseMassSum","delta","magnitude","correctionScale","scale","resolveInelasticCollision","collider","resolveCollision","allowedPenetration","positionBeforeCollision","clone","preservedDisplacement","prevPosition","collisionRadius","correction","correctionLength","excessPenetration","outwardNormal","scaleBy","inwardDistance","dot","measureCollisionPenetration","particleRadius","resolvedPosition","getFallbackRotationAxis","direction","reference","x","axisPX","axisPY","cross","inplaceNormalize","solveAngleLimit","child","maxAngleDegrees","preserveVelocity","poseDirection","simulatedDirection","simulatedLength","magnitudeSq","angle","acos","limit","PI","axis","allowedDirection","Quaternion","fromAxisAngle","transform","previousPosition"],"mappings":"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"}

package/dist/animation/spring/spring_system.js

@@ -1,7 +1,8 @@
 import { Vector3, Quaternion } from '@zephyr3d/base';
 import { IKUtils } from '../ik/ik_utils.js';
-import { updateColliderFromNode, resolveSphereCollision, resolveCapsuleCollision, resolvePlaneCollision } from './spring_collider.js';
+import { updateColliderFromNode, resolveSphereCollision, resolveCapsuleCollision, resolvePlaneCollision, resolveBoxCollision } from './spring_collider.js';
 import { SpringNodePoseTracker } from './spring_node_pose_tracker.js';
+import { DEFAULT_INITIAL_COLLISION_PENETRATION_RELEASE_TIME, getSpringPoseTopology, getKawaiiPoseTarget, interpolateSpringValue, solveAngleLimit, solveDistanceConstraint, resolveInelasticCollision, measureCollisionPenetration, INITIAL_COLLISION_PENETRATION_SLOP, getReleasedCollisionPenetration, getIterationStrength } from './spring_solver.js';
 
 const FIXED_SIMULATION_TIME_STEP = 1 / 60;
 const MAX_ACCUMULATED_SIMULATION_TIME = 1 / 20;
@@ -35,7 +36,16 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
     _smoothedSphereCenters;
     _smoothedCapsuleEndpoints;
     _smoothedPlaneData;
+    _smoothedBoxData;
     _nodePoseTracker;
+    _motionModel;
+    _angleLimitRoot;
+    _angleLimitTip;
+    _constraintVelocityHistoryRetention;
+    _preserveInitialCollisionPenetration;
+    _initialCollisionPenetrationReleaseTime;
+    _initialCollisionPenetrationElapsed;
+    _initialCollisionPenetration;
     constructor(chain, options){
         this._chain = chain;
         this._iterations = options?.iterations ?? 5;
@@ -58,7 +68,16 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
         this._smoothedSphereCenters = new WeakMap();
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
+        this._smoothedBoxData = new WeakMap();
         this._nodePoseTracker = new SpringNodePoseTracker();
+        this._motionModel = options?.motionModel ?? 'kawaii';
+        this._angleLimitRoot = Math.max(0, options?.angleLimitRoot ?? 0);
+        this._angleLimitTip = Math.max(0, options?.angleLimitTip ?? this._angleLimitRoot);
+        this._constraintVelocityHistoryRetention = Math.max(0, Math.min(1, options?.constraintVelocityHistoryRetention ?? 0.35));
+        this._preserveInitialCollisionPenetration = options?.preserveInitialCollisionPenetration ?? this._motionModel === 'kawaii';
+        this._initialCollisionPenetrationReleaseTime = Math.max(0, options?.initialCollisionPenetrationReleaseTime ?? DEFAULT_INITIAL_COLLISION_PENETRATION_RELEASE_TIME);
+        this._initialCollisionPenetrationElapsed = 0;
+        this._initialCollisionPenetration = new WeakMap();
     }
     /**
    * Updates the physics simulation
@@ -76,10 +95,10 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
         }
         this._timeAccumulator = Math.max(0, this._timeAccumulator - stepCount * FIXED_SIMULATION_TIME_STEP);
         for(let i = 0; i < stepCount; i++){
-            this.simulateStep(FIXED_SIMULATION_TIME_STEP, i === 0 ? frameDt : 0);
+            this.simulateStep(FIXED_SIMULATION_TIME_STEP, i === 0 ? frameDt : 0, i, stepCount);
         }
     }
-    simulateStep(dt, inputDeltaTime) {
+    simulateStep(dt, inputDeltaTime, stepIndex, stepCount) {
         // Step 1: Save all particle positions before updating
         if (this._enableInertialForces) {
             for (const p of this._chain.particles){
@@ -87,7 +106,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
             }
         }
         // Step 2: Update fixed particles from their scene nodes
-        this.updateFixedParticles(inputDeltaTime);
+        const substepBlend = 1 / Math.max(1, stepCount - stepIndex);
+        this.updateFixedParticles(inputDeltaTime, substepBlend);
         // Step 3: Calculate global rotation parameters
         let rotationCenter = null;
         let angularVelocity = null;
@@ -125,8 +145,13 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
                 constraint.lambda = 0;
             }
         }
+        if (this._motionModel === 'kawaii') {
+            this.solvePosePreservation(1, true);
+        }
         for(let iter = 0; iter < this._iterations; iter++){
-            for (const constraint of this._chain.constraints){
+            const reverse = this._motionModel === 'kawaii' && !!(iter & 1);
+            for(let constraintIndex = 0; constraintIndex < this._chain.constraints.length; constraintIndex++){
+                const constraint = this._chain.constraints[reverse ? this._chain.constraints.length - 1 - constraintIndex : constraintIndex];
                 if (this._solver === 'xpbd') {
                     this.solveConstraintXPBD(constraint, dt);
                 } else {
@@ -135,15 +160,56 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
             }
             // Pull particles back toward the animated pose to preserve hair silhouette.
             // Normalize follow strength across solver iterations so tuning stays intuitive.
-            this.solvePosePreservation(this._iterations);
-            // Apply collision constraints
-            this.solveCollisions(inputDeltaTime);
+            if (this._motionModel === 'legacy') {
+                this.solvePosePreservation(this._iterations, false);
+            }
+            if (this._motionModel === 'legacy') {
+                this.solveCollisions(inputDeltaTime);
+            }
         }
+        if (this._motionModel === 'kawaii') {
+            this.solveCollisions(inputDeltaTime, substepBlend);
+            this.solveAngleLimits();
+            if (this._solver === 'xpbd') {
+                this.solveCollisions(0, 0);
+                for (const constraint of this._chain.constraints){
+                    constraint.lambda = 0;
+                }
+                const closureIterations = Math.min(16, Math.max(4, this._iterations));
+                for(let iteration = 0; iteration < closureIterations; iteration++){
+                    const reverse = !!(iteration & 1);
+                    for(let constraintIndex = 0; constraintIndex < this._chain.constraints.length; constraintIndex++){
+                        const constraint = this._chain.constraints[reverse ? this._chain.constraints.length - 1 - constraintIndex : constraintIndex];
+                        this.solveConstraintXPBD(constraint, dt);
+                    }
+                }
+                if (this._colliders.some((collider)=>collider.enabled)) {
+                    for (const constraint of this._chain.constraints){
+                        constraint.lambda = 0;
+                    }
+                    const contactClosureIterations = Math.min(4, closureIterations);
+                    for(let iteration = 0; iteration < contactClosureIterations; iteration++){
+                        const reverse = !!(iteration & 1);
+                        for(let constraintIndex = 0; constraintIndex < this._chain.constraints.length; constraintIndex++){
+                            const constraint = this._chain.constraints[reverse ? this._chain.constraints.length - 1 - constraintIndex : constraintIndex];
+                            this.solveConstraintXPBD(constraint, dt);
+                        }
+                        this.solveCollisions(0, 0);
+                    }
+                }
+            } else {
+                for (const constraint of this._chain.constraints){
+                    this.solveConstraint(constraint);
+                }
+                this.solveCollisions(0, 0);
+            }
+        }
+        this.advanceInitialCollisionPenetrationRelease(dt);
     }
     /**
    * Updates fixed particles to match their scene node positions
-   */ updateFixedParticles(deltaTime) {
-        const blend = this.getTemporalBlendFactor(deltaTime, DEFAULT_PARTICLE_TARGET_SMOOTHING_TIME);
+   */ updateFixedParticles(deltaTime, substepBlend) {
+        const blend = this._motionModel === 'kawaii' ? substepBlend : this.getTemporalBlendFactor(deltaTime, DEFAULT_PARTICLE_TARGET_SMOOTHING_TIME);
         for (const particle of this._chain.particles){
             const sourceNode = particle.anchorNode ?? particle.node;
             if (!sourceNode) {
@@ -172,35 +238,46 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
     /**
    * Solves pose preservation (long-range attachment to animated pose).
    * This keeps strands close to authored shape while preserving dynamic movement.
-   */ solvePosePreservation(totalIterations) {
+   */ solvePosePreservation(totalIterations, parentRelative) {
         if (this._poseFollowRoot <= 0 && this._poseFollowTip <= 0) {
             return;
         }
-        const lastIndex = Math.max(1, this._chain.particles.length - 1);
+        const topology = getSpringPoseTopology(this._chain.particles);
         for(let i = 0; i < this._chain.particles.length; i++){
             const particle = this._chain.particles[i];
             if (particle.fixed) {
                 continue;
             }
-            const t = Math.pow(i / lastIndex, this._poseFollowExponent);
+            const t = Math.pow(topology[i].normalizedDistance, this._poseFollowExponent);
             const particlePoseFollow = this.lerp(this._poseFollowRoot, this._poseFollowTip, t);
             // Convert user-facing per-frame follow into per-iteration follow:
             // effective = 1 - (1 - follow)^iterations
-            const iterationFollow = totalIterations > 1 ? 1 - Math.pow(Math.max(0, 1 - particlePoseFollow), 1 / totalIterations) : particlePoseFollow;
-            const toAnim = Vector3.sub(particle.animPosition, particle.position, new Vector3());
+            const iterationFollow = getIterationStrength(particlePoseFollow, totalIterations);
+            const poseTarget = parentRelative ? getKawaiiPoseTarget(particle, topology[i]) : particle.animPosition;
+            const toAnim = Vector3.sub(poseTarget, particle.position, new Vector3());
             const correction = Vector3.scale(toAnim, iterationFollow, new Vector3());
             Vector3.add(particle.position, correction, particle.position);
             const particleMaxPoseOffset = this.lerp(this._maxPoseOffsetRoot, this._maxPoseOffsetTip, t);
             if (particleMaxPoseOffset > 0) {
-                const offset = Vector3.sub(particle.position, particle.animPosition, new Vector3());
+                const offset = Vector3.sub(particle.position, poseTarget, new Vector3());
                 const offsetLen = offset.magnitude;
                 if (offsetLen > particleMaxPoseOffset && offsetLen > 1e-6) {
                     offset.scaleBy(particleMaxPoseOffset / offsetLen);
-                    Vector3.add(particle.animPosition, offset, particle.position);
+                    Vector3.add(poseTarget, offset, particle.position);
                 }
             }
         }
     }
+    solveAngleLimits() {
+        if (this._angleLimitRoot <= 0 && this._angleLimitTip <= 0) {
+            return;
+        }
+        const particles = this._chain.particles;
+        for(let i = 1; i < particles.length; i++){
+            const limit = interpolateSpringValue(this._angleLimitRoot, this._angleLimitTip, this._poseFollowExponent, i, particles.length);
+            solveAngleLimit(particles[i - 1], particles[i], limit, this._solver === 'xpbd');
+        }
+    }
     lerp(a, b, t) {
         return a + (b - a) * t;
     }
@@ -388,11 +465,19 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
         const n = Vector3.scale(delta, 1.0 / currentLength, new Vector3());
         if (!pA.fixed) {
             // deltaX_a = -w_a * deltaLambda * n
-            Vector3.add(pA.position, Vector3.scale(n, -wA * deltaLambda, new Vector3()), pA.position);
+            const correction = Vector3.scale(n, -wA * deltaLambda, new Vector3());
+            Vector3.add(pA.position, correction, pA.position);
+            if (this._motionModel === 'kawaii') {
+                Vector3.add(pA.prevPosition, Vector3.scale(correction, this._constraintVelocityHistoryRetention, new Vector3()), pA.prevPosition);
+            }
         }
         if (!pB.fixed) {
             // deltaX_b = +w_b * deltaLambda * n
-            Vector3.add(pB.position, Vector3.scale(n, wB * deltaLambda, new Vector3()), pB.position);
+            const correction = Vector3.scale(n, wB * deltaLambda, new Vector3());
+            Vector3.add(pB.position, correction, pB.position);
+            if (this._motionModel === 'kawaii') {
+                Vector3.add(pB.prevPosition, Vector3.scale(correction, this._constraintVelocityHistoryRetention, new Vector3()), pB.prevPosition);
+            }
         }
     }
     /**
@@ -400,6 +485,10 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
    */ solveConstraint(constraint) {
         const pA = this._chain.particles[constraint.particleA];
         const pB = this._chain.particles[constraint.particleB];
+        if (this._motionModel === 'kawaii') {
+            solveDistanceConstraint(pA, pB, constraint.restLength, constraint.stiffness);
+            return;
+        }
         // Calculate current distance
         const delta = Vector3.sub(pB.position, pA.position, new Vector3());
         const currentLength = delta.magnitude;
@@ -419,12 +508,13 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
     }
     /**
    * Solves collisions for all particles
-   */ solveCollisions(deltaTime) {
+   */ solveCollisions(deltaTime, blendOverride) {
         // Update dynamic colliders from their nodes
-        const blend = this.getTemporalBlendFactor(deltaTime, DEFAULT_COLLIDER_SMOOTHING_TIME);
+        const blend = blendOverride ?? this.getTemporalBlendFactor(deltaTime, DEFAULT_COLLIDER_SMOOTHING_TIME);
         const spheres = [];
         const capsules = [];
         const planes = [];
+        const boxes = [];
         for (const collider of this._colliders){
             if (collider.node) {
                 updateColliderFromNode(collider);
@@ -473,6 +563,18 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
                         });
                         break;
                     }
+                case 'box':
+                    {
+                        const source = collider;
+                        boxes.push({
+                            particleCollider: source,
+                            collider: {
+                                ...source,
+                                ...this.getSmoothedBoxData(source, blend)
+                            }
+                        });
+                        break;
+                    }
             }
         }
         // Check each particle against all colliders
@@ -481,13 +583,32 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
                 continue; // Skip fixed particles
             }
             for (const collider of spheres){
-                resolveSphereCollision(particle.position, collider.collider);
+                if (this._motionModel === 'kawaii') {
+                    resolveInelasticCollision(particle, collider.collider, resolveSphereCollision, this.getInitialCollisionPenetration(particle, collider.particleCollider, collider.collider, resolveSphereCollision));
+                } else {
+                    resolveSphereCollision(particle.position, collider.collider, particle.collisionRadius);
+                }
             }
             for (const collider of capsules){
-                resolveCapsuleCollision(particle.position, collider.collider);
+                if (this._motionModel === 'kawaii') {
+                    resolveInelasticCollision(particle, collider.collider, resolveCapsuleCollision, this.getInitialCollisionPenetration(particle, collider.particleCollider, collider.collider, resolveCapsuleCollision));
+                } else {
+                    resolveCapsuleCollision(particle.position, collider.collider, particle.collisionRadius);
+                }
             }
             for (const collider of planes){
-                resolvePlaneCollision(particle.position, collider.collider);
+                if (this._motionModel === 'kawaii') {
+                    resolveInelasticCollision(particle, collider.collider, resolvePlaneCollision, this.getInitialCollisionPenetration(particle, collider.particleCollider, collider.collider, resolvePlaneCollision));
+                } else {
+                    resolvePlaneCollision(particle.position, collider.collider, particle.collisionRadius);
+                }
+            }
+            for (const collider of boxes){
+                if (this._motionModel === 'kawaii') {
+                    resolveInelasticCollision(particle, collider.collider, resolveBoxCollision, this.getInitialCollisionPenetration(particle, collider.particleCollider, collider.collider, resolveBoxCollision));
+                } else {
+                    resolveBoxCollision(particle.position, collider.collider, particle.collisionRadius);
+                }
             }
         }
     }
@@ -561,6 +682,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
         this._smoothedSphereCenters = new WeakMap();
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
+        this._smoothedBoxData = new WeakMap();
+        this._initialCollisionPenetrationElapsed = 0;
+        this._initialCollisionPenetration = new WeakMap();
     }
     /**
    * Gets the spring chain
@@ -630,6 +754,57 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
             }
         }
     }
+    get motionModel() {
+        return this._motionModel;
+    }
+    set motionModel(value) {
+        if (value !== 'legacy' && value !== 'kawaii') {
+            return;
+        }
+        if (this._motionModel !== value) {
+            this._motionModel = value;
+            this.reset();
+        }
+    }
+    get angleLimitRoot() {
+        return this._angleLimitRoot;
+    }
+    set angleLimitRoot(value) {
+        this._angleLimitRoot = Math.max(0, Number(value) || 0);
+    }
+    get angleLimitTip() {
+        return this._angleLimitTip;
+    }
+    set angleLimitTip(value) {
+        this._angleLimitTip = Math.max(0, Number(value) || 0);
+    }
+    get constraintVelocityHistoryRetention() {
+        return this._constraintVelocityHistoryRetention;
+    }
+    set constraintVelocityHistoryRetention(value) {
+        this._constraintVelocityHistoryRetention = Math.max(0, Math.min(1, Number(value) || 0));
+    }
+    get preserveInitialCollisionPenetration() {
+        return this._preserveInitialCollisionPenetration;
+    }
+    set preserveInitialCollisionPenetration(value) {
+        if (this._preserveInitialCollisionPenetration !== value) {
+            this._preserveInitialCollisionPenetration = value;
+            this._initialCollisionPenetrationElapsed = 0;
+            this._initialCollisionPenetration = new WeakMap();
+        }
+    }
+    get initialCollisionPenetrationReleaseTime() {
+        return this._initialCollisionPenetrationReleaseTime;
+    }
+    set initialCollisionPenetrationReleaseTime(value) {
+        const duration = Math.max(0, Number(value) || 0);
+        if (this._initialCollisionPenetrationReleaseTime !== duration) {
+            this._initialCollisionPenetrationReleaseTime = duration;
+            this._initialCollisionPenetrationElapsed = 0;
+            this._initialCollisionPenetration = new WeakMap();
+        }
+    }
     /**
    * Gets pose preservation strength [0-1]
    */ get poseFollow() {
@@ -699,6 +874,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
         this._smoothedSphereCenters = new WeakMap();
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
+        this._smoothedBoxData = new WeakMap();
+        this._initialCollisionPenetrationElapsed = 0;
+        this._initialCollisionPenetration = new WeakMap();
     }
     /**
    * Removes a collider from the system
@@ -709,6 +887,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
             this._smoothedSphereCenters = new WeakMap();
             this._smoothedCapsuleEndpoints = new WeakMap();
             this._smoothedPlaneData = new WeakMap();
+            this._smoothedBoxData = new WeakMap();
+            this._initialCollisionPenetrationElapsed = 0;
+            this._initialCollisionPenetration = new WeakMap();
             return true;
         }
         return false;
@@ -720,12 +901,37 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
         this._smoothedSphereCenters = new WeakMap();
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
+        this._smoothedBoxData = new WeakMap();
+        this._initialCollisionPenetrationElapsed = 0;
+        this._initialCollisionPenetration = new WeakMap();
     }
     /**
    * Gets all colliders
    */ get colliders() {
         return this._colliders;
     }
+    getInitialCollisionPenetration(particle, sourceCollider, collider, resolveCollision) {
+        if (!this._preserveInitialCollisionPenetration) {
+            return 0;
+        }
+        let particlePenetrations = this._initialCollisionPenetration.get(particle);
+        if (!particlePenetrations) {
+            particlePenetrations = new WeakMap();
+            this._initialCollisionPenetration.set(particle, particlePenetrations);
+        }
+        let penetration = particlePenetrations.get(sourceCollider);
+        if (penetration === undefined) {
+            penetration = measureCollisionPenetration(particle.animPosition, collider, resolveCollision, particle.collisionRadius) + INITIAL_COLLISION_PENETRATION_SLOP;
+            particlePenetrations.set(sourceCollider, penetration);
+        }
+        return getReleasedCollisionPenetration(penetration, this._initialCollisionPenetrationElapsed, this._initialCollisionPenetrationReleaseTime);
+    }
+    advanceInitialCollisionPenetrationRelease(deltaTime) {
+        if (!this._preserveInitialCollisionPenetration) {
+            return;
+        }
+        this._initialCollisionPenetrationElapsed = Math.min(this._initialCollisionPenetrationReleaseTime, this._initialCollisionPenetrationElapsed + Math.max(0, deltaTime));
+    }
     getTemporalBlendFactor(deltaTime, smoothingTime) {
         const dt = Math.min(Math.max(Number(deltaTime) || 0, 0), MAX_ACCUMULATED_SIMULATION_TIME);
         if (smoothingTime <= 0) {
@@ -798,6 +1004,25 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME = 1 / 30;
         }
         return cached;
     }
+    getSmoothedBoxData(collider, blend) {
+        const current = {
+            center: collider.center.clone(),
+            halfExtents: collider.halfExtents.clone(),
+            axes: collider.axes.map((axis)=>axis.clone())
+        };
+        const cached = this._smoothedBoxData.get(collider);
+        if (!cached || blend >= 1) {
+            this._smoothedBoxData.set(collider, current);
+            return current;
+        }
+        Vector3.lerp(cached.center, current.center, blend, cached.center);
+        Vector3.lerp(cached.halfExtents, current.halfExtents, blend, cached.halfExtents);
+        for(let i = 0; i < 3; i++){
+            Vector3.lerp(cached.axes[i], current.axes[i], blend, cached.axes[i]);
+            cached.axes[i].inplaceNormalize();
+        }
+        return cached;
+    }
 }
 
 export { SpringSystem };