Enum Animation 

pub enum Animation {
    Default,
    Bezier {
        duration: Duration,
        x1: f32,
        y1: f32,
        x2: f32,
        y2: f32,
    },
    Spring {
        stiffness: f32,
        damping: f32,
    },
}

An enumeration representing different types of animations

This enum exposes two native animation primitives:

• Bezier: Timed animations represented by cubic bezier control points
• Spring: Physics-based movement with configurable stiffness and damping

Convenience constructors (linear, ease_in, etc.) all map to Bezier.

Variants

Default

Default animation behavior (uses system defaults)

Bezier

Timed cubic bezier animation with control points (x1, y1, x2, y2)

Fields

duration: Duration

Animation duration

x1: f32

First control point X (0.0 to 1.0)

y1: f32

First control point Y

x2: f32

Second control point X (0.0 to 1.0)

y2: f32

Second control point Y

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 const fn linear(duration: Duration) -> Self

Creates a new Linear animation with the specified duration

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 const fn ease_in(duration: Duration) -> Self

Creates a new ease-in animation with the specified duration

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 const fn ease_out(duration: Duration) -> Self

Creates a new ease-out animation with the specified duration

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 const fn ease_in_out(duration: Duration) -> Self

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

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);

Panics

Panics if stiffness is not finite or is less than or equal to zero, or if damping is not finite or is negative.

pub const fn bezier( duration: Duration, x1: f32, y1: f32, x2: f32, y2: f32, ) -> Self

Creates a new custom cubic bezier animation

Control points define the shape of the easing curve. Standard curves can be created with these control points:

• Linear: (0.0, 0.0, 1.0, 1.0)
• Ease-in: (0.42, 0.0, 1.0, 1.0)
• Ease-out: (0.0, 0.0, 0.58, 1.0)
• Ease-in-out: (0.42, 0.0, 0.58, 1.0)

Examples

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

// Custom bounce-like curve
let animation = Animation::bezier(Duration::from_millis(400), 0.25, 0.1, 0.25, 1.0);

Panics

Panics if any control point is non-finite or if x1 or x2 falls outside the normalized [0, 1] range.

pub const fn curve(&self) -> EasingCurve

Get the underlying easing curve for this animation.

This allows using the unified easing system for interpolation.

pub const fn duration(&self) -> Duration

Get the total duration of this animation.

For spring animations, returns a default duration (600ms) since spring duration depends on the physics parameters.

pub fn progress(&self, elapsed: Duration) -> f32

Get the eased progress for the given elapsed time.

Returns a value typically between 0.0 and 1.0, though spring animations may temporarily overshoot (return values > 1.0 or < 0.0).

Arguments

• elapsed - Time elapsed since animation started

pub fn interpolate<T: Animatable>( &self, from: &T, to: &T, elapsed: Duration, ) -> T

Interpolate between two values based on elapsed time.

Uses the animation’s easing curve to calculate the current value.

Examples

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

let anim = Animation::ease_in_out(Duration::from_millis(300));
let elapsed = Duration::from_millis(150); // halfway through

let value = anim.interpolate(&0.0_f32, &100.0_f32, elapsed);
// value is approximately 50.0, but eased

pub fn is_complete(&self, elapsed: Duration) -> bool

Returns true if the animation is complete.

An animation is complete when the elapsed time equals or exceeds its duration.

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Signal for Animation

type Output = Animation

The type of value produced by this computation.

type Guard = ()

The guard type returned by the watch method that manages watcher lifecycle.

fn get(&self) -> Self::Output

Execute the computation and return the current value.

fn watch(&self, _watcher: impl Fn(Context<Self::Output>) + 'static)

Register a watcher to be notified when the computed value changes.

fn identity(&self) -> Option<SignalIdentity>

Returns the stable semantic identity of this signal, when one exists.

impl StructuralPartialEq for Animation