Enum Easing 

#[non_exhaustive]
pub enum Easing {
    Linear,
    EaseInQuad,
    EaseOutQuad,
    EaseInOutQuad,
    EaseInCubic,
    EaseOutCubic,
    EaseInOutCubic,
    EaseInSine,
    EaseOutSine,
    EaseInOutSine,
    EaseOutElastic,
    EaseOutBounce,
}

A normalized easing curve: reshapes a linear progress fraction (0.0..=1.0) into an eased one, the same named curves as CSS transitions and https://easings.net.

Linear is the default. The In variants start slow, Out variants end slow, and InOut variants do both (matching the usual naming convention: “In” describes the start of the motion, not a direction).

EaseOutElastic and EaseOutBounce are the only curves in their families: both are used for a settle/overshoot effect at the end of a motion, and the in/in-out variants (the same shape mirrored to the start) are uncommon enough in practice that this curated set omits them.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Linear

Constant speed: t unchanged.

1 |           ,-'
  |        ,-'
  |     ,-'
  |  ,-'
0 +-'------------
  0             1

EaseInQuad

Starts slow, accelerates, quadratically.

1 |                 ,'
  |               ,'
  |             ,'
  |       __,-''
0 +------''-------
  0             1

EaseOutQuad

Starts fast, decelerates, quadratically.

1 |       __,,-------
  |    ,-'
  |   ,'
  | ,'
0 +'---------------
  0             1

EaseInOutQuad

Slow -> fast -> slow, quadratically.

1 |             ___,,--
  |          ,-'
  |        ,'
  |   __,-'
0 +-''-------------
  0             1

EaseInCubic

Starts slow, accelerates, cubically: a stronger version of EaseInQuad.

1 |                  ,'
  |                 ,
  |               ,'
  |        ____,-'
0 +-------''--------
  0             1

EaseOutCubic

Starts fast, decelerates, cubically: a stronger version of EaseOutQuad.

1 |   __,,-----------
  | ,'
  |,
  |'
0 +-----------------
  0             1

EaseInOutCubic

Slow -> fast -> slow, cubically: a stronger version of EaseInOutQuad.

1 |              ___,---
  |            ,'
  |           ,
  |       __,'
0 +-----''----------
  0              1

EaseInSine

A gentle sine-shaped start.

1 |               ,--'
  |            ,-'
  |         ,-'
  |     ,--'
0 +--''-------------
  0              1

EaseOutSine

A gentle sine-shaped end.

1 |    ,--''''''''''''
  |  ,'
  | ,'
  |,'
0 +-----------------
  0              1

EaseInOutSine

A gentle sine-shaped start and end.

1 |           ____,----
  |         ,'
  |       ,'
  |   __,'
0 +--''--------------
  0              1

EaseOutElastic

Springs past the target and oscillates back before settling, going outside 0.0..=1.0 for part of the curve.

    ,-.
1 -+   \      ______________
    |    \    /
    |     `--'
0 -+
    0                     1

EaseOutBounce

Bounces (like a dropped ball) to a stop at the target.

1 |        __       _   _.
  |       /  \     / |_/ |
  |      /    \   /      |
  |     /      \_/       |
0 +----'                 |
  0                    1

Implementations

impl Easing

pub fn apply(self, t: f32) -> f32

Applies this curve to t (clamped to 0.0..=1.0 first), returning the eased fraction.

Trait Implementations

impl Clone for Easing

fn clone(&self) -> Easing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Easing

impl Debug for Easing

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

Formats the value using the given formatter.

impl Default for Easing

fn default() -> Easing

Returns the “default value” for a type.

impl Eq for Easing

impl Hash for Easing

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Easing

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