Enum Curve 

pub enum Curve {
    Linear,
    Decelerate,
    Cubic {
        x1: f32,
        y1: f32,
        x2: f32,
        y2: f32,
    },
    CriticalSpring {
        omega: f32,
    },
    Interval {
        begin: f32,
        end: f32,
        inner: Box<Curve>,
    },
    Flipped(Box<Curve>),
}

The shared animation layer — physics, curves, driver — see frus_core::animation. Re-exported here so applications can reach it through frus_widgets without depending on frus-core directly. An easing curve remapping [0,1] → [0,1].

f(0) = 0 and f(1) = 1 hold for every variant.

Variants

Linear

The identity: f(t) = t.

Decelerate

A quadratic ease-out, f(t) = 1 − (1 − t)²: fast at once, then coasting to a stop. It is the shape of something arriving — a glow flaring at an edge, a value settling — where the interesting part is the start.

Cubic

A cubic Bézier defined by its two control points (x1,y1) and (x2,y2) — the same parameterisation as CSS’s cubic-bezier().

Fields

x1: f32

The first control point’s x coordinate.

y1: f32

The first control point’s y coordinate.

x2: f32

The second control point’s x coordinate.

y2: f32

The second control point’s y coordinate.

CriticalSpring

The step response of a critically damped spring: starts at rest, settles gently with no overshoot, renormalised so that f(1) = 1. omega sets how lively it feels.

Fields

omega: f32

The spring’s natural frequency, in radians per second: higher settles faster.

Interval

Applies inner only over the sub-window [begin, end]: 0 before, 1 after. This is what unlocks staggered animations.

Fields

begin: f32

The progress at which inner starts, as a fraction of [0,1].

end: f32

The progress at which inner reaches 1, as a fraction of [0,1].

inner: Box<Curve>

The curve applied within [begin, end].

Flipped(Box<Curve>)

Mirrored: f(t) = 1 − inner(1 − t), which turns an ease-in into an ease-out.

Implementations

impl Curve

pub fn ease() -> Curve

The web’s ease (cubic-bezier(0.25, 0.1, 0.25, 1.0)).

pub fn ease_in() -> Curve

ease-in: starts slowly.

pub fn ease_out() -> Curve

ease-out: finishes slowly.

pub fn ease_in_out() -> Curve

ease-in-out: slow at both ends.

pub fn critical_spring() -> Curve

The framework’s default spring curve (omega = 8): the feel of screen and sheet transitions, in closed form.

pub fn transform(&self, t: f32) -> f32

Evaluates the curve at t, clamped to [0,1].

Trait Implementations

impl Clone for Curve

fn clone(&self) -> Curve

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Curve

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

Formats the value using the given formatter.

impl PartialEq for Curve

fn eq(&self, other: &Curve) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Curve