Struct Animated 

pub struct Animated<T, Time>
where
    T: FloatRepresentable + Clone + Copy + PartialEq,
    Time: AnimationTime,
{
    pub value: T,
    /* private fields */
}

Wraps state to enable interpolated transitions

Example

use lilt::Animated;
use std::time::Instant;

struct MyViewState {
    animated_toggle: Animated<bool, Instant>,
}
// Initialize
let mut state = MyViewState {
    animated_toggle: Animated::new(false),
};
// Update
let now = std::time::Instant::now();
state
    .animated_toggle
    .transition(!state.animated_toggle.value, now);
// Animate
let animated_width = state.animated_toggle.animate_bool(0., 100., now);
let animated_width = state.animated_toggle.animate(
   |on| if on { 0. } else { 100. },
   now,
);

An Animated struct represents a single animation axis. Multiple axes require multiple Animated structs. For example - to animate an x and a y position on the screen with different durations you’d need to wrap multiple float values independently.

use std::time::Instant;
use lilt::Animated;

struct MyState {
    animated_x: Animated<f32, Instant>,
    animated_y: Animated<f32, Instant>,
}

Fields

value: T

Implementations

impl<T, Time> Animated<T, Time>

where T: FloatRepresentable + Clone + Copy + PartialEq, Time: AnimationTime,

pub fn new_with_settings(value: T, duration_ms: f32, easing: Easing) -> Self

Creates an animated value with specified animation settings

pub fn new(value: T) -> Self

Creates an animated value with a default animation

pub fn duration(self, duration_ms: f32) -> Self

Specifies the duration of the animation in milliseconds

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

Specifies the easing with which to animate transitions

pub fn delay(self, delay_ms: f32) -> Self

Delays the animation by the given number of milliseconds

pub fn repeat(self, count: u32) -> Self

Repeats animations the specified number of times Passing a repetition count of 1 plays the animation twice in total

pub fn repeat_forever(self) -> Self

Repeats transitions forever

pub fn auto_reverse(self) -> Self

Automatically play repetitions in reverse after they complete

pub fn auto_start(self, new_value: T, at: Time) -> Self

Begins a transition as soon as the animation is created

pub fn asymmetric_duration(self, duration_ms: f32) -> Self

Applies an alternative duration while animating backwards

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

Applies an alternative easing while animating backwards

pub fn transition(&mut self, new_value: T, at: Time)

Updates the wrapped state & begins an animation

pub fn transition_instantaneous(&mut self, new_value: T, at: Time)

Updates the wrapped state & instantaneously completes an animation. Ignores animation settings such as delay & duration.

pub fn in_progress(&self, time: Time) -> bool

Returns whether the animation is complete, given the current time

pub fn animate<I>(&self, map: impl Fn(T) -> I, time: Time) -> I

where I: Interpolable,

Interpolates between states of any value that implements Interpolable, given the current time

impl<T, Time> Animated<T, Time>

where T: FloatRepresentable + Clone + Copy + PartialEq, Time: AnimationTime,

pub fn animate_if_eq<I>(&self, value: T, equal: I, default: I, time: Time) -> I

where I: Interpolable + Clone,

Interpolates to equal when the wrapped value matches the provided value Otherwise interpolate towards default

impl<T, Time> Animated<T, Time>

where T: FloatRepresentable + Clone + Copy + PartialEq + Interpolable, Time: AnimationTime,

pub fn animate_wrapped(&self, time: Time) -> T

impl<Time> Animated<bool, Time>

where Time: AnimationTime,

pub fn animate_bool<I>(&self, false_value: I, true_value: I, time: Time) -> I

where I: Interpolable + Clone,

Interpolates any value that implements Interpolable, given the current time

Trait Implementations

impl<T, Time> Clone for Animated<T, Time>

where T: FloatRepresentable + Clone + Copy + PartialEq + Clone, Time: AnimationTime + Clone,

fn clone(&self) -> Animated<T, Time>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Time> Debug for Animated<T, Time>

where T: FloatRepresentable + Clone + Copy + PartialEq + Debug, Time: AnimationTime + Debug,

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

Formats the value using the given formatter.

impl<T, Time> Default for Animated<T, Time>

where T: FloatRepresentable + Clone + Copy + PartialEq + Default, Time: AnimationTime + Default,

fn default() -> Animated<T, Time>

Returns the “default value” for a type.