Struct Animation 

pub struct Animation<T: Interpolate> {
    pub start: T,
    pub end: T,
    pub duration: f32,
    pub elapsed: f32,
    pub easing: EasingFunction,
    pub state: AnimationState,
}

A generic animation that interpolates between two values over time

Example

use armas_basic::animation::{Animation, EasingFunction};

let mut anim = Animation::new(0.0_f32, 1.0, 0.3)
    .easing(EasingFunction::EaseOut);
anim.start();
anim.update(0.15);
let value = anim.value(); // interpolated between 0.0 and 1.0

Fields

start: T

Starting value

end: T

Target value

duration: f32

Duration of the animation in seconds

elapsed: f32

Elapsed time in seconds

easing: EasingFunction

Easing function to apply

state: AnimationState

Current state of the animation

Implementations

impl<T: Interpolate> Animation<T>

pub const fn new(start: T, end: T, duration: f32) -> Self

Create a new animation from start to end over duration

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

Set the easing function

pub const fn start(&mut self)

Start the animation

pub fn pause(&mut self)

Pause the animation

pub fn resume(&mut self)

Resume the animation

pub const fn reset(&mut self)

Reset the animation to the beginning

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

Update the animation with delta time

pub fn value(&self) -> T

Get the current value of the animation

pub fn progress(&self) -> f32

Get the normalized progress (0.0 to 1.0)

pub fn is_complete(&self) -> bool

Check if the animation is complete

pub fn is_running(&self) -> bool

Check if the animation is running

Trait Implementations

impl<T: Clone + Interpolate> Clone for Animation<T>

fn clone(&self) -> Animation<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Interpolate> Debug for Animation<T>

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

Formats the value using the given formatter.