Struct Spring 

pub struct Spring {
    pub stiffness: f32,
    pub damping: f32,
    pub mass: f32,
}

A damped spring, solved in closed form so a position is a function of time rather than of how many frames happened to be delivered.

Fields

stiffness: f32

damping: f32

mass: f32

Implementations

impl Spring

pub fn new(stiffness: f32, damping: f32, mass: f32) -> Self

pub fn perceptual(duration: Duration, bounce: f32) -> Self

A spring described the way a design decision is: how long it takes and how much it overshoots.

Stiffness, damping and mass are three numbers for two decisions, and neither decision is either of the three. This is the same parameterisation as SwiftUI’s Spring(duration:bounce:), and it is a change of variables rather than an approximation:

• mass is fixed at 1. A spring’s behaviour depends on stiffness and damping only through k/m and c/m, so nothing is lost by it;
• duration is the period of the undamped oscillation, which is what sets the pace whatever the damping does: omega = 2 * PI / duration, and stiffness = omega^2 * mass;
• bounce is the damping ratio turned inside out, so that 0 is critically damped whichever side of it the value is on: zeta = 1 - bounce for a positive bounce, which reaches the undamped zeta = 0 at 1, and zeta = 1 / (1 + bounce) for a negative one, which grows without bound toward -1. Damping follows from the ratio: damping = 2 * zeta * sqrt(stiffness * mass), which with the frequency above is 4 * PI * zeta * mass / duration.

So a bounce of 0 settles without passing its target, a positive bounce overshoots and comes back, and a negative one crawls in. The bounce is held inside -0.99..=0.99.

Spring::new is unchanged and remains the way in for a spring whose three constants are already known, a token preset included.

pub fn preset(theme: &Theme, preset: SpringPreset) -> Self

pub fn damping_ratio(self) -> f32

Damping ratio: below one oscillates, one settles fastest, above one crawls.

pub fn perceptual_duration(self) -> Duration

The duration half of Spring::perceptual, for a spring built any other way: the period of the undamped oscillation.

It is not the settle time. A spring is still perceptibly arriving after its perceptual duration — at a bounce of 0 it is roughly 99% of the way there — and Spring::settle_time is the honest end of the motion.

pub fn bounce(self) -> f32

The bounce half, inverted from the damping ratio.

pub fn value(self, elapsed: Duration) -> f32

Normalized step response: 0 at rest, approaching 1 as it settles.

pub fn value_at(self, elapsed: Duration, velocity: f32) -> (f32, f32)

Normalized step response for a spring that was already moving when it was aimed here.

velocity is the speed carried into the motion, in units of the full distance per second and positive toward the target. The pair is the value and its own velocity, so a caller that retargets again can hand the motion on rather than restarting it.

pub fn settle_time(self) -> Duration

How long until the spring stays within one part in a thousand of its target.

pub fn settle_time_at(self, velocity: f32) -> Duration

The same, for a spring released with velocity already carried into the motion: one that is travelling fast needs longer to come to rest.

pub fn animation(self) -> Animation

Expresses the spring as a GPUI animation, so it can drive with_animation alongside curve-based motion.

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 Copy for Spring

impl Debug for Spring

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

Formats the value using the given formatter.

impl From<SpringTokens> for Spring

fn from(tokens: SpringTokens) -> Self

Converts to this type from the input type.

impl PartialEq for Spring

fn eq(&self, other: &Spring) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Spring