Struct ScalarSpring

pub struct ScalarSpring {
    pub smooth: f32,
    pub undamp: f32,
    pub goal: f32,
    pub value: f32,
    pub vel: f32,
    pub time: u64,
    pub enabled: bool,
}

Critically damped spring modulator. Moves towards its set goal with smooth seconds of delay, critically damping its arrival so it slows down and stops at the goal without overshooting or oscillation.

If overshooting is desired, positive values of undamp can be set to add artificial overshoot/oscillations around the goal.

Fields

smooth: f32

Spring delay (smoothing), in seconds

undamp: f32

Amount of damping to remove (0..1)

goal: f32

Current target for the spring

value: f32

Current position of the spring (value)

vel: f32

Current velocity

time: u64

Accumulated microseconds

enabled: bool

Enabling toggle

Implementations

impl ScalarSpring

pub fn new(smooth: f32, undamp: f32, initial: f32) -> Self

Make a critically damped spring

pub fn spring_to(&mut self, goal: f32)

Update the target the spring is moving towards

pub fn jump_to(&mut self, goal: f32)

Jump immediately to the given goal, zero velocity

Trait Implementations

impl Modulator<f32> for ScalarSpring

fn value(&self) -> f32

Value of the modulator at the current time.

fn goal(&self) -> Option<f32>

Current goal of the modulator, or None if not applicable.

fn set_goal(&mut self, goal: f32)

Set a goal for the modulator to move towards, if possible.

fn elapsed_us(&self) -> u64

Total accumulated microseconds for the modulator.

fn enabled(&self) -> bool

Check if the modulator is disabled

fn set_enabled(&mut self, enabled: bool)

Toggle enabling/disabling the modulator

fn advance(&mut self, dt: u64)

Move the modulator ahead by dt microseconds.

fn as_any(&mut self) -> &mut dyn Any

Allow donwcasting.

fn range(&self) -> Option<[T; 2]>

Range of the modulator as min..=max, or None if the range is indeterminate.