Struct Animation 

pub struct Animation {
    pub motion: Motion,
    pub synced: bool,
    pub max_fps: Option<f32>,
}

A timed change to an element, applied with AnimationExt::with_animation.

An animation is a Motion with two more options: whether its phase follows the app’s shared clock, and an optional cap on how often it redraws. A Duration turns into one linear pass.

Examples

use std::time::Duration;

use gpui::{Animation, Direction, Iterations, Motion, ease_out_quint, millis};

let once = Animation::new(Duration::from_millis(300)).with_easing(ease_out_quint());
assert!(!once.synced);
assert_eq!(once.motion.playback().iterations(), Iterations::default());

// Pass an alternating motion, then repeat it, to ping-pong forever.
let ping_pong = Animation::new(Motion::new(millis(300)).alternate()).repeat();
assert_eq!(ping_pong.motion.playback().iterations(), Iterations::Forever);
assert_eq!(ping_pong.motion.playback().direction(), Direction::Alternate);

assert_eq!(Animation::new(millis(16)).with_max_fps(30.).max_fps, Some(30.0));

Fields

motion: Motion

The timing, repetition and easing of this animation.

synced: bool

Whether the phase follows the app’s shared clock rather than the time this element began animating. See Animation::repeat_synced.

max_fps: Option<f32>

The maximum number of re-renders per second. None re-renders on every frame. See Animation::with_max_fps.

Implementations

impl Animation

pub fn new(motion: impl Into<Motion>) -> Self

Creates an animation from a Motion or a Duration.

A duration creates one linear pass that runs once.

pub fn repeat(self) -> Self

Repeats the animation forever.

Each cycle starts again from the beginning. The direction doesn’t reverse. To ping-pong, build the motion with Motion::alternate and pass it to Animation::new.

pub fn repeat_synced(self) -> Self

Repeats the animation forever, with its phase set by a clock shared by the whole App.

Elements that use it stay in step with each other. An element that mounts later joins the shared phase, rather than starting from zero.

pub fn with_easing(self, easing: impl Fn(f32) -> f32 + 'static) -> Self

Sets the easing curve.

The output isn’t clamped. An overshooting curve gives values outside 0.0..=1.0, so clamp in your animator if the property can’t take them. A curve such as ease_out_quint stays within that range.

pub fn with_max_fps(self, max_fps: f32) -> Self

Caps re-renders at max_fps per second, using a timer between frames.

A value that is not finite or not positive is ignored, and the animation re-renders on every frame.

Trait Implementations

impl Clone for Animation

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.