Struct Spring 

pub struct Spring {
    pub stiffness: f64,
    pub damping: f64,
    pub mass: f64,
    pub initial_velocity: f64,
    pub rest_threshold: f64,
}

Spring configuration with physics-based parameters

Example

use uzor_animation::Spring;

let spring = Spring::new()
    .stiffness(180.0)
    .damping(12.0)
    .mass(1.0);

let (position, velocity) = spring.evaluate(0.1);

Fields

stiffness: f64

Spring stiffness (rigidity). Higher = more sudden movement. Default: 100.0

damping: f64

Damping coefficient (friction). Dissipates energy, slows oscillation. Default: 10.0

mass: f64

Mass of the animated object. Higher = more lethargic movement. Default: 1.0

initial_velocity: f64

Initial velocity (speed at t=0). Default: 0.0

rest_threshold: f64

Rest threshold - animation stops when |displacement| + |velocity| < threshold. Default: 0.001

Implementations

impl Spring

pub fn new() -> Self

Create a new spring with default parameters

pub fn stiffness(self, s: f64) -> Self

Set stiffness (spring rigidity)

pub fn damping(self, d: f64) -> Self

Set damping coefficient

pub fn mass(self, m: f64) -> Self

Set mass

pub fn initial_velocity(self, v: f64) -> Self

Set initial velocity

pub fn rest_threshold(self, t: f64) -> Self

Set rest threshold

pub fn damping_ratio(&self) -> f64

Calculate damping ratio: ζ = damping / (2 * sqrt(stiffness * mass))

Determines oscillation behavior:

• ζ < 1: Under-damped (bouncy, oscillates)
• ζ = 1: Critically damped (fastest settling, no overshoot)
• ζ > 1: Over-damped (slow, no oscillation)

pub fn angular_frequency(&self) -> f64

Calculate angular frequency: ω₀ = sqrt(stiffness / mass)

pub fn evaluate(&self, t: f64) -> (f64, f64)

Evaluate spring position and velocity at time t (seconds from start)

Returns (position, velocity) where:

• position: displacement from target (1.0 at start, 0.0 at rest)
• velocity: rate of change

Uses analytical solution for damped harmonic oscillator.

pub fn is_at_rest(&self, t: f64) -> bool

Check if spring is at rest at time t

pub fn estimated_duration(&self) -> f64

Estimate duration until spring reaches rest

Uses exponential decay envelope to estimate settling time. For under-damped and critically damped springs, the envelope decays as e^(-ζω₀t). We solve for when envelope < threshold.

pub fn gentle() -> Self

Gentle spring - iOS-style default

Smooth, natural feel with subtle bounce.

pub fn bouncy() -> Self

Bouncy spring - noticeable overshoot

Playful animation with visible oscillation.

pub fn stiff() -> Self

Stiff spring - fast, minimal overshoot

Snappy response, crisp motion.

pub fn slow() -> Self

Slow spring - deliberate, smooth

Leisurely animation with soft motion.

pub fn as_easing(&self, samples: usize) -> Vec<f64>

Convert spring to a lookup table for use as an easing function

Returns vector of position values sampled over estimated duration. Each sample represents spring position at t = i * (duration / samples).

Can be used to create an easing curve from spring physics.

Trait Implementations

impl Clone for Spring

fn clone(&self) -> Spring

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Spring

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Spring

fn default() -> Self

Returns the “default value” for a type.

impl Copy for Spring