Struct Spring 

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

A damped-harmonic-oscillator spring, solved in closed form.

Parameters follow the common “physical” convention: mass, stiffness (k) and damping (c). The angular frequency is ω₀ = √(k/m) and the damping ratio is ζ = c / (2√(k·m)).

Fields

mass: f32

Oscillator mass (> 0).

stiffness: f32

Spring stiffness k (> 0).

damping: f32

Damping coefficient c (>= 0).

Implementations

impl Spring

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

Construct a spring from physical parameters.

pub fn from_frequency(omega0: f32, zeta: f32) -> Self

Build a spring with the given natural frequency ω₀ (rad/s) and damping ratio ζ (unit mass). ζ = 1 is critically damped.

pub fn natural_frequency(&self) -> f32

The undamped natural angular frequency ω₀ = √(k/m).

pub fn damping_ratio(&self) -> f32

The damping ratio ζ. < 1 under-, == 1 critically-, > 1 over-damped.

pub fn position(&self, from: f32, to: f32, v0: f32, t: f32) -> f32

Position at time t (seconds) for a spring released from displacement from - to with initial velocity v0, settling towards to.

Returns the absolute position (already offset by to). The solution is the exact analytic response of m·x'' + c·x' + k·x = 0, so it is numerically stable at any t and frame rate.

pub fn is_settled( &self, from: f32, to: f32, v0: f32, t: f32, tolerance: f32, ) -> bool

Whether the spring has effectively settled at to by time t, within tolerance of the rest position.

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

fn default() -> Self

A snappy, slightly-underdamped UI spring.

impl PartialEq for Spring

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Spring