Fixes #17

This supports an animation like the following:

pub fn error_shake(current: &Transform) -> Sequence<Transform> {
    let wiggle = Quat::from_rotation_z(PI / 16.);
    Tween::new(
        EaseMethod::Linear,
        TweeningType::Once,
        Duration::from_millis(25),
        TransformRotationLens {
            start: current.rotation,
            end: current.rotation * wiggle.inverse(),
        },
    )
    .then(Tween::new(
        EaseMethod::Linear,
        TweeningType::PingPongTimes(3),
        Duration::from_millis(50),
        TransformRotationLens {
            start: current.rotation * wiggle.inverse(),
            end: current.rotation * wiggle,
        },
    ))
    .then(Tween::new(
        EaseMethod::Linear,
        TweeningType::Once,
        Duration::from_millis(25),
        TransformRotationLens {
            start: current.rotation * wiggle,
            end: current.rotation,
        },
    ))
}

Here is the code:

use bevy::prelude::*;
use bevy_tweening::{lens::*, *};

fn main() {
    App::default()
        .add_plugins(DefaultPlugins)
        .add_plugin(TweeningPlugin)
        .add_startup_system(setup)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn_bundle(OrthographicCameraBundle::new_2d());

    let size = 80.;
    let tween = Tween::new(
        EaseMethod::Linear,
        TweeningType::PingPong,
        std::time::Duration::from_secs(1),
        TransformRotationLens {
            start: Quat::IDENTITY,
            end: Quat::from_axis_angle(Vec3::Z, std::f32::consts::PI),
        },
    );

    commands
        .spawn_bundle((
            Transform::default(),
            GlobalTransform::default(),
        ))
        .with_children(|parent| {
            parent
                .spawn_bundle(SpriteBundle {
                    sprite: Sprite {
                        color: Color::RED,
                        custom_size: Some(Vec2::new(size, size * 0.5)),
                        ..Default::default()
                    },
                    ..Default::default()
                })
                .insert(Animator::new(tween));
        });
}

It works correctly, sprite rotates. But if you replace std::f32::consts::PI with std::f32::consts::TAU the sprite becomes invisible.

bevy::prelude::ColorMaterial does not implementbevy::prelude::Component, which breaks ColorMaterialColorLens.

Full error message:

error[E0277]: the trait bound bevy::prelude::ColorMaterial: bevy::prelude::Component is not satisfied --> src\main.rs:265:44 | 265 | commands.entity(e2).insert(Animator::new(Tween::new( | ^^^^^^^^ the trait bevy::prelude::Component is not implemented for bevy::prelude::ColorMaterial | = help: the following other types implement trait bevy::prelude::Component: AdditionalMassProperties AlphaMode AnimationPlayer Animator AssetAnimator BackgroundColor Ball BloomSettings and 120 others note: required by a bound in Animator --> {DIRECTORY}\bevy_tweening-0.6.0\src\lib.rs:408:24 | 408 | pub struct Animator<T: Component> { | ^^^^^^^^^ required by this bound in Animator

Current paint points:

• All tweenables in sequences and tracks are allocated even though most people will primarily use the built-ins.
• There's double boxing causing extreme indirection: tweenables are stored in a vec which contains boxes of boxes (since IntoBoxDynTweenable unconditionally boxes and there's no way to avoid this without specialization which is a long ways away).
• Creating seqs/tracks of heterogeneous types is very ugly and confusing.

Solutions:

• Use an enum to fake dynamic typing for built-ins.
• Provide an impl for boxed types for 3P tweenables.
• Export a BoxedTweenable type to alleviate typing pain.

This makes built-ins zero cost while 3P types only suffer one layer of indirection.

Closes #28

bevy 0.8 has just been released and I would love to use bevy_tweening with it. I've successfully been using these changes with a local copy. bevy-inspector-egui does not have a compatible release yet, unfortunately.

Hi, i was trying to implement simple custom lens for animating my ui image alpha, but it doesn't work, am i doing something wrong ?

struct ImageOpacityLens {
    start: f32,
    end: f32,
}

impl Lens<BackgroundColor> for ImageOpacityLens {
    fn lerp(&mut self, target: &mut BackgroundColor, ratio: f32) {
        let interpolated_value = self.start + (self.end - self.start) * ratio;
        target.0.set_a(interpolated_value);
    }
}

let tween = Tween::new(
        EaseFunction::QuadraticInOut,
        Duration::from_secs(2),
        ImageOpacityLens {
            start: 0.0,
            end: 1.0,
        },
    )
    .with_repeat_count(RepeatCount::Finite(2))
    .with_repeat_strategy(RepeatStrategy::MirroredRepeat);

commands.spawn((
        ImageBundle {
            style: Style {
                margin: UiRect::all(Val::Auto),
                size: Size::new(Val::Px(300.0), Val::Auto),
                ..default()
            },
            image: UiImage(icon),
            ..default()
        },
        Animator::new(tween),
    ));

Whenever I use the TransformPositionLens with TweeningType::Once, even after the animation is completed, the entitities transform seems to be "changed" still. I know this because I have another system listening on transform Change and it is triggering every frame.

#[derive(Component)]
pub struct ImTweeningHere;

pub fn move_player_on_click(
    mut commands: Commands,
    mouse_input: Res<Input<MouseButton>>,
    grid_dimensions: Res<GridDimensions>,
    mouse_map_pos: Option<Res<MouseMapPos>>,
    player: Query<(Entity, &Transform), (With<Player>, Without<ImTweeningHere>)>,
) {
    if let (true, Some(mouse_map_pos)) = (
        mouse_input.just_pressed(MouseButton::Left),
        mouse_map_pos.as_deref(),
    ) {
        if let Ok((entity, player_transform)) = player.get_single() {
            let end_position = grid_dimensions.grid_loc_to_vec2(
                (mouse_map_pos.0.x / grid_dimensions.tile_area).floor(),
                (mouse_map_pos.0.y / grid_dimensions.tile_area).floor(),
            );

            let tween = Tween::new(
                EaseFunction::CircularInOut,
                TweeningType::Once,
                std::time::Duration::from_millis(500),
                TransformPositionLens {
                    start: player_transform.translation,
                    end: Transform::from_translation(end_position.extend(player_transform.translation.z))
                        .translation,
                },
            )
            .with_completed_event(true, 0);

            let animator = Animator::new(tween);
            commands
                .entity(entity)
                .insert(animator)
                .insert(ImTweeningHere);
        }
    }
}

the above system triggers the animation on map click, when the animation completes, the entities Transform still fires off

fn player_transforming(
    player: Query<&Transform, (With<Player>, Changed<Transform>)>,
) {
    if let Ok(transforming) = player.get_single() {
        info!("player is transforming!: {transforming:?}");
    }
}

as a work around, I manually remove the AnimatorTransform on tween complete

fn movement_completed(mut commands: Commands, mut on_tween_complete: EventReader<TweenCompleted>) {
    for evt in on_tween_complete.iter() {
        if evt.user_data == 0 {
            commands
                .entity(evt.entity)
                .remove::<ImTweeningHere>()
                .remove::<Animator<Transform>>();
        }
    }
}

However, I am not sure if this is the intended behavior. do we need to remove the Animator on animation complete. I expect that the intended behavior when using a TweeningType of Once is the component will be removed on animation complete for the entity and we use the TweenCompleted event for other stuff, like my use case here to remove my own component.

Admitted – this issue is not very original, but it does not hurt to have it filed: Bevy 0.9 has just been released, and there is a migration guide at https://bevyengine.org/learn/book/migration-guides/0.8-0.9/

I am still inexperienced with rust and cargo and run into the most basic of problems: bevy_tweening 0.5.0 still depends on bevy 0.8.1, and I am getting compilation errors related to mismatching dependency versions.

Hey,

I want to create a turtlegraphics clone in bevy. So far I achieved the basic functionality:

https://user-images.githubusercontent.com/290005/186853826-97c6a175-39a0-4dfc-8357-e08811e18a8a.mp4

I did so by one line/circle etc each being one bundle with an animator...

Now I would like to make this form filled: like here https://github.com/sunjay/turtle/blob/master/docs/assets/images/examples/ferris.gif

But to fill that all the lines need to be in one bundle I think. Of course I could create a rather complicated lens that draws that bundle but the lerping would break because all the steps in the middle would be faster than at the beginning or the end...

I'm not sure if I found all the relevant documentation so I might miss something obvious. However I'd very much appreciate some hints on how such a thing could be achieved.

Thank you!

Currently a tweenable callback has little information. It contains a reference to the Tween<T>, and (change not merged yet) the Entity of the Animator<T> or AssetAnimator<T>.

Kero on Discord suggested providing a &mut world to allow the callback to do something useful, similar to what bevy-tick-timers does. But this forces the system ticking the animators to take a global lock and become exclusive, serializing execution and being a potential choke point for other Bevy systems, which can cause performance issues. This is particularly bad for bevy_tweening which has a series of such systems, once per component type:

https://github.com/djeedai/bevy_tweening/blob/38e99394749d834f5afd7e5bf76b4692b7d44ce1/src/plugin.rs#L48-L59

A possible alternative which sounds more Bevy-esque would be to replace the callback with a Bevy event. This way the user app can design any system they want to read that event, with any resource / query they need. This however implies being able to write an event without knowing its type at build time, to avoid depending on the event type as an extra generic parameter for the system:

let mut tween = Tween::new(...);
tween.set_completed::<MyEvent>();

then

pub fn component_animator_system<T: Component>( 
    time: Res<Time>, 
    mut query: Query<(&mut T, &mut Animator<T>)>,
    mut writer: EventWriter<????>, //< Here we don't know the type
) { 
    for (ref mut target, ref mut animator) in query.iter_mut() { 
        if animator.state != AnimatorState::Paused { 
            if let Some(tweenable) = animator.tweenable_mut() { 
                tweenable.tick(time.delta(), target, writer); 
            } 
        } 
    } 
} 

This was pretty easy to do with the old bevy_easings crate, that this crate was based on, because it dealt with the entire Transform all at once.

Here, you are providing separate "lenses" for translation, rotation, and scale, and all of them set the generic parameter on Lens<T> to T: Transform, meaning that I cannot add multiple to the same entity simultaneously. There is no lens for working with the whole transform. :(

So have you made it impossible to tween between two Transforms? Only leaving the possibility to operate on one field at a time?

Hey,

I was trying to have an object zoom into existence then wiggle infinitely... I tried doing that with:

Tween::new(
            EaseFunction::QuadraticInOut,
            Duration::from_millis(1000),
            TransformScaleLens {
                start: Vec3::ZERO,
                end: Vec3::ONE,
            },
        )
        .then(
            Tween::new(
                EaseFunction::QuadraticInOut,
                Duration::from_millis(200),
                TransformRotateZLens {
                    start: 0.05,
                    end: -0.05,
                },
            )
            .with_repeat_strategy(bevy_tweening::RepeatStrategy::MirroredRepeat)
            .with_repeat_count(RepeatCount::Infinite),
        )

But when Running the first animation works well, however the second one panics with:

thread 'Compute Task Pool (13)' panicked at 'overflow when subtracting durations', library/core/src/time.rs:930:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

The same happens if repeat_count is set to a finite number even when set to 1.

It might be that this is "known" or "intended" but if so it should probably be in the documentation for the then method or the Sequence type.

The Behaviour I expected would have been an infinite sequence first the zoom then forever wiggling...

set_completed_event/with_completed_event are currently only available on the Tween type. It'd be nice to have them on any Tweenable, but especially on the compound ones: Sequence and Tracks.

My current workaround for this is to attach the completion to the last tweenable in sequence. This is pretty awkward, because you have to do it before you type-erase it, e.g.:

// `transitions` is Vec<(Duration, /* target alpha */ f32)>
let mut sequence: Vec<BoxedTweenable<Sprite>> = Vec::with_capacity(transitions.len());

let mut current_alpha = initial;
for (i, &(duration, end_alpha)) in transitions.iter().enumerate() {
    if (end_alpha - current_alpha).abs() < 0.01 {
        sequence.push(Box::new(Delay::new(duration)));
    } else {
        let lens = SpriteColorLens {
            start: fade_sprite_color(current_alpha),
            end: fade_sprite_color(end_alpha),
        };

        let mut tween = Tween::new(EaseMethod::Linear, TweeningType::Once, duration, lens);
        if i == transitions.len() - 1 {
            tween.set_completed_event(TWEEN_COMPLETION_COOKIE);
        }

        sequence.push(Box::new(tween));
    }
    current_alpha = end_alpha;
}

Sequence::new(sequence)

This also doesn't work if the last tweenable is Delay. For that case, you need to turn your Sequence into Tracks, with a parallel Tween that does nothing but provide the completion event. This might require a custom NoopLens<T: Component> type.

All in all, pretty messy. Having set_completed_event on more tweenable types would eliminate the need for tricks like this.

Add an animator speed test which actually ticks a tween. Currently because the ticking is deferred to the tween itself, and applied "manually" by the built-in animator systems, it's easy to break the feature without noticing as the systems are also not tested.

The set_progress() (and discussed set_elapsed()) method allow you to move the animation to an earlier point than the one it's in currently. Traditionally for tick-based animation the tween will emit a completion event each time it's completed. However, when playback jumps backward, it's unclear what should be done for completion events, especially when the tween is repeating, and jumping backward can decrease the completed count (times_completed) by more than one.

Conceptually it feels like jumping backward this way is not a natural way of animating, and is more geared toward editors or manual seeking, so it feels like ignoring completion events (and callbacks) in that case is the best approach.

Note however that there is also the playback direction which allows smooth playback but in reverse order. Although this is a distinct and probably orthogonal feature (it only swaps the endpoints of the lens), conceptually it can be confusing to make a distinction between "moving by 1 second in backward direction" and "seeking 1 second before the current point", which both result in the same state for the underlying animated component, but not for the tween which has a different direction.

Hey, I'm back from vacation. :) Can we get the ball rolling again? This PR builds on #37 and again managed to organically catch more bugs (the duration underflow one in particular). Next I'm planning on converting the Tracks tests and fiddling around with Kani to see if we can get some cool proofs going. After that I'd like to revamp/add more benchmarks plus do a clippy pedantic pass and then finally get back to #38.

Currently we'll block you from updating the underlying structure if the tween is complete, but we should probably remove that optimization or keep track of whether or not the underlying was updated and perform the update even if the tween is completed.