Struct Tween

Source

pub struct Tween { /* private fields */ }

Expand description

A retargetable animation from one f32 value to another over a fixed duration, reshaped by an Easing curve.

See the 08_animation example for Tween in action: https://main.retroglyph.dev/examples/08_animation/terminal/.

use core::time::Duration;
use retroglyph_ui::{Easing, Tween};

let mut fade = Tween::new(0.0, 1.0)
    .duration(Duration::from_millis(200))
    .easing(Easing::EaseOutCubic);

fade.update(Duration::from_millis(100)); // halfway through, by elapsed time
assert!(fade.value() > 0.5); // EaseOutCubic front-loads motion, so it's already past halfway
assert!(!fade.is_finished());

fade.update(Duration::from_millis(100)); // now fully elapsed
assert_eq!(fade.value(), 1.0);
assert!(fade.is_finished());

Implementations§

Source §

impl Tween

Source

pub const DEFAULT_DURATION: Duration

duration’s default if never overridden: 200ms.

200ms is the usual “fast UI transition” window: long enough to register as motion rather than a snap, short enough that it does not feel sluggish on a hover/focus change. It is a default for convenience, not a constraint; any call that cares sets duration explicitly.

Source

pub const fn new(from: f32, to: f32) -> Self

A new tween animating from from to to over DEFAULT_DURATION with Easing::Linear. Chain duration/easing to override either, then call update once per frame.

Source

pub const fn duration(self, duration: Duration) -> Self

Overrides the total duration of the animation.

Source

pub const fn easing(self, easing: Easing) -> Self

Overrides the easing curve.

Source

pub fn update(&mut self, dt: Duration)

Advances the animation by dt: call once per frame with Frame::delta. Clamped to duration: calling this after the animation has already finished is a no-op, not an overshoot into negative “time left.”

Source

pub fn progress(&self) -> f32

Linear progress through the animation: 0.0 at the start, 1.0 once is_finished. Doesn’t have the easing curve applied yet; see value for that.

Source

pub fn value(&self) -> f32

The current animated value: progress run through this tween’s Easing curve, then used to interpolate between from and to.

Source

pub fn is_finished(&self) -> bool

true once update has accumulated at least duration of elapsed time.

Source

pub const fn target(&self) -> f32

The value this tween is animating toward: what value equals once is_finished, and what retarget last set it to.

Source

pub const fn origin(&self) -> f32

The value this tween started animating from: either the from passed to new or, after a retarget, the value at the moment of that retarget.

Source

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

Redirects the animation toward a new target, smoothly: the current value becomes the new start, elapsed time resets to zero, and target becomes the new end. duration/easing are unchanged.

Calling this repeatedly (e.g. once every time a pointer re-enters or leaves a hover rect, faster than any single fade finishes) never causes a visible snap to some earlier value: each retarget starts from wherever the animation actually is right now, not from its original from.