Struct Spring 

pub struct Spring<T: Animatable> { /* private fields */ }

An animation driven by one or more damped spring channels.

Spring::new creates one channel and preserves the original behavior in which every field shares the same physical progress. Use Spring::with_channels when fields need different stiffness, damping, or mass. Each channel produces a complete T; the compositor selects the fields owned by each channel.

Channels use the analytic solution of the damped harmonic oscillator. Time is therefore not discarded for frame intervals greater than 100 ms, and simulation results are stable across different frame subdivisions.

Examples

use aura_anim_core::{
    spring::{Spring, SpringConfig},
    timing::Duration,
    traits::Animation,
};

let soft = SpringConfig::new(80.0, 18.0);
let snappy = SpringConfig::new(420.0, 28.0);
let mut spring = Spring::with_channels(
    (0.0_f32, 0.0_f32),
    (100.0, 1.0),
    [soft, snappy],
    |outputs| (outputs[0].0, outputs[1].1),
);

spring.tick(Duration::from_millis(100.0));
assert!(spring.value().1 > spring.value().0 / 100.0);

Implementations

impl<T: Animatable> Spring<T>

pub fn new(from: T, to: T, config: SpringConfig) -> Self

Creates a running spring animation with one physical channel.

All fields in T share this channel. For independently configured fields, use Spring::with_channels.

pub fn with_channels( from: T, to: T, configs: impl IntoIterator<Item = SpringConfig>, compose: impl Fn(&[T]) -> T + 'static, ) -> Self

Creates a running spring with independently configured channels.

Every channel evaluates the full transition from from to to with its own physical state. compose must build the final value by selecting the fields owned by each channel, in the same order as configs.

An empty configuration iterator falls back to one default channel.

pub fn channel_count(&self) -> usize

Returns the number of independently simulated physical channels.

pub fn retarget(&mut self, target: T)

Restarts every channel from the current value toward target.

Each channel keeps its normalized velocity so interrupted motion retains momentum while its position is rebased to the current value.

Trait Implementations

impl<T: Animatable> Animation<T> for Spring<T>

fn value(&self) -> &T

Returns the animation’s current value.

fn state(&self) -> AnimationState

Returns the animation’s lifecycle state.

fn tick(&mut self, delta: Duration)

Advances the animation by delta.

fn pause(&mut self)

Pauses a running animation.

fn resume(&mut self)

Resumes a paused animation.

fn cancel(&mut self)

Cancels the animation.

fn seek(&mut self, progress: f32)

Seeks to normalized progress within the animation.

fn finish(&mut self)

Moves the animation to its completed state.

fn retarget(&mut self, target: &T) -> bool

Attempts to continue the animation toward a new target.

fn into_value(self: Box<Self>) -> T

Consumes the animation and returns its current value.

fn duration(&self) -> Option<Duration>

Returns the total duration when it is finite and known.

fn advance(&mut self, delta: Duration) -> Duration

Advances the animation and returns any unconsumed duration.

fn is_active(&self) -> bool

Returns whether the animation is currently running.

fn set_rate(&mut self, _rate: f64)

Updates playback rate by adjusting the animation’s stored durations.

fn rate(self, rate: f64) -> Self

where Self: Sized,

Returns this animation with its playback rate adjusted.

impl<T: Clone + Animatable> Clone for Spring<T>

fn clone(&self) -> Spring<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Animatable + Debug> Debug for Spring<T>

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

Formats the value using the given formatter.