Struct Transition 

pub struct Transition<T: Lerp + Clone + PartialEq + 'static> { /* private fields */ }

An animated transition between values of type T.

Transition manages the interpolation of a value from a start state to a goal state over a specified duration. It supports customizable easing functions and can operate in continuous or non-continuous mode.

Type Parameters

• T - The type of value being transitioned. Must implement Lerp, Clone, and PartialEq.

Continuous vs Non-Continuous Mode

By default, transitions operate in continuous mode. When the goal is updated:

• Continuous mode (continuous = true): The transition smoothly continues from the current interpolated value to the new goal.
• Non-continuous mode (continuous = false): The transition restarts from the initial value to the new goal.

Example

let transition = window.use_transition(cx, Duration::from_millis(300), |_, _| 0.0_f32)
    .with_easing(ease_in_out);

// Get the current interpolated value
let value = transition.evaluate(window, cx);

// Update the goal
transition.update(cx, |val, cx| {
    *val = 1.0;
    cx.notify();
});

Implementations

impl<T: Lerp + Clone + PartialEq + 'static> Transition<T>

pub fn new(state: Entity<TransitionState<T>>, duration: Duration) -> Self

Create a new transition with the given duration using the specified state.

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

Set the easing function to use for this transition. The easing function will take a time delta between 0 and 1 and return a new delta between 0 and 1

pub fn continuous(self, continuous: bool) -> Self

Sets whether the transition should be continuous.

On goal updates, transitions continue from the current value by default. If continuous is set to false, the transition will restart from its initial value.

pub fn evaluate(&self, window: &mut Window, cx: &mut App) -> Ref<'_, T>

Evaluates and returns the current interpolated value of the transition.

This method calculates the value based on the elapsed time since the last goal update, applies the easing function, and caches the result. If the transition is still in progress, it automatically requests an animation frame to continue the animation.

The returned value is cached for the duration of the current frame to avoid redundant calculations when called multiple times.

pub fn read_goal<'b>(&'b self, cx: &'b mut App) -> &'b T

Reads the end goal of the transitions.

pub fn read_cache(&self) -> Ref<'_, Option<T>>

Reads the current value of the cached transition, if it exists.

pub fn evaluate_delta<'b>(&'b self, cx: &'b App) -> f32

Evaluates and returns the current progress delta of the transition.

Returns a value between 0.0 and 1.0 representing how far the transition has progressed, after applying the easing function. A value of 0.0 means the transition just started, and 1.0 means it has completed.

pub fn update<R>( &self, cx: &mut App, update: impl FnOnce(&mut T, &mut Context<'_, TransitionState<T>>) -> R, ) -> bool

Updates the goal value for the transition.

The provided closure receives a mutable reference to the current goal value and can modify it. If the goal changes (and continuous mode is enabled), a new animation will begin from the current interpolated value toward the new goal.

Returns true if the goal was actually updated (i.e., the new value differs from the previous goal), false otherwise.

Note: This method does not automatically notify GPUI of changes. You should call cx.notify() within the closure if you want to trigger a re-render.

pub fn jump_to(&self, target: T, cx: &mut App)

Instantly set the transition to the given target value without animation.

Sets both the start and end goals to target so that subsequent evaluations return target immediately. This is useful for transitions that require a different start value on each update.

pub fn scale_by(&self, ratio: f32, cx: &mut App)

where T: Mul<f32, Output = T>,

Scale the transition’s start and end goals by the given ratio.

This preserves the relative progress of an in-flight animation when the coordinate space changes (e.g. on window resize). Both the start and end goal are multiplied by ratio so the interpolated value remains proportionally correct.

pub fn entity_id(&self) -> EntityId

Returns the entity ID associated with this transition’s state.

This can be useful for tracking or comparing transitions.

pub fn reset(&self, cx: &mut App)

Resets the transition to its initial state.

This clears all progress and sets both the start and end goals back to the initial value that was provided when the transition was created. The cache is also cleared.

Trait Implementations

impl<T: Clone + Lerp + Clone + PartialEq + 'static> Clone for Transition<T>

fn clone(&self) -> Transition<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.