Struct bevy_tweening::Tween

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

Single tweening animation instance.

Implementations

impl<T: 'static> Tween<T>

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

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

Example

let tween1 = Tween::new(
    EaseFunction::QuadraticInOut,
    Duration::from_secs(1),
    TransformPositionLens {
        start: Vec3::ZERO,
        end: Vec3::new(3.5, 0., 0.),
    },
);
let tween2 = Tween::new(
    EaseFunction::QuadraticInOut,
    Duration::from_secs(1),
    TransformRotationLens {
        start: Quat::IDENTITY,
        end: Quat::from_rotation_x(90.0_f32.to_radians()),
    },
);
let seq = tween1.then(tween2);

impl<T> Tween<T>

pub fn new<L>( ease_function: impl Into<EaseMethod>, duration: Duration, lens: L ) -> Selfwhere L: Lens<T> + Send + Sync + 'static,

Create a new tween animation.

Example

let tween = Tween::new(
    EaseFunction::QuadraticInOut,
    Duration::from_secs(1),
    TransformPositionLens {
        start: Vec3::ZERO,
        end: Vec3::new(3.5, 0., 0.),
    },
);

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

Enable raising a completed event.

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

Example

let tween = Tween::new(
    // [...]
)
.with_completed_event(42);

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

pub fn with_completed<C>(self, callback: C) -> Selfwhere 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 Tween. 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, _tween| {
  println!("Tween completed on entity {:?}", entity);
});

pub fn set_direction(&mut self, direction: TweeningDirection)

Set the playback direction of the tween.

The playback direction influences the mapping of the progress ratio (in [0:1]) to the actual ratio passed to the lens. TweeningDirection::Forward maps the 0 value of progress to the 0 value of the lens ratio. Conversely, TweeningDirection::Backward reverses the mapping, which effectively makes the tween play reversed, going from end to start.

Changing the direction doesn’t change any target state, nor any progress of the tween. Only the direction of animation from this moment potentially changes. To force a target state change, call Tweenable::tick() with a zero delta (Duration::ZERO).

pub fn with_direction(self, direction: TweeningDirection) -> Self

Set the playback direction of the tween.

See Tween::set_direction().

pub fn direction(&self) -> TweeningDirection

The current animation direction.

See TweeningDirection for details.

pub fn with_repeat_count(self, count: impl Into<RepeatCount>) -> Self

Set the number of times to repeat the animation.

pub fn with_repeat_strategy(self, strategy: RepeatStrategy) -> Self

Choose how the animation behaves upon a repetition.

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<Tween<T>> for BoxedTweenable<T>

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

Converts to this type from the input type.

impl<T> Tweenable<T> for Tween<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.