Struct bevy_tweening::Delay

pub struct Delay<T> { /* private fields */ }

A time delay that doesn’t animate anything.

This is generally useful for combining with other tweenables into sequences and tracks, for example to delay the start of a tween in a track relative to another track. The menu example (examples/menu.rs) uses this technique to delay the animation of its buttons.

Implementations

impl<T: 'static> Delay<T>

pub fn then(self, tween: impl Tweenable<T> + 'static) -> Sequence<T>

Chain another Tweenable after this tween, making a Sequence with the two.

impl<T> Delay<T>

pub fn new(duration: Duration) -> Self

Create a new Delay with a given duration.

Panics

Panics if the duration is zero.

pub fn with_completed_event(self, user_data: u64) -> Self

Enable raising a completed event.

If enabled, the tweenable will raise a TweenCompleted event when it completed. This is similar to the set_completed() callback, but uses Bevy events instead.

Example

let delay: Delay<Transform> = Delay::new(Duration::from_secs(5))
  .with_completed_event(42);

fn my_system(mut reader: EventReader<TweenCompleted>) {
  for ev in reader.read() {
    assert_eq!(ev.user_data, 42);
    println!("Entity {:?} raised TweenCompleted!", ev.entity);
  }
}

pub fn with_completed<C>(self, callback: C) -> Self

where C: Fn(Entity, &Self) + Send + Sync + 'static,

Set a callback invoked when the delay completes.

The callback when invoked receives as parameters the [Entity] on which the target and the animator are, as well as a reference to the current Delay. This is similar to with_completed_event(), but with a callback instead.

Only non-looping tweenables can complete.

Example

let tween = Tween::new(
    // [...]
)
.with_completed(|entity, delay| {
  println!("Delay of {} seconds elapsed on entity {:?}",
    delay.duration().as_secs(), entity);
});

pub fn is_completed(&self) -> bool

Check if the delay completed.

pub fn state(&self) -> TweenState

Get the current tweenable state.

pub fn set_completed<C>(&mut self, callback: C)

where C: Fn(Entity, &Self) + Send + Sync + 'static,

Set a callback invoked when the animation completes.

The callback when invoked receives as parameters the [Entity] on which the target and the animator are, as well as a reference to the current Tween.

Only non-looping tweenables can complete.

pub fn clear_completed(&mut self)

Clear the callback invoked when the animation completes.

See also set_completed().

pub fn set_completed_event(&mut self, user_data: u64)

Enable or disable raising a completed event.

If enabled, the tween will raise a TweenCompleted event when the animation completed. This is similar to the set_completed() callback, but uses Bevy events instead.

See with_completed_event() for details.

pub fn clear_completed_event(&mut self)

Clear the event sent when the animation completes.

See also set_completed_event().

Trait Implementations

impl<T: 'static> From<Delay<T>> for BoxedTweenable<T>

fn from(t: Delay<T>) -> Self

Converts to this type from the input type.

impl<T> Tweenable<T> for Delay<T>

fn duration(&self) -> Duration

Get the duration of a single iteration of the animation.

fn total_duration(&self) -> TotalDuration

Get the total duration of the entire animation, including looping.

fn set_elapsed(&mut self, elapsed: Duration)

Set the current animation playback elapsed time.

fn elapsed(&self) -> Duration

Get the current elapsed duration.

fn tick( &mut self, delta: Duration, _target: &mut dyn Targetable<T>, entity: Entity, events: &mut Mut<'_, Events<TweenCompleted>> ) -> TweenState

Tick the animation, advancing it by the given delta time and mutating the given target component or asset.

fn rewind(&mut self)

Rewind the animation to its starting state.

fn set_progress(&mut self, progress: f32)

Set the current animation playback progress.

fn progress(&self) -> f32

Get the current progress in [0:1] of the animation.

fn times_completed(&self) -> u32

Get the number of times this tweenable completed.