Enum Animation 

pub enum Animation {
    Default,
    Linear(Duration),
    EaseIn(Duration),
    EaseOut(Duration),
    EaseInOut(Duration),
    Spring {
        stiffness: f32,
        damping: f32,
    },
}

An enumeration representing different types of animations

This enum provides various animation types for UI elements or graphics:

• Linear: Constant speed from start to finish
• EaseIn: Starts slow and accelerates
• EaseOut: Starts fast and decelerates
• EaseInOut: Starts and ends slowly with acceleration in the middle
• Spring: Physics-based movement with configurable stiffness and damping

Each animation type (except Spring) takes a Duration parameter that specifies how long the animation should take to complete.

Variants

Default

Default animation behavior (uses system defaults)

Linear(Duration)

Linear animation with constant velocity

EaseIn(Duration)

Ease-in animation that starts slow and accelerates

EaseOut(Duration)

Ease-out animation that starts fast and decelerates

EaseInOut(Duration)

Ease-in-out animation that starts and ends slowly with acceleration in the middle

Spring

Spring animation with physics-based movement

Fields

stiffness: f32

Stiffness of the spring (higher values create faster animations)

damping: f32

Damping factor to control oscillation (higher values reduce bouncing)

Implementations

impl Animation

pub fn linear(duration: impl Into<Duration>) -> Self

Creates a new Linear animation with the specified duration

This is an ergonomic constructor that accepts any type that can be converted into a Duration (such as u64 milliseconds, etc.)

Examples

use waterui_core::animation::Animation;
use core::time::Duration;

let animation = Animation::linear(Duration::from_millis(300)); // 300ms
let animation = Animation::linear(Duration::from_secs(1)); // 1 second

pub fn ease_in(duration: impl Into<Duration>) -> Self

Creates a new ease-in animation with the specified duration

This is an ergonomic constructor that accepts any type that can be converted into a Duration (such as u64 milliseconds, etc.)

Examples

use waterui_core::animation::Animation;
use core::time::Duration;

let animation = Animation::ease_in(Duration::from_millis(300)); // 300ms
let animation = Animation::ease_in(Duration::from_secs(1)); // 1 second

pub fn ease_out(duration: impl Into<Duration>) -> Self

Creates a new ease-out animation with the specified duration

This is an ergonomic constructor that accepts any type that can be converted into a Duration (such as u64 milliseconds, etc.)

Examples

use waterui_core::animation::Animation;
use core::time::Duration;

let animation = Animation::ease_out(Duration::from_millis(300)); // 300ms
let animation = Animation::ease_out(Duration::from_secs(1)); // 1 second

pub fn ease_in_out(duration: impl Into<Duration>) -> Self

Creates a new ease-in-out animation with the specified duration

This is an ergonomic constructor that accepts any type that can be converted into a Duration (such as u64 milliseconds, etc.)

Examples

use waterui_core::animation::Animation;
use core::time::Duration;

let animation = Animation::ease_in_out(Duration::from_millis(300)); // 300ms
let animation = Animation::ease_in_out(Duration::from_secs(1)); // 1 second

pub const fn spring(stiffness: f32, damping: f32) -> Self

Creates a new Spring animation with the specified stiffness and damping

Examples

use waterui_core::animation::Animation;

let animation = Animation::spring(100.0, 10.0);

Trait Implementations

impl Clone for Animation

fn clone(&self) -> Animation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Animation

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

Formats the value using the given formatter.

impl Default for Animation

fn default() -> Animation

Returns the “default value” for a type.

impl PartialEq for Animation

fn eq(&self, other: &Animation) -> 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 Animation