From 826532a06631424ab55192d6600ce9b5230f60d0 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Mon, 29 Apr 2024 20:40:57 +0100
Subject: [PATCH 01/66] v2

---
 Cargo.toml                        |   1 +
 examples/menu.rs                  |  84 ++--
 examples/sequence.rs              |  23 +-
 examples/sprite_color.rs          |   2 +-
 examples/text_color.rs            |   2 +-
 examples/transform_rotation.rs    |   7 +-
 examples/transform_translation.rs |   7 +-
 examples/ui_position.rs           |   4 +-
 src/lib.rs                        | 624 +++++++++++++++++++-----------
 src/plugin.rs                     | 144 ++-----
 src/tweenable.rs                  | 152 ++++----
 11 files changed, 577 insertions(+), 473 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4493cef..1a26e59 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ bevy_text = ["bevy/bevy_text", "bevy/bevy_render", "bevy/bevy_sprite"]
 
 [dependencies]
 interpolation = "0.3"
+slotmap = "1.0"
 bevy = { version = "0.14", default-features = false }
 
 [dev-dependencies]
diff --git a/examples/menu.rs b/examples/menu.rs
index 25d6660..d33b72a 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -88,50 +88,49 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 )
                 .with_completed_event(INIT_TRANSITION_DONE);
 
-                let animator = if start_time_ms > 0 {
+                let mut ec = container.spawn((
+                    ButtonBundle {
+                        style: Style {
+                            min_width: Val::Px(300.),
+                            min_height: Val::Px(80.),
+                            margin: UiRect::all(Val::Px(8.)),
+                            padding: UiRect::all(Val::Px(8.)),
+                            align_content: AlignContent::Center,
+                            align_items: AlignItems::Center,
+                            align_self: AlignSelf::Center,
+                            justify_content: JustifyContent::Center,
+                            ..default()
+                        },
+                        background_color: BackgroundColor(NORMAL_COLOR),
+                        transform: Transform::from_scale(Vec3::splat(0.01)),
+                        ..default()
+                    },
+                    Name::new(format!("button:{}", text)),
+                    label,
+                ));
+
+                let mut ec = if start_time_ms > 0 {
                     let delay = Delay::new(Duration::from_millis(start_time_ms));
-                    Animator::new(delay.then(tween_scale))
+                    ec.tween(delay.then(tween_scale))
                 } else {
-                    Animator::new(tween_scale)
+                    ec.tween(tween_scale)
                 };
-
                 start_time_ms += 500;
-                container
-                    .spawn((
-                        ButtonBundle {
-                            style: Style {
-                                min_width: Val::Px(300.),
-                                min_height: Val::Px(80.),
-                                margin: UiRect::all(Val::Px(8.)),
-                                padding: UiRect::all(Val::Px(8.)),
-                                align_content: AlignContent::Center,
-                                align_items: AlignItems::Center,
-                                align_self: AlignSelf::Center,
-                                justify_content: JustifyContent::Center,
-                                ..default()
+
+                ec.with_children(|parent| {
+                    parent.spawn(TextBundle {
+                        text: Text::from_section(
+                            text.to_string(),
+                            TextStyle {
+                                font: font.clone(),
+                                font_size: 48.0,
+                                color: TEXT_COLOR,
                             },
-                            background_color: BackgroundColor(NORMAL_COLOR),
-                            transform: Transform::from_scale(Vec3::splat(0.01)),
-                            ..default()
-                        },
-                        Name::new(format!("button:{}", text)),
-                        animator,
-                        label,
-                    ))
-                    .with_children(|parent| {
-                        parent.spawn(TextBundle {
-                            text: Text::from_section(
-                                text.to_string(),
-                                TextStyle {
-                                    font: font.clone(),
-                                    font_size: 48.0,
-                                    color: TEXT_COLOR,
-                                },
-                            )
-                            .with_justify(JustifyText::Center),
-                            ..default()
-                        });
+                        )
+                        .with_justify(JustifyText::Center),
+                        ..default()
                     });
+                });
             }
         });
 }
@@ -159,9 +158,10 @@ enum ButtonLabel {
 }
 
 fn interaction(
+    mut commands: Commands,
     mut interaction_query: Query<
         (
-            &mut Animator<Transform>,
+            Entity,
             &Transform,
             &Interaction,
             &mut BackgroundColor,
@@ -170,7 +170,7 @@ fn interaction(
         (Changed<Interaction>, With<InitTransitionDone>),
     >,
 ) {
-    for (mut animator, transform, interaction, mut color, button_label) in &mut interaction_query {
+    for (entity, transform, interaction, mut color, button_label) in &mut interaction_query {
         match *interaction {
             Interaction::Pressed => {
                 *color = CLICK_COLOR.into();
@@ -192,7 +192,7 @@ fn interaction(
             }
             Interaction::Hovered => {
                 *color = HOVER_COLOR.into();
-                animator.set_tweenable(Tween::new(
+                commands.entity(entity).tween(Tween::new(
                     EaseFunction::QuadraticIn,
                     Duration::from_millis(200),
                     TransformScaleLens {
@@ -205,7 +205,7 @@ fn interaction(
                 *color = NORMAL_COLOR.into();
                 let start_scale = transform.scale;
 
-                animator.set_tweenable(Tween::new(
+                commands.entity(entity).tween(Tween::new(
                     EaseFunction::QuadraticIn,
                     Duration::from_millis(200),
                     TransformScaleLens {
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 5753ccf..79a88e9 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -146,11 +146,9 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 custom_size: Some(Vec2::new(size, size)),
                 ..default()
             },
-            ..default()
-        },
-        RedSprite,
-        Animator::new(seq),
-    ));
+            RedSprite,
+        ))
+        .tween(seq);
 
     // First move from left to right, then rotate around self 180 degrees while
     // scaling size at the same time.
@@ -193,22 +191,21 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 custom_size: Some(Vec2::new(size * 3., size)),
                 ..default()
             },
-            ..Default::default()
-        },
-        BlueSprite,
-        Animator::new(seq2),
-    ));
+            BlueSprite,
+        ))
+        .tween(seq2);
 }
 
 fn update_text(
+    animator: Res<TweenAnimator>,
     mut query_text_red: Query<&mut Text, (With<RedProgress>, Without<BlueProgress>)>,
     mut query_text_blue: Query<&mut Text, (With<BlueProgress>, Without<RedProgress>)>,
-    query_anim_red: Query<&Animator<Transform>, With<RedSprite>>,
-    query_anim_blue: Query<&Animator<Transform>, With<BlueSprite>>,
+    query_anim_red: Query<Entity, With<RedSprite>>,
+    query_anim_blue: Query<Entity, With<BlueSprite>>,
     mut query_event: EventReader<TweenCompleted>,
 ) {
     let anim_red = query_anim_red.single();
-    let progress_red = anim_red.tweenable().progress();
+    let progress_red = animator.get(anim_red).tweenable().progress();
 
     let anim_blue = query_anim_blue.single();
     let progress_blue = anim_blue.tweenable().progress();
diff --git a/examples/sprite_color.rs b/examples/sprite_color.rs
index 6c74782..647ecdc 100644
--- a/examples/sprite_color.rs
+++ b/examples/sprite_color.rs
@@ -84,7 +84,7 @@ fn setup(mut commands: Commands) {
                 },
                 ..default()
             },
-            Animator::new(tween),
+            TweenAnimator::new(tween),
         ));
 
         y -= size * spacing;
diff --git a/examples/text_color.rs b/examples/text_color.rs
index 10c11a2..be194e5 100644
--- a/examples/text_color.rs
+++ b/examples/text_color.rs
@@ -108,7 +108,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 ),
                 ..default()
             },
-            Animator::new(tween),
+            TweenAnimator::new(tween),
         ));
 
         y += delta_y;
diff --git a/examples/transform_rotation.rs b/examples/transform_rotation.rs
index 54757bc..da0f13b 100644
--- a/examples/transform_rotation.rs
+++ b/examples/transform_rotation.rs
@@ -106,7 +106,7 @@ fn setup(mut commands: Commands) {
                         },
                         ..default()
                     },
-                    Animator::new(tween),
+                    TweenAnimator::new(tween),
                 ));
             });
 
@@ -118,7 +118,10 @@ fn setup(mut commands: Commands) {
     }
 }
 
-fn update_animation_speed(options: Res<Options>, mut animators: Query<&mut Animator<Transform>>) {
+fn update_animation_speed(
+    options: Res<Options>,
+    mut animators: Query<&mut TweenAnimator<Transform>>,
+) {
     if !options.is_changed() {
         return;
     }
diff --git a/examples/transform_translation.rs b/examples/transform_translation.rs
index 7cce2a2..b6ca207 100644
--- a/examples/transform_translation.rs
+++ b/examples/transform_translation.rs
@@ -99,14 +99,17 @@ fn setup(mut commands: Commands) {
                 },
                 ..default()
             },
-            Animator::new(tween),
+            TweenAnimator::new(tween),
         ));
 
         x += size * spacing;
     }
 }
 
-fn update_animation_speed(options: Res<Options>, mut animators: Query<&mut Animator<Transform>>) {
+fn update_animation_speed(
+    options: Res<Options>,
+    mut animators: Query<&mut TweenAnimator<Transform>>,
+) {
     if !options.is_changed() {
         return;
     }
diff --git a/examples/ui_position.rs b/examples/ui_position.rs
index c8b5699..70de678 100644
--- a/examples/ui_position.rs
+++ b/examples/ui_position.rs
@@ -119,14 +119,14 @@ fn setup(mut commands: Commands) {
                 background_color: BackgroundColor(RED.into()),
                 ..default()
             },
-            Animator::new(tween),
+            TweenAnimator::new(tween),
         ));
 
         x += offset_x;
     }
 }
 
-fn update_animation_speed(options: Res<Options>, mut animators: Query<&mut Animator<Style>>) {
+fn update_animation_speed(options: Res<Options>, mut animators: Query<&mut TweenAnimator<Style>>) {
     if !options.is_changed() {
         return;
     }
diff --git a/src/lib.rs b/src/lib.rs
index 37eaf8b..f4b15c6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -206,19 +206,23 @@
 
 use std::time::Duration;
 
-use bevy::prelude::*;
+use bevy::{
+    ecs::system::{EntityCommand, EntityCommands},
+    prelude::*,
+};
 use interpolation::Ease as IEase;
 pub use interpolation::{EaseFunction, Lerp};
+use slotmap::new_key_type;
 
 pub use lens::Lens;
-#[cfg(feature = "bevy_asset")]
-pub use plugin::asset_animator_system;
-pub use plugin::{component_animator_system, AnimationSystem, TweeningPlugin};
+pub use plugin::{AnimationSystem, TweeningPlugin};
+use slotmap::SlotMap;
 #[cfg(feature = "bevy_asset")]
 pub use tweenable::AssetTarget;
+use tweenable::Tweenable;
 pub use tweenable::{
     BoxedTweenable, ComponentTarget, Delay, Sequence, Targetable, TotalDuration, Tracks, Tween,
-    TweenCompleted, TweenState, Tweenable,
+    TweenCompleted, TweenState, UntypedTweenable,
 };
 
 pub mod lens;
@@ -440,81 +444,150 @@ impl std::ops::Not for TweeningDirection {
     }
 }
 
-macro_rules! animator_impl {
-    () => {
-        /// Set the initial playback state of the animator.
-        #[must_use]
-        pub fn with_state(mut self, state: AnimatorState) -> Self {
-            self.state = state;
-            self
-        }
-
-        /// Set the initial speed of the animator. See [`Animator::set_speed`] for
-        /// details.
-        #[must_use]
-        pub fn with_speed(mut self, speed: f32) -> Self {
-            self.speed = speed;
-            self
-        }
+// macro_rules! animator_impl {
+//     () => {
+//         /// Set the initial playback state of the animator.
+//         #[must_use]
+//         pub fn with_state(mut self, state: AnimatorState) -> Self {
+//             self.state = state;
+//             self
+//         }
+
+//         /// Set the initial speed of the animator. See
+// [`Animator::set_speed`] for         /// details.
+//         #[must_use]
+//         pub fn with_speed(mut self, speed: f32) -> Self {
+//             self.speed = speed;
+//             self
+//         }
+
+//         /// Set the animation speed. Defaults to 1.
+//         ///
+//         /// A speed of 2 means the animation will run twice as fast while a
+// speed of 0.1         /// will result in a 10x slowed animation.
+//         pub fn set_speed(&mut self, speed: f32) {
+//             self.speed = speed;
+//         }
+
+//         /// Get the animation speed.
+//         ///
+//         /// See [`set_speed()`] for a definition of what the animation speed
+// is.         ///
+//         /// [`set_speed()`]: Animator::speed
+//         pub fn speed(&self) -> f32 {
+//             self.speed
+//         }
+
+//         /// Set the top-level tweenable item this animator controls.
+//         pub fn set_tweenable(&mut self, tween: impl Tweenable<T> + 'static) {
+//             self.tweenable = Box::new(tween);
+//         }
+
+//         /// Get the top-level tweenable this animator is currently
+// controlling.         #[must_use]
+//         pub fn tweenable(&self) -> &dyn Tweenable<T> {
+//             self.tweenable.as_ref()
+//         }
+
+//         /// Get the top-level mutable tweenable this animator is currently
+// controlling.         #[must_use]
+//         pub fn tweenable_mut(&mut self) -> &mut dyn Tweenable<T> {
+//             self.tweenable.as_mut()
+//         }
+
+//         /// Stop animation playback and rewind the animation.
+//         ///
+//         /// This changes the animator state to [`AnimatorState::Paused`] and
+// rewind its         /// tweenable.
+//         pub fn stop(&mut self) {
+//             self.state = AnimatorState::Paused;
+//             self.tweenable_mut().rewind();
+//         }
+//     };
+// }
+
+new_key_type! {
+    /// Tween ID.
+    pub struct TweenId;
+}
 
-        /// Set the animation speed. Defaults to 1.
-        ///
-        /// A speed of 2 means the animation will run twice as fast while a speed of 0.1
-        /// will result in a 10x slowed animation.
-        pub fn set_speed(&mut self, speed: f32) {
-            self.speed = speed;
-        }
+/// Extensions for [`EntityCommands`] to queue tween-based animations.
+pub trait EntityCommandsTweeningExtensions<'a> {
+    /// Queue the given [`Tweenable`].
+    fn tween<T: Component>(&mut self, tweenable: impl Tweenable<T> + 'static) -> &mut Self;
 
-        /// Get the animation speed.
-        ///
-        /// See [`set_speed()`] for a definition of what the animation speed is.
-        ///
-        /// [`set_speed()`]: Animator::speed
-        pub fn speed(&self) -> f32 {
-            self.speed
-        }
+    /// Queue a new tween animation to move the current entity.
+    ///
+    /// The entity must have a [`Transform`] component. The tween animation will
+    /// be initialized with the current [`Transform::translation`] as its
+    /// starting point, and the given endpoint and duration.
+    ///
+    /// Note that the starting point position is saved when the command is
+    /// applied, generally after the current system when [`apply_deferred()`]
+    /// runs. So any change to [`Transform::translation`] between this call and
+    /// [`apply_deferred()`] will be taken into account.
+    fn move_to(&mut self, end: Vec3, duration: Duration) -> &mut Self;
+}
 
-        /// Set the top-level tweenable item this animator controls.
-        pub fn set_tweenable(&mut self, tween: impl Tweenable<T> + 'static) {
-            self.tweenable = Box::new(tween);
-        }
+/// Build an [`EntityCommand`] which queues the new tweenable into the
+/// [`Animator`].
+fn make_tween_command<C: Component>(tweenable: impl Tweenable<C> + 'static) -> impl EntityCommand {
+    move |target: Entity, world: &mut World| {
+        let (target, action) = TweenAnimator::make(target, tweenable);
+        world.resource_mut::<TweenAnimator>().queue(target, action);
+    }
+}
 
-        /// Get the top-level tweenable this animator is currently controlling.
-        #[must_use]
-        pub fn tweenable(&self) -> &dyn Tweenable<T> {
-            self.tweenable.as_ref()
-        }
+fn make_transform_from_command(end: Vec3, duration: Duration) -> impl EntityCommand {
+    move |target: Entity, world: &mut World| {
+        let start = world.entity(target).get::<Transform>().unwrap().translation;
+        let tween = Tween::new(
+            EaseMethod::Linear,
+            duration,
+            lens::TransformPositionLens { start, end },
+        );
+        let (target, action) = TweenAnimator::make(target, tween);
+        world.resource_mut::<TweenAnimator>().queue(target, action);
+    }
+}
 
-        /// Get the top-level mutable tweenable this animator is currently controlling.
-        #[must_use]
-        pub fn tweenable_mut(&mut self) -> &mut dyn Tweenable<T> {
-            self.tweenable.as_mut()
-        }
+impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
+    fn tween<T: Component>(
+        &mut self,
+        tweenable: impl Tweenable<T> + 'static,
+    ) -> &mut EntityCommands<'a> {
+        self.add(make_tween_command(tweenable))
+    }
 
-        /// Stop animation playback and rewind the animation.
-        ///
-        /// This changes the animator state to [`AnimatorState::Paused`] and rewind its
-        /// tweenable.
-        pub fn stop(&mut self) {
-            self.state = AnimatorState::Paused;
-            self.tweenable_mut().rewind();
-        }
-    };
+    fn move_to(&mut self, end: Vec3, duration: Duration) -> &mut EntityCommands<'a> {
+        self.add(make_transform_from_command(end, duration))
+    }
 }
 
-/// Component to control the animation of another component.
-///
-/// The animated component is the component located on the same entity as the
-/// [`Animator<T>`] itself.
-#[derive(Component)]
-pub struct Animator<T: Component> {
-    /// Control if this animation is played or not.
+type TypeErasedAnimAction = dyn FnMut(&mut World, Entity, Duration, Mut<Events<TweenCompleted>>) -> TweenState
+    + Send
+    + Sync
+    + 'static;
+
+/// Animator for tween-based animations.
+#[derive(Resource)]
+pub struct TweenAnimator {
+    /// Control if animations are played or not.
     pub state: AnimatorState,
-    tweenable: BoxedTweenable<T>,
-    speed: f32,
+    /// Queue of animations currently playing.
+    anims: SlotMap<TweenId, (Entity, Box<TypeErasedAnimAction>)>,
 }
 
-impl<T: Component + std::fmt::Debug> std::fmt::Debug for Animator<T> {
+impl Default for TweenAnimator {
+    fn default() -> Self {
+        Self {
+            state: AnimatorState::default(),
+            anims: Default::default(),
+        }
+    }
+}
+
+impl std::fmt::Debug for TweenAnimator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Animator")
             .field("state", &self.state)
@@ -522,55 +595,164 @@ impl<T: Component + std::fmt::Debug> std::fmt::Debug for Animator<T> {
     }
 }
 
-impl<T: Component> Animator<T> {
-    /// Create a new animator component from a single tweenable.
-    #[must_use]
-    pub fn new(tween: impl Tweenable<T> + 'static) -> Self {
-        Self {
-            state: default(),
-            tweenable: Box::new(tween),
-            speed: 1.,
-        }
+impl TweenAnimator {
+    /// Add a new component animation to the animator queue.
+    ///
+    /// In general you don't need to call this directly. Instead, use the
+    /// extensions provided by [`EntityCommandsTweening`] to directly create and
+    /// queue tweenable animations on a given [`EntityCommands`], like this:
+    ///
+    /// ```
+    /// # use bevy::prelude::*
+    /// # use bevy_tweening::{lens::*, *};
+    /// # use std::time::Duration;
+    /// # let mut world = World::default();
+    /// # let entity = Entity::default();
+    /// let tween = Tween::new(
+    ///     EaseFunction::QuadraticInOut,
+    ///     Duration::from_secs(1),
+    ///     TransformPositionLens {
+    ///         start: Vec3::ZERO,
+    ///         end: Vec3::new(3.5, 0., 0.),
+    /// };
+    /// world.entity(entity).tween(tween);
+    /// ```
+    #[inline]
+    pub fn add<T: Component>(
+        &mut self,
+        target: Entity,
+        tweenable: impl Tweenable<T> + 'static,
+    ) -> TweenId {
+        self.anims.insert(Self::make(target, tweenable))
     }
 
-    animator_impl!();
-}
+    /// Make a type-erased tweenable animation entry for subsequent queueing
+    /// with [`queue()`].
+    ///
+    /// [`queue()`]: Animator::queue
+    pub(crate) fn make<T: Component>(
+        target: Entity,
+        mut tweenable: impl Tweenable<T> + 'static,
+    ) -> (Entity, Box<TypeErasedAnimAction>) {
+        // Build the type-erased action which will be invoked to mutate the component.
+        let action = move |world: &mut World,
+                           entity: Entity,
+                           delta_time: Duration,
+                           events: Mut<Events<TweenCompleted>>|
+              -> TweenState {
+
+            TODO: can move that call outside, and pass an EntityMut<> instead, which
+            allows via World::get_many_entities_mut to parallelize animating different Entity
+            let mut ent_ref = world.entity_mut(entity);
+
+            TODO: it feels silly to have 1 closure per tweenable which essentially cast to
+            the component then call the Tweenable<T> trait. Can we have 1 closure per component
+            type rather? That would require the closure taking a type-erased Tweenable<T> which
+            can still tick()...
+
+            let comp = ent_ref.get_mut::<T>().unwrap();
+
+            let mut target = ComponentTarget::new(comp);
+
+            // Animate
+            tweenable.tick(delta_time, &mut target, entity, events)
+        };
+
+        (target, Box::new(action))
+    }
 
-/// Component to control the animation of an asset.
-///
-/// The animated asset is the asset referenced by a [`Handle<T>`] component
-/// located on the same entity as the [`AssetAnimator<T>`] itself.
-#[cfg(feature = "bevy_asset")]
-#[derive(Component)]
-pub struct AssetAnimator<T: Asset> {
-    /// Control if this animation is played or not.
-    pub state: AnimatorState,
-    tweenable: BoxedTweenable<T>,
-    speed: f32,
-}
+    /// Queue a prepared tweenable animation.
+    ///
+    /// See [`make()`] to prepare the animation closure.
+    ///
+    /// [`make()`]: Animator::make
+    #[inline]
+    pub(crate) fn queue(&mut self, target: Entity, action: Box<TypeErasedAnimAction>) {
+        self.anims.insert((target, action));
+    }
 
-#[cfg(feature = "bevy_asset")]
-impl<T: Asset + std::fmt::Debug> std::fmt::Debug for AssetAnimator<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("AssetAnimator")
-            .field("state", &self.state)
-            .finish()
+    /// Get a tweenable from its ID.
+    ///
+    /// This fails and returns `None` if the tweenable has completed and was
+    /// removed from the animator's internal queue.
+    pub fn get(&self, id: TweenId) -> Option<&dyn UntypedTweenable> {
+        self.anims.get(id).map(|(_, tweenable)| tweenable)
     }
-}
 
-#[cfg(feature = "bevy_asset")]
-impl<T: Asset> AssetAnimator<T> {
-    /// Create a new asset animator component from a single tweenable.
-    #[must_use]
-    pub fn new(tween: impl Tweenable<T> + 'static) -> Self {
-        Self {
-            state: default(),
-            tweenable: Box::new(tween),
-            speed: 1.,
-        }
+    /// Play all queued animations.
+    ///
+    /// Loop over the internal queue of tweenable animations, apply them to
+    /// their respective target [`Entity`], and prune all the completed
+    /// ones (the ones returning [`TweenState::Completed`]). In the later case,
+    /// send [`TweenCompleted`] events if enabled on the tweenable.
+    pub fn play(
+        &mut self,
+        world: &mut World,
+        delta_time: Duration,
+        mut events: Mut<Events<TweenCompleted>>,
+    ) {
+        self.anims.retain(|_id, (entity, action)| {
+            let state = action(world, *entity, delta_time, events.reborrow());
+            state == TweenState::Active
+        });
     }
+}
 
-    animator_impl!();
+// /// Component to control the animation of an asset.
+// ///
+// /// The animated asset is the asset referenced by a [`Handle<T>`] component
+// /// located on the same entity as the [`AssetAnimator<T>`] itself.
+// #[cfg(feature = "bevy_asset")]
+// #[derive(Component)]
+// pub struct AssetAnimator<T: Asset> {
+//     /// Control if this animation is played or not.
+//     pub state: AnimatorState,
+//     tweenable: BoxedTweenable<T>,
+//     speed: f32,
+// }
+
+// #[cfg(feature = "bevy_asset")]
+// impl<T: Asset + std::fmt::Debug> std::fmt::Debug for AssetAnimator<T> {
+//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+//         f.debug_struct("AssetAnimator")
+//             .field("state", &self.state)
+//             .finish()
+//     }
+// }
+
+// #[cfg(feature = "bevy_asset")]
+// impl<T: Asset> AssetAnimator<T> {
+//     /// Create a new asset animator component from a single tweenable.
+//     #[must_use]
+//     pub fn new(tween: impl Tweenable<T> + 'static) -> Self {
+//         Self {
+//             state: default(),
+//             tweenable: Box::new(tween),
+//             speed: 1.,
+//         }
+//     }
+
+//     //animator_impl!();
+// }
+
+/// Trait to interpolate between two values.
+/// Needed for color.
+#[allow(dead_code)]
+#[cfg(any(feature = "bevy_sprite", feature = "bevy_ui", feature = "bevy_text"))]
+trait ColorLerper {
+    fn lerp(&self, target: &Self, ratio: f32) -> Self;
+}
+
+#[allow(dead_code)]
+#[cfg(any(feature = "bevy_sprite", feature = "bevy_ui", feature = "bevy_text"))]
+impl ColorLerper for Color {
+    fn lerp(&self, target: &Color, ratio: f32) -> Color {
+        let r = self.r().lerp(target.r(), ratio);
+        let g = self.g().lerp(target.g(), ratio);
+        let b = self.b().lerp(target.b(), ratio);
+        let a = self.a().lerp(target.a(), ratio);
+        Color::rgba(r, g, b, a)
+    }
 }
 
 #[cfg(test)]
@@ -718,117 +900,117 @@ mod tests {
         assert_eq!(1., ease.sample(0.));
     }
 
-    #[test]
-    fn animator_new() {
-        let tween = Tween::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-        let animator = Animator::<DummyComponent>::new(tween);
-        assert_eq!(animator.state, AnimatorState::default());
-        assert_eq!(animator.tweenable().progress(), 0.);
-    }
-
-    #[test]
-    fn animator_with_state() {
-        for state in [AnimatorState::Playing, AnimatorState::Paused] {
-            let tween = Tween::<DummyComponent>::new(
-                EaseFunction::QuadraticInOut,
-                Duration::from_secs(1),
-                DummyLens { start: 0., end: 1. },
-            );
-            let animator = Animator::new(tween).with_state(state);
-            assert_eq!(animator.state, state);
-
-            // impl Debug
-            let debug_string = format!("{:?}", animator);
-            assert_eq!(
-                debug_string,
-                format!("Animator {{ state: {:?} }}", animator.state)
-            );
-        }
-    }
-
-    #[test]
-    fn animator_controls() {
-        let tween = Tween::<DummyComponent>::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-        let mut animator = Animator::new(tween);
-        assert_eq!(animator.state, AnimatorState::Playing);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.stop();
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.tweenable_mut().set_progress(0.5);
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.5);
-
-        animator.tweenable_mut().rewind();
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.tweenable_mut().set_progress(0.5);
-        animator.state = AnimatorState::Playing;
-        assert_eq!(animator.state, AnimatorState::Playing);
-        assert_approx_eq!(animator.tweenable().progress(), 0.5);
-
-        animator.tweenable_mut().rewind();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.stop();
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-    }
-
-    #[test]
-    fn animator_speed() {
-        let tween = Tween::<DummyComponent>::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-
-        let mut animator = Animator::new(tween);
-        assert_approx_eq!(animator.speed(), 1.); // default speed
-
-        animator.set_speed(2.4);
-        assert_approx_eq!(animator.speed(), 2.4);
-
-        let tween = Tween::<DummyComponent>::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-
-        let animator = Animator::new(tween).with_speed(3.5);
-        assert_approx_eq!(animator.speed(), 3.5);
-    }
-
-    #[test]
-    fn animator_set_tweenable() {
-        let tween = Tween::<DummyComponent>::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-        let mut animator = Animator::new(tween);
-
-        let tween2 = Tween::<DummyComponent>::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(2),
-            DummyLens { start: 0., end: 1. },
-        );
-        animator.set_tweenable(tween2);
-
-        assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
-    }
+    // #[test]
+    // fn animator_new() {
+    //     let tween = Tween::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     let animator = Animator::<DummyComponent>::new(tween);
+    //     assert_eq!(animator.state, AnimatorState::default());
+    //     assert_eq!(animator.tweenable().progress(), 0.);
+    // }
+
+    // #[test]
+    // fn animator_with_state() {
+    //     for state in [AnimatorState::Playing, AnimatorState::Paused] {
+    //         let tween = Tween::<DummyComponent>::new(
+    //             EaseFunction::QuadraticInOut,
+    //             Duration::from_secs(1),
+    //             DummyLens { start: 0., end: 1. },
+    //         );
+    //         let animator = Animator::new(tween).with_state(state);
+    //         assert_eq!(animator.state, state);
+
+    //         // impl Debug
+    //         let debug_string = format!("{:?}", animator);
+    //         assert_eq!(
+    //             debug_string,
+    //             format!("Animator {{ state: {:?} }}", animator.state)
+    //         );
+    //     }
+    // }
+
+    // #[test]
+    // fn animator_controls() {
+    //     let tween = Tween::<DummyComponent>::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     let mut animator = Animator::new(tween);
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+
+    //     animator.stop();
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+
+    //     animator.tweenable_mut().set_progress(0.5);
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.5);
+
+    //     animator.tweenable_mut().rewind();
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+
+    //     animator.tweenable_mut().set_progress(0.5);
+    //     animator.state = AnimatorState::Playing;
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.5);
+
+    //     animator.tweenable_mut().rewind();
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+
+    //     animator.stop();
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+    // }
+
+    // #[test]
+    // fn animator_speed() {
+    //     let tween = Tween::<DummyComponent>::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+
+    //     let mut animator = Animator::new(tween);
+    //     assert_approx_eq!(animator.speed(), 1.); // default speed
+
+    //     animator.set_speed(2.4);
+    //     assert_approx_eq!(animator.speed(), 2.4);
+
+    //     let tween = Tween::<DummyComponent>::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+
+    //     let animator = Animator::new(tween).with_speed(3.5);
+    //     assert_approx_eq!(animator.speed(), 3.5);
+    // }
+
+    // #[test]
+    // fn animator_set_tweenable() {
+    //     let tween = Tween::<DummyComponent>::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     let mut animator = Animator::new(tween);
+
+    //     let tween2 = Tween::<DummyComponent>::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(2),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     animator.set_tweenable(tween2);
+
+    //     assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
+    // }
 
     #[cfg(feature = "bevy_asset")]
     #[test]
diff --git a/src/plugin.rs b/src/plugin.rs
index e03e0a7..b4a6555 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,8 +1,6 @@
 use bevy::prelude::*;
 
-#[cfg(feature = "bevy_asset")]
-use crate::{tweenable::AssetTarget, AssetAnimator};
-use crate::{tweenable::ComponentTarget, Animator, AnimatorState, TweenCompleted};
+use crate::{TweenAnimator, TweenCompleted};
 
 /// Plugin to add systems related to tweening of common components and assets.
 ///
@@ -37,39 +35,12 @@ pub struct TweeningPlugin;
 
 impl Plugin for TweeningPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<TweenCompleted>().add_systems(
-            Update,
-            component_animator_system::<Transform>.in_set(AnimationSystem::AnimationUpdate),
-        );
-
-        #[cfg(feature = "bevy_ui")]
-        app.add_systems(
-            Update,
-            component_animator_system::<Style>.in_set(AnimationSystem::AnimationUpdate),
-        );
-        #[cfg(feature = "bevy_ui")]
-        app.add_systems(
-            Update,
-            component_animator_system::<BackgroundColor>.in_set(AnimationSystem::AnimationUpdate),
-        );
-
-        #[cfg(feature = "bevy_sprite")]
-        app.add_systems(
-            Update,
-            component_animator_system::<Sprite>.in_set(AnimationSystem::AnimationUpdate),
-        );
-
-        #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
-        app.add_systems(
-            Update,
-            asset_animator_system::<ColorMaterial>.in_set(AnimationSystem::AnimationUpdate),
-        );
-
-        #[cfg(feature = "bevy_text")]
-        app.add_systems(
-            Update,
-            component_animator_system::<Text>.in_set(AnimationSystem::AnimationUpdate),
-        );
+        app.init_resource::<TweenAnimator>()
+            .add_event::<TweenCompleted>()
+            .add_systems(
+                Update,
+                animator_system.in_set(AnimationSystem::AnimationUpdate),
+            );
     }
 }
 
@@ -84,60 +55,13 @@ pub enum AnimationSystem {
 ///
 /// This system extracts all components of type `T` with an [`Animator<T>`]
 /// attached to the same entity, and tick the animator to animate the component.
-pub fn component_animator_system<T: Component>(
-    time: Res<Time>,
-    mut query: Query<(Entity, &mut T, &mut Animator<T>)>,
-    events: ResMut<Events<TweenCompleted>>,
-    mut commands: Commands,
-) {
-    let mut events: Mut<Events<TweenCompleted>> = events.into();
-    for (entity, target, mut animator) in query.iter_mut() {
-        if animator.state != AnimatorState::Paused {
-            let speed = animator.speed();
-            let mut target = ComponentTarget::new(target);
-            animator.tweenable_mut().tick(
-                time.delta().mul_f32(speed),
-                &mut target,
-                entity,
-                &mut events,
-                &mut commands,
-            );
-        }
-    }
-}
-
-/// Animator system for assets.
-///
-/// This system ticks all [`AssetAnimator<T>`] components to animate their
-/// associated asset.
-///
-/// This requires the `bevy_asset` feature (enabled by default).
-#[cfg(feature = "bevy_asset")]
-pub fn asset_animator_system<T: Asset>(
-    time: Res<Time>,
-    mut assets: ResMut<Assets<T>>,
-    mut query: Query<(Entity, &Handle<T>, &mut AssetAnimator<T>)>,
-    events: ResMut<Events<TweenCompleted>>,
-    mut commands: Commands,
-) {
-    let mut events: Mut<Events<TweenCompleted>> = events.into();
-    let mut target = AssetTarget::new(assets.reborrow());
-    for (entity, handle, mut animator) in query.iter_mut() {
-        if animator.state != AnimatorState::Paused {
-            target.handle = handle.clone();
-            if !target.is_valid() {
-                continue;
-            }
-            let speed = animator.speed();
-            animator.tweenable_mut().tick(
-                time.delta().mul_f32(speed),
-                &mut target,
-                entity,
-                &mut events,
-                &mut commands,
-            );
-        }
-    }
+pub fn animator_system(world: &mut World) {
+    let delta_time = world.resource::<Time>().delta();
+    world.resource_scope(|world, events: Mut<Events<TweenCompleted>>| {
+        world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
+            animator.play(world, delta_time, events);
+        });
+    });
 }
 
 #[cfg(test)]
@@ -164,12 +88,16 @@ mod tests {
     impl<T: Component + Default> TestEnv<T> {
         /// Create a new test environment containing a single entity with a
         /// [`Transform`], and add the given animator on that same entity.
-        pub fn new(animator: Animator<T>) -> Self {
+        pub fn new(tweenable: impl Tweenable<T> + 'static) -> Self {
             let mut world = World::new();
-            world.init_resource::<Events<TweenCompleted>>();
             world.init_resource::<Time>();
+            world.init_resource::<Events<TweenCompleted>>();
+            world.init_resource::<TweenAnimator>();
 
-            let entity = world.spawn((T::default(), animator)).id();
+            let entity = world.spawn(T::default()).id();
+            world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
+                animator.add(entity, tweenable);
+            });
 
             Self {
                 world,
@@ -207,8 +135,8 @@ mod tests {
         }
 
         /// Get the animator for the component.
-        pub fn animator(&self) -> &Animator<T> {
-            self.world.entity(self.entity).get::<Animator<T>>().unwrap()
+        pub fn animator(&self) -> &TweenAnimator {
+            self.world.resource::<TweenAnimator>()
         }
 
         /// Get the component.
@@ -235,7 +163,7 @@ mod tests {
         )
         .with_completed_event(0);
 
-        let mut env = TestEnv::new(Animator::new(tween));
+        let mut env = TestEnv::new(tween);
 
         // After being inserted, components are always considered changed
         let transform = env.component_mut();
@@ -243,14 +171,14 @@ mod tests {
 
         // fn nit() {}
         // let mut system = IntoSystem::into_system(nit);
-        let mut system = IntoSystem::into_system(component_animator_system::<Transform>);
+        let mut system = IntoSystem::into_system(plugin::animator_system);
         system.initialize(env.world_mut());
 
         env.tick(Duration::ZERO, &mut system);
 
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 0);
+        // assert_eq!(animator.tweenable().times_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
@@ -260,7 +188,7 @@ mod tests {
         assert_eq!(env.event_count(), 0);
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 0);
+        // assert_eq!(animator.tweenable().times_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.5), 1e-5));
@@ -270,7 +198,7 @@ mod tests {
         assert_eq!(env.event_count(), 1);
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 1);
+        // assert_eq!(animator.tweenable().times_completed(), 1);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
@@ -280,7 +208,7 @@ mod tests {
         assert_eq!(env.event_count(), 0);
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 1);
+        // assert_eq!(animator.tweenable().times_completed(), 1);
         let transform = env.component_mut();
         assert!(!transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
@@ -317,13 +245,13 @@ mod tests {
         )
         .with_completed_event(0);
 
-        let mut env = TestEnv::new(Animator::new(tween));
+        let mut env = TestEnv::new(tween);
 
         // After being inserted, components are always considered changed
         let component = env.component_mut();
         assert!(component.is_changed());
 
-        let mut system = IntoSystem::into_system(component_animator_system::<DummyComponent>);
+        let mut system = IntoSystem::into_system(plugin::animator_system);
         system.initialize(env.world_mut());
 
         assert!(!defer.load(Ordering::SeqCst));
@@ -333,7 +261,7 @@ mod tests {
 
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 0);
+        // assert_eq!(animator.tweenable().times_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!((component.value - 0.).abs() <= 1e-5);
@@ -343,7 +271,7 @@ mod tests {
 
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 0);
+        // assert_eq!(animator.tweenable().times_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!((component.value - 0.).abs() <= 1e-5);
@@ -353,7 +281,7 @@ mod tests {
 
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 0);
+        // assert_eq!(animator.tweenable().times_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!((component.value - 0.).abs() <= 1e-5);
@@ -368,7 +296,7 @@ mod tests {
 
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 0);
+        // assert_eq!(animator.tweenable().times_completed(), 0);
         let component = env.component_mut();
         assert!(component.is_changed());
         assert!((component.value - 0.2).abs() <= 1e-5);
@@ -381,7 +309,7 @@ mod tests {
 
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
-        assert_eq!(animator.tweenable().times_completed(), 0);
+        // assert_eq!(animator.tweenable().times_completed(), 0);
         let component = env.component_mut();
         assert!(component.is_changed());
         assert!((component.value - 0.7).abs() <= 1e-5);
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 8443773..c4ea7f5 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -291,7 +291,7 @@ impl<'a, T: Asset> Targetable<T> for AssetTarget<'a, T> {
 }
 
 /// An animatable entity, either a single [`Tween`] or a collection of them.
-pub trait Tweenable<T>: Send + Sync {
+pub trait UntypedTweenable: Send + Sync {
     /// Get the duration of a single iteration of the animation.
     ///
     /// Note that for [`RepeatStrategy::MirroredRepeat`], this is the duration
@@ -333,31 +333,6 @@ pub trait Tweenable<T>: Send + Sync {
     /// [`duration()`]: Tweenable::duration
     fn elapsed(&self) -> Duration;
 
-    /// Tick the animation, advancing it by the given delta time and mutating
-    /// the given target component or asset.
-    ///
-    /// This returns [`TweenState::Active`] if the tweenable didn't reach its
-    /// final state yet (progress < `1.0`), or [`TweenState::Completed`] if
-    /// the tweenable completed this tick. Only non-looping tweenables return
-    /// a completed state, since looping ones continue forever.
-    ///
-    /// Calling this method with a duration of [`Duration::ZERO`] is valid, and
-    /// updates the target to the current state of the tweenable without
-    /// actually modifying the tweenable state. This is useful after certain
-    /// operations like [`rewind()`] or [`set_progress()`] whose effect is
-    /// otherwise only visible on target on next frame.
-    ///
-    /// [`rewind()`]: Tweenable::rewind
-    /// [`set_progress()`]: Tweenable::set_progress
-    fn tick(
-        &mut self,
-        delta: Duration,
-        target: &mut dyn Targetable<T>,
-        entity: Entity,
-        events: &mut Mut<Events<TweenCompleted>>,
-        commands: &mut Commands,
-    ) -> TweenState;
-
     /// Rewind the animation to its starting state.
     ///
     /// Note that the starting state depends on the current direction. For
@@ -408,6 +383,32 @@ pub trait Tweenable<T>: Send + Sync {
     }
 }
 
+pub trait Tweenable<T>: UntypedTweenable {
+    /// Tick the animation, advancing it by the given delta time and mutating
+    /// the given target component or asset.
+    ///
+    /// This returns [`TweenState::Active`] if the tweenable didn't reach its
+    /// final state yet (progress < `1.0`), or [`TweenState::Completed`] if
+    /// the tweenable completed this tick. Only non-looping tweenables return
+    /// a completed state, since looping ones continue forever.
+    ///
+    /// Calling this method with a duration of [`Duration::ZERO`] is valid, and
+    /// updates the target to the current state of the tweenable without
+    /// actually modifying the tweenable state. This is useful after certain
+    /// operations like [`rewind()`] or [`set_progress()`] whose effect is
+    /// otherwise only visible on target on next frame.
+    ///
+    /// [`rewind()`]: Tweenable::rewind
+    /// [`set_progress()`]: Tweenable::set_progress
+    fn tick(
+        &mut self,
+        delta: Duration,
+        target: &mut dyn Targetable<T>,
+        entity: Entity,
+        events: Mut<Events<TweenCompleted>>,
+    ) -> TweenState;
+}
+
 macro_rules! impl_boxed {
     ($tweenable:ty) => {
         impl<T: 'static> From<$tweenable> for BoxedTweenable<T> {
@@ -738,7 +739,7 @@ impl<T> Tween<T> {
     }
 }
 
-impl<T> Tweenable<T> for Tween<T> {
+impl<T> UntypedTweenable for Tween<T> {
     fn duration(&self) -> Duration {
         self.clock.duration
     }
@@ -755,13 +756,32 @@ impl<T> Tweenable<T> for Tween<T> {
         self.clock.elapsed()
     }
 
+    fn rewind(&mut self) {
+        if self.clock.strategy == RepeatStrategy::MirroredRepeat {
+            // In mirrored mode, direction alternates each loop. To reset to the original
+            // direction on Tween creation, we count the number of completions, ignoring the
+            // last one if the Tween is currently in TweenState::Completed because that one
+            // freezes all parameters.
+            let mut times_completed = self.clock.times_completed();
+            if self.clock.state() == TweenState::Completed {
+                debug_assert!(times_completed > 0);
+                times_completed -= 1;
+            }
+            if times_completed & 1 != 0 {
+                self.direction = !self.direction;
+            }
+        }
+        self.clock.reset();
+    }
+}
+
+impl<T> Tweenable<T> for Tween<T> {
     fn tick(
         &mut self,
         delta: Duration,
         target: &mut dyn Targetable<T>,
         entity: Entity,
-        events: &mut Mut<Events<TweenCompleted>>,
-        commands: &mut Commands,
+        mut events: Mut<Events<TweenCompleted>>,
     ) -> TweenState {
         if self.clock.state() == TweenState::Completed {
             return TweenState::Completed;
@@ -806,24 +826,6 @@ impl<T> Tweenable<T> for Tween<T> {
 
         state
     }
-
-    fn rewind(&mut self) {
-        if self.clock.strategy == RepeatStrategy::MirroredRepeat {
-            // In mirrored mode, direction alternates each loop. To reset to the original
-            // direction on Tween creation, we count the number of completions, ignoring the
-            // last one if the Tween is currently in TweenState::Completed because that one
-            // freezes all parameters.
-            let mut times_completed = self.clock.times_completed();
-            if self.clock.state() == TweenState::Completed {
-                debug_assert!(times_completed > 0);
-                times_completed -= 1;
-            }
-            if times_completed & 1 != 0 {
-                self.direction = !self.direction;
-            }
-        }
-        self.clock.reset();
-    }
 }
 
 /// A sequence of tweens played back in order one after the other.
@@ -900,7 +902,7 @@ impl<T> Sequence<T> {
     }
 }
 
-impl<T> Tweenable<T> for Sequence<T> {
+impl<T> UntypedTweenable for Sequence<T> {
     fn duration(&self) -> Duration {
         self.duration
     }
@@ -937,19 +939,29 @@ impl<T> Tweenable<T> for Sequence<T> {
         self.elapsed
     }
 
+    fn rewind(&mut self) {
+        self.elapsed = Duration::ZERO;
+        self.index = 0;
+        for tween in &mut self.tweens {
+            // or only first?
+            tween.rewind();
+        }
+    }
+}
+
+impl<T> Tweenable<T> for Sequence<T> {
     fn tick(
         &mut self,
         mut delta: Duration,
         target: &mut dyn Targetable<T>,
         entity: Entity,
-        events: &mut Mut<Events<TweenCompleted>>,
-        commands: &mut Commands,
+        mut events: Mut<Events<TweenCompleted>>,
     ) -> TweenState {
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
         while self.index < self.tweens.len() {
             let tween = &mut self.tweens[self.index];
             let tween_remaining = tween.duration() - tween.elapsed();
-            if let TweenState::Active = tween.tick(delta, target, entity, events, commands) {
+            if let TweenState::Active = tween.tick(delta, target, entity, events.reborrow()) {
                 return TweenState::Active;
             }
 
@@ -960,15 +972,6 @@ impl<T> Tweenable<T> for Sequence<T> {
 
         TweenState::Completed
     }
-
-    fn rewind(&mut self) {
-        self.elapsed = Duration::ZERO;
-        self.index = 0;
-        for tween in &mut self.tweens {
-            // or only first?
-            tween.rewind();
-        }
-    }
 }
 
 /// A collection of [`Tweenable`] executing in parallel.
@@ -1024,13 +1027,12 @@ impl<T> Tweenable<T> for Tracks<T> {
         delta: Duration,
         target: &mut dyn Targetable<T>,
         entity: Entity,
-        events: &mut Mut<Events<TweenCompleted>>,
-        commands: &mut Commands,
+        mut events: Mut<Events<TweenCompleted>>,
     ) -> TweenState {
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
         let mut any_active = false;
         for tweenable in &mut self.tracks {
-            let state = tweenable.tick(delta, target, entity, events, commands);
+            let state = tweenable.tick(delta, target, entity, events.reborrow());
             any_active = any_active || (state == TweenState::Active);
         }
         if any_active {
@@ -1309,8 +1311,7 @@ impl<T> Tweenable<T> for Delay<T> {
         delta: Duration,
         _target: &mut dyn Targetable<T>,
         entity: Entity,
-        events: &mut Mut<Events<TweenCompleted>>,
-        commands: &mut Commands,
+        mut events: Mut<Events<TweenCompleted>>,
     ) -> TweenState {
         let was_completed = self.is_completed();
 
@@ -1388,22 +1389,11 @@ mod tests {
         world: &mut World,
         entity: Entity,
     ) -> TweenState {
-        world.resource_scope(
-            |world: &mut World, mut events: Mut<Events<TweenCompleted>>| {
-                let transform = world.get_mut::<T>(entity).unwrap();
-                let mut target = ComponentTarget::new(transform);
-                // let command_queue = &mut CommandQueue::default(); // todo
-                // let mut asd = Commands::new(command_queue, world);
-                tween.tick(
-                    duration,
-                    &mut target,
-                    entity,
-                    &mut events,
-                    // passing dummy values to let things compile
-                    &mut Commands::new(&mut CommandQueue::default(), &World::default()),
-                )
-            },
-        )
+        world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
+            let transform = world.get_mut::<T>(entity).unwrap();
+            let mut target = ComponentTarget::new(transform);
+            tween.tick(duration, &mut target, entity, events)
+        })
     }
 
     #[derive(Debug, Default, Clone, Copy, Component)]

From 9439e56989b1ca53ada85b272d2c725651c0bcfa Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 1 May 2024 22:47:23 +0100
Subject: [PATCH 02/66] Move action into `Tween` itself

---
 examples/menu.rs |   4 +-
 src/lib.rs       | 127 ++++----
 src/tweenable.rs | 794 +++++++++++++++--------------------------------
 3 files changed, 318 insertions(+), 607 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index d33b72a..30e95b6 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -85,8 +85,8 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         start: Vec3::splat(0.01),
                         end: Vec3::ONE,
                     },
-                )
-                .with_completed_event(INIT_TRANSITION_DONE);
+                );
+                //.with_completed_event(INIT_TRANSITION_DONE);
 
                 let mut ec = container.spawn((
                     ButtonBundle {
diff --git a/src/lib.rs b/src/lib.rs
index f4b15c6..4084189 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -219,7 +219,6 @@ pub use plugin::{AnimationSystem, TweeningPlugin};
 use slotmap::SlotMap;
 #[cfg(feature = "bevy_asset")]
 pub use tweenable::AssetTarget;
-use tweenable::Tweenable;
 pub use tweenable::{
     BoxedTweenable, ComponentTarget, Delay, Sequence, Targetable, TotalDuration, Tracks, Tween,
     TweenCompleted, TweenState, UntypedTweenable,
@@ -514,7 +513,9 @@ new_key_type! {
 /// Extensions for [`EntityCommands`] to queue tween-based animations.
 pub trait EntityCommandsTweeningExtensions<'a> {
     /// Queue the given [`Tweenable`].
-    fn tween<T: Component>(&mut self, tweenable: impl Tweenable<T> + 'static) -> &mut Self;
+    fn tween<T>(&mut self, tweenable: T) -> &mut Self
+    where
+        T: UntypedTweenable + 'static;
 
     /// Queue a new tween animation to move the current entity.
     ///
@@ -531,31 +532,31 @@ pub trait EntityCommandsTweeningExtensions<'a> {
 
 /// Build an [`EntityCommand`] which queues the new tweenable into the
 /// [`Animator`].
-fn make_tween_command<C: Component>(tweenable: impl Tweenable<C> + 'static) -> impl EntityCommand {
+fn make_tween_command<T>(tweenable: T) -> impl EntityCommand
+where
+    T: UntypedTweenable + 'static,
+{
     move |target: Entity, world: &mut World| {
-        let (target, action) = TweenAnimator::make(target, tweenable);
-        world.resource_mut::<TweenAnimator>().queue(target, action);
+        world
+            .resource_mut::<TweenAnimator>()
+            .queue(target, tweenable);
     }
 }
 
 fn make_transform_from_command(end: Vec3, duration: Duration) -> impl EntityCommand {
     move |target: Entity, world: &mut World| {
         let start = world.entity(target).get::<Transform>().unwrap().translation;
-        let tween = Tween::new(
-            EaseMethod::Linear,
-            duration,
-            lens::TransformPositionLens { start, end },
-        );
-        let (target, action) = TweenAnimator::make(target, tween);
-        world.resource_mut::<TweenAnimator>().queue(target, action);
+        let lens = lens::TransformPositionLens { start, end };
+        let tween = Tween::new(EaseMethod::Linear, duration, lens);
+        world.resource_mut::<TweenAnimator>().queue(target, tween);
     }
 }
 
 impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
-    fn tween<T: Component>(
-        &mut self,
-        tweenable: impl Tweenable<T> + 'static,
-    ) -> &mut EntityCommands<'a> {
+    fn tween<T>(&mut self, tweenable: T) -> &mut EntityCommands<'a>
+    where
+        T: UntypedTweenable + 'static,
+    {
         self.add(make_tween_command(tweenable))
     }
 
@@ -564,18 +565,13 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     }
 }
 
-type TypeErasedAnimAction = dyn FnMut(&mut World, Entity, Duration, Mut<Events<TweenCompleted>>) -> TweenState
-    + Send
-    + Sync
-    + 'static;
-
 /// Animator for tween-based animations.
 #[derive(Resource)]
 pub struct TweenAnimator {
     /// Control if animations are played or not.
     pub state: AnimatorState,
     /// Queue of animations currently playing.
-    anims: SlotMap<TweenId, (Entity, Box<TypeErasedAnimAction>)>,
+    anims: SlotMap<TweenId, (Entity, BoxedTweenable)>,
 }
 
 impl Default for TweenAnimator {
@@ -618,47 +614,11 @@ impl TweenAnimator {
     /// world.entity(entity).tween(tween);
     /// ```
     #[inline]
-    pub fn add<T: Component>(
-        &mut self,
-        target: Entity,
-        tweenable: impl Tweenable<T> + 'static,
-    ) -> TweenId {
-        self.anims.insert(Self::make(target, tweenable))
-    }
-
-    /// Make a type-erased tweenable animation entry for subsequent queueing
-    /// with [`queue()`].
-    ///
-    /// [`queue()`]: Animator::queue
-    pub(crate) fn make<T: Component>(
-        target: Entity,
-        mut tweenable: impl Tweenable<T> + 'static,
-    ) -> (Entity, Box<TypeErasedAnimAction>) {
-        // Build the type-erased action which will be invoked to mutate the component.
-        let action = move |world: &mut World,
-                           entity: Entity,
-                           delta_time: Duration,
-                           events: Mut<Events<TweenCompleted>>|
-              -> TweenState {
-
-            TODO: can move that call outside, and pass an EntityMut<> instead, which
-            allows via World::get_many_entities_mut to parallelize animating different Entity
-            let mut ent_ref = world.entity_mut(entity);
-
-            TODO: it feels silly to have 1 closure per tweenable which essentially cast to
-            the component then call the Tweenable<T> trait. Can we have 1 closure per component
-            type rather? That would require the closure taking a type-erased Tweenable<T> which
-            can still tick()...
-
-            let comp = ent_ref.get_mut::<T>().unwrap();
-
-            let mut target = ComponentTarget::new(comp);
-
-            // Animate
-            tweenable.tick(delta_time, &mut target, entity, events)
-        };
-
-        (target, Box::new(action))
+    pub fn add<C: Component, T>(&mut self, target: Entity, tweenable: T) -> TweenId
+    where
+        T: UntypedTweenable + 'static,
+    {
+        self.anims.insert((target, Box::new(tweenable)))
     }
 
     /// Queue a prepared tweenable animation.
@@ -667,8 +627,8 @@ impl TweenAnimator {
     ///
     /// [`make()`]: Animator::make
     #[inline]
-    pub(crate) fn queue(&mut self, target: Entity, action: Box<TypeErasedAnimAction>) {
-        self.anims.insert((target, action));
+    pub(crate) fn queue(&mut self, target: Entity, tweenable: impl UntypedTweenable + 'static) {
+        self.anims.insert((target, Box::new(tweenable)));
     }
 
     /// Get a tweenable from its ID.
@@ -676,7 +636,7 @@ impl TweenAnimator {
     /// This fails and returns `None` if the tweenable has completed and was
     /// removed from the animator's internal queue.
     pub fn get(&self, id: TweenId) -> Option<&dyn UntypedTweenable> {
-        self.anims.get(id).map(|(_, tweenable)| tweenable)
+        self.anims.get(id).map(|(_, tweenable)| &**tweenable)
     }
 
     /// Play all queued animations.
@@ -691,8 +651,39 @@ impl TweenAnimator {
         delta_time: Duration,
         mut events: Mut<Events<TweenCompleted>>,
     ) {
-        self.anims.retain(|_id, (entity, action)| {
-            let state = action(world, *entity, delta_time, events.reborrow());
+        // // Tick all active tweenables
+        // for (_, (target, action, tweenable)) in &mut self.anims {
+        //     // Note: we use get_many_entities_mut() to get an EntityMut instead of an EntityWorldMut,
+        //     // as the former is enough. This can be optimized by parallelizing tweening of separate entities.
+        //     let ent_mut = &mut world.get_many_entities_mut([*target]).unwrap()[0];
+        //     let state = action(
+        //         ent_mut.reborrow(),
+        //         *target,
+        //         tweenable.as_mut(),
+        //         delta_time,
+        //         events.reborrow(),
+        //     );
+        // }
+
+        self.anims.retain(|_id, (entity, tweenable)| {
+            // Note: we use get_many_entities_mut() to get an EntityMut instead of an EntityWorldMut,
+            // as the former is enough. This can be optimized by parallelizing tweening of separate entities.
+            let ent_mut = &mut world.get_many_entities_mut([*entity]).unwrap()[0];
+
+            // Apply the animation tweenable
+            let (_ratio, state) = tweenable.tick(delta_time, *entity);
+
+            // Apply the state
+            tweenable.apply_state(ent_mut.reborrow());
+
+            // Raise completed event
+            if state == TweenState::Completed {
+                events.send(TweenCompleted {
+                    entity: *entity,
+                    user_data: 0, // TODO
+                });
+            }
+
             state == TweenState::Active
         });
     }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index c4ea7f5..265816b 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -51,7 +51,7 @@ use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweeningDirection};
 ///     }
 /// }
 /// ```
-pub type BoxedTweenable<T> = Box<dyn Tweenable<T> + 'static>;
+pub type BoxedTweenable = Box<dyn UntypedTweenable + 'static>;
 
 /// Playback state of a [`Tweenable`].
 ///
@@ -333,6 +333,12 @@ pub trait UntypedTweenable: Send + Sync {
     /// [`duration()`]: Tweenable::duration
     fn elapsed(&self) -> Duration;
 
+    /// Tick the tweenable.
+    fn tick(&mut self, delta: Duration, entity: Entity) -> (f32, TweenState);
+
+    /// Apply the current state.
+    fn apply_state(&mut self, ent_mut: EntityMut);
+
     /// Rewind the animation to its starting state.
     ///
     /// Note that the starting state depends on the current direction. For
@@ -411,7 +417,7 @@ pub trait Tweenable<T>: UntypedTweenable {
 
 macro_rules! impl_boxed {
     ($tweenable:ty) => {
-        impl<T: 'static> From<$tweenable> for BoxedTweenable<T> {
+        impl From<$tweenable> for BoxedTweenable {
             fn from(t: $tweenable) -> Self {
                 Box::new(t)
             }
@@ -419,28 +425,23 @@ macro_rules! impl_boxed {
     };
 }
 
-impl_boxed!(Tween<T>);
-impl_boxed!(Sequence<T>);
-impl_boxed!(Tracks<T>);
-impl_boxed!(Delay<T>);
+impl_boxed!(Tween);
+impl_boxed!(Sequence);
+impl_boxed!(Tracks);
+impl_boxed!(Delay);
 
-/// Type of a callback invoked when a [`Tween`] or [`Delay`] has completed.
-///
-/// See [`Tween::set_completed()`] or [`Delay::set_completed()`] for usage.
-pub type CompletedCallback<T> = dyn Fn(Entity, &T) + Send + Sync + 'static;
+type TweenAction = dyn FnMut(EntityMut, f32) + Send + Sync + 'static;
 
 /// Single tweening animation instance.
-pub struct Tween<T> {
+pub struct Tween {
     ease_function: EaseMethod,
     clock: AnimClock,
     direction: TweeningDirection,
-    lens: Box<dyn Lens<T> + Send + Sync + 'static>,
-    on_completed: Option<Box<CompletedCallback<Tween<T>>>>,
-    event_data: Option<u64>,
+    action: Box<TweenAction>,
     system_id: Option<SystemId>,
 }
 
-impl<T: 'static> Tween<T> {
+impl Tween {
     /// Chain another [`Tweenable`] after this tween, making a [`Sequence`] with
     /// the two.
     ///
@@ -468,12 +469,12 @@ impl<T: 'static> Tween<T> {
     /// let seq = tween1.then(tween2);
     /// ```
     #[must_use]
-    pub fn then(self, tween: impl Tweenable<T> + 'static) -> Sequence<T> {
+    pub fn then(self, tween: impl UntypedTweenable + 'static) -> Sequence {
         Sequence::with_capacity(2).then(self).then(tween)
     }
 }
 
-impl<T> Tween<T> {
+impl Tween {
     /// Create a new tween animation.
     ///
     /// # Example
@@ -491,137 +492,29 @@ impl<T> Tween<T> {
     /// );
     /// ```
     #[must_use]
-    pub fn new<L>(ease_function: impl Into<EaseMethod>, duration: Duration, lens: L) -> Self
+    pub fn new<C: Component, L>(
+        ease_function: impl Into<EaseMethod>,
+        duration: Duration,
+        mut lens: L,
+    ) -> Self
     where
-        L: Lens<T> + Send + Sync + 'static,
+        L: Lens<C> + Send + Sync + 'static,
     {
+        let action = move |mut ent_mut: EntityMut, ratio: f32| {
+            let Some(comp) = ent_mut.get_mut::<C>() else {
+                return; // TODO
+            };
+            let mut target = ComponentTarget::new(comp);
+            lens.lerp(&mut target, ratio);
+        };
         Self {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
             direction: TweeningDirection::Forward,
-            lens: Box::new(lens),
-            on_completed: None,
-            event_data: None,
-            system_id: None,
+            action: Box::new(action),
         }
     }
 
-    /// 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
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::Vec3};
-    /// # use std::time::Duration;
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .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);
-    ///   }
-    /// }
-    /// ```
-    ///
-    /// [`with_completed()`]: Tween::with_completed
-    #[must_use]
-    pub fn with_completed_event(mut self, user_data: u64) -> Self {
-        self.event_data = Some(user_data);
-        self
-    }
-
-    /// 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
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::Vec3};
-    /// # use std::time::Duration;
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed(|entity, _tween| {
-    ///   println!("Tween completed on entity {:?}", entity);
-    /// });
-    /// ```
-    ///
-    /// [`with_completed_event()`]: Tween::with_completed_event
-    pub fn with_completed<C>(mut self, callback: C) -> Self
-    where
-        C: Fn(Entity, &Self) + Send + Sync + 'static,
-    {
-        self.on_completed = Some(Box::new(callback));
-        self
-    }
-
-    /// Enable running a one-shot system upon completion.
-    ///
-    /// If enabled, the tween will run a system via a provided [`SystemId`] when
-    /// the animation completes. This is similar to the
-    /// [`with_completed()`], but uses a system registered by
-    /// [`register_system()`] instead of a callback.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::Vec3, ecs::world::World, ecs::system::Query, ecs::entity::Entity, ecs::query::With};
-    /// # use std::time::Duration;
-    /// let mut world = World::new();
-    /// let test_system_system_id = world.register_system(test_system);
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed_system(test_system_system_id);
-    ///
-    /// fn test_system(query: Query<Entity>) {
-    ///    for entity in query.iter() {
-    ///       println!("Found an entity!");
-    ///    }
-    /// }
-    /// ```
-    /// [`with_completed()`]: Tween::with_completed
-    /// [`register_system()`]: bevy::ecs::world::World::register_system
-    #[must_use]
-    pub fn with_completed_system(mut self, system_id: SystemId) -> Self {
-        self.system_id = Some(system_id);
-        self
-    }
-
     /// Set the playback direction of the tween.
     ///
     /// The playback direction influences the mapping of the progress ratio (in
@@ -669,77 +562,9 @@ impl<T> Tween<T> {
         self.clock.strategy = strategy;
         self
     }
-
-    /// 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 set_completed<C>(&mut self, callback: C)
-    where
-        C: Fn(Entity, &Self) + Send + Sync + 'static,
-    {
-        self.on_completed = Some(Box::new(callback));
-    }
-
-    /// Clear the callback invoked when the animation completes.
-    ///
-    /// See also [`set_completed()`].
-    ///
-    /// [`set_completed()`]: Tween::set_completed
-    pub fn clear_completed(&mut self) {
-        self.on_completed = None;
-    }
-
-    /// 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.
-    ///
-    /// [`set_completed()`]: Tween::set_completed
-    /// [`with_completed_event()`]: Tween::with_completed_event
-    pub fn set_completed_event(&mut self, user_data: u64) {
-        self.event_data = Some(user_data);
-    }
-
-    /// Clear the event sent when the animation completes.
-    ///
-    /// See also [`set_completed_event()`].
-    ///
-    /// [`set_completed_event()`]: Tween::set_completed_event
-    pub fn clear_completed_event(&mut self) {
-        self.event_data = None;
-    }
-
-    /// Enable running a one-shot system upon completion.
-    ///
-    /// If enabled, the tween will run a system via a provided [`SystemId`] when
-    /// the animation completes. This is similar to the
-    /// [`with_completed()`], but uses a system registered by
-    /// [`register_system()`] instead of a callback.
-    ///
-    /// [`with_completed()`]: Tween::with_completed
-    /// [`register_system()`]: bevy::ecs::world::World::register_system
-    pub fn set_completed_system(&mut self, user_data: SystemId) {
-        self.system_id = Some(user_data);
-    }
-
-    /// Clear the system that will execute when the animation completes.
-    ///
-    /// See also [`set_completed_system()`].
-    ///
-    /// [`set_completed_system()`]: Tween::set_completed_system
-    pub fn clear_completed_system(&mut self) {
-        self.system_id = None;
-    }
 }
 
-impl<T> UntypedTweenable for Tween<T> {
+impl UntypedTweenable for Tween {
     fn duration(&self) -> Duration {
         self.clock.duration
     }
@@ -756,35 +581,9 @@ impl<T> UntypedTweenable for Tween<T> {
         self.clock.elapsed()
     }
 
-    fn rewind(&mut self) {
-        if self.clock.strategy == RepeatStrategy::MirroredRepeat {
-            // In mirrored mode, direction alternates each loop. To reset to the original
-            // direction on Tween creation, we count the number of completions, ignoring the
-            // last one if the Tween is currently in TweenState::Completed because that one
-            // freezes all parameters.
-            let mut times_completed = self.clock.times_completed();
-            if self.clock.state() == TweenState::Completed {
-                debug_assert!(times_completed > 0);
-                times_completed -= 1;
-            }
-            if times_completed & 1 != 0 {
-                self.direction = !self.direction;
-            }
-        }
-        self.clock.reset();
-    }
-}
-
-impl<T> Tweenable<T> for Tween<T> {
-    fn tick(
-        &mut self,
-        delta: Duration,
-        target: &mut dyn Targetable<T>,
-        entity: Entity,
-        mut events: Mut<Events<TweenCompleted>>,
-    ) -> TweenState {
+    fn tick(&mut self, delta: Duration, _entity: Entity) -> (f32, TweenState) {
         if self.clock.state() == TweenState::Completed {
-            return TweenState::Completed;
+            return (1., TweenState::Completed);
         }
 
         // Tick the animation clock
@@ -806,48 +605,111 @@ impl<T> Tweenable<T> for Tween<T> {
             factor = 1. - factor;
         }
         let factor = self.ease_function.sample(factor);
-        self.lens.lerp(target, factor);
-
-        // If completed at least once this frame, notify the user
-        if times_completed > 0 {
-            if let Some(user_data) = &self.event_data {
-                events.send(TweenCompleted {
-                    entity,
-                    user_data: *user_data,
-                });
+
+        (factor, state)
+    }
+
+    fn apply_state(&mut self, ent_mut: EntityMut) {
+        let mut factor = self.progress();
+        if self.direction.is_backward() {
+            factor = 1. - factor;
+        }
+        let factor = self.ease_function.sample(factor);
+        (self.action)(ent_mut, factor);
+    }
+
+    fn rewind(&mut self) {
+        if self.clock.strategy == RepeatStrategy::MirroredRepeat {
+            // In mirrored mode, direction alternates each loop. To reset to the original
+            // direction on Tween creation, we count the number of completions, ignoring the
+            // last one if the Tween is currently in TweenState::Completed because that one
+            // freezes all parameters.
+            let mut times_completed = self.clock.times_completed();
+            if self.clock.state() == TweenState::Completed {
+                debug_assert!(times_completed > 0);
+                times_completed -= 1;
             }
-            if let Some(cb) = &self.on_completed {
-                cb(entity, self);
+            if times_completed & 1 != 0 {
+                self.direction = !self.direction;
             }
             if let Some(system_id) = &self.system_id {
                 commands.run_system(*system_id);
             }
         }
-
-        state
+        self.clock.reset();
     }
 }
 
+// impl<T> Tweenable<T> for Tween {
+//     fn tick(
+//         &mut self,
+//         delta: Duration,
+//         target: &mut dyn Targetable<T>,
+//         entity: Entity,
+//         mut events: Mut<Events<TweenCompleted>>,
+//     ) -> TweenState {
+//         if self.clock.state() == TweenState::Completed {
+//             return TweenState::Completed;
+//         }
+
+//         // Tick the animation clock
+//         let (state, times_completed) = self.clock.tick(delta);
+//         let (progress, times_completed_for_direction) = match state {
+//             TweenState::Active => (self.progress(), times_completed),
+//             TweenState::Completed => (1., times_completed.max(1) - 1), // ignore last
+//         };
+//         if self.clock.strategy == RepeatStrategy::MirroredRepeat
+//             && times_completed_for_direction & 1 != 0
+//         {
+//             self.direction = !self.direction;
+//         }
+
+//         // Apply the lens, even if the animation finished, to ensure the state is
+//         // consistent
+//         let mut factor = progress;
+//         if self.direction.is_backward() {
+//             factor = 1. - factor;
+//         }
+//         let factor = self.ease_function.sample(factor);
+//         self.lens.lerp(target, factor);
+
+//         // If completed at least once this frame, notify the user
+//         if times_completed > 0 {
+//             if let Some(user_data) = &self.event_data {
+//                 events.send(TweenCompleted {
+//                     entity,
+//                     user_data: *user_data,
+//                 });
+//             }
+//             if let Some(cb) = &self.on_completed {
+//                 cb(entity, self);
+//             }
+//         }
+
+//         state
+//     }
+// }
+
 /// A sequence of tweens played back in order one after the other.
-pub struct Sequence<T> {
-    tweens: Vec<BoxedTweenable<T>>,
+pub struct Sequence {
+    tweens: Vec<BoxedTweenable>,
     index: usize,
     duration: Duration,
     elapsed: Duration,
 }
 
-impl<T> Sequence<T> {
+impl Sequence {
     /// Create a new sequence of tweens.
     ///
     /// This method panics if the input collection is empty.
     #[must_use]
-    pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable<T>>>) -> Self {
+    pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable>>) -> Self {
         let tweens: Vec<_> = items.into_iter().map(Into::into).collect();
         assert!(!tweens.is_empty());
         let duration = tweens
             .iter()
             .map(AsRef::as_ref)
-            .map(Tweenable::duration)
+            .map(UntypedTweenable::duration)
             .sum();
         Self {
             tweens,
@@ -859,9 +721,9 @@ impl<T> Sequence<T> {
 
     /// Create a new sequence containing a single tween.
     #[must_use]
-    pub fn from_single(tween: impl Tweenable<T> + 'static) -> Self {
+    pub fn from_single(tween: impl UntypedTweenable + 'static) -> Self {
         let duration = tween.duration();
-        let boxed: BoxedTweenable<T> = Box::new(tween);
+        let boxed: BoxedTweenable = Box::new(tween);
         Self {
             tweens: vec![boxed],
             index: 0,
@@ -883,7 +745,7 @@ impl<T> Sequence<T> {
 
     /// Append a [`Tweenable`] to this sequence.
     #[must_use]
-    pub fn then(mut self, tween: impl Tweenable<T> + 'static) -> Self {
+    pub fn then(mut self, tween: impl UntypedTweenable + 'static) -> Self {
         self.duration += tween.duration();
         self.tweens.push(Box::new(tween));
         self
@@ -897,12 +759,12 @@ impl<T> Sequence<T> {
 
     /// Get the current active tween in the sequence.
     #[must_use]
-    pub fn current(&self) -> &dyn Tweenable<T> {
+    pub fn current(&self) -> &dyn UntypedTweenable {
         self.tweens[self.index()].as_ref()
     }
 }
 
-impl<T> UntypedTweenable for Sequence<T> {
+impl UntypedTweenable for Sequence {
     fn duration(&self) -> Duration {
         self.duration
     }
@@ -939,30 +801,13 @@ impl<T> UntypedTweenable for Sequence<T> {
         self.elapsed
     }
 
-    fn rewind(&mut self) {
-        self.elapsed = Duration::ZERO;
-        self.index = 0;
-        for tween in &mut self.tweens {
-            // or only first?
-            tween.rewind();
-        }
-    }
-}
-
-impl<T> Tweenable<T> for Sequence<T> {
-    fn tick(
-        &mut self,
-        mut delta: Duration,
-        target: &mut dyn Targetable<T>,
-        entity: Entity,
-        mut events: Mut<Events<TweenCompleted>>,
-    ) -> TweenState {
+    fn tick(&mut self, mut delta: Duration, entity: Entity) -> (f32, TweenState) {
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
         while self.index < self.tweens.len() {
             let tween = &mut self.tweens[self.index];
             let tween_remaining = tween.duration() - tween.elapsed();
-            if let TweenState::Active = tween.tick(delta, target, entity, events.reborrow()) {
-                return TweenState::Active;
+            if let (ratio, TweenState::Active) = tween.tick(delta, entity) {
+                return (ratio, TweenState::Active);
             }
 
             tween.rewind();
@@ -970,27 +815,73 @@ impl<T> Tweenable<T> for Sequence<T> {
             self.index += 1;
         }
 
-        TweenState::Completed
+        (1., TweenState::Completed)
+    }
+
+    fn apply_state(&mut self, ent_mut: EntityMut) {
+        let num = self.tweens.len();
+        if num == 0 {
+            return;
+        }
+        if self.index < num {
+            self.tweens[self.index].apply_state(ent_mut);
+        } else {
+            self.tweens[num - 1].apply_state(ent_mut);
+        }
+    }
+
+    fn rewind(&mut self) {
+        self.elapsed = Duration::ZERO;
+        self.index = 0;
+        for tween in &mut self.tweens {
+            // or only first?
+            tween.rewind();
+        }
     }
 }
 
+// impl<T> Tweenable<T> for Sequence {
+//     fn tick(
+//         &mut self,
+//         mut delta: Duration,
+//         target: &mut dyn Targetable<T>,
+//         entity: Entity,
+//         mut events: Mut<Events<TweenCompleted>>,
+//     ) -> TweenState {
+//         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
+//         while self.index < self.tweens.len() {
+//             let tween = &mut self.tweens[self.index];
+//             let tween_remaining = tween.duration() - tween.elapsed();
+//             if let TweenState::Active = tween.tick(delta, target, entity, events.reborrow()) {
+//                 return TweenState::Active;
+//             }
+
+//             tween.rewind();
+//             delta -= tween_remaining;
+//             self.index += 1;
+//         }
+
+//         TweenState::Completed
+//     }
+// }
+
 /// A collection of [`Tweenable`] executing in parallel.
-pub struct Tracks<T> {
-    tracks: Vec<BoxedTweenable<T>>,
+pub struct Tracks {
+    tracks: Vec<BoxedTweenable>,
     duration: Duration,
     elapsed: Duration,
 }
 
-impl<T> Tracks<T> {
+impl Tracks {
     /// Create a new [`Tracks`] from an iterator over a collection of
     /// [`Tweenable`].
     #[must_use]
-    pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable<T>>>) -> Self {
+    pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable>>) -> Self {
         let tracks: Vec<_> = items.into_iter().map(Into::into).collect();
         let duration = tracks
             .iter()
             .map(AsRef::as_ref)
-            .map(Tweenable::duration)
+            .map(UntypedTweenable::duration)
             .max()
             .unwrap();
         Self {
@@ -1001,7 +892,7 @@ impl<T> Tracks<T> {
     }
 }
 
-impl<T> Tweenable<T> for Tracks<T> {
+impl UntypedTweenable for Tracks {
     fn duration(&self) -> Duration {
         self.duration
     }
@@ -1022,23 +913,25 @@ impl<T> Tweenable<T> for Tracks<T> {
         self.elapsed
     }
 
-    fn tick(
-        &mut self,
-        delta: Duration,
-        target: &mut dyn Targetable<T>,
-        entity: Entity,
-        mut events: Mut<Events<TweenCompleted>>,
-    ) -> TweenState {
+    fn tick(&mut self, delta: Duration, entity: Entity) -> (f32, TweenState) {
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
         let mut any_active = false;
         for tweenable in &mut self.tracks {
-            let state = tweenable.tick(delta, target, entity, events.reborrow());
+            let (_, state) = tweenable.tick(delta, entity);
             any_active = any_active || (state == TweenState::Active);
         }
         if any_active {
-            TweenState::Active
+            // FIXME(nightly): Duration::div_duration_f32()
+            let ratio = self.elapsed.as_secs_f32() / self.duration.as_secs_f32();
+            (ratio, TweenState::Active) // TODO
         } else {
-            TweenState::Completed
+            (1., TweenState::Completed)
+        }
+    }
+
+    fn apply_state(&mut self, mut ent_mut: EntityMut) {
+        for tweenable in &mut self.tracks {
+            tweenable.apply_state(ent_mut.reborrow());
         }
     }
 
@@ -1050,29 +943,46 @@ impl<T> Tweenable<T> for Tracks<T> {
     }
 }
 
+// impl<T> Tweenable<T> for Tracks {
+//     fn tick(
+//         &mut self,
+//         delta: Duration,
+//         target: &mut dyn Targetable<T>,
+//         entity: Entity,
+//         mut events: Mut<Events<TweenCompleted>>,
+//     ) -> TweenState {
+//         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
+//         let mut any_active = false;
+//         for tweenable in &mut self.tracks {
+//             let state = tweenable.tick(delta, target, entity, events.reborrow());
+//             any_active = any_active || (state == TweenState::Active);
+//         }
+//         if any_active {
+//             TweenState::Active
+//         } else {
+//             TweenState::Completed
+//         }
+//     }
+// }
+
 /// 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.
-pub struct Delay<T> {
+pub struct Delay {
     timer: Timer,
-    on_completed: Option<Box<CompletedCallback<Delay<T>>>>,
-    event_data: Option<u64>,
-    system_id: Option<SystemId>,
 }
 
-impl<T: 'static> Delay<T> {
+impl Delay {
     /// Chain another [`Tweenable`] after this tween, making a [`Sequence`] with
     /// the two.
     #[must_use]
-    pub fn then(self, tween: impl Tweenable<T> + 'static) -> Sequence<T> {
+    pub fn then(self, tween: impl UntypedTweenable + 'static) -> Sequence {
         Sequence::with_capacity(2).then(self).then(tween)
     }
-}
 
-impl<T> Delay<T> {
     /// Create a new [`Delay`] with a given duration.
     ///
     /// # Panics
@@ -1083,122 +993,9 @@ impl<T> Delay<T> {
         assert!(!duration.is_zero());
         Self {
             timer: Timer::new(duration, TimerMode::Once),
-            on_completed: None,
-            event_data: None,
-            system_id: None,
         }
     }
 
-    /// 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
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::Vec3, transform::components::Transform};
-    /// # use std::time::Duration;
-    /// 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);
-    ///   }
-    /// }
-    /// ```
-    ///
-    /// [`set_completed()`]: Delay::set_completed
-    #[must_use]
-    pub fn with_completed_event(mut self, user_data: u64) -> Self {
-        self.event_data = Some(user_data);
-        self
-    }
-
-    /// 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
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::Vec3};
-    /// # use std::time::Duration;
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed(|entity, delay| {
-    ///   println!("Delay of {} seconds elapsed on entity {:?}",
-    ///     delay.duration().as_secs(), entity);
-    /// });
-    /// ```
-    ///
-    /// [`with_completed_event()`]: Delay::with_completed_event
-    pub fn with_completed<C>(mut self, callback: C) -> Self
-    where
-        C: Fn(Entity, &Self) + Send + Sync + 'static,
-    {
-        self.on_completed = Some(Box::new(callback));
-        self
-    }
-
-    /// Enable running a one-shot system upon completion.
-    ///
-    /// If enabled, the tween will run a system via a provided [`SystemId`] when
-    /// the animation completes. This is similar to the
-    /// [`with_completed()`], but uses a system registered by
-    /// [`register_system()`] instead.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::Vec3, ecs::world::World, ecs::system::Query, ecs::entity::Entity};
-    /// # use std::time::Duration;
-    /// let mut world = World::new();
-    /// let test_system_system_id = world.register_system(test_system);
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed_system(test_system_system_id);
-    ///
-    /// fn test_system(query: Query<Entity>) {
-    ///    for entity in query.iter() {
-    ///       println!("Found an Entity!");
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// [`with_completed()`]: Delay::with_completed
-    /// [`register_system()`]: bevy::ecs::world::World::register_system
-    #[must_use]
-    pub fn with_completed_system(mut self, system_id: SystemId) -> Self {
-        self.system_id = Some(system_id);
-        self
-    }
-
     /// Check if the delay completed.
     pub fn is_completed(&self) -> bool {
         self.timer.finished()
@@ -1212,80 +1009,9 @@ impl<T> Delay<T> {
             TweenState::Active
         }
     }
-
-    /// 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 set_completed<C>(&mut self, callback: C)
-    where
-        C: Fn(Entity, &Self) + Send + Sync + 'static,
-    {
-        self.on_completed = Some(Box::new(callback));
-    }
-
-    /// Clear the callback invoked when the animation completes.
-    ///
-    /// See also [`set_completed()`].
-    ///
-    /// [`set_completed()`]: Delay::set_completed
-    pub fn clear_completed(&mut self) {
-        self.on_completed = None;
-    }
-
-    /// 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.
-    ///
-    /// [`set_completed()`]: Delay::set_completed
-    /// [`with_completed_event()`]: Delay::with_completed_event
-    pub fn set_completed_event(&mut self, user_data: u64) {
-        self.event_data = Some(user_data);
-    }
-
-    /// Clear the event sent when the animation completes.
-    ///
-    /// See also [`set_completed_event()`].
-    ///
-    /// [`set_completed_event()`]: Delay::set_completed_event
-    pub fn clear_completed_event(&mut self) {
-        self.event_data = None;
-    }
-
-    /// Enable running a one-shot system upon completion.
-    ///
-    /// If enabled, the tween will run a system via a provided [`SystemId`] when
-    /// the animation completes. This is similar to the
-    /// [`with_completed()`], but uses a system registered by
-    /// [`register_system()`] instead of a callback.
-    ///
-    /// See [`with_completed_system()`] for details.
-    ///
-    /// [`with_completed()`]: Delay::with_completed
-    /// [`with_completed_system()`]: Delay::with_completed_system
-    /// [`register_system()`]: bevy::ecs::world::World::register_system
-    pub fn set_completed_system(&mut self, system_id: SystemId) {
-        self.system_id = Some(system_id);
-    }
-
-    /// Clear the system that will execute when the animation completes.
-    ///
-    /// See also [`set_completed_system()`].
-    ///
-    /// [`set_completed_system()`]: Delay::set_completed_system
-    pub fn clear_completed_system(&mut self) {
-        self.system_id = None;
-    }
 }
 
-impl<T> Tweenable<T> for Delay<T> {
+impl UntypedTweenable for Delay {
     fn duration(&self) -> Duration {
         self.timer.duration()
     }
@@ -1306,43 +1032,53 @@ impl<T> Tweenable<T> for Delay<T> {
         self.timer.elapsed()
     }
 
-    fn tick(
-        &mut self,
-        delta: Duration,
-        _target: &mut dyn Targetable<T>,
-        entity: Entity,
-        mut events: Mut<Events<TweenCompleted>>,
-    ) -> TweenState {
-        let was_completed = self.is_completed();
-
+    fn tick(&mut self, delta: Duration, _entity: Entity) -> (f32, TweenState) {
         self.timer.tick(delta);
 
+        let ratio = self.elapsed().as_secs_f32() / self.duration().as_secs_f32();
         let state = self.state();
 
-        // If completed this frame, notify the user
-        if (state == TweenState::Completed) && !was_completed {
-            if let Some(user_data) = &self.event_data {
-                events.send(TweenCompleted {
-                    entity,
-                    user_data: *user_data,
-                });
-            }
-            if let Some(cb) = &self.on_completed {
-                cb(entity, self);
-            }
-            if let Some(system_id) = &self.system_id {
-                commands.run_system(*system_id);
-            }
-        }
-
-        state
+        (ratio, state)
     }
 
+    fn apply_state(&mut self, _: EntityMut) {}
+
     fn rewind(&mut self) {
         self.timer.reset();
     }
 }
 
+// impl<T> Tweenable<T> for Delay {
+//     fn tick(
+//         &mut self,
+//         delta: Duration,
+//         _target: &mut dyn Targetable<T>,
+//         entity: Entity,
+//         mut events: Mut<Events<TweenCompleted>>,
+//     ) -> TweenState {
+//         let was_completed = self.is_completed();
+
+//         self.timer.tick(delta);
+
+//         let state = self.state();
+
+//         // If completed this frame, notify the user
+//         if (state == TweenState::Completed) && !was_completed {
+//             if let Some(user_data) = &self.event_data {
+//                 events.send(TweenCompleted {
+//                     entity,
+//                     user_data: *user_data,
+//                 });
+//             }
+//             if let Some(cb) = &self.on_completed {
+//                 cb(entity, self);
+//             }
+//         }
+
+//         state
+//     }
+// }
+
 #[cfg(test)]
 mod tests {
     use std::sync::{Arc, Mutex};
@@ -1359,10 +1095,9 @@ mod tests {
     }
 
     /// Utility to create a tween for testing.
-    fn make_test_tween() -> Tween<Transform> {
-        Tween::new(
-            EaseMethod::Linear,
-            Duration::from_secs(1),
+    fn make_test_tween() -> (Tween, impl Lens<Transform>) {
+        (
+            Tween::new(EaseMethod::Linear, Duration::from_secs(1)),
             TransformPositionLens {
                 start: Vec3::ZERO,
                 end: Vec3::ONE,
@@ -1463,29 +1198,14 @@ mod tests {
 
     #[test]
     fn into_repeat_count() {
-        let tween = Tween::new(
-            EaseMethod::Linear,
-            Duration::from_secs(1),
-            TransformPositionLens {
-                start: Vec3::ZERO,
-                end: Vec3::ONE,
-            },
-        )
-        .with_repeat_count(5);
+        let tween = Tween::new(EaseMethod::Linear, Duration::from_secs(1)).with_repeat_count(5);
         assert_eq!(
             tween.total_duration(),
             TotalDuration::Finite(Duration::from_secs(5))
         );
 
-        let tween = Tween::new(
-            EaseMethod::Linear,
-            Duration::from_secs(1),
-            TransformPositionLens {
-                start: Vec3::ZERO,
-                end: Vec3::ONE,
-            },
-        )
-        .with_repeat_count(Duration::from_secs(3));
+        let tween = Tween::new(EaseMethod::Linear, Duration::from_secs(1))
+            .with_repeat_count(Duration::from_secs(3));
         assert_eq!(
             tween.total_duration(),
             TotalDuration::Finite(Duration::from_secs(3))

From c3ced14d84694baf4534668fc9f082ea3f2a4236 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 1 May 2024 22:49:16 +0100
Subject: [PATCH 03/66] Re-rename (-Untyped)Tweenable trait

---
 examples/menu.rs |  2 +-
 src/lib.rs       | 14 ++++++-------
 src/tweenable.rs | 52 ++++++++++++------------------------------------
 3 files changed, 21 insertions(+), 47 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index 30e95b6..98b4dc2 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -109,7 +109,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                     label,
                 ));
 
-                let mut ec = if start_time_ms > 0 {
+                let ec = if start_time_ms > 0 {
                     let delay = Delay::new(Duration::from_millis(start_time_ms));
                     ec.tween(delay.then(tween_scale))
                 } else {
diff --git a/src/lib.rs b/src/lib.rs
index 4084189..269cf6e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -221,7 +221,7 @@ use slotmap::SlotMap;
 pub use tweenable::AssetTarget;
 pub use tweenable::{
     BoxedTweenable, ComponentTarget, Delay, Sequence, Targetable, TotalDuration, Tracks, Tween,
-    TweenCompleted, TweenState, UntypedTweenable,
+    TweenCompleted, TweenState, Tweenable,
 };
 
 pub mod lens;
@@ -515,7 +515,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// Queue the given [`Tweenable`].
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
     where
-        T: UntypedTweenable + 'static;
+        T: Tweenable + 'static;
 
     /// Queue a new tween animation to move the current entity.
     ///
@@ -534,7 +534,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
 /// [`Animator`].
 fn make_tween_command<T>(tweenable: T) -> impl EntityCommand
 where
-    T: UntypedTweenable + 'static,
+    T: Tweenable + 'static,
 {
     move |target: Entity, world: &mut World| {
         world
@@ -555,7 +555,7 @@ fn make_transform_from_command(end: Vec3, duration: Duration) -> impl EntityComm
 impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     fn tween<T>(&mut self, tweenable: T) -> &mut EntityCommands<'a>
     where
-        T: UntypedTweenable + 'static,
+        T: Tweenable + 'static,
     {
         self.add(make_tween_command(tweenable))
     }
@@ -616,7 +616,7 @@ impl TweenAnimator {
     #[inline]
     pub fn add<C: Component, T>(&mut self, target: Entity, tweenable: T) -> TweenId
     where
-        T: UntypedTweenable + 'static,
+        T: Tweenable + 'static,
     {
         self.anims.insert((target, Box::new(tweenable)))
     }
@@ -627,7 +627,7 @@ impl TweenAnimator {
     ///
     /// [`make()`]: Animator::make
     #[inline]
-    pub(crate) fn queue(&mut self, target: Entity, tweenable: impl UntypedTweenable + 'static) {
+    pub(crate) fn queue(&mut self, target: Entity, tweenable: impl Tweenable + 'static) {
         self.anims.insert((target, Box::new(tweenable)));
     }
 
@@ -635,7 +635,7 @@ impl TweenAnimator {
     ///
     /// This fails and returns `None` if the tweenable has completed and was
     /// removed from the animator's internal queue.
-    pub fn get(&self, id: TweenId) -> Option<&dyn UntypedTweenable> {
+    pub fn get(&self, id: TweenId) -> Option<&dyn Tweenable> {
         self.anims.get(id).map(|(_, tweenable)| &**tweenable)
     }
 
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 265816b..e6c9698 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -51,7 +51,7 @@ use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweeningDirection};
 ///     }
 /// }
 /// ```
-pub type BoxedTweenable = Box<dyn UntypedTweenable + 'static>;
+pub type BoxedTweenable = Box<dyn Tweenable + 'static>;
 
 /// Playback state of a [`Tweenable`].
 ///
@@ -291,7 +291,7 @@ impl<'a, T: Asset> Targetable<T> for AssetTarget<'a, T> {
 }
 
 /// An animatable entity, either a single [`Tween`] or a collection of them.
-pub trait UntypedTweenable: Send + Sync {
+pub trait Tweenable: Send + Sync {
     /// Get the duration of a single iteration of the animation.
     ///
     /// Note that for [`RepeatStrategy::MirroredRepeat`], this is the duration
@@ -389,32 +389,6 @@ pub trait UntypedTweenable: Send + Sync {
     }
 }
 
-pub trait Tweenable<T>: UntypedTweenable {
-    /// Tick the animation, advancing it by the given delta time and mutating
-    /// the given target component or asset.
-    ///
-    /// This returns [`TweenState::Active`] if the tweenable didn't reach its
-    /// final state yet (progress < `1.0`), or [`TweenState::Completed`] if
-    /// the tweenable completed this tick. Only non-looping tweenables return
-    /// a completed state, since looping ones continue forever.
-    ///
-    /// Calling this method with a duration of [`Duration::ZERO`] is valid, and
-    /// updates the target to the current state of the tweenable without
-    /// actually modifying the tweenable state. This is useful after certain
-    /// operations like [`rewind()`] or [`set_progress()`] whose effect is
-    /// otherwise only visible on target on next frame.
-    ///
-    /// [`rewind()`]: Tweenable::rewind
-    /// [`set_progress()`]: Tweenable::set_progress
-    fn tick(
-        &mut self,
-        delta: Duration,
-        target: &mut dyn Targetable<T>,
-        entity: Entity,
-        events: Mut<Events<TweenCompleted>>,
-    ) -> TweenState;
-}
-
 macro_rules! impl_boxed {
     ($tweenable:ty) => {
         impl From<$tweenable> for BoxedTweenable {
@@ -469,7 +443,7 @@ impl Tween {
     /// let seq = tween1.then(tween2);
     /// ```
     #[must_use]
-    pub fn then(self, tween: impl UntypedTweenable + 'static) -> Sequence {
+    pub fn then(self, tween: impl Tweenable + 'static) -> Sequence {
         Sequence::with_capacity(2).then(self).then(tween)
     }
 }
@@ -564,7 +538,7 @@ impl Tween {
     }
 }
 
-impl UntypedTweenable for Tween {
+impl Tweenable for Tween {
     fn duration(&self) -> Duration {
         self.clock.duration
     }
@@ -709,7 +683,7 @@ impl Sequence {
         let duration = tweens
             .iter()
             .map(AsRef::as_ref)
-            .map(UntypedTweenable::duration)
+            .map(Tweenable::duration)
             .sum();
         Self {
             tweens,
@@ -721,7 +695,7 @@ impl Sequence {
 
     /// Create a new sequence containing a single tween.
     #[must_use]
-    pub fn from_single(tween: impl UntypedTweenable + 'static) -> Self {
+    pub fn from_single(tween: impl Tweenable + 'static) -> Self {
         let duration = tween.duration();
         let boxed: BoxedTweenable = Box::new(tween);
         Self {
@@ -745,7 +719,7 @@ impl Sequence {
 
     /// Append a [`Tweenable`] to this sequence.
     #[must_use]
-    pub fn then(mut self, tween: impl UntypedTweenable + 'static) -> Self {
+    pub fn then(mut self, tween: impl Tweenable + 'static) -> Self {
         self.duration += tween.duration();
         self.tweens.push(Box::new(tween));
         self
@@ -759,12 +733,12 @@ impl Sequence {
 
     /// Get the current active tween in the sequence.
     #[must_use]
-    pub fn current(&self) -> &dyn UntypedTweenable {
+    pub fn current(&self) -> &dyn Tweenable {
         self.tweens[self.index()].as_ref()
     }
 }
 
-impl UntypedTweenable for Sequence {
+impl Tweenable for Sequence {
     fn duration(&self) -> Duration {
         self.duration
     }
@@ -881,7 +855,7 @@ impl Tracks {
         let duration = tracks
             .iter()
             .map(AsRef::as_ref)
-            .map(UntypedTweenable::duration)
+            .map(Tweenable::duration)
             .max()
             .unwrap();
         Self {
@@ -892,7 +866,7 @@ impl Tracks {
     }
 }
 
-impl UntypedTweenable for Tracks {
+impl Tweenable for Tracks {
     fn duration(&self) -> Duration {
         self.duration
     }
@@ -979,7 +953,7 @@ impl Delay {
     /// Chain another [`Tweenable`] after this tween, making a [`Sequence`] with
     /// the two.
     #[must_use]
-    pub fn then(self, tween: impl UntypedTweenable + 'static) -> Sequence {
+    pub fn then(self, tween: impl Tweenable + 'static) -> Sequence {
         Sequence::with_capacity(2).then(self).then(tween)
     }
 
@@ -1011,7 +985,7 @@ impl Delay {
     }
 }
 
-impl UntypedTweenable for Delay {
+impl Tweenable for Delay {
     fn duration(&self) -> Duration {
         self.timer.duration()
     }

From 946b17e692cedde76cb8b0a78f52faba21c46c25 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 4 May 2024 22:35:32 +0100
Subject: [PATCH 04/66] Add TweenAnim container

---
 examples/menu.rs     |   8 +-
 examples/sequence.rs |  69 ++++--
 src/lib.rs           | 381 ++++++++++++------------------
 src/plugin.rs        | 198 ++++++++--------
 src/tweenable.rs     | 550 ++++++++++++++++++++++---------------------
 5 files changed, 582 insertions(+), 624 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index 98b4dc2..f414e22 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -85,8 +85,8 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         start: Vec3::splat(0.01),
                         end: Vec3::ONE,
                     },
-                );
-                //.with_completed_event(INIT_TRANSITION_DONE);
+                )
+                .with_completed_event(true);
 
                 let mut ec = container.spawn((
                     ButtonBundle {
@@ -140,9 +140,7 @@ fn enable_interaction_after_initial_animation(
     mut reader: EventReader<TweenCompleted>,
 ) {
     for event in reader.read() {
-        if event.user_data == INIT_TRANSITION_DONE {
-            commands.entity(event.entity).insert(InitTransitionDone);
-        }
+        commands.entity(event.entity).insert(InitTransitionDone);
     }
 }
 
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 79a88e9..0475fb5 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -29,12 +29,16 @@ struct RedProgress;
 struct BlueProgress;
 
 #[derive(Component)]
-struct RedSprite;
+struct RedSprite(pub TweenId);
 
 #[derive(Component)]
-struct BlueSprite;
+struct BlueSprite(pub TweenId);
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut animator: ResMut<TweenAnimator>,
+) {
     commands.spawn(Camera2dBundle::default());
 
     let font = asset_server.load("fonts/FiraMono-Regular.ttf");
@@ -135,20 +139,25 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 },
             )
             // Get an event after each segment
-            .with_completed_event(index as u64),
+            ,//.with_completed_event(index as u64),
         ])
     }));
 
-    commands.spawn((
-        SpriteBundle {
+    // Because we want to monitor the progress of the animations, we need to fetch
+    // their TweenId. This requires inserting them manually in the TweenAnimator
+    // resource, instead of using the extensions of EntityCommands.
+    let entity = commands
+        .spawn(SpriteBundle {
             sprite: Sprite {
                 color: RED.into(),
                 custom_size: Some(Vec2::new(size, size)),
                 ..default()
             },
-            RedSprite,
-        ))
-        .tween(seq);
+            ..default()
+        })
+        .id();
+    let tween_id = animator.add(entity, seq);
+    commands.entity(entity).insert(RedSprite(tween_id));
 
     // First move from left to right, then rotate around self 180 degrees while
     // scaling size at the same time.
@@ -159,8 +168,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
             start: Vec3::new(-200., 100., 0.),
             end: Vec3::new(200., 100., 0.),
         },
-    )
-    .with_completed_event(99); // Get an event once move completed
+    ); //.with_completed_event(99); // Get an event once move completed
     let tween_rotate = Tween::new(
         EaseFunction::QuadraticInOut,
         Duration::from_secs(1),
@@ -182,33 +190,46 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     let tracks = Tracks::new([tween_rotate, tween_scale]);
     // Build a sequence from an heterogeneous list of tweenables by casting them
     // manually to a BoxedTweenable: first move, then { rotate + scale }.
-    let seq2 = Sequence::new([Box::new(tween_move) as BoxedTweenable<_>, tracks.into()]);
+    let seq2 = Sequence::new([Box::new(tween_move) as BoxedTweenable, tracks.into()]);
 
-    commands.spawn((
-        SpriteBundle {
+    // Because we want to monitor the progress of the animations, we need to fetch
+    // their TweenId. This requires inserting them manually in the TweenAnimator
+    // resource, instead of using the extensions of EntityCommands.
+    let entity = commands
+        .spawn((SpriteBundle {
             sprite: Sprite {
-                color: BLUE.into(),
+                color: Color::BLUE,
                 custom_size: Some(Vec2::new(size * 3., size)),
                 ..default()
             },
-            BlueSprite,
-        ))
-        .tween(seq2);
+            ..Default::default()
+        },))
+        .id();
+    let tween_id = animator.add(entity, seq2);
+    commands.entity(entity).insert(BlueSprite(tween_id));
 }
 
 fn update_text(
     animator: Res<TweenAnimator>,
     mut query_text_red: Query<&mut Text, (With<RedProgress>, Without<BlueProgress>)>,
     mut query_text_blue: Query<&mut Text, (With<BlueProgress>, Without<RedProgress>)>,
-    query_anim_red: Query<Entity, With<RedSprite>>,
-    query_anim_blue: Query<Entity, With<BlueSprite>>,
+    query_anim_red: Query<&RedSprite>,
+    query_anim_blue: Query<&BlueSprite>,
     mut query_event: EventReader<TweenCompleted>,
 ) {
     let anim_red = query_anim_red.single();
-    let progress_red = animator.get(anim_red).tweenable().progress();
+    let progress_red = if let Some(anim) = animator.get(anim_red.0) {
+        anim.tweenable.progress()
+    } else {
+        1.
+    };
 
     let anim_blue = query_anim_blue.single();
-    let progress_blue = anim_blue.tweenable().progress();
+    let progress_blue = if let Some(anim) = animator.get(anim_blue.0) {
+        anim.tweenable.progress()
+    } else {
+        1.
+    };
 
     let mut red_text = query_text_red.single_mut();
     red_text.sections[1].value = format!("{:5.1}%", progress_red * 100.);
@@ -218,8 +239,8 @@ fn update_text(
 
     for ev in query_event.read() {
         println!(
-            "Event: TweenCompleted entity={:?} user_data={}",
-            ev.entity, ev.user_data
+            "Event: TweenCompleted tween_id={:?} entity={:?}",
+            ev.id, ev.entity
         );
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 269cf6e..295046b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -443,70 +443,8 @@ impl std::ops::Not for TweeningDirection {
     }
 }
 
-// macro_rules! animator_impl {
-//     () => {
-//         /// Set the initial playback state of the animator.
-//         #[must_use]
-//         pub fn with_state(mut self, state: AnimatorState) -> Self {
-//             self.state = state;
-//             self
-//         }
-
-//         /// Set the initial speed of the animator. See
-// [`Animator::set_speed`] for         /// details.
-//         #[must_use]
-//         pub fn with_speed(mut self, speed: f32) -> Self {
-//             self.speed = speed;
-//             self
-//         }
-
-//         /// Set the animation speed. Defaults to 1.
-//         ///
-//         /// A speed of 2 means the animation will run twice as fast while a
-// speed of 0.1         /// will result in a 10x slowed animation.
-//         pub fn set_speed(&mut self, speed: f32) {
-//             self.speed = speed;
-//         }
-
-//         /// Get the animation speed.
-//         ///
-//         /// See [`set_speed()`] for a definition of what the animation speed
-// is.         ///
-//         /// [`set_speed()`]: Animator::speed
-//         pub fn speed(&self) -> f32 {
-//             self.speed
-//         }
-
-//         /// Set the top-level tweenable item this animator controls.
-//         pub fn set_tweenable(&mut self, tween: impl Tweenable<T> + 'static) {
-//             self.tweenable = Box::new(tween);
-//         }
-
-//         /// Get the top-level tweenable this animator is currently
-// controlling.         #[must_use]
-//         pub fn tweenable(&self) -> &dyn Tweenable<T> {
-//             self.tweenable.as_ref()
-//         }
-
-//         /// Get the top-level mutable tweenable this animator is currently
-// controlling.         #[must_use]
-//         pub fn tweenable_mut(&mut self) -> &mut dyn Tweenable<T> {
-//             self.tweenable.as_mut()
-//         }
-
-//         /// Stop animation playback and rewind the animation.
-//         ///
-//         /// This changes the animator state to [`AnimatorState::Paused`] and
-// rewind its         /// tweenable.
-//         pub fn stop(&mut self) {
-//             self.state = AnimatorState::Paused;
-//             self.tweenable_mut().rewind();
-//         }
-//     };
-// }
-
 new_key_type! {
-    /// Tween ID.
+    /// Unique identifier for a tweenable.
     pub struct TweenId;
 }
 
@@ -565,32 +503,54 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     }
 }
 
+/// A [`Tweenable`]-based animation.
+pub struct TweenAnim {
+    /// Target [`Entity`] containing the component to animate.
+    pub target: Entity,
+    /// Animation description.
+    pub tweenable: BoxedTweenable,
+    /// Control if the animation is played or not.
+    pub state: AnimatorState,
+    /// Relative playback speed. Defaults to `1.` (normal speed).
+    pub speed: f32,
+}
+
+impl TweenAnim {
+    /// Create a new tween animation.
+    pub fn new(target: Entity, tweenable: impl Tweenable + 'static) -> Self {
+        Self {
+            target,
+            tweenable: Box::new(tweenable),
+            state: AnimatorState::Playing,
+            speed: 1.,
+        }
+    }
+
+    /// Stop animation playback and rewind the animation.
+    ///
+    /// This changes the animator state to [`AnimatorState::Paused`] and  rewind
+    /// its tweenable.
+    pub fn stop(&mut self) {
+        self.state = AnimatorState::Paused;
+        self.tweenable.rewind();
+    }
+}
+
 /// Animator for tween-based animations.
 #[derive(Resource)]
 pub struct TweenAnimator {
-    /// Control if animations are played or not.
-    pub state: AnimatorState,
     /// Queue of animations currently playing.
-    anims: SlotMap<TweenId, (Entity, BoxedTweenable)>,
+    anims: SlotMap<TweenId, TweenAnim>,
 }
 
 impl Default for TweenAnimator {
     fn default() -> Self {
         Self {
-            state: AnimatorState::default(),
             anims: Default::default(),
         }
     }
 }
 
-impl std::fmt::Debug for TweenAnimator {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Animator")
-            .field("state", &self.state)
-            .finish()
-    }
-}
-
 impl TweenAnimator {
     /// Add a new component animation to the animator queue.
     ///
@@ -614,11 +574,11 @@ impl TweenAnimator {
     /// world.entity(entity).tween(tween);
     /// ```
     #[inline]
-    pub fn add<C: Component, T>(&mut self, target: Entity, tweenable: T) -> TweenId
+    pub fn add<T>(&mut self, target: Entity, tweenable: T) -> TweenId
     where
         T: Tweenable + 'static,
     {
-        self.anims.insert((target, Box::new(tweenable)))
+        self.anims.insert(TweenAnim::new(target, tweenable))
     }
 
     /// Queue a prepared tweenable animation.
@@ -628,15 +588,33 @@ impl TweenAnimator {
     /// [`make()`]: Animator::make
     #[inline]
     pub(crate) fn queue(&mut self, target: Entity, tweenable: impl Tweenable + 'static) {
-        self.anims.insert((target, Box::new(tweenable)));
+        self.anims.insert(TweenAnim::new(target, tweenable));
     }
 
     /// Get a tweenable from its ID.
     ///
     /// This fails and returns `None` if the tweenable has completed and was
     /// removed from the animator's internal queue.
-    pub fn get(&self, id: TweenId) -> Option<&dyn Tweenable> {
-        self.anims.get(id).map(|(_, tweenable)| &**tweenable)
+    pub fn get(&self, id: TweenId) -> Option<&TweenAnim> {
+        self.anims.get(id)
+    }
+
+    /// Get a tweenable from its ID.
+    ///
+    /// This fails and returns `None` if the tweenable has completed and was
+    /// removed from the animator's internal queue.
+    pub fn get_mut(&mut self, id: TweenId) -> Option<&mut TweenAnim> {
+        self.anims.get_mut(id)
+    }
+
+    /// Get an iterator over the active tweens.
+    pub fn iter(&self) -> impl Iterator<Item = (TweenId, &TweenAnim)> {
+        self.anims.iter()
+    }
+
+    /// Get a mutable iterator over the active tweens.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (TweenId, &mut TweenAnim)> {
+        self.anims.iter_mut()
     }
 
     /// Play all queued animations.
@@ -644,43 +622,30 @@ impl TweenAnimator {
     /// Loop over the internal queue of tweenable animations, apply them to
     /// their respective target [`Entity`], and prune all the completed
     /// ones (the ones returning [`TweenState::Completed`]). In the later case,
-    /// send [`TweenCompleted`] events if enabled on the tweenable.
+    /// send [`TweenCompleted`] events if enabled on each individual tweenable.
     pub fn play(
         &mut self,
         world: &mut World,
         delta_time: Duration,
         mut events: Mut<Events<TweenCompleted>>,
     ) {
-        // // Tick all active tweenables
-        // for (_, (target, action, tweenable)) in &mut self.anims {
-        //     // Note: we use get_many_entities_mut() to get an EntityMut instead of an EntityWorldMut,
-        //     // as the former is enough. This can be optimized by parallelizing tweening of separate entities.
-        //     let ent_mut = &mut world.get_many_entities_mut([*target]).unwrap()[0];
-        //     let state = action(
-        //         ent_mut.reborrow(),
-        //         *target,
-        //         tweenable.as_mut(),
-        //         delta_time,
-        //         events.reborrow(),
-        //     );
-        // }
-
-        self.anims.retain(|_id, (entity, tweenable)| {
-            // Note: we use get_many_entities_mut() to get an EntityMut instead of an EntityWorldMut,
-            // as the former is enough. This can be optimized by parallelizing tweening of separate entities.
-            let ent_mut = &mut world.get_many_entities_mut([*entity]).unwrap()[0];
+        // Loop over active animations, tick them, and retain those which are still
+        // active after that
+        self.anims.retain(|id, anim| {
+            // Note: we use get_many_entities_mut() to get an EntityMut instead of an
+            // EntityWorldMut, as the former is enough. This can allow
+            // optimizing by parallelizing tweening of separate entities (which can't be
+            // done with EntityWorldMut has it has exclusive World access).
+            let ent_mut = &mut world.get_many_entities_mut([anim.target]).unwrap()[0];
 
             // Apply the animation tweenable
-            let (_ratio, state) = tweenable.tick(delta_time, *entity);
-
-            // Apply the state
-            tweenable.apply_state(ent_mut.reborrow());
+            let (_ratio, state) = anim.tweenable.tick(delta_time, ent_mut.reborrow());
 
             // Raise completed event
             if state == TweenState::Completed {
                 events.send(TweenCompleted {
-                    entity: *entity,
-                    user_data: 0, // TODO
+                    id,
+                    entity: anim.target,
                 });
             }
 
@@ -749,6 +714,7 @@ impl ColorLerper for Color {
 #[cfg(test)]
 mod tests {
     use bevy::ecs::component::Tick;
+    use slotmap::Key as _;
 
     use self::tweenable::ComponentTarget;
 
@@ -891,17 +857,13 @@ mod tests {
         assert_eq!(1., ease.sample(0.));
     }
 
-    // #[test]
-    // fn animator_new() {
-    //     let tween = Tween::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(1),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
-    //     let animator = Animator::<DummyComponent>::new(tween);
-    //     assert_eq!(animator.state, AnimatorState::default());
-    //     assert_eq!(animator.tweenable().progress(), 0.);
-    // }
+    #[test]
+    fn animator_default() {
+        let mut animator = TweenAnimator::default();
+        assert!(animator.get(TweenId::null()).is_none());
+        assert!(animator.iter().next().is_none());
+        assert!(animator.iter_mut().next().is_none());
+    }
 
     // #[test]
     // fn animator_with_state() {
@@ -1003,121 +965,82 @@ mod tests {
     //     assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
     // }
 
-    #[cfg(feature = "bevy_asset")]
-    #[test]
-    fn asset_animator_new() {
-        let tween = Tween::<DummyAsset>::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-        let animator = AssetAnimator::new(tween);
-        assert_eq!(animator.state, AnimatorState::default());
-        let tween = animator;
-        assert_eq!(tween.tweenable().progress(), 0.);
-    }
+    // #[cfg(feature = "bevy_asset")]
+    // #[test]
+    // fn asset_animator_with_state() {
+    //     for state in [AnimatorState::Playing, AnimatorState::Paused] {
+    //         let tween = Tween::new(
+    //             EaseFunction::QuadraticInOut,
+    //             Duration::from_secs(1),
+    //             DummyLens { start: 0., end: 1. },
+    //         );
+    //         let animator = AssetAnimator::new(tween).with_state(state);
+    //         assert_eq!(animator.state, state);
 
-    #[cfg(feature = "bevy_asset")]
-    #[test]
-    fn asset_animator_with_state() {
-        for state in [AnimatorState::Playing, AnimatorState::Paused] {
-            let tween = Tween::<DummyAsset>::new(
-                EaseFunction::QuadraticInOut,
-                Duration::from_secs(1),
-                DummyLens { start: 0., end: 1. },
-            );
-            let animator = AssetAnimator::new(tween).with_state(state);
-            assert_eq!(animator.state, state);
-
-            // impl Debug
-            let debug_string = format!("{:?}", animator);
-            assert_eq!(
-                debug_string,
-                format!("AssetAnimator {{ state: {:?} }}", animator.state)
-            );
-        }
-    }
+    //         // impl Debug
+    //         let debug_string = format!("{:?}", animator);
+    //         assert_eq!(
+    //             debug_string,
+    //             format!("AssetAnimator {{ state: {:?} }}", animator.state)
+    //         );
+    //     }
+    // }
 
-    #[cfg(feature = "bevy_asset")]
-    #[test]
-    fn asset_animator_controls() {
-        let tween: Tween<DummyAsset> = Tween::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-        let mut animator = AssetAnimator::new(tween);
-        assert_eq!(animator.state, AnimatorState::Playing);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.stop();
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.tweenable_mut().set_progress(0.5);
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.5);
-
-        animator.tweenable_mut().rewind();
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.tweenable_mut().set_progress(0.5);
-        animator.state = AnimatorState::Playing;
-        assert_eq!(animator.state, AnimatorState::Playing);
-        assert_approx_eq!(animator.tweenable().progress(), 0.5);
-
-        animator.tweenable_mut().rewind();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-
-        animator.stop();
-        assert_eq!(animator.state, AnimatorState::Paused);
-        assert_approx_eq!(animator.tweenable().progress(), 0.);
-    }
+    // #[cfg(feature = "bevy_asset")]
+    // #[test]
+    // fn asset_animator_controls() {
+    //     let tween = Tween::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     let mut animator = AssetAnimator::new(tween);
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
 
-    #[cfg(feature = "bevy_asset")]
-    #[test]
-    fn asset_animator_speed() {
-        let tween: Tween<DummyAsset> = Tween::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-
-        let mut animator = AssetAnimator::new(tween);
-        assert_approx_eq!(animator.speed(), 1.); // default speed
-
-        animator.set_speed(2.4);
-        assert_approx_eq!(animator.speed(), 2.4);
-
-        let tween: Tween<DummyAsset> = Tween::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-
-        let animator = AssetAnimator::new(tween).with_speed(3.5);
-        assert_approx_eq!(animator.speed(), 3.5);
-    }
+    //     animator.stop();
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
 
-    #[cfg(feature = "bevy_asset")]
-    #[test]
-    fn asset_animator_set_tweenable() {
-        let tween: Tween<DummyAsset> = Tween::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-        let mut animator = AssetAnimator::new(tween);
-
-        let tween2 = Tween::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(2),
-            DummyLens { start: 0., end: 1. },
-        );
-        animator.set_tweenable(tween2);
-
-        assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
-    }
+    //     animator.tweenable_mut().set_progress(0.5);
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.5);
+
+    //     animator.tweenable_mut().rewind();
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+
+    //     animator.tweenable_mut().set_progress(0.5);
+    //     animator.state = AnimatorState::Playing;
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.5);
+
+    //     animator.tweenable_mut().rewind();
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+
+    //     animator.stop();
+    //     assert_eq!(animator.state, AnimatorState::Paused);
+    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+    // }
+
+    // #[cfg(feature = "bevy_asset")]
+    // #[test]
+    // fn asset_animator_set_tweenable() {
+    //     let tween = Tween::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     let mut animator = AssetAnimator::new(tween);
+
+    //     let tween2 = Tween::new(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(2),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     animator.set_tweenable(tween2);
+
+    //     assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
+    // }
 }
diff --git a/src/plugin.rs b/src/plugin.rs
index b4a6555..194204a 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -82,26 +82,28 @@ mod tests {
     struct TestEnv<T: Component> {
         world: World,
         entity: Entity,
+        tween_id: TweenId,
         _phantom: PhantomData<T>,
     }
 
     impl<T: Component + Default> TestEnv<T> {
         /// Create a new test environment containing a single entity with a
         /// [`Transform`], and add the given animator on that same entity.
-        pub fn new(tweenable: impl Tweenable<T> + 'static) -> Self {
+        pub fn new(tweenable: impl Tweenable + 'static) -> Self {
             let mut world = World::new();
             world.init_resource::<Time>();
             world.init_resource::<Events<TweenCompleted>>();
             world.init_resource::<TweenAnimator>();
 
             let entity = world.spawn(T::default()).id();
-            world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
-                animator.add(entity, tweenable);
+            let tween_id = world.resource_scope(|_, mut animator: Mut<'_, TweenAnimator>| {
+                animator.add(entity, tweenable)
             });
 
             Self {
                 world,
                 entity,
+                tween_id,
                 _phantom: PhantomData,
             }
         }
@@ -160,25 +162,23 @@ mod tests {
                 start: Vec3::ZERO,
                 end: Vec3::ONE,
             },
-        )
-        .with_completed_event(0);
+        );
 
-        let mut env = TestEnv::new(tween);
+        let mut env = TestEnv::<Transform>::new(tween);
 
         // After being inserted, components are always considered changed
         let transform = env.component_mut();
         assert!(transform.is_changed());
 
-        // fn nit() {}
-        // let mut system = IntoSystem::into_system(nit);
         let mut system = IntoSystem::into_system(plugin::animator_system);
         system.initialize(env.world_mut());
 
         env.tick(Duration::ZERO, &mut system);
 
         let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 0);
+        let anim = animator.get(env.tween_id).unwrap();
+        assert_eq!(anim.state, AnimatorState::Playing);
+        assert_eq!(anim.tweenable.times_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
@@ -187,28 +187,32 @@ mod tests {
 
         assert_eq!(env.event_count(), 0);
         let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 0);
+        let anim = animator.get(env.tween_id).unwrap();
+        assert_eq!(anim.state, AnimatorState::Playing);
+        assert_eq!(anim.tweenable.times_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.5), 1e-5));
 
         env.tick(Duration::from_millis(500), &mut system);
 
+        // The animation is done now, and was deleted from the animator queue.
+        // The final state was still applied before deleting the animation,
+        // so the component is changed.
+
         assert_eq!(env.event_count(), 1);
         let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 1);
+        assert!(animator.get(env.tween_id).is_none()); // done and deleted
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
 
+        // We can continue to tick as much as we want, this doesn't change anything
         env.tick(Duration::from_millis(100), &mut system);
 
         assert_eq!(env.event_count(), 0);
         let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 1);
+        assert!(animator.get(env.tween_id).is_none()); // done and deleted
         let transform = env.component_mut();
         assert!(!transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
@@ -233,85 +237,85 @@ mod tests {
         }
     }
 
-    #[test]
-    fn change_detect_component_conditional() {
-        let defer = Arc::new(AtomicBool::new(false));
-        let tween = Tween::new(
-            EaseMethod::Linear,
-            Duration::from_secs(1),
-            ConditionalDeferLens {
-                defer: Arc::clone(&defer),
-            },
-        )
-        .with_completed_event(0);
-
-        let mut env = TestEnv::new(tween);
-
-        // After being inserted, components are always considered changed
-        let component = env.component_mut();
-        assert!(component.is_changed());
-
-        let mut system = IntoSystem::into_system(plugin::animator_system);
-        system.initialize(env.world_mut());
-
-        assert!(!defer.load(Ordering::SeqCst));
-
-        // Mutation disabled
-        env.tick(Duration::ZERO, &mut system);
-
-        let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 0);
-        let component = env.component_mut();
-        assert!(!component.is_changed());
-        assert!((component.value - 0.).abs() <= 1e-5);
-
-        // Zero-length tick should not change the component
-        env.tick(Duration::from_millis(0), &mut system);
-
-        let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 0);
-        let component = env.component_mut();
-        assert!(!component.is_changed());
-        assert!((component.value - 0.).abs() <= 1e-5);
-
-        // New tick, but lens mutation still disabled
-        env.tick(Duration::from_millis(200), &mut system);
-
-        let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 0);
-        let component = env.component_mut();
-        assert!(!component.is_changed());
-        assert!((component.value - 0.).abs() <= 1e-5);
-
-        // Enable lens mutation
-        defer.store(true, Ordering::SeqCst);
-
-        // The current time is already at t=0.2s, so even if we don't increment it, for
-        // a tween duration of 1s the ratio is t=0.2, so the lens will actually
-        // increment the component's value.
-        env.tick(Duration::from_millis(0), &mut system);
-
-        let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 0);
-        let component = env.component_mut();
-        assert!(component.is_changed());
-        assert!((component.value - 0.2).abs() <= 1e-5);
-
-        // 0.2s + 0.3s = 0.5s
-        // t = 0.5s / 1s = 0.5
-        // value += 0.5
-        // value == 0.7
-        env.tick(Duration::from_millis(300), &mut system);
-
-        let animator = env.animator();
-        assert_eq!(animator.state, AnimatorState::Playing);
-        // assert_eq!(animator.tweenable().times_completed(), 0);
-        let component = env.component_mut();
-        assert!(component.is_changed());
-        assert!((component.value - 0.7).abs() <= 1e-5);
-    }
+    // #[test]
+    // fn change_detect_component_conditional() {
+    //     let defer = Arc::new(AtomicBool::new(false));
+    //     let tween = Tween::new(
+    //         EaseMethod::Linear,
+    //         Duration::from_secs(1),
+    //         ConditionalDeferLens {
+    //             defer: Arc::clone(&defer),
+    //         },
+    //     )
+    //     .with_completed_event(true);
+
+    //     let mut env = TestEnv::<DummyComponent>::new(tween);
+
+    //     // After being inserted, components are always considered changed
+    //     let component = env.component_mut();
+    //     assert!(component.is_changed());
+
+    //     let mut system = IntoSystem::into_system(plugin::animator_system);
+    //     system.initialize(env.world_mut());
+
+    //     assert!(!defer.load(Ordering::SeqCst));
+
+    //     // Mutation disabled
+    //     env.tick(Duration::ZERO, &mut system);
+
+    //     let animator = env.animator();
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     // assert_eq!(animator.tweenable().times_completed(), 0);
+    //     let component = env.component_mut();
+    //     assert!(!component.is_changed());
+    //     assert!(((*component).value - 0.).abs() <= 1e-5);
+
+    //     // Zero-length tick should not change the component
+    //     env.tick(Duration::from_millis(0), &mut system);
+
+    //     let animator = env.animator();
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     // assert_eq!(animator.tweenable().times_completed(), 0);
+    //     let component = env.component_mut();
+    //     assert!(!component.is_changed());
+    //     assert!(((*component).value - 0.).abs() <= 1e-5);
+
+    //     // New tick, but lens mutation still disabled
+    //     env.tick(Duration::from_millis(200), &mut system);
+
+    //     let animator = env.animator();
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     // assert_eq!(animator.tweenable().times_completed(), 0);
+    //     let component = env.component_mut();
+    //     assert!(!component.is_changed());
+    //     assert!(((*component).value - 0.).abs() <= 1e-5);
+
+    //     // Enable lens mutation
+    //     defer.store(true, Ordering::SeqCst);
+
+    //     // The current time is already at t=0.2s, so even if we don't
+    // increment it, for     // a tween duration of 1s the ratio is t=0.2,
+    // so the lens will actually     // increment the component's value.
+    //     env.tick(Duration::from_millis(0), &mut system);
+
+    //     let animator = env.animator();
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     // assert_eq!(animator.tweenable().times_completed(), 0);
+    //     let component = env.component_mut();
+    //     assert!(component.is_changed());
+    //     assert!(((*component).value - 0.2).abs() <= 1e-5);
+
+    //     // 0.2s + 0.3s = 0.5s
+    //     // t = 0.5s / 1s = 0.5
+    //     // value += 0.5
+    //     // value == 0.7
+    //     env.tick(Duration::from_millis(300), &mut system);
+
+    //     let animator = env.animator();
+    //     assert_eq!(animator.state, AnimatorState::Playing);
+    //     // assert_eq!(animator.tweenable().times_completed(), 0);
+    //     let component = env.component_mut();
+    //     assert!(component.is_changed());
+    //     assert!(((*component).value - 0.7).abs() <= 1e-5);
+    // }
 }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index e6c9698..dd78608 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -5,7 +5,7 @@ use std::{
 
 use bevy::{ecs::system::SystemId, prelude::*};
 
-use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweeningDirection};
+use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweenId, TweeningDirection};
 
 /// The dynamic tweenable type.
 ///
@@ -87,17 +87,11 @@ pub enum TweenState {
 /// iteration.
 #[derive(Copy, Clone, Event)]
 pub struct TweenCompleted {
+    /// The ID of the tween which completed.
+    pub id: TweenId,
     /// The [`Entity`] the tween which completed and its animator are attached
     /// to.
     pub entity: Entity,
-    /// An opaque value set by the user when activating event raising, used to
-    /// identify the particular tween which raised this event. The value is
-    /// passed unmodified from a call to [`with_completed_event()`]
-    /// or [`set_completed_event()`].
-    ///
-    /// [`with_completed_event()`]: Tween::with_completed_event
-    /// [`set_completed_event()`]: Tween::set_completed_event
-    pub user_data: u64,
 }
 
 /// Calculate the progress fraction in \[0:1\] of the ratio between two
@@ -199,6 +193,9 @@ fn compute_total_duration(duration: Duration, count: RepeatCount) -> TotalDurati
 
 // TODO - Targetable et al. should be replaced with Mut->Mut from Bevy 0.9
 // https://github.com/bevyengine/bevy/pull/6199
+// However this is blocked on the impossibility to get a Mut<R: Resource> from a
+// ResMut<Assets<R>> without triggering change detection.
+// https://github.com/bevyengine/bevy/issues/13104
 
 /// Trait to workaround the discrepancies of the change detection mechanisms of
 /// assets and components.
@@ -334,10 +331,19 @@ pub trait Tweenable: Send + Sync {
     fn elapsed(&self) -> Duration;
 
     /// Tick the tweenable.
-    fn tick(&mut self, delta: Duration, entity: Entity) -> (f32, TweenState);
-
-    /// Apply the current state.
-    fn apply_state(&mut self, ent_mut: EntityMut);
+    ///
+    /// Advance the internal clock of the animation by the specified amount of
+    /// time. This doesn't apply the new state to the tweenable target; use
+    /// [`apply_state()`] after this call to ensure the state of the animation
+    /// target reflects the current animation progress.
+    ///
+    /// # Returns
+    ///
+    /// Returns the new progress factor in `0..=1`, and the state of the
+    /// tweenable.
+    ///
+    /// [`apply_state()`]: Tweenable::apply_state
+    fn tick(&mut self, delta: Duration, ent_mut: EntityMut) -> (f32, TweenState);
 
     /// Rewind the animation to its starting state.
     ///
@@ -348,25 +354,38 @@ pub trait Tweenable: Send + Sync {
 
     /// Set the current animation playback progress.
     ///
-    /// See [`progress()`] for details on the meaning.
+    /// See [`progress()`] for details on the exact meaning of "progress".
     ///
-    /// Setting the progress seeks the animation to a new position, but does not
-    /// apply that change to the underlying component being animated. To
-    /// force the change to apply, call [`tick()`] with a `delta` of
-    /// `Duration::ZERO`.
+    /// Similar to [`tick()`], setting the progress seeks the animation to a new
+    /// position, but does not apply that change to the underlying component
+    /// being animated. To apply the change to the animation target (component
+    /// or asset), call [`apply_state()`].
+    ///
+    /// This is a shortcut to [`set_elapsed()`]. In general, prefer
+    /// [`set_elapsed()`] if you can, to avoid rounding errors due to the use of
+    /// floating points.
     ///
     /// [`progress()`]: Tweenable::progress
     /// [`tick()`]: Tweenable::tick
+    /// [`apply_state()`]: Tweenable::apply_state
+    /// [`set_elapsed()`]: Tweenable::set_elapsed
     fn set_progress(&mut self, progress: f32) {
         self.set_elapsed(self.duration().mul_f32(progress.max(0.)));
     }
 
-    /// Get the current progress in \[0:1\] of the animation.
+    /// Get the current progress in `0..=1` of the animation.
+    ///
+    /// In general, this is equal to the fractional part of the ratio of
+    /// [`elapsed()`] over [`duration()`].
+    ///
+    /// For looping animations (repeat count > 1), the exact value `1.` is never
+    /// reached while active, since the tweenable immediately loops over to `0.`
+    /// to start a new loop when it reaches the end of the current loop.
     ///
-    /// While looping, the exact value `1.0` is never reached, since the
-    /// tweenable loops over to `0.0` immediately when it changes direction at
-    /// either endpoint. Upon completion, the tweenable always reports exactly
-    /// `1.0`.
+    /// Upon completion ([`TweenState::Completed`]), this returns exactly `1.`.
+    ///
+    /// [`elapsed()`]: Tweenable::elapsed
+    /// [`duration()`]: Tweenable::duration
     fn progress(&self) -> f32 {
         let elapsed = self.elapsed();
         if let TotalDuration::Finite(total_duration) = self.total_duration() {
@@ -413,6 +432,7 @@ pub struct Tween {
     direction: TweeningDirection,
     action: Box<TweenAction>,
     system_id: Option<SystemId>,
+    send_completed_event: bool,
 }
 
 impl Tween {
@@ -446,9 +466,7 @@ impl Tween {
     pub fn then(self, tween: impl Tweenable + 'static) -> Sequence {
         Sequence::with_capacity(2).then(self).then(tween)
     }
-}
 
-impl Tween {
     /// Create a new tween animation.
     ///
     /// # Example
@@ -466,12 +484,9 @@ impl Tween {
     /// );
     /// ```
     #[must_use]
-    pub fn new<C: Component, L>(
-        ease_function: impl Into<EaseMethod>,
-        duration: Duration,
-        mut lens: L,
-    ) -> Self
+    pub fn new<C, L>(ease_function: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
     where
+        C: Component,
         L: Lens<C> + Send + Sync + 'static,
     {
         let action = move |mut ent_mut: EntityMut, ratio: f32| {
@@ -486,9 +501,62 @@ impl Tween {
             clock: AnimClock::new(duration),
             direction: TweeningDirection::Forward,
             action: Box::new(action),
+            send_completed_event: false,
         }
     }
 
+    /// 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
+    ///
+    /// ```
+    /// # use bevy_tweening::{lens::*, *};
+    /// # use bevy::{ecs::event::EventReader, math::Vec3};
+    /// # use std::time::Duration;
+    /// let tween = Tween::new(
+    ///     // [...]
+    /// #    EaseFunction::QuadraticInOut,
+    /// #    Duration::from_secs(1),
+    /// #    TransformPositionLens {
+    /// #        start: Vec3::ZERO,
+    /// #        end: Vec3::new(3.5, 0., 0.),
+    /// #    },
+    /// )
+    /// .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);
+    ///   }
+    /// }
+    /// ```
+    ///
+    /// [`with_completed()`]: Tween::with_completed
+    #[must_use]
+    pub fn with_completed_event(mut self, send: bool) -> Self {
+        self.send_completed_event = send;
+        self
+    }
+
+    /// 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.
+    ///
+    /// [`set_completed()`]: Tween::set_completed
+    /// [`with_completed_event()`]: Tween::with_completed_event
+    pub fn send_completed_event(&mut self, send: bool) {
+        self.send_completed_event = send;
+    }
+
     /// Set the playback direction of the tween.
     ///
     /// The playback direction influences the mapping of the progress ratio (in
@@ -555,7 +623,7 @@ impl Tweenable for Tween {
         self.clock.elapsed()
     }
 
-    fn tick(&mut self, delta: Duration, _entity: Entity) -> (f32, TweenState) {
+    fn tick(&mut self, delta: Duration, ent_mut: EntityMut) -> (f32, TweenState) {
         if self.clock.state() == TweenState::Completed {
             return (1., TweenState::Completed);
         }
@@ -580,16 +648,9 @@ impl Tweenable for Tween {
         }
         let factor = self.ease_function.sample(factor);
 
-        (factor, state)
-    }
-
-    fn apply_state(&mut self, ent_mut: EntityMut) {
-        let mut factor = self.progress();
-        if self.direction.is_backward() {
-            factor = 1. - factor;
-        }
-        let factor = self.ease_function.sample(factor);
         (self.action)(ent_mut, factor);
+
+        (factor, state)
     }
 
     fn rewind(&mut self) {
@@ -630,16 +691,16 @@ impl Tweenable for Tween {
 //         let (state, times_completed) = self.clock.tick(delta);
 //         let (progress, times_completed_for_direction) = match state {
 //             TweenState::Active => (self.progress(), times_completed),
-//             TweenState::Completed => (1., times_completed.max(1) - 1), // ignore last
-//         };
+//             TweenState::Completed => (1., times_completed.max(1) - 1), //
+// ignore last         };
 //         if self.clock.strategy == RepeatStrategy::MirroredRepeat
 //             && times_completed_for_direction & 1 != 0
 //         {
 //             self.direction = !self.direction;
 //         }
 
-//         // Apply the lens, even if the animation finished, to ensure the state is
-//         // consistent
+//         // Apply the lens, even if the animation finished, to ensure the
+// state is         // consistent
 //         let mut factor = progress;
 //         if self.direction.is_backward() {
 //             factor = 1. - factor;
@@ -775,16 +836,17 @@ impl Tweenable for Sequence {
         self.elapsed
     }
 
-    fn tick(&mut self, mut delta: Duration, entity: Entity) -> (f32, TweenState) {
+    fn tick(&mut self, mut delta: Duration, mut ent_mut: EntityMut) -> (f32, TweenState) {
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
         while self.index < self.tweens.len() {
+            // Tick the current tween
             let tween = &mut self.tweens[self.index];
             let tween_remaining = tween.duration() - tween.elapsed();
-            if let (ratio, TweenState::Active) = tween.tick(delta, entity) {
+            if let (ratio, TweenState::Active) = tween.tick(delta, ent_mut.reborrow()) {
                 return (ratio, TweenState::Active);
             }
 
-            tween.rewind();
+            // Current tween done; consume and move to next one
             delta -= tween_remaining;
             self.index += 1;
         }
@@ -792,18 +854,6 @@ impl Tweenable for Sequence {
         (1., TweenState::Completed)
     }
 
-    fn apply_state(&mut self, ent_mut: EntityMut) {
-        let num = self.tweens.len();
-        if num == 0 {
-            return;
-        }
-        if self.index < num {
-            self.tweens[self.index].apply_state(ent_mut);
-        } else {
-            self.tweens[num - 1].apply_state(ent_mut);
-        }
-    }
-
     fn rewind(&mut self) {
         self.elapsed = Duration::ZERO;
         self.index = 0;
@@ -826,8 +876,8 @@ impl Tweenable for Sequence {
 //         while self.index < self.tweens.len() {
 //             let tween = &mut self.tweens[self.index];
 //             let tween_remaining = tween.duration() - tween.elapsed();
-//             if let TweenState::Active = tween.tick(delta, target, entity, events.reborrow()) {
-//                 return TweenState::Active;
+//             if let TweenState::Active = tween.tick(delta, target, entity,
+// events.reborrow()) {                 return TweenState::Active;
 //             }
 
 //             tween.rewind();
@@ -887,11 +937,11 @@ impl Tweenable for Tracks {
         self.elapsed
     }
 
-    fn tick(&mut self, delta: Duration, entity: Entity) -> (f32, TweenState) {
+    fn tick(&mut self, delta: Duration, mut ent_mut: EntityMut) -> (f32, TweenState) {
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
         let mut any_active = false;
         for tweenable in &mut self.tracks {
-            let (_, state) = tweenable.tick(delta, entity);
+            let (_, state) = tweenable.tick(delta, ent_mut.reborrow());
             any_active = any_active || (state == TweenState::Active);
         }
         if any_active {
@@ -903,12 +953,6 @@ impl Tweenable for Tracks {
         }
     }
 
-    fn apply_state(&mut self, mut ent_mut: EntityMut) {
-        for tweenable in &mut self.tracks {
-            tweenable.apply_state(ent_mut.reborrow());
-        }
-    }
-
     fn rewind(&mut self) {
         self.elapsed = Duration::ZERO;
         for tween in &mut self.tracks {
@@ -928,9 +972,9 @@ impl Tweenable for Tracks {
 //         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
 //         let mut any_active = false;
 //         for tweenable in &mut self.tracks {
-//             let state = tweenable.tick(delta, target, entity, events.reborrow());
-//             any_active = any_active || (state == TweenState::Active);
-//         }
+//             let state = tweenable.tick(delta, target, entity,
+// events.reborrow());             any_active = any_active || (state ==
+// TweenState::Active);         }
 //         if any_active {
 //             TweenState::Active
 //         } else {
@@ -1006,7 +1050,7 @@ impl Tweenable for Delay {
         self.timer.elapsed()
     }
 
-    fn tick(&mut self, delta: Duration, _entity: Entity) -> (f32, TweenState) {
+    fn tick(&mut self, delta: Duration, _ent_mut: EntityMut) -> (f32, TweenState) {
         self.timer.tick(delta);
 
         let ratio = self.elapsed().as_secs_f32() / self.duration().as_secs_f32();
@@ -1015,8 +1059,6 @@ impl Tweenable for Delay {
         (ratio, state)
     }
 
-    fn apply_state(&mut self, _: EntityMut) {}
-
     fn rewind(&mut self) {
         self.timer.reset();
     }
@@ -1055,23 +1097,24 @@ impl Tweenable for Delay {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::{Arc, Mutex};
+    // use std::sync::{Arc, Mutex};
 
     use bevy::ecs::{component::Tick, event::Events, system::SystemState, world::CommandQueue};
 
     use super::*;
     use crate::{lens::*, test_utils::*};
 
-    #[derive(Default, Copy, Clone)]
-    struct CallbackMonitor {
-        invoke_count: u64,
-        last_reported_count: u32,
-    }
+    // #[derive(Default, Copy, Clone)]
+    // struct CallbackMonitor {
+    //     invoke_count: u64,
+    //     last_reported_count: u32,
+    // }
 
     /// Utility to create a tween for testing.
-    fn make_test_tween() -> (Tween, impl Lens<Transform>) {
-        (
-            Tween::new(EaseMethod::Linear, Duration::from_secs(1)),
+    fn make_test_tween() -> Tween {
+        Tween::new(
+            EaseMethod::Linear,
+            Duration::from_secs(1),
             TransformPositionLens {
                 start: Vec3::ZERO,
                 end: Vec3::ONE,
@@ -1092,16 +1135,16 @@ mod tests {
     fn oneshot_test() {}
 
     /// Manually tick a test tweenable targeting a component.
-    fn manual_tick_component<T: Component>(
+    fn manual_tick_component(
         duration: Duration,
-        tween: &mut dyn Tweenable<T>,
+        tween: &mut dyn Tweenable,
         world: &mut World,
         entity: Entity,
     ) -> TweenState {
-        world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
-            let transform = world.get_mut::<T>(entity).unwrap();
-            let mut target = ComponentTarget::new(transform);
-            tween.tick(duration, &mut target, entity, events)
+        world.resource_scope(|world: &mut World, _events: Mut<Events<TweenCompleted>>| {
+            let entity_mut = &mut world.get_many_entities_mut([entity]).unwrap()[0];
+            let (_, state) = tween.tick(duration, entity_mut.reborrow());
+            state
         })
     }
 
@@ -1172,14 +1215,29 @@ mod tests {
 
     #[test]
     fn into_repeat_count() {
-        let tween = Tween::new(EaseMethod::Linear, Duration::from_secs(1)).with_repeat_count(5);
+        let tween = Tween::new(
+            EaseMethod::Linear,
+            Duration::from_secs(1),
+            TransformPositionLens {
+                start: Vec3::ZERO,
+                end: Vec3::ONE,
+            },
+        )
+        .with_repeat_count(5);
         assert_eq!(
             tween.total_duration(),
             TotalDuration::Finite(Duration::from_secs(5))
         );
 
-        let tween = Tween::new(EaseMethod::Linear, Duration::from_secs(1))
-            .with_repeat_count(Duration::from_secs(3));
+        let tween = Tween::new(
+            EaseMethod::Linear,
+            Duration::from_secs(1),
+            TransformPositionLens {
+                start: Vec3::ZERO,
+                end: Vec3::ONE,
+            },
+        )
+        .with_repeat_count(Duration::from_secs(3));
         assert_eq!(
             tween.total_duration(),
             TotalDuration::Finite(Duration::from_secs(3))
@@ -1189,8 +1247,8 @@ mod tests {
     /// Test ticking of a single tween in isolation.
     #[test]
     fn tween_tick() {
-        for tweening_direction in &[TweeningDirection::Forward, TweeningDirection::Backward] {
-            for (count, strategy) in &[
+        for tweening_direction in [TweeningDirection::Forward, TweeningDirection::Backward] {
+            for (count, strategy) in [
                 (RepeatCount::Finite(1), RepeatStrategy::default()),
                 (RepeatCount::Infinite, RepeatStrategy::Repeat),
                 (RepeatCount::Finite(2), RepeatStrategy::Repeat),
@@ -1203,36 +1261,17 @@ mod tests {
 
                 // Create a linear tween over 1 second
                 let mut tween = make_test_tween()
-                    .with_direction(*tweening_direction)
-                    .with_repeat_count(*count)
-                    .with_repeat_strategy(*strategy);
-                assert_eq!(tween.direction(), *tweening_direction);
-                assert!(tween.on_completed.is_none());
-                assert!(tween.event_data.is_none());
+                    .with_direction(tweening_direction)
+                    .with_repeat_count(count)
+                    .with_repeat_strategy(strategy)
+                    .with_completed_event(true);
+                assert_eq!(tween.direction(), tweening_direction);
 
                 let (mut world, entity, system_id) = make_test_env();
                 let mut event_reader_system_state: SystemState<EventReader<TweenCompleted>> =
                     SystemState::new(&mut world);
 
-                // Register callbacks to count started/ended events
-                let callback_monitor = Arc::new(Mutex::new(CallbackMonitor::default()));
-                let cb_mon_ptr = Arc::clone(&callback_monitor);
-                let reference_entity = entity;
-                tween.set_completed(move |completed_entity, tween| {
-                    assert_eq!(completed_entity, reference_entity);
-                    let mut cb_mon = cb_mon_ptr.lock().unwrap();
-                    cb_mon.invoke_count += 1;
-                    cb_mon.last_reported_count = tween.times_completed();
-                });
-                assert!(tween.on_completed.is_some());
-                assert!(tween.event_data.is_none());
-                assert_eq!(callback_monitor.lock().unwrap().invoke_count, 0);
-
-                // Activate event sending
-                const USER_DATA: u64 = 54789; // dummy
-                tween.set_completed_event(USER_DATA);
-                assert!(tween.event_data.is_some());
-                assert_eq!(tween.event_data.unwrap(), USER_DATA);
+                assert!(tween.send_completed_event);
 
                 // Activate oneshot system
                 tween.set_completed_system(system_id);
@@ -1264,12 +1303,12 @@ mod tests {
                             }
                             RepeatCount::Finite(count) => {
                                 let total_progress = i as f32 * 0.2;
-                                let progress = if total_progress >= *count as f32 {
+                                let progress = if total_progress >= count as f32 {
                                     1.
                                 } else {
                                     total_progress.fract()
                                 };
-                                if *strategy == RepeatStrategy::Repeat {
+                                if strategy == RepeatStrategy::Repeat {
                                     let times_completed = i / 5;
                                     let just_completed = i % 5 == 0;
                                     (
@@ -1308,7 +1347,7 @@ mod tests {
                             }
                             RepeatCount::Infinite => {
                                 let progress = (i as f32 * 0.2).fract();
-                                if *strategy == RepeatStrategy::Repeat {
+                                if strategy == RepeatStrategy::Repeat {
                                     let times_completed = i / 5;
                                     let just_completed = i % 5 == 0;
                                     (
@@ -1375,9 +1414,6 @@ mod tests {
                         .translation
                         .abs_diff_eq(expected_translation, 1e-5));
                     assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
-                    let cb_mon = callback_monitor.lock().unwrap();
-                    assert_eq!(cb_mon.invoke_count, times_completed as u64);
-                    assert_eq!(cb_mon.last_reported_count, times_completed);
                     {
                         let mut event_reader = event_reader_system_state.get_mut(&mut world);
                         let event = event_reader.read().next();
@@ -1385,7 +1421,6 @@ mod tests {
                             assert!(event.is_some());
                             if let Some(event) = event {
                                 assert_eq!(event.entity, entity);
-                                assert_eq!(event.user_data, USER_DATA);
                             }
                         } else {
                             assert!(event.is_none());
@@ -1395,7 +1430,7 @@ mod tests {
 
                 // Rewind
                 tween.rewind();
-                assert_eq!(tween.direction(), *tweening_direction); // does not change
+                assert_eq!(tween.direction(), tweening_direction); // does not change
                 assert_approx_eq!(tween.progress(), 0.);
                 assert_eq!(tween.times_completed(), 0);
 
@@ -1414,13 +1449,9 @@ mod tests {
                     .abs_diff_eq(expected_translation, 1e-5));
                 assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
 
-                // Clear callback
-                tween.clear_completed();
-                assert!(tween.on_completed.is_none());
-
                 // Clear event sending
-                tween.clear_completed_event();
-                assert!(tween.event_data.is_none());
+                tween.send_completed_event(false);
+                assert!(!tween.send_completed_event);
 
                 // Clear oneshot system
                 tween.clear_completed_system();
@@ -1721,7 +1752,7 @@ mod tests {
     /// Delay::then()
     #[test]
     fn delay_then() {
-        let seq: Sequence<Transform> =
+        let seq: Sequence =
             Delay::new(Duration::from_secs(1)).then(Delay::new(Duration::from_secs(2)));
         assert_eq!(seq.duration(), Duration::from_secs(3));
         assert_eq!(seq.tweens.len(), 2);
@@ -1730,142 +1761,123 @@ mod tests {
         }
     }
 
-    /// Test ticking a delay.
-    #[test]
-    fn delay_tick() {
-        let duration = Duration::from_secs(1);
-        // Dummy world and registered oneshot system ID
-        let (mut world, entity, system_id) = make_test_env();
-
-        const USER_DATA: u64 = 42;
-        let mut delay = Delay::new(duration)
-            .with_completed_event(USER_DATA)
-            .with_completed_system(system_id);
-
-        assert!(delay.event_data.is_some());
-        assert_eq!(delay.event_data.unwrap(), USER_DATA);
-
-        assert!(delay.system_id.is_some());
-        assert_eq!(delay.system_id.unwrap(), system_id);
-
-        delay.clear_completed_event();
-        assert!(delay.event_data.is_none());
-
-        delay.set_completed_event(USER_DATA);
-        assert!(delay.event_data.is_some());
-        assert_eq!(delay.event_data.unwrap(), USER_DATA);
-
-        delay.clear_completed_system();
-        assert!(delay.system_id.is_none());
-
-        delay.set_completed_system(system_id);
-        assert!(delay.system_id.is_some());
-        assert_eq!(delay.system_id.unwrap(), system_id);
-
-        {
-            let tweenable: &dyn Tweenable<Transform> = &delay;
-            assert_eq!(tweenable.duration(), duration);
-            assert_approx_eq!(tweenable.progress(), 0.);
-            assert_eq!(tweenable.elapsed(), Duration::ZERO);
-        }
-
-        // Dummy event writer
-        let mut event_reader_system_state: SystemState<EventReader<TweenCompleted>> =
-            SystemState::new(&mut world);
-
-        // Register callbacks to count completed events
-        let callback_monitor = Arc::new(Mutex::new(CallbackMonitor::default()));
-        let cb_mon_ptr = Arc::clone(&callback_monitor);
-        let reference_entity = entity;
-        assert!(delay.on_completed.is_none());
-        delay.set_completed(move |completed_entity, delay| {
-            assert_eq!(completed_entity, reference_entity);
-            let mut cb_mon = cb_mon_ptr.lock().unwrap();
-            cb_mon.invoke_count += 1;
-            cb_mon.last_reported_count = delay.times_completed();
-        });
-        assert!(delay.on_completed.is_some());
-        assert_eq!(callback_monitor.lock().unwrap().invoke_count, 0);
-
-        for i in 1..=6 {
-            let state = manual_tick_component::<Transform>(
-                Duration::from_millis(200),
-                &mut delay,
-                &mut world,
-                entity,
-            );
-
-            // Propagate events
-            {
-                let mut events = world.resource_mut::<Events<TweenCompleted>>();
-                events.update();
-            }
-
-            // Check state
-            {
-                assert_eq!(state, delay.state());
-
-                let tweenable: &dyn Tweenable<Transform> = &delay;
-
-                {
-                    let mut event_reader = event_reader_system_state.get_mut(&mut world);
-                    let event = event_reader.read().next();
-                    if i == 5 {
-                        assert!(event.is_some());
-                        let event = event.unwrap();
-                        assert_eq!(event.entity, entity);
-                        assert_eq!(event.user_data, USER_DATA);
-                    } else {
-                        assert!(event.is_none());
-                    }
-                }
-
-                let times_completed = if i < 5 {
-                    assert_eq!(state, TweenState::Active);
-                    assert!(!delay.is_completed());
-                    assert_eq!(tweenable.times_completed(), 0);
-                    let r = i as f32 * 0.2;
-                    assert_approx_eq!(tweenable.progress(), r);
-                    0
-                } else {
-                    assert_eq!(state, TweenState::Completed);
-                    assert!(delay.is_completed());
-                    assert_eq!(tweenable.times_completed(), 1);
-                    assert_approx_eq!(tweenable.progress(), 1.);
-                    1
-                };
-
-                let cb_mon = callback_monitor.lock().unwrap();
-                assert_eq!(cb_mon.invoke_count, times_completed as u64);
-                assert_eq!(cb_mon.last_reported_count, times_completed);
-            }
-        }
-
-        delay.rewind();
-        assert_eq!(delay.times_completed(), 0);
-        assert_approx_eq!(delay.progress(), 0.);
-        let state = manual_tick_component(Duration::ZERO, &mut delay, &mut world, entity);
-        assert_eq!(state, TweenState::Active);
-
-        delay.set_progress(0.3);
-        assert_eq!(delay.times_completed(), 0);
-        assert_approx_eq!(delay.progress(), 0.3);
-        delay.set_progress(1.);
-        assert_eq!(delay.times_completed(), 1);
-        assert_approx_eq!(delay.progress(), 1.);
-
-        // Clear callback
-        delay.clear_completed();
-        assert!(delay.on_completed.is_none());
-
-        // Clear event sending
-        delay.clear_completed_event();
-        assert!(delay.event_data.is_none());
-    }
+    // /// Test ticking a delay.
+    // #[test]
+    // fn delay_tick() {
+    //     let duration = Duration::from_secs(1);
+
+    //     let mut delay = Delay::new(duration).with_completed_event();
+
+    //     assert!(delay.event_data.is_some());
+
+    //     delay.clear_completed_event();
+    //     assert!(delay.event_data.is_none());
+
+    //     delay.set_completed_event();
+    //     assert!(delay.event_data.is_some());
+
+    //     {
+    //         let tweenable: &dyn Tweenable = &delay;
+    //         assert_eq!(tweenable.duration(), duration);
+    //         assert_approx_eq!(tweenable.progress(), 0.);
+    //         assert_eq!(tweenable.elapsed(), Duration::ZERO);
+    //     }
+
+    //     // Dummy world and event writer
+    //     let (mut world, entity) = make_test_env();
+    //     let mut event_reader_system_state:
+    // SystemState<EventReader<TweenCompleted>> =         SystemState::new(&mut
+    // world);
+
+    //     // Register callbacks to count completed events
+    //     let callback_monitor = Arc::new(Mutex::new(CallbackMonitor::default()));
+    //     let cb_mon_ptr = Arc::clone(&callback_monitor);
+    //     let reference_entity = entity;
+    //     assert!(delay.on_completed.is_none());
+    //     delay.set_completed(move |completed_entity, delay| {
+    //         assert_eq!(completed_entity, reference_entity);
+    //         let mut cb_mon = cb_mon_ptr.lock().unwrap();
+    //         cb_mon.invoke_count += 1;
+    //         cb_mon.last_reported_count = delay.times_completed();
+    //     });
+    //     assert!(delay.on_completed.is_some());
+    //     assert_eq!(callback_monitor.lock().unwrap().invoke_count, 0);
+
+    //     for i in 1..=6 {
+    //         let state =
+    //             manual_tick_component(Duration::from_millis(200), &mut delay,
+    // &mut world, entity);
+
+    //         // Propagate events
+    //         {
+    //             let mut events = world.resource_mut::<Events<TweenCompleted>>();
+    //             events.update();
+    //         }
+
+    //         // Check state
+    //         {
+    //             assert_eq!(state, delay.state());
+
+    //             let tweenable: &dyn Tweenable = &delay;
+
+    //             {
+    //                 let mut event_reader = event_reader_system_state.get_mut(&mut
+    // world);                 let event = event_reader.read().next();
+    //                 if i == 5 {
+    //                     assert!(event.is_some());
+    //                     let event = event.unwrap();
+    //                     assert_eq!(event.entity, entity);
+    //                 } else {
+    //                     assert!(event.is_none());
+    //                 }
+    //             }
+
+    //             let times_completed = if i < 5 {
+    //                 assert_eq!(state, TweenState::Active);
+    //                 assert!(!delay.is_completed());
+    //                 assert_eq!(tweenable.times_completed(), 0);
+    //                 let r = i as f32 * 0.2;
+    //                 assert_approx_eq!(tweenable.progress(), r);
+    //                 0
+    //             } else {
+    //                 assert_eq!(state, TweenState::Completed);
+    //                 assert!(delay.is_completed());
+    //                 assert_eq!(tweenable.times_completed(), 1);
+    //                 assert_approx_eq!(tweenable.progress(), 1.);
+    //                 1
+    //             };
+
+    //             let cb_mon = callback_monitor.lock().unwrap();
+    //             assert_eq!(cb_mon.invoke_count, times_completed as u64);
+    //             assert_eq!(cb_mon.last_reported_count, times_completed);
+    //         }
+    //     }
+
+    //     delay.rewind();
+    //     assert_eq!(delay.times_completed(), 0);
+    //     assert_approx_eq!(delay.progress(), 0.);
+    //     let state = manual_tick_component(Duration::ZERO, &mut delay, &mut world,
+    // entity);     assert_eq!(state, TweenState::Active);
+
+    //     delay.set_progress(0.3);
+    //     assert_eq!(delay.times_completed(), 0);
+    //     assert_approx_eq!(delay.progress(), 0.3);
+    //     delay.set_progress(1.);
+    //     assert_eq!(delay.times_completed(), 1);
+    //     assert_approx_eq!(delay.progress(), 1.);
+
+    //     // Clear callback
+    //     delay.clear_completed();
+    //     assert!(delay.on_completed.is_none());
+
+    //     // Clear event sending
+    //     delay.clear_completed_event();
+    //     assert!(delay.event_data.is_none());
+    // }
 
     #[test]
     fn delay_elapsed() {
-        let mut delay: Delay<f32> = Delay::new(Duration::from_secs(1));
+        let mut delay = Delay::new(Duration::from_secs(1));
         let duration = delay.duration();
         for ms in [0, 1, 500, 100, 300, 999, 847, 1000, 900] {
             let elapsed = Duration::from_millis(ms);
@@ -1893,7 +1905,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn delay_zero_duration_panics() {
-        let _: Delay<f32> = Delay::new(Duration::ZERO);
+        let _ = Delay::new(Duration::ZERO);
     }
 
     #[test]

From 7e556e76b94e16565c0f247cbe54468e372e6a14 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 5 May 2024 10:16:52 +0100
Subject: [PATCH 05/66] Add AnimCompleted event, fix tests

---
 src/lib.rs       |  49 +++++-----
 src/plugin.rs    |  25 +++--
 src/tweenable.rs | 241 ++++++++++++++++++++++++++++++++++++-----------
 3 files changed, 231 insertions(+), 84 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 295046b..436e8eb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -303,24 +303,19 @@ impl Default for RepeatStrategy {
     }
 }
 
-/// Playback state of an animator.
+/// Playback state of a [`TweenAnim`].
 ///
 /// Default: `Playing`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AnimatorState {
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum PlaybackState {
     /// The animation is playing. This is the default state.
+    #[default]
     Playing,
     /// The animation is paused in its current state.
     Paused,
 }
 
-impl Default for AnimatorState {
-    fn default() -> Self {
-        Self::Playing
-    }
-}
-
-impl std::ops::Not for AnimatorState {
+impl std::ops::Not for PlaybackState {
     type Output = Self;
 
     fn not(self) -> Self::Output {
@@ -503,6 +498,15 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     }
 }
 
+/// Event raised when a [`TweenAnim`] completed.
+#[derive(Copy, Clone, Event)]
+pub struct AnimCompleted {
+    /// The ID of the tween animation which completed.
+    pub id: TweenId,
+    /// The [`Entity`] the animation which completed is attached to.
+    pub entity: Entity,
+}
+
 /// A [`Tweenable`]-based animation.
 pub struct TweenAnim {
     /// Target [`Entity`] containing the component to animate.
@@ -510,7 +514,7 @@ pub struct TweenAnim {
     /// Animation description.
     pub tweenable: BoxedTweenable,
     /// Control if the animation is played or not.
-    pub state: AnimatorState,
+    pub state: PlaybackState,
     /// Relative playback speed. Defaults to `1.` (normal speed).
     pub speed: f32,
 }
@@ -521,7 +525,7 @@ impl TweenAnim {
         Self {
             target,
             tweenable: Box::new(tweenable),
-            state: AnimatorState::Playing,
+            state: PlaybackState::Playing,
             speed: 1.,
         }
     }
@@ -531,7 +535,7 @@ impl TweenAnim {
     /// This changes the animator state to [`AnimatorState::Paused`] and  rewind
     /// its tweenable.
     pub fn stop(&mut self) {
-        self.state = AnimatorState::Paused;
+        self.state = PlaybackState::Paused;
         self.tweenable.rewind();
     }
 }
@@ -628,10 +632,11 @@ impl TweenAnimator {
         world: &mut World,
         delta_time: Duration,
         mut events: Mut<Events<TweenCompleted>>,
+        mut anim_events: Mut<Events<AnimCompleted>>,
     ) {
         // Loop over active animations, tick them, and retain those which are still
         // active after that
-        self.anims.retain(|id, anim| {
+        self.anims.retain(|tween_id, anim| {
             // Note: we use get_many_entities_mut() to get an EntityMut instead of an
             // EntityWorldMut, as the former is enough. This can allow
             // optimizing by parallelizing tweening of separate entities (which can't be
@@ -639,12 +644,14 @@ impl TweenAnimator {
             let ent_mut = &mut world.get_many_entities_mut([anim.target]).unwrap()[0];
 
             // Apply the animation tweenable
-            let (_ratio, state) = anim.tweenable.tick(delta_time, ent_mut.reborrow());
+            let (_progress, state) =
+                anim.tweenable
+                    .tick(tween_id, delta_time, ent_mut.reborrow(), events.reborrow());
 
             // Raise completed event
             if state == TweenState::Completed {
-                events.send(TweenCompleted {
-                    id,
+                anim_events.send(AnimCompleted {
+                    id: tween_id,
                     entity: anim.target,
                 });
             }
@@ -823,12 +830,12 @@ mod tests {
 
     #[test]
     fn animator_state() {
-        let mut state = AnimatorState::default();
-        assert_eq!(state, AnimatorState::Playing);
+        let mut state = PlaybackState::default();
+        assert_eq!(state, PlaybackState::Playing);
         state = !state;
-        assert_eq!(state, AnimatorState::Paused);
+        assert_eq!(state, PlaybackState::Paused);
         state = !state;
-        assert_eq!(state, AnimatorState::Playing);
+        assert_eq!(state, PlaybackState::Playing);
     }
 
     #[test]
diff --git a/src/plugin.rs b/src/plugin.rs
index 194204a..6d88964 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{TweenAnimator, TweenCompleted};
+use crate::{AnimCompleted, TweenAnimator, TweenCompleted};
 
 /// Plugin to add systems related to tweening of common components and assets.
 ///
@@ -37,6 +37,7 @@ impl Plugin for TweeningPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<TweenAnimator>()
             .add_event::<TweenCompleted>()
+            .add_event::<AnimCompleted>()
             .add_systems(
                 Update,
                 animator_system.in_set(AnimationSystem::AnimationUpdate),
@@ -51,15 +52,15 @@ pub enum AnimationSystem {
     AnimationUpdate,
 }
 
-/// Animator system for components.
-///
-/// This system extracts all components of type `T` with an [`Animator<T>`]
-/// attached to the same entity, and tick the animator to animate the component.
+/// TODO
 pub fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
+    // TODO: Use SystemState to cache all of that...
     world.resource_scope(|world, events: Mut<Events<TweenCompleted>>| {
-        world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
-            animator.play(world, delta_time, events);
+        world.resource_scope(|world, anim_events: Mut<Events<AnimCompleted>>| {
+            world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
+                animator.play(world, delta_time, events, anim_events);
+            });
         });
     });
 }
@@ -93,6 +94,7 @@ mod tests {
             let mut world = World::new();
             world.init_resource::<Time>();
             world.init_resource::<Events<TweenCompleted>>();
+            world.init_resource::<Events<AnimCompleted>>();
             world.init_resource::<TweenAnimator>();
 
             let entity = world.spawn(T::default()).id();
@@ -134,6 +136,8 @@ mod tests {
             // Update events after system ticked, in case system emitted some events
             let mut events = self.world.resource_mut::<Events<TweenCompleted>>();
             events.update();
+            let mut events = self.world.resource_mut::<Events<AnimCompleted>>();
+            events.update();
         }
 
         /// Get the animator for the component.
@@ -162,7 +166,8 @@ mod tests {
                 start: Vec3::ZERO,
                 end: Vec3::ONE,
             },
-        );
+        )
+        .with_completed_event(true);
 
         let mut env = TestEnv::<Transform>::new(tween);
 
@@ -177,7 +182,7 @@ mod tests {
 
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, AnimatorState::Playing);
+        assert_eq!(anim.state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.times_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
@@ -188,7 +193,7 @@ mod tests {
         assert_eq!(env.event_count(), 0);
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, AnimatorState::Playing);
+        assert_eq!(anim.state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.times_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
diff --git a/src/tweenable.rs b/src/tweenable.rs
index dd78608..2da0a9e 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -69,10 +69,10 @@ pub enum TweenState {
     Completed,
 }
 
-/// Event raised when a tween completed.
+/// Event raised when a [`Tween`] completed.
 ///
-/// This event is raised when a tween completed. When looping, this is raised
-/// once per iteration. In case the animation direction changes
+/// This event is raised when a [`Tween`] completed. When looping, this is
+/// raised once per iteration. In case the animation direction changes
 /// ([`RepeatStrategy::MirroredRepeat`]), an iteration corresponds to a single
 /// progress from one endpoint to the other, whatever the direction. Therefore a
 /// complete cycle start -> end -> start counts as 2 iterations and raises 2
@@ -87,11 +87,16 @@ pub enum TweenState {
 /// iteration.
 #[derive(Copy, Clone, Event)]
 pub struct TweenCompleted {
-    /// The ID of the tween which completed.
+    /// The ID of the tween animation which completed.
+    ///
+    /// This is the ID of the top-level [`TweenAnim`] this tween is part of. It
+    /// can be used to retrieve the animation with [`TweenAnimator::get`].
     pub id: TweenId,
-    /// The [`Entity`] the tween which completed and its animator are attached
-    /// to.
+    /// The [`Entity`] the tween which completed and the [`TweenAnim`] it's part
+    /// of are attached to.
     pub entity: Entity,
+    /// Current progress of the owner [`TweenAnim`].
+    pub progress: f32,
 }
 
 /// Calculate the progress fraction in \[0:1\] of the ratio between two
@@ -343,7 +348,13 @@ pub trait Tweenable: Send + Sync {
     /// tweenable.
     ///
     /// [`apply_state()`]: Tweenable::apply_state
-    fn tick(&mut self, delta: Duration, ent_mut: EntityMut) -> (f32, TweenState);
+    fn tick(
+        &mut self,
+        tween_id: TweenId,
+        delta: Duration,
+        ent_mut: EntityMut,
+        events: Mut<Events<TweenCompleted>>,
+    ) -> (f32, TweenState);
 
     /// Rewind the animation to its starting state.
     ///
@@ -623,12 +634,18 @@ impl Tweenable for Tween {
         self.clock.elapsed()
     }
 
-    fn tick(&mut self, delta: Duration, ent_mut: EntityMut) -> (f32, TweenState) {
+    fn tick(
+        &mut self,
+        tween_id: TweenId,
+        delta: Duration,
+        ent_mut: EntityMut,
+        mut events: Mut<Events<TweenCompleted>>,
+    ) -> (f32, TweenState) {
         if self.clock.state() == TweenState::Completed {
             return (1., TweenState::Completed);
         }
 
-        // Tick the animation clock
+        // Advance the animation clock
         let (state, times_completed) = self.clock.tick(delta);
         let (progress, times_completed_for_direction) = match state {
             TweenState::Active => (self.progress(), times_completed),
@@ -640,17 +657,30 @@ impl Tweenable for Tween {
             self.direction = !self.direction;
         }
 
-        // Apply the lens, even if the animation finished, to ensure the state is
-        // consistent
-        let mut factor = progress;
-        if self.direction.is_backward() {
-            factor = 1. - factor;
+        let entity = ent_mut.id();
+
+        // Apply new animation state to target, even if the animation finished, to
+        // ensure the state is consistent
+        {
+            // 'factor' maps to Lens 0:start and 1:end, whatever the playback direction
+            let mut factor = progress;
+            if self.direction.is_backward() {
+                factor = 1. - factor;
+            }
+            let factor = self.ease_function.sample(factor);
+            (self.action)(ent_mut, factor);
         }
-        let factor = self.ease_function.sample(factor);
 
-        (self.action)(ent_mut, factor);
+        // Send completion event
+        if self.send_completed_event && times_completed > 0 {
+            events.send(TweenCompleted {
+                id: tween_id,
+                entity,
+                progress,
+            });
+        }
 
-        (factor, state)
+        (progress, state)
     }
 
     fn rewind(&mut self) {
@@ -836,13 +866,24 @@ impl Tweenable for Sequence {
         self.elapsed
     }
 
-    fn tick(&mut self, mut delta: Duration, mut ent_mut: EntityMut) -> (f32, TweenState) {
+    fn tick(
+        &mut self,
+        tween_id: TweenId,
+        mut delta: Duration,
+        mut ent_mut: EntityMut,
+        mut events: Mut<Events<TweenCompleted>>,
+    ) -> (f32, TweenState) {
+        // Calculate the new elapsed time at the end of this tick
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
+
+        // Tick one or more tweenables until the new elapsed time is reached.
         while self.index < self.tweens.len() {
-            // Tick the current tween
+            // Tick the current tweenable
             let tween = &mut self.tweens[self.index];
             let tween_remaining = tween.duration() - tween.elapsed();
-            if let (ratio, TweenState::Active) = tween.tick(delta, ent_mut.reborrow()) {
+            if let (ratio, TweenState::Active) =
+                tween.tick(tween_id, delta, ent_mut.reborrow(), events.reborrow())
+            {
                 return (ratio, TweenState::Active);
             }
 
@@ -937,11 +978,17 @@ impl Tweenable for Tracks {
         self.elapsed
     }
 
-    fn tick(&mut self, delta: Duration, mut ent_mut: EntityMut) -> (f32, TweenState) {
+    fn tick(
+        &mut self,
+        tween_id: TweenId,
+        delta: Duration,
+        mut ent_mut: EntityMut,
+        mut events: Mut<Events<TweenCompleted>>,
+    ) -> (f32, TweenState) {
         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
         let mut any_active = false;
         for tweenable in &mut self.tracks {
-            let (_, state) = tweenable.tick(delta, ent_mut.reborrow());
+            let (_, state) = tweenable.tick(tween_id, delta, ent_mut.reborrow(), events.reborrow());
             any_active = any_active || (state == TweenState::Active);
         }
         if any_active {
@@ -1050,13 +1097,19 @@ impl Tweenable for Delay {
         self.timer.elapsed()
     }
 
-    fn tick(&mut self, delta: Duration, _ent_mut: EntityMut) -> (f32, TweenState) {
+    fn tick(
+        &mut self,
+        _tween_id: TweenId,
+        delta: Duration,
+        _ent_mut: EntityMut,
+        _events: Mut<Events<TweenCompleted>>,
+    ) -> (f32, TweenState) {
         self.timer.tick(delta);
 
-        let ratio = self.elapsed().as_secs_f32() / self.duration().as_secs_f32();
+        let progress = fraction_progress(self.elapsed(), self.duration());
         let state = self.state();
 
-        (ratio, state)
+        (progress, state)
     }
 
     fn rewind(&mut self) {
@@ -1100,6 +1153,7 @@ mod tests {
     // use std::sync::{Arc, Mutex};
 
     use bevy::ecs::{component::Tick, event::Events, system::SystemState, world::CommandQueue};
+    use slotmap::Key as _;
 
     use super::*;
     use crate::{lens::*, test_utils::*};
@@ -1136,14 +1190,15 @@ mod tests {
 
     /// Manually tick a test tweenable targeting a component.
     fn manual_tick_component(
+        tween_id: TweenId,
         duration: Duration,
         tween: &mut dyn Tweenable,
         world: &mut World,
         entity: Entity,
     ) -> TweenState {
-        world.resource_scope(|world: &mut World, _events: Mut<Events<TweenCompleted>>| {
+        world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
             let entity_mut = &mut world.get_many_entities_mut([entity]).unwrap()[0];
-            let (_, state) = tween.tick(duration, entity_mut.reborrow());
+            let (_, state) = tween.tick(tween_id, duration, entity_mut.reborrow(), events);
             state
         })
     }
@@ -1395,8 +1450,13 @@ mod tests {
                     );
 
                     // Tick the tween
-                    let actual_state =
-                        manual_tick_component(tick_duration, &mut tween, &mut world, entity);
+                    let actual_state = manual_tick_component(
+                        TweenId::null(), // unused in this test
+                        tick_duration,
+                        &mut tween,
+                        &mut world,
+                        entity,
+                    );
 
                     // Propagate events
                     {
@@ -1435,8 +1495,13 @@ mod tests {
                 assert_eq!(tween.times_completed(), 0);
 
                 // Dummy tick to update target
-                let actual_state =
-                    manual_tick_component(Duration::ZERO, &mut tween, &mut world, entity);
+                let actual_state = manual_tick_component(
+                    TweenId::null(), // unused in this test
+                    Duration::ZERO,
+                    &mut tween,
+                    &mut world,
+                    entity,
+                );
                 assert_eq!(actual_state, TweenState::Active);
                 let expected_translation = if tweening_direction.is_backward() {
                     Vec3::ONE
@@ -1492,7 +1557,13 @@ mod tests {
         // Progress always increases alongside the current direction
         tween.set_direction(TweeningDirection::Backward);
         assert_approx_eq!(tween.progress(), 0.3);
-        manual_tick_component(Duration::from_millis(100), &mut tween, &mut world, entity);
+        manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(100),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_approx_eq!(tween.progress(), 0.4);
         let transform = world.entity(entity).get::<Transform>().unwrap();
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.6), 1e-5));
@@ -1545,8 +1616,13 @@ mod tests {
         let (mut world, entity, _system_id) = make_test_env();
 
         for i in 1..=16 {
-            let state =
-                manual_tick_component(Duration::from_millis(200), &mut seq, &mut world, entity);
+            let state = manual_tick_component(
+                TweenId::null(), // unused in this test
+                Duration::from_millis(200),
+                &mut seq,
+                &mut world,
+                entity,
+            );
             let transform = world.entity(entity).get::<Transform>().unwrap();
             if i < 5 {
                 assert_eq!(state, TweenState::Active);
@@ -1592,6 +1668,7 @@ mod tests {
         // - Start the third tween
         for delta_ms in [500, 2000] {
             manual_tick_component(
+                TweenId::null(), // unused in this test
                 Duration::from_millis(delta_ms),
                 &mut seq,
                 &mut world,
@@ -1699,8 +1776,13 @@ mod tests {
         let (mut world, entity, _system_id) = make_test_env();
 
         for i in 1..=6 {
-            let state =
-                manual_tick_component(Duration::from_millis(200), &mut tracks, &mut world, entity);
+            let state = manual_tick_component(
+                TweenId::null(), // unused in this test
+                Duration::from_millis(200),
+                &mut tracks,
+                &mut world,
+                entity,
+            );
             let transform = world.entity(entity).get::<Transform>().unwrap();
             if i < 5 {
                 assert_eq!(state, TweenState::Active);
@@ -1730,21 +1812,39 @@ mod tests {
         tracks.set_progress(0.9);
         assert_approx_eq!(tracks.progress(), 0.9);
         // tick to udpate state (set_progress() does not update state)
-        let state = manual_tick_component(Duration::ZERO, &mut tracks, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::ZERO,
+            &mut tracks,
+            &mut world,
+            entity,
+        );
         assert_eq!(state, TweenState::Active);
         assert_eq!(tracks.times_completed(), 0);
 
         tracks.set_progress(3.2);
         assert_approx_eq!(tracks.progress(), 1.);
         // tick to udpate state (set_progress() does not update state)
-        let state = manual_tick_component(Duration::ZERO, &mut tracks, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::ZERO,
+            &mut tracks,
+            &mut world,
+            entity,
+        );
         assert_eq!(state, TweenState::Completed);
         assert_eq!(tracks.times_completed(), 1); // no looping
 
         tracks.set_progress(-0.5);
         assert_approx_eq!(tracks.progress(), 0.);
         // tick to udpate state (set_progress() does not update state)
-        let state = manual_tick_component(Duration::ZERO, &mut tracks, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::ZERO,
+            &mut tracks,
+            &mut world,
+            entity,
+        );
         assert_eq!(state, TweenState::Active);
         assert_eq!(tracks.times_completed(), 0); // no looping
     }
@@ -1919,8 +2019,13 @@ mod tests {
         let (mut world, entity, _system_id) = make_test_env();
 
         // 10%
-        let state =
-            manual_tick_component(Duration::from_millis(100), &mut tween, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(100),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_eq!(TweenState::Active, state);
         assert_eq!(0, tween.times_completed());
         assert_approx_eq!(tween.progress(), 0.1);
@@ -1928,8 +2033,13 @@ mod tests {
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.1), 1e-5));
 
         // 130%
-        let state =
-            manual_tick_component(Duration::from_millis(1200), &mut tween, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(1200),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_eq!(TweenState::Active, state);
         assert_eq!(1, tween.times_completed());
         assert_approx_eq!(tween.progress(), 0.3);
@@ -1937,8 +2047,13 @@ mod tests {
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.3), 1e-5));
 
         // 480%
-        let state =
-            manual_tick_component(Duration::from_millis(3500), &mut tween, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(3500),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_eq!(TweenState::Active, state);
         assert_eq!(4, tween.times_completed());
         assert_approx_eq!(tween.progress(), 0.8);
@@ -1946,8 +2061,13 @@ mod tests {
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.8), 1e-5));
 
         // 500% - done
-        let state =
-            manual_tick_component(Duration::from_millis(200), &mut tween, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(200),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_eq!(TweenState::Completed, state);
         assert_eq!(5, tween.times_completed());
         assert_approx_eq!(tween.progress(), 1.0);
@@ -1966,8 +2086,13 @@ mod tests {
         let (mut world, entity, _system_id) = make_test_env();
 
         // 10%
-        let state =
-            manual_tick_component(Duration::from_millis(100), &mut tween, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(100),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_eq!(TweenState::Active, state);
         assert_eq!(TweeningDirection::Forward, tween.direction());
         assert_eq!(0, tween.times_completed());
@@ -1984,8 +2109,13 @@ mod tests {
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.1), 1e-5)); // no-op, rewind doesn't apply Lens
 
         // 120% - mirror
-        let state =
-            manual_tick_component(Duration::from_millis(1200), &mut tween, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(1200),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_eq!(TweeningDirection::Backward, tween.direction());
         assert_eq!(TweenState::Active, state);
         assert_eq!(1, tween.times_completed());
@@ -2002,8 +2132,13 @@ mod tests {
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.8), 1e-5)); // no-op, rewind doesn't apply Lens
 
         // 400% - done mirror (because Completed freezes the state)
-        let state =
-            manual_tick_component(Duration::from_millis(4000), &mut tween, &mut world, entity);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::from_millis(4000),
+            &mut tween,
+            &mut world,
+            entity,
+        );
         assert_eq!(TweenState::Completed, state);
         assert_eq!(TweeningDirection::Backward, tween.direction()); // frozen from last loop
         assert_eq!(4, tween.times_completed());

From f7a9fe27ba33446860f2930954b2792544a0de38 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 5 May 2024 10:46:25 +0100
Subject: [PATCH 06/66] Fix more tests and docs

---
 src/lib.rs       |   9 +-
 src/plugin.rs    | 167 +++++++++++----------
 src/tweenable.rs | 376 +++++++++++++----------------------------------
 3 files changed, 197 insertions(+), 355 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 436e8eb..cfa57be 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -563,19 +563,20 @@ impl TweenAnimator {
     /// queue tweenable animations on a given [`EntityCommands`], like this:
     ///
     /// ```
-    /// # use bevy::prelude::*
+    /// # use bevy::prelude::*;
     /// # use bevy_tweening::{lens::*, *};
     /// # use std::time::Duration;
     /// # let mut world = World::default();
-    /// # let entity = Entity::default();
+    /// # let entity = Entity::PLACEHOLDER;
     /// let tween = Tween::new(
     ///     EaseFunction::QuadraticInOut,
     ///     Duration::from_secs(1),
     ///     TransformPositionLens {
     ///         start: Vec3::ZERO,
     ///         end: Vec3::new(3.5, 0., 0.),
-    /// };
-    /// world.entity(entity).tween(tween);
+    ///     },
+    /// );
+    /// world.entity_mut(entity).tween(tween);
     /// ```
     #[inline]
     pub fn add<T>(&mut self, target: Entity, tweenable: T) -> TweenId
diff --git a/src/plugin.rs b/src/plugin.rs
index 6d88964..9b0935e 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -242,85 +242,90 @@ mod tests {
         }
     }
 
-    // #[test]
-    // fn change_detect_component_conditional() {
-    //     let defer = Arc::new(AtomicBool::new(false));
-    //     let tween = Tween::new(
-    //         EaseMethod::Linear,
-    //         Duration::from_secs(1),
-    //         ConditionalDeferLens {
-    //             defer: Arc::clone(&defer),
-    //         },
-    //     )
-    //     .with_completed_event(true);
-
-    //     let mut env = TestEnv::<DummyComponent>::new(tween);
-
-    //     // After being inserted, components are always considered changed
-    //     let component = env.component_mut();
-    //     assert!(component.is_changed());
-
-    //     let mut system = IntoSystem::into_system(plugin::animator_system);
-    //     system.initialize(env.world_mut());
-
-    //     assert!(!defer.load(Ordering::SeqCst));
-
-    //     // Mutation disabled
-    //     env.tick(Duration::ZERO, &mut system);
-
-    //     let animator = env.animator();
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     // assert_eq!(animator.tweenable().times_completed(), 0);
-    //     let component = env.component_mut();
-    //     assert!(!component.is_changed());
-    //     assert!(((*component).value - 0.).abs() <= 1e-5);
-
-    //     // Zero-length tick should not change the component
-    //     env.tick(Duration::from_millis(0), &mut system);
-
-    //     let animator = env.animator();
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     // assert_eq!(animator.tweenable().times_completed(), 0);
-    //     let component = env.component_mut();
-    //     assert!(!component.is_changed());
-    //     assert!(((*component).value - 0.).abs() <= 1e-5);
-
-    //     // New tick, but lens mutation still disabled
-    //     env.tick(Duration::from_millis(200), &mut system);
-
-    //     let animator = env.animator();
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     // assert_eq!(animator.tweenable().times_completed(), 0);
-    //     let component = env.component_mut();
-    //     assert!(!component.is_changed());
-    //     assert!(((*component).value - 0.).abs() <= 1e-5);
-
-    //     // Enable lens mutation
-    //     defer.store(true, Ordering::SeqCst);
-
-    //     // The current time is already at t=0.2s, so even if we don't
-    // increment it, for     // a tween duration of 1s the ratio is t=0.2,
-    // so the lens will actually     // increment the component's value.
-    //     env.tick(Duration::from_millis(0), &mut system);
-
-    //     let animator = env.animator();
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     // assert_eq!(animator.tweenable().times_completed(), 0);
-    //     let component = env.component_mut();
-    //     assert!(component.is_changed());
-    //     assert!(((*component).value - 0.2).abs() <= 1e-5);
-
-    //     // 0.2s + 0.3s = 0.5s
-    //     // t = 0.5s / 1s = 0.5
-    //     // value += 0.5
-    //     // value == 0.7
-    //     env.tick(Duration::from_millis(300), &mut system);
-
-    //     let animator = env.animator();
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     // assert_eq!(animator.tweenable().times_completed(), 0);
-    //     let component = env.component_mut();
-    //     assert!(component.is_changed());
-    //     assert!(((*component).value - 0.7).abs() <= 1e-5);
-    // }
+    #[test]
+    fn change_detect_component_conditional() {
+        let defer = Arc::new(AtomicBool::new(false));
+        let tween = Tween::new(
+            EaseMethod::Linear,
+            Duration::from_secs(1),
+            ConditionalDeferLens {
+                defer: Arc::clone(&defer),
+            },
+        )
+        .with_completed_event(true);
+
+        let mut env = TestEnv::<DummyComponent>::new(tween);
+
+        // After being inserted, components are always considered changed
+        let component = env.component_mut();
+        assert!(component.is_changed());
+
+        let mut system = IntoSystem::into_system(plugin::animator_system);
+        system.initialize(env.world_mut());
+
+        assert!(!defer.load(Ordering::SeqCst));
+
+        // Mutation disabled
+        env.tick(Duration::ZERO, &mut system);
+
+        let animator = env.animator();
+        let anim = animator.get(env.tween_id).unwrap();
+        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.tweenable.times_completed(), 0);
+        let component = env.component_mut();
+        assert!(!component.is_changed());
+        assert!(((*component).value - 0.).abs() <= 1e-5);
+
+        // Zero-length tick should not change the component
+        env.tick(Duration::from_millis(0), &mut system);
+
+        let animator = env.animator();
+        let anim = animator.get(env.tween_id).unwrap();
+        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.tweenable.times_completed(), 0);
+        let component = env.component_mut();
+        assert!(!component.is_changed());
+        assert!(((*component).value - 0.).abs() <= 1e-5);
+
+        // New tick, but lens mutation still disabled
+        env.tick(Duration::from_millis(200), &mut system);
+
+        let animator = env.animator();
+        let anim = animator.get(env.tween_id).unwrap();
+        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.tweenable.times_completed(), 0);
+        let component = env.component_mut();
+        assert!(!component.is_changed());
+        assert!(((*component).value - 0.).abs() <= 1e-5);
+
+        // Enable lens mutation
+        defer.store(true, Ordering::SeqCst);
+
+        // The current time is already at t=0.2s, so even if we don't increment it, for
+        // a tween duration of 1s the ratio is t=0.2, so the lens will actually
+        // increment the component's value.
+        env.tick(Duration::from_millis(0), &mut system);
+
+        let animator = env.animator();
+        let anim = animator.get(env.tween_id).unwrap();
+        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.tweenable.times_completed(), 0);
+        let component = env.component_mut();
+        assert!(component.is_changed());
+        assert!(((*component).value - 0.2).abs() <= 1e-5);
+
+        // 0.2s + 0.3s = 0.5s
+        // t = 0.5s / 1s = 0.5
+        // value += 0.5
+        // value == 0.7
+        env.tick(Duration::from_millis(300), &mut system);
+
+        let animator = env.animator();
+        let anim = animator.get(env.tween_id).unwrap();
+        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.tweenable.times_completed(), 0);
+        let component = env.component_mut();
+        assert!(component.is_changed());
+        assert!(((*component).value - 0.7).abs() <= 1e-5);
+    }
 }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 2da0a9e..9f78845 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -11,41 +11,46 @@ use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweenId, TweeningDire
 ///
 /// When creating lists of tweenables, you will need to box them to create a
 /// homogeneous array like so:
+///
 /// ```no_run
 /// # use bevy::prelude::Transform;
 /// # use bevy_tweening::{BoxedTweenable, Delay, Sequence, Tween};
 /// #
-/// # let delay: Delay<Transform> = unimplemented!();
-/// # let tween: Tween<Transform> = unimplemented!();
+/// # let delay: Delay = unimplemented!();
+/// # let tween: Tween = unimplemented!();
 ///
-/// Sequence::new([Box::new(delay) as BoxedTweenable<Transform>, tween.into()]);
+/// Sequence::new([Box::new(delay) as BoxedTweenable, tween.into()]);
 /// ```
 ///
 /// When using your own [`Tweenable`] types, APIs will be easier to use if you
 /// implement [`From`]:
+///
 /// ```no_run
 /// # use std::time::Duration;
 /// # use bevy::ecs::system::Commands;
-/// # use bevy::prelude::{Entity, Events, Mut, Transform};
-/// # use bevy_tweening::{BoxedTweenable, Sequence, Tweenable, TweenCompleted, TweenState, Targetable, TotalDuration};
+/// # use bevy::prelude::*;
+/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompleted, TweenState, Targetable, TotalDuration};
 /// #
 /// # struct MyTweenable;
-/// # impl Tweenable<Transform> for MyTweenable {
+/// # impl Tweenable for MyTweenable {
 /// #     fn duration(&self) -> Duration  { unimplemented!() }
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
-/// #     fn tick<'a>(&mut self, delta: Duration, target: &'a mut dyn Targetable<Transform>, entity: Entity, events: &mut Mut<Events<TweenCompleted>>, commands: &mut Commands) -> TweenState  { unimplemented!() }
+/// #     fn tick(&mut self, tween_id: TweenId, delta: Duration, ent_mut: EntityMut, events: Mut<Events<TweenCompleted>>) -> (f32, TweenState)  { unimplemented!() }
 /// #     fn rewind(&mut self) { unimplemented!() }
+/// #     fn set_progress(&mut self, progress: f32) { unimplemented!() }
+/// #     fn progress(&self) -> f32 { unimplemented!() }
+/// #     fn times_completed(&self) -> u32 { unimplemented!() }
 /// # }
 ///
-/// Sequence::new([Box::new(MyTweenable) as BoxedTweenable<_>]);
+/// Sequence::new([Box::new(MyTweenable) as BoxedTweenable]);
 ///
 /// // OR
 ///
 /// Sequence::new([MyTweenable]);
 ///
-/// impl From<MyTweenable> for BoxedTweenable<Transform> {
+/// impl From<MyTweenable> for BoxedTweenable {
 ///     fn from(t: MyTweenable) -> Self {
 ///         Box::new(t)
 ///     }
@@ -516,11 +521,13 @@ impl Tween {
         }
     }
 
-    /// Enable raising a completed event.
+    /// Enable raising a completed event on looping.
     ///
-    /// 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.
+    /// If enabled, the tween will raise a [`TweenCompleted`] event each time
+    /// the tween's progress reaches `1.`. In case of looping tweens (repeat
+    /// count > 1), the event is raised once per loop. For mirrored repeats, a
+    /// "loop" is one travel from start to end or end to start (so the full
+    /// cycle start -> end -> start counts as 2 loops and raises 2 events).
     ///
     /// # Example
     ///
@@ -537,17 +544,17 @@ impl Tween {
     /// #        end: Vec3::new(3.5, 0., 0.),
     /// #    },
     /// )
-    /// .with_completed_event(42);
+    /// // Raise a TweenCompleted event each loop
+    /// .with_completed_event(true);
     ///
     /// fn my_system(mut reader: EventReader<TweenCompleted>) {
     ///   for ev in reader.read() {
-    ///     assert_eq!(ev.user_data, 42);
-    ///     println!("Entity {:?} raised TweenCompleted!", ev.entity);
+    ///     println!(
+    ///       "Tween animation {:?} raised TweenCompleted for target entity {:?}!",
+    ///       ev.id, ev.entity);
     ///   }
     /// }
     /// ```
-    ///
-    /// [`with_completed()`]: Tween::with_completed
     #[must_use]
     pub fn with_completed_event(mut self, send: bool) -> Self {
         self.send_completed_event = send;
@@ -705,56 +712,6 @@ impl Tweenable for Tween {
     }
 }
 
-// impl<T> Tweenable<T> for Tween {
-//     fn tick(
-//         &mut self,
-//         delta: Duration,
-//         target: &mut dyn Targetable<T>,
-//         entity: Entity,
-//         mut events: Mut<Events<TweenCompleted>>,
-//     ) -> TweenState {
-//         if self.clock.state() == TweenState::Completed {
-//             return TweenState::Completed;
-//         }
-
-//         // Tick the animation clock
-//         let (state, times_completed) = self.clock.tick(delta);
-//         let (progress, times_completed_for_direction) = match state {
-//             TweenState::Active => (self.progress(), times_completed),
-//             TweenState::Completed => (1., times_completed.max(1) - 1), //
-// ignore last         };
-//         if self.clock.strategy == RepeatStrategy::MirroredRepeat
-//             && times_completed_for_direction & 1 != 0
-//         {
-//             self.direction = !self.direction;
-//         }
-
-//         // Apply the lens, even if the animation finished, to ensure the
-// state is         // consistent
-//         let mut factor = progress;
-//         if self.direction.is_backward() {
-//             factor = 1. - factor;
-//         }
-//         let factor = self.ease_function.sample(factor);
-//         self.lens.lerp(target, factor);
-
-//         // If completed at least once this frame, notify the user
-//         if times_completed > 0 {
-//             if let Some(user_data) = &self.event_data {
-//                 events.send(TweenCompleted {
-//                     entity,
-//                     user_data: *user_data,
-//                 });
-//             }
-//             if let Some(cb) = &self.on_completed {
-//                 cb(entity, self);
-//             }
-//         }
-
-//         state
-//     }
-// }
-
 /// A sequence of tweens played back in order one after the other.
 pub struct Sequence {
     tweens: Vec<BoxedTweenable>,
@@ -905,31 +862,6 @@ impl Tweenable for Sequence {
     }
 }
 
-// impl<T> Tweenable<T> for Sequence {
-//     fn tick(
-//         &mut self,
-//         mut delta: Duration,
-//         target: &mut dyn Targetable<T>,
-//         entity: Entity,
-//         mut events: Mut<Events<TweenCompleted>>,
-//     ) -> TweenState {
-//         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
-//         while self.index < self.tweens.len() {
-//             let tween = &mut self.tweens[self.index];
-//             let tween_remaining = tween.duration() - tween.elapsed();
-//             if let TweenState::Active = tween.tick(delta, target, entity,
-// events.reborrow()) {                 return TweenState::Active;
-//             }
-
-//             tween.rewind();
-//             delta -= tween_remaining;
-//             self.index += 1;
-//         }
-
-//         TweenState::Completed
-//     }
-// }
-
 /// A collection of [`Tweenable`] executing in parallel.
 pub struct Tracks {
     tracks: Vec<BoxedTweenable>,
@@ -1008,28 +940,6 @@ impl Tweenable for Tracks {
     }
 }
 
-// impl<T> Tweenable<T> for Tracks {
-//     fn tick(
-//         &mut self,
-//         delta: Duration,
-//         target: &mut dyn Targetable<T>,
-//         entity: Entity,
-//         mut events: Mut<Events<TweenCompleted>>,
-//     ) -> TweenState {
-//         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
-//         let mut any_active = false;
-//         for tweenable in &mut self.tracks {
-//             let state = tweenable.tick(delta, target, entity,
-// events.reborrow());             any_active = any_active || (state ==
-// TweenState::Active);         }
-//         if any_active {
-//             TweenState::Active
-//         } else {
-//             TweenState::Completed
-//         }
-//     }
-// }
-
 /// A time delay that doesn't animate anything.
 ///
 /// This is generally useful for combining with other tweenables into sequences
@@ -1117,37 +1027,6 @@ impl Tweenable for Delay {
     }
 }
 
-// impl<T> Tweenable<T> for Delay {
-//     fn tick(
-//         &mut self,
-//         delta: Duration,
-//         _target: &mut dyn Targetable<T>,
-//         entity: Entity,
-//         mut events: Mut<Events<TweenCompleted>>,
-//     ) -> TweenState {
-//         let was_completed = self.is_completed();
-
-//         self.timer.tick(delta);
-
-//         let state = self.state();
-
-//         // If completed this frame, notify the user
-//         if (state == TweenState::Completed) && !was_completed {
-//             if let Some(user_data) = &self.event_data {
-//                 events.send(TweenCompleted {
-//                     entity,
-//                     user_data: *user_data,
-//                 });
-//             }
-//             if let Some(cb) = &self.on_completed {
-//                 cb(entity, self);
-//             }
-//         }
-
-//         state
-//     }
-// }
-
 #[cfg(test)]
 mod tests {
     // use std::sync::{Arc, Mutex};
@@ -1196,11 +1075,21 @@ mod tests {
         world: &mut World,
         entity: Entity,
     ) -> TweenState {
-        world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
-            let entity_mut = &mut world.get_many_entities_mut([entity]).unwrap()[0];
-            let (_, state) = tween.tick(tween_id, duration, entity_mut.reborrow(), events);
-            state
-        })
+        // Tick the given tween and apply its state to the given entity target
+        let state =
+            world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
+                let entity_mut = &mut world.get_many_entities_mut([entity]).unwrap()[0];
+                let (_, state) = tween.tick(tween_id, duration, entity_mut.reborrow(), events);
+                state
+            });
+
+        // Propagate events
+        {
+            let mut events = world.resource_mut::<Events<TweenCompleted>>();
+            events.update();
+        }
+
+        state
     }
 
     #[derive(Debug, Default, Clone, Copy, Component)]
@@ -1458,12 +1347,6 @@ mod tests {
                         entity,
                     );
 
-                    // Propagate events
-                    {
-                        let mut events = world.resource_mut::<Events<TweenCompleted>>();
-                        events.update();
-                    }
-
                     // Check actual values
                     assert_eq!(tween.direction(), direction);
                     assert_eq!(actual_state, expected_state);
@@ -1861,119 +1744,72 @@ mod tests {
         }
     }
 
-    // /// Test ticking a delay.
-    // #[test]
-    // fn delay_tick() {
-    //     let duration = Duration::from_secs(1);
-
-    //     let mut delay = Delay::new(duration).with_completed_event();
-
-    //     assert!(delay.event_data.is_some());
-
-    //     delay.clear_completed_event();
-    //     assert!(delay.event_data.is_none());
-
-    //     delay.set_completed_event();
-    //     assert!(delay.event_data.is_some());
-
-    //     {
-    //         let tweenable: &dyn Tweenable = &delay;
-    //         assert_eq!(tweenable.duration(), duration);
-    //         assert_approx_eq!(tweenable.progress(), 0.);
-    //         assert_eq!(tweenable.elapsed(), Duration::ZERO);
-    //     }
-
-    //     // Dummy world and event writer
-    //     let (mut world, entity) = make_test_env();
-    //     let mut event_reader_system_state:
-    // SystemState<EventReader<TweenCompleted>> =         SystemState::new(&mut
-    // world);
-
-    //     // Register callbacks to count completed events
-    //     let callback_monitor = Arc::new(Mutex::new(CallbackMonitor::default()));
-    //     let cb_mon_ptr = Arc::clone(&callback_monitor);
-    //     let reference_entity = entity;
-    //     assert!(delay.on_completed.is_none());
-    //     delay.set_completed(move |completed_entity, delay| {
-    //         assert_eq!(completed_entity, reference_entity);
-    //         let mut cb_mon = cb_mon_ptr.lock().unwrap();
-    //         cb_mon.invoke_count += 1;
-    //         cb_mon.last_reported_count = delay.times_completed();
-    //     });
-    //     assert!(delay.on_completed.is_some());
-    //     assert_eq!(callback_monitor.lock().unwrap().invoke_count, 0);
-
-    //     for i in 1..=6 {
-    //         let state =
-    //             manual_tick_component(Duration::from_millis(200), &mut delay,
-    // &mut world, entity);
-
-    //         // Propagate events
-    //         {
-    //             let mut events = world.resource_mut::<Events<TweenCompleted>>();
-    //             events.update();
-    //         }
-
-    //         // Check state
-    //         {
-    //             assert_eq!(state, delay.state());
-
-    //             let tweenable: &dyn Tweenable = &delay;
-
-    //             {
-    //                 let mut event_reader = event_reader_system_state.get_mut(&mut
-    // world);                 let event = event_reader.read().next();
-    //                 if i == 5 {
-    //                     assert!(event.is_some());
-    //                     let event = event.unwrap();
-    //                     assert_eq!(event.entity, entity);
-    //                 } else {
-    //                     assert!(event.is_none());
-    //                 }
-    //             }
-
-    //             let times_completed = if i < 5 {
-    //                 assert_eq!(state, TweenState::Active);
-    //                 assert!(!delay.is_completed());
-    //                 assert_eq!(tweenable.times_completed(), 0);
-    //                 let r = i as f32 * 0.2;
-    //                 assert_approx_eq!(tweenable.progress(), r);
-    //                 0
-    //             } else {
-    //                 assert_eq!(state, TweenState::Completed);
-    //                 assert!(delay.is_completed());
-    //                 assert_eq!(tweenable.times_completed(), 1);
-    //                 assert_approx_eq!(tweenable.progress(), 1.);
-    //                 1
-    //             };
-
-    //             let cb_mon = callback_monitor.lock().unwrap();
-    //             assert_eq!(cb_mon.invoke_count, times_completed as u64);
-    //             assert_eq!(cb_mon.last_reported_count, times_completed);
-    //         }
-    //     }
-
-    //     delay.rewind();
-    //     assert_eq!(delay.times_completed(), 0);
-    //     assert_approx_eq!(delay.progress(), 0.);
-    //     let state = manual_tick_component(Duration::ZERO, &mut delay, &mut world,
-    // entity);     assert_eq!(state, TweenState::Active);
-
-    //     delay.set_progress(0.3);
-    //     assert_eq!(delay.times_completed(), 0);
-    //     assert_approx_eq!(delay.progress(), 0.3);
-    //     delay.set_progress(1.);
-    //     assert_eq!(delay.times_completed(), 1);
-    //     assert_approx_eq!(delay.progress(), 1.);
-
-    //     // Clear callback
-    //     delay.clear_completed();
-    //     assert!(delay.on_completed.is_none());
-
-    //     // Clear event sending
-    //     delay.clear_completed_event();
-    //     assert!(delay.event_data.is_none());
-    // }
+    /// Test ticking a delay.
+    #[test]
+    fn delay_tick() {
+        let duration = Duration::from_secs(1);
+
+        let mut delay = Delay::new(duration);
+
+        {
+            let tweenable: &dyn Tweenable = &delay;
+            assert_eq!(tweenable.duration(), duration);
+            assert_approx_eq!(tweenable.progress(), 0.);
+            assert_eq!(tweenable.elapsed(), Duration::ZERO);
+        }
+
+        // Dummy world and event writer
+        let (mut world, entity) = make_test_env();
+
+        for i in 1..=6 {
+            let state = manual_tick_component(
+                TweenId::null(), // unused in this test
+                Duration::from_millis(200),
+                &mut delay,
+                &mut world,
+                entity,
+            );
+
+            // Check state
+            {
+                assert_eq!(state, delay.state());
+
+                let tweenable: &dyn Tweenable = &delay;
+
+                if i < 5 {
+                    assert_eq!(state, TweenState::Active);
+                    assert!(!delay.is_completed());
+                    assert_eq!(tweenable.times_completed(), 0);
+                    let r = i as f32 * 0.2;
+                    assert_approx_eq!(tweenable.progress(), r);
+                } else {
+                    assert_eq!(state, TweenState::Completed);
+                    assert!(delay.is_completed());
+                    assert_eq!(tweenable.times_completed(), 1);
+                    assert_approx_eq!(tweenable.progress(), 1.);
+                }
+            }
+        }
+
+        delay.rewind();
+        assert_eq!(delay.times_completed(), 0);
+        assert_approx_eq!(delay.progress(), 0.);
+        let state = manual_tick_component(
+            TweenId::null(), // unused in this test
+            Duration::ZERO,
+            &mut delay,
+            &mut world,
+            entity,
+        );
+        assert_eq!(state, TweenState::Active);
+
+        delay.set_progress(0.3);
+        assert_eq!(delay.times_completed(), 0);
+        assert_approx_eq!(delay.progress(), 0.3);
+        delay.set_progress(1.);
+        assert_eq!(delay.times_completed(), 1);
+        assert_approx_eq!(delay.progress(), 1.);
+    }
 
     #[test]
     fn delay_elapsed() {

From 3315d8bf2ec612ad61313c6c37661b301dd1d811 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 25 Jun 2025 20:08:33 +0100
Subject: [PATCH 07/66] Start attempting to re-add Asset support...

---
 examples/colormaterial_color.rs |  2 +-
 examples/sprite_color.rs        |  9 +++---
 src/lib.rs                      |  2 +-
 src/tweenable.rs                | 52 ++++++++++++++++++++++++++++++---
 4 files changed, 54 insertions(+), 11 deletions(-)

diff --git a/examples/colormaterial_color.rs b/examples/colormaterial_color.rs
index 6f45119..d897915 100644
--- a/examples/colormaterial_color.rs
+++ b/examples/colormaterial_color.rs
@@ -80,7 +80,7 @@ fn setup(
         // asset would change the color of all entities using that material.
         let unique_material = materials.add(Color::BLACK);
 
-        let tween = Tween::new(
+        let tween = Tween::new_asset(
             *ease_function,
             Duration::from_secs(1),
             ColorMaterialColorLens {
diff --git a/examples/sprite_color.rs b/examples/sprite_color.rs
index 647ecdc..79fb28c 100644
--- a/examples/sprite_color.rs
+++ b/examples/sprite_color.rs
@@ -74,8 +74,8 @@ fn setup(mut commands: Commands) {
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands.spawn((
-            SpriteBundle {
+        commands
+            .spawn((SpriteBundle {
                 transform: Transform::from_translation(Vec3::new(x, y, 0.)),
                 sprite: Sprite {
                     color: Color::BLACK,
@@ -83,9 +83,8 @@ fn setup(mut commands: Commands) {
                     ..default()
                 },
                 ..default()
-            },
-            TweenAnimator::new(tween),
-        ));
+            },))
+            .tween(tween);
 
         y -= size * spacing;
         if y < -screen_y {
diff --git a/src/lib.rs b/src/lib.rs
index cfa57be..1183068 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -221,7 +221,7 @@ use slotmap::SlotMap;
 pub use tweenable::AssetTarget;
 pub use tweenable::{
     BoxedTweenable, ComponentTarget, Delay, Sequence, Targetable, TotalDuration, Tracks, Tween,
-    TweenCompleted, TweenState, Tweenable,
+    TweenAssetExtensions, TweenCompleted, TweenState, Tweenable,
 };
 
 pub mod lens;
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 9f78845..b152604 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -439,14 +439,29 @@ impl_boxed!(Sequence);
 impl_boxed!(Tracks);
 impl_boxed!(Delay);
 
-type TweenAction = dyn FnMut(EntityMut, f32) + Send + Sync + 'static;
+type ComponentAction = dyn FnMut(EntityMut, f32) + Send + Sync + 'static;
+type AssetAction = dyn FnMut(&mut World, UntypedHandle, f32) + Send + Sync + 'static;
+
+/// TODO
+pub trait TweenAssetExtensions {
+    /// TODO
+    fn new<A, L>(ease_function: impl Into<EaseMethod>, duration: Duration, lens: L) -> Self
+    where
+        A: Asset,
+        L: Lens<A> + Send + Sync + 'static;
+}
+
+enum TweenAction {
+    Component(Box<ComponentAction>),
+    Asset(Box<AssetAction>),
+}
 
 /// Single tweening animation instance.
 pub struct Tween {
     ease_function: EaseMethod,
     clock: AnimClock,
     direction: TweeningDirection,
-    action: Box<TweenAction>,
+    action: TweenAction,
     system_id: Option<SystemId>,
     send_completed_event: bool,
 }
@@ -516,7 +531,7 @@ impl Tween {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
             direction: TweeningDirection::Forward,
-            action: Box::new(action),
+            action: TweenAction::Component(Box::new(action)),
             send_completed_event: false,
         }
     }
@@ -624,6 +639,30 @@ impl Tween {
     }
 }
 
+impl TweenAssetExtensions for Tween {
+    #[must_use]
+    fn new<A, L>(ease_function: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
+    where
+        A: Asset,
+        L: Lens<A> + Send + Sync + 'static,
+    {
+        let action = move |world: &mut World, handle: UntypedHandle, ratio: f32| {
+            if let Some(assets) = world.get_resource_mut::<Assets<A>>() {
+                let mut target = AssetTarget::new(assets);
+                target.handle = handle.typed::<A>();
+                lens.lerp(&mut target, ratio);
+            }
+        };
+        Self {
+            ease_function: ease_function.into(),
+            clock: AnimClock::new(duration),
+            direction: TweeningDirection::Forward,
+            action: TweenAction::Asset(Box::new(action)),
+            send_completed_event: false,
+        }
+    }
+}
+
 impl Tweenable for Tween {
     fn duration(&self) -> Duration {
         self.clock.duration
@@ -675,7 +714,12 @@ impl Tweenable for Tween {
                 factor = 1. - factor;
             }
             let factor = self.ease_function.sample(factor);
-            (self.action)(ent_mut, factor);
+            match &mut self.action {
+                TweenAction::Component(action) => {
+                    action(ent_mut, factor);
+                }
+                _ => debug!("Ignoring call to tick() a component with an asset action."),
+            };
         }
 
         // Send completion event

From ec4a27592f2ba8fd610f238439a7e5ee174353d6 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 26 Jun 2025 18:30:21 +0100
Subject: [PATCH 08/66] Build fixes

---
 src/lib.rs       |  39 ++++----
 src/plugin.rs    |  29 +-----
 src/tweenable.rs | 232 +++++++++++++++--------------------------------
 3 files changed, 97 insertions(+), 203 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 47b4eb7..f7ef0cf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -210,7 +210,7 @@ use bevy::prelude::*;
 
 pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
-use slotmap::SlotMap;
+use slotmap::{new_key_type, SlotMap};
 #[cfg(feature = "bevy_asset")]
 pub use tweenable::AssetTarget;
 pub use tweenable::{
@@ -460,19 +460,19 @@ fn make_tween_command<T>(tweenable: T) -> impl EntityCommand
 where
     T: Tweenable + 'static,
 {
-    move |target: Entity, world: &mut World| {
-        world
-            .resource_mut::<TweenAnimator>()
-            .queue(target, tweenable);
+    move |mut entity: EntityWorldMut| {
+        let e = entity.id();
+        entity.resource_mut::<TweenAnimator>().queue(e, tweenable);
     }
 }
 
 fn make_transform_from_command(end: Vec3, duration: Duration) -> impl EntityCommand {
-    move |target: Entity, world: &mut World| {
-        let start = world.entity(target).get::<Transform>().unwrap().translation;
+    move |mut entity: EntityWorldMut| {
+        let start = entity.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
-        let tween = Tween::new(EaseMethod::Linear, duration, lens);
-        world.resource_mut::<TweenAnimator>().queue(target, tween);
+        let tween = Tween::new(EaseFunction::Linear, duration, lens);
+        let e = entity.id();
+        entity.resource_mut::<TweenAnimator>().queue(e, tween);
     }
 }
 
@@ -481,11 +481,11 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     where
         T: Tweenable + 'static,
     {
-        self.add(make_tween_command(tweenable))
+        self.queue(make_tween_command(tweenable))
     }
 
     fn move_to(&mut self, end: Vec3, duration: Duration) -> &mut EntityCommands<'a> {
-        self.add(make_transform_from_command(end, duration))
+        self.queue(make_transform_from_command(end, duration))
     }
 }
 
@@ -629,11 +629,11 @@ impl TweenAnimator {
         // Loop over active animations, tick them, and retain those which are still
         // active after that
         self.anims.retain(|tween_id, anim| {
-            // Note: we use get_many_entities_mut() to get an EntityMut instead of an
+            // Note: we use get_entity_mut() to get an EntityMut instead of an
             // EntityWorldMut, as the former is enough. This can allow
             // optimizing by parallelizing tweening of separate entities (which can't be
             // done with EntityWorldMut has it has exclusive World access).
-            let ent_mut = &mut world.get_many_entities_mut([anim.target]).unwrap()[0];
+            let ent_mut = &mut world.get_entity_mut([anim.target]).unwrap()[0];
 
             // Apply the animation tweenable
             let (_progress, state) =
@@ -702,17 +702,20 @@ trait ColorLerper {
 #[cfg(any(feature = "bevy_sprite", feature = "bevy_ui", feature = "bevy_text"))]
 impl ColorLerper for Color {
     fn lerp(&self, target: &Color, ratio: f32) -> Color {
-        let r = self.r().lerp(target.r(), ratio);
-        let g = self.g().lerp(target.g(), ratio);
-        let b = self.b().lerp(target.b(), ratio);
-        let a = self.a().lerp(target.a(), ratio);
-        Color::rgba(r, g, b, a)
+        let src = self.to_linear();
+        let dst = target.to_linear();
+        let r = src.red.lerp(dst.red, ratio);
+        let g = src.green.lerp(dst.green, ratio);
+        let b = src.blue.lerp(dst.blue, ratio);
+        let a = src.alpha.lerp(dst.alpha, ratio);
+        Color::linear_rgba(r, g, b, a)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
+    use slotmap::Key as _;
 
     use self::tweenable::ComponentTarget;
 
diff --git a/src/plugin.rs b/src/plugin.rs
index c90935d..941dafc 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,4 +1,4 @@
-use bevy::{ecs::component::Mutable, prelude::*};
+use bevy::prelude::*;
 
 use crate::{AnimCompleted, TweenAnimator, TweenCompleted};
 
@@ -106,25 +106,8 @@ mod tests {
 
             Self {
                 world,
-
                 entity,
                 tween_id,
-            }
-        }
-
-        /// Like [`TestEnv::new`], but the component is placed on a separate entity.
-        pub fn new_separated(animator: Animator<T>) -> Self {
-            let mut world = World::new();
-            world.init_resource::<Events<TweenCompleted>>();
-            world.init_resource::<Time>();
-
-            let target = world.spawn(T::default()).id();
-            let entity = world.spawn(animator.with_target(target)).id();
-
-            Self {
-                world,
-                animator_entity: entity,
-                target_entity: Some(target),
                 _phantom: PhantomData,
             }
         }
@@ -166,9 +149,7 @@ mod tests {
 
         /// Get the component.
         pub fn component_mut(&mut self) -> Mut<T> {
-            self.world
-                .get_mut::<T>(self.target_entity.unwrap_or(self.animator_entity))
-                .unwrap()
+            self.world.get_mut::<T>(self.entity).unwrap()
         }
 
         /// Get the emitted event count since last tick.
@@ -188,9 +169,9 @@ mod tests {
                 end: Vec3::ONE,
             },
         )
-        .with_completed_event(0);
-        let mut env = TestEnv::new_separated(Animator::new(tween));
-        let mut system = IntoSystem::into_system(component_animator_system::<Transform>);
+        .with_completed_event(true);
+        let mut env = TestEnv::<Transform>::new(tween);
+        let mut system = IntoSystem::into_system(plugin::animator_system);
         system.initialize(env.world_mut());
 
         env.tick(Duration::ZERO, &mut system);
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 7f593c8..acf5043 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -3,7 +3,10 @@ use std::{
     time::Duration,
 };
 
-use bevy::{ecs::system::SystemId, prelude::*};
+use bevy::{
+    ecs::{component::Mutable, system::SystemId},
+    prelude::*,
+};
 
 use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweenId, TweeningDirection};
 
@@ -107,8 +110,7 @@ pub struct TweenCompleted {
 /// Calculate the progress fraction in \[0:1\] of the ratio between two
 /// [`Duration`]s.
 fn fraction_progress(n: Duration, d: Duration) -> f32 {
-    // TODO - Replace with div_duration_f32() once it's stable
-    (n.as_secs_f64() / d.as_secs_f64()).fract() as f32
+    n.div_duration_f32(d)
 }
 
 #[derive(Debug)]
@@ -453,6 +455,7 @@ pub trait TweenAssetExtensions {
 
 enum TweenAction {
     Component(Box<ComponentAction>),
+    #[allow(dead_code)]
     Asset(Box<AssetAction>),
 }
 
@@ -517,7 +520,7 @@ impl Tween {
     #[must_use]
     pub fn new<C, L>(ease_function: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
     where
-        C: Component,
+        C: Component<Mutability = Mutable>,
         L: Lens<C> + Send + Sync + 'static,
     {
         let action = move |mut ent_mut: EntityMut, ratio: f32| {
@@ -532,6 +535,7 @@ impl Tween {
             clock: AnimClock::new(duration),
             direction: TweeningDirection::Forward,
             action: TweenAction::Component(Box::new(action)),
+            system_id: None,
             send_completed_event: false,
         }
     }
@@ -576,38 +580,9 @@ impl Tween {
         self
     }
 
-    /// 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.
     ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::{Vec3, curve::EaseFunction}};
-    /// # use std::time::Duration;
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed(|entity, _tween| {
-    ///   println!("Tween completed on entity {:?}", entity);
-    /// });
-    /// ```
-    ///
-    /// [`set_completed()`]: Tween::set_completed
-    /// [`with_completed_event()`]: Tween::with_completed_event
-    pub fn with_completed<C>(mut self, callback: C) -> Self
-    where
-        C: Fn(Entity, &Self) + Send + Sync + 'static,
-    {
-        self.on_completed = Some(Box::new(callback));
-        self
+    pub fn send_completed_event(&mut self, send: bool) {
+        self.send_completed_event = send;
     }
 
     /// Enable running a one-shot system upon completion.
@@ -650,6 +625,16 @@ impl Tween {
         self
     }
 
+    ///
+    pub fn set_completed_system(&mut self, system_id: SystemId) {
+        self.system_id = Some(system_id);
+    }
+
+    ///
+    pub fn clear_completed_system(&mut self) {
+        self.system_id = None;
+    }
+
     /// Set the playback direction of the tween.
     ///
     /// The playback direction influences the mapping of the progress ratio (in
@@ -718,6 +703,7 @@ impl TweenAssetExtensions for Tween {
             clock: AnimClock::new(duration),
             direction: TweeningDirection::Forward,
             action: TweenAction::Asset(Box::new(action)),
+            system_id: None,
             send_completed_event: false,
         }
     }
@@ -765,33 +751,32 @@ impl Tweenable for Tween {
 
         let entity = ent_mut.id();
 
+        let factor = self.ease_function.sample(progress);
+        match &mut self.action {
+            TweenAction::Component(action) => {
+                action(ent_mut, factor);
+            }
+            _ => (), //debug!("Ignoring call to tick() a component with an asset action."),
+        };
+
         // If completed at least once this frame, notify the user
         if times_completed > 0 {
-            if let Some(user_data) = &self.event_data {
+            if self.send_completed_event {
                 let event = TweenCompleted {
+                    id: tween_id,
                     entity,
-                    user_data: *user_data,
+                    progress,
                 };
 
                 // send regular event
                 events.send(event);
 
                 // trigger all entity-scoped observers
-                commands.trigger_targets(event, entity);
+                //commands.trigger_targets(event, entity);
             }
-            if let Some(cb) = &self.on_completed {
-                cb(entity, self);
-            }
-            if let Some(system_id) = &self.system_id {
-                commands.run_system(*system_id);
-            }
-            let factor = self.ease_function.sample(factor);
-            match &mut self.action {
-                TweenAction::Component(action) => {
-                    action(ent_mut, factor);
-                }
-                _ => debug!("Ignoring call to tick() a component with an asset action."),
-            };
+            // if let Some(system_id) = &self.system_id {
+            //     commands.run_system(*system_id);
+            // }
         }
 
         // Send completion event
@@ -820,9 +805,9 @@ impl Tweenable for Tween {
             if times_completed & 1 != 0 {
                 self.direction = !self.direction;
             }
-            if let Some(system_id) = &self.system_id {
-                commands.run_system(*system_id);
-            }
+            // if let Some(system_id) = &self.system_id {
+            //     commands.run_system(*system_id);
+            // }
         }
         self.clock.reset();
     }
@@ -962,14 +947,10 @@ impl Tweenable for Sequence {
 
             let tween_remaining = tween.duration().saturating_sub(tween.elapsed());
 
-            if let TweenState::Active = tween.tick(
-                delta,
-                target,
-                ent_mut.reborrow(),
-                events.reborrow(),
-                commands,
-            ) {
-                return TweenState::Active;
+            if let (progress, TweenState::Active) =
+                tween.tick(tween_id, delta, ent_mut.reborrow(), events.reborrow())
+            {
+                return (progress, TweenState::Active);
             }
 
             // Current tween done; consume and move to next one
@@ -1076,6 +1057,7 @@ impl Tweenable for Tracks {
 /// to delay the animation of its buttons.
 pub struct Delay {
     timer: Timer,
+    system_id: Option<SystemId>,
 }
 
 impl Delay {
@@ -1096,78 +1078,10 @@ impl Delay {
         assert!(!duration.is_zero());
         Self {
             timer: Timer::new(duration, TimerMode::Once),
+            system_id: None,
         }
     }
 
-    /// 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
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::Vec3, transform::components::Transform};
-    /// # use std::time::Duration;
-    /// 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);
-    ///   }
-    /// }
-    /// ```
-    ///
-    /// [`set_completed()`]: Delay::set_completed
-    #[must_use]
-    pub fn with_completed_event(mut self, user_data: u64) -> Self {
-        self.event_data = Some(user_data);
-        self
-    }
-
-    /// 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
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::{Vec3, curve::EaseFunction}};
-    /// # use std::time::Duration;
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed(|entity, delay| {
-    ///   println!("Delay of {} seconds elapsed on entity {:?}",
-    ///     delay.duration().as_secs(), entity);
-    /// });
-    /// ```
-    ///
-    /// [`with_completed_event()`]: Delay::with_completed_event
-    pub fn with_completed<C>(mut self, callback: C) -> Self
-    where
-        C: Fn(Entity, &Self) + Send + Sync + 'static,
-    {
-        self.on_completed = Some(Box::new(callback));
-        self
-    }
-
     /// Enable running a one-shot system upon completion.
     ///
     /// If enabled, the tween will run a system via a provided [`SystemId`] when
@@ -1257,29 +1171,27 @@ impl Tweenable for Delay {
         let progress = fraction_progress(self.elapsed(), self.duration());
         let state = self.state();
 
-        // If completed this frame, notify the user
-        if (state == TweenState::Completed) && !was_completed {
-            if let Some(user_data) = &self.event_data {
-                let event = TweenCompleted {
-                    entity,
-                    user_data: *user_data,
-                };
-
-                // send regular event
-                events.send(event);
-
-                // trigger all entity-scoped observers
-                commands.trigger_targets(event, entity);
-            }
-            if let Some(cb) = &self.on_completed {
-                cb(entity, self);
-            }
-            if let Some(system_id) = &self.system_id {
-                commands.run_system(*system_id);
-            }
-        }
+        // // If completed this frame, notify the user
+        // if (state == TweenState::Completed) && !was_completed {
+        //     if self.send_completed_events {
+        //         let event = TweenCompleted {
+        //             id: tween_id,
+        //             entity,
+        //             progress,
+        //         };
+
+        //         // send regular event
+        //         events.send(event);
+
+        //         // trigger all entity-scoped observers
+        //         //commands.trigger_targets(event, entity);
+        //     }
+        //     if let Some(system_id) = &self.system_id {
+        //         commands.run_system(*system_id);
+        //     }
+        // }
 
-        state
+        (progress, state)
     }
 
     fn rewind(&mut self) {
@@ -1292,12 +1204,9 @@ mod tests {
     // use std::sync::{Arc, Mutex};
 
     use bevy::ecs::{
-        change_detection::MaybeLocation,
-        component::{Mutable, Tick},
-        event::Events,
-        system::SystemState,
-        world::CommandQueue,
+        change_detection::MaybeLocation, component::Tick, event::Events, system::SystemState,
     };
+    use slotmap::Key as _;
 
     use super::*;
     use crate::{lens::*, test_utils::*};
@@ -1333,7 +1242,8 @@ mod tests {
     fn oneshot_test() {}
 
     /// Manually tick a test tweenable targeting a component.
-    fn manual_tick_component<T: Component<Mutability = Mutable>>(
+    fn manual_tick_component(
+        tween_id: TweenId,
         duration: Duration,
         tween: &mut dyn Tweenable,
         world: &mut World,
@@ -1342,7 +1252,7 @@ mod tests {
         // Tick the given tween and apply its state to the given entity target
         let state =
             world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
-                let entity_mut = &mut world.get_many_entities_mut([entity]).unwrap()[0];
+                let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
                 let (_, state) = tween.tick(tween_id, duration, entity_mut.reborrow(), events);
                 state
             });
@@ -2025,7 +1935,7 @@ mod tests {
         }
 
         // Dummy world and event writer
-        let (mut world, entity) = make_test_env();
+        let (mut world, entity, _system_id) = make_test_env();
 
         for i in 1..=6 {
             let state = manual_tick_component(

From 263c981231d50551a2ba9255c436bfb9fa48b6d1 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 28 Jun 2025 12:16:22 +0100
Subject: [PATCH 09/66] Rework animation clock

---
 CHANGELOG.md                      |    2 +
 Cargo.toml                        |    2 +-
 examples/colormaterial_color.rs   |  205 ++---
 examples/menu.rs                  |    3 +-
 examples/sequence.rs              |    3 +-
 examples/transform_rotation.rs    |    1 -
 examples/transform_translation.rs |    1 -
 examples/ui_position.rs           |    1 -
 src/lens.rs                       |   16 +-
 src/lib.rs                        |   15 +-
 src/plugin.rs                     |   14 +-
 src/test_utils.rs                 |   67 +-
 src/tweenable.rs                  | 1314 ++++++++++++++++-------------
 13 files changed, 910 insertions(+), 734 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a5fa151..06ec7c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.0] - 2025-04-28
+
 ### Changed
 
 - Compatible with Bevy 0.16
diff --git a/Cargo.toml b/Cargo.toml
index 1ea2653..cea1f5e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_tweening"
-version = "0.13.0"
+version = "0.14.0-dev"
 authors = [
     "François Mockers <mockersf@gmail.com>",
     "Jerome Humbert <djeedai@gmail.com>",
diff --git a/examples/colormaterial_color.rs b/examples/colormaterial_color.rs
index d90df47..8b6e54e 100644
--- a/examples/colormaterial_color.rs
+++ b/examples/colormaterial_color.rs
@@ -1,102 +1,103 @@
-use bevy::{color::palettes::css::*, prelude::*};
-use bevy_tweening::{lens::*, *};
-use std::time::Duration;
-
-mod utils;
-
-fn main() {
-    App::default()
-        .add_plugins(DefaultPlugins.set(WindowPlugin {
-            primary_window: Some(Window {
-                title: "ColorMaterialColorLens".to_string(),
-                resolution: (1200., 600.).into(),
-                present_mode: bevy::window::PresentMode::Fifo, // vsync
-                ..default()
-            }),
-            ..default()
-        }))
-        .add_systems(Update, utils::close_on_esc)
-        .add_plugins(TweeningPlugin)
-        .add_systems(Startup, setup)
-        .run();
-}
-
-fn setup(
-    mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-) {
-    commands.spawn(Camera2d::default());
-
-    let size = 80.;
-
-    let spacing = 1.25;
-    let screen_x = 450.;
-    let screen_y = 120.;
-    let mut x = -screen_x;
-    let mut y = screen_y;
-
-    let quad_mesh = meshes.add(Rectangle::new(1., 1.));
-
-    for ease_function in &[
-        EaseFunction::QuadraticIn,
-        EaseFunction::QuadraticOut,
-        EaseFunction::QuadraticInOut,
-        EaseFunction::CubicIn,
-        EaseFunction::CubicOut,
-        EaseFunction::CubicInOut,
-        EaseFunction::QuarticIn,
-        EaseFunction::QuarticOut,
-        EaseFunction::QuarticInOut,
-        EaseFunction::QuinticIn,
-        EaseFunction::QuinticOut,
-        EaseFunction::QuinticInOut,
-        EaseFunction::SineIn,
-        EaseFunction::SineOut,
-        EaseFunction::SineInOut,
-        EaseFunction::CircularIn,
-        EaseFunction::CircularOut,
-        EaseFunction::CircularInOut,
-        EaseFunction::ExponentialIn,
-        EaseFunction::ExponentialOut,
-        EaseFunction::ExponentialInOut,
-        EaseFunction::ElasticIn,
-        EaseFunction::ElasticOut,
-        EaseFunction::ElasticInOut,
-        EaseFunction::BackIn,
-        EaseFunction::BackOut,
-        EaseFunction::BackInOut,
-        EaseFunction::BounceIn,
-        EaseFunction::BounceOut,
-        EaseFunction::BounceInOut,
-    ] {
-        // Create a unique material per entity, so that it can be animated
-        // without affecting the other entities. Note that we could share
-        // that material among multiple entities, and animating the material
-        // asset would change the color of all entities using that material.
-        let unique_material = materials.add(Color::BLACK);
-
-        let tween = Tween::new_asset(
-            *ease_function,
-            Duration::from_secs(1),
-            ColorMaterialColorLens {
-                start: RED.into(),
-                end: BLUE.into(),
-            },
-        )
-        .with_repeat_count(RepeatCount::Infinite)
-        .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
-
-        commands.spawn((
-            Mesh2d(quad_mesh.clone()),
-            MeshMaterial2d(unique_material),
-            Transform::from_translation(Vec3::new(x, y, 0.)).with_scale(Vec3::splat(size)),
-            AssetAnimator::new(tween),
-        ));
-        y -= size * spacing;
-        if y < -screen_y {
-            x += size * spacing;
-            y = screen_y;
-        }
-    }
-}
+use std::time::Duration;
+
+use bevy::{color::palettes::css::*, prelude::*};
+use bevy_tweening::{lens::*, *};
+
+mod utils;
+
+fn main() {
+    App::default()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "ColorMaterialColorLens".to_string(),
+                resolution: (1200., 600.).into(),
+                present_mode: bevy::window::PresentMode::Fifo, // vsync
+                ..default()
+            }),
+            ..default()
+        }))
+        .add_systems(Update, utils::close_on_esc)
+        .add_plugins(TweeningPlugin)
+        .add_systems(Startup, setup)
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    commands.spawn(Camera2d::default());
+
+    let size = 80.;
+
+    let spacing = 1.25;
+    let screen_x = 450.;
+    let screen_y = 120.;
+    let mut x = -screen_x;
+    let mut y = screen_y;
+
+    let quad_mesh = meshes.add(Rectangle::new(1., 1.));
+
+    for ease_function in &[
+        EaseFunction::QuadraticIn,
+        EaseFunction::QuadraticOut,
+        EaseFunction::QuadraticInOut,
+        EaseFunction::CubicIn,
+        EaseFunction::CubicOut,
+        EaseFunction::CubicInOut,
+        EaseFunction::QuarticIn,
+        EaseFunction::QuarticOut,
+        EaseFunction::QuarticInOut,
+        EaseFunction::QuinticIn,
+        EaseFunction::QuinticOut,
+        EaseFunction::QuinticInOut,
+        EaseFunction::SineIn,
+        EaseFunction::SineOut,
+        EaseFunction::SineInOut,
+        EaseFunction::CircularIn,
+        EaseFunction::CircularOut,
+        EaseFunction::CircularInOut,
+        EaseFunction::ExponentialIn,
+        EaseFunction::ExponentialOut,
+        EaseFunction::ExponentialInOut,
+        EaseFunction::ElasticIn,
+        EaseFunction::ElasticOut,
+        EaseFunction::ElasticInOut,
+        EaseFunction::BackIn,
+        EaseFunction::BackOut,
+        EaseFunction::BackInOut,
+        EaseFunction::BounceIn,
+        EaseFunction::BounceOut,
+        EaseFunction::BounceInOut,
+    ] {
+        // Create a unique material per entity, so that it can be animated
+        // without affecting the other entities. Note that we could share
+        // that material among multiple entities, and animating the material
+        // asset would change the color of all entities using that material.
+        let unique_material = materials.add(Color::BLACK);
+
+        let tween = Tween::new_asset(
+            *ease_function,
+            Duration::from_secs(1),
+            ColorMaterialColorLens {
+                start: RED.into(),
+                end: BLUE.into(),
+            },
+        )
+        .with_repeat_count(RepeatCount::Infinite)
+        .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
+
+        commands.spawn((
+            Mesh2d(quad_mesh.clone()),
+            MeshMaterial2d(unique_material),
+            Transform::from_translation(Vec3::new(x, y, 0.)).with_scale(Vec3::splat(size)),
+            AssetAnimator::new(tween),
+        ));
+        y -= size * spacing;
+        if y < -screen_y {
+            x += size * spacing;
+            y = screen_y;
+        }
+    }
+}
diff --git a/examples/menu.rs b/examples/menu.rs
index 32af29d..4537d82 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -1,7 +1,8 @@
+use std::time::Duration;
+
 use bevy::{color::palettes::css::*, prelude::*};
 use bevy_inspector_egui::{bevy_egui::EguiPlugin, quick::WorldInspectorPlugin};
 use bevy_tweening::{lens::*, *};
-use std::time::Duration;
 
 mod utils;
 
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 1cb7d5a..bf6342b 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -1,6 +1,7 @@
+use std::time::Duration;
+
 use bevy::{color::palettes::css::*, prelude::*};
 use bevy_tweening::{lens::*, *};
-use std::time::Duration;
 
 mod utils;
 
diff --git a/examples/transform_rotation.rs b/examples/transform_rotation.rs
index 3986c31..6b3565c 100644
--- a/examples/transform_rotation.rs
+++ b/examples/transform_rotation.rs
@@ -1,6 +1,5 @@
 use bevy::{color::palettes::css::*, prelude::*};
 use bevy_inspector_egui::{bevy_egui::EguiPlugin, prelude::*, quick::ResourceInspectorPlugin};
-
 use bevy_tweening::{lens::*, *};
 
 mod utils;
diff --git a/examples/transform_translation.rs b/examples/transform_translation.rs
index 71f73a6..1052fa8 100644
--- a/examples/transform_translation.rs
+++ b/examples/transform_translation.rs
@@ -1,6 +1,5 @@
 use bevy::{color::palettes::css::*, prelude::*};
 use bevy_inspector_egui::{bevy_egui::EguiPlugin, prelude::*, quick::ResourceInspectorPlugin};
-
 use bevy_tweening::{lens::*, *};
 
 mod utils;
diff --git a/examples/ui_position.rs b/examples/ui_position.rs
index 5813780..23bc747 100644
--- a/examples/ui_position.rs
+++ b/examples/ui_position.rs
@@ -1,6 +1,5 @@
 use bevy::{color::palettes::css::*, prelude::*};
 use bevy_inspector_egui::{bevy_egui::EguiPlugin, prelude::*, quick::ResourceInspectorPlugin};
-
 use bevy_tweening::{lens::*, *};
 
 mod utils;
diff --git a/src/lens.rs b/src/lens.rs
index 5204384..5c9afde 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -54,17 +54,17 @@ use crate::Targetable;
 /// # use bevy::prelude::*;
 /// # use bevy_tweening::*;
 /// struct MyLens {
-///   start: f32,
-///   end: f32,
+///     start: f32,
+///     end: f32,
 /// }
 ///
 /// #[derive(Component)]
 /// struct MyStruct(f32);
 ///
 /// impl Lens<MyStruct> for MyLens {
-///   fn lerp(&mut self, target: &mut dyn Targetable<MyStruct>, ratio: f32) {
-///     target.0 = self.start + (self.end - self.start) * ratio;
-///   }
+///     fn lerp(&mut self, target: &mut dyn Targetable<MyStruct>, ratio: f32) {
+///         target.0 = self.start + (self.end - self.start) * ratio;
+///     }
 /// }
 /// ```
 pub trait Lens<T> {
@@ -376,18 +376,16 @@ impl Lens<Sprite> for SpriteColorLens {
 
 #[cfg(test)]
 mod tests {
-    use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
     use std::f32::consts::TAU;
 
     #[cfg(any(feature = "bevy_sprite", feature = "bevy_text"))]
     use bevy::color::palettes::css::{BLUE, RED};
+    use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
 
     use super::*;
-
-    use crate::tweenable::ComponentTarget;
-
     #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
     use crate::tweenable::AssetTarget;
+    use crate::tweenable::ComponentTarget;
 
     #[cfg(feature = "bevy_text")]
     #[test]
diff --git a/src/lib.rs b/src/lib.rs
index f7ef0cf..434d1f0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -106,9 +106,10 @@
 //! # use bevy_tweening::*;
 //! # let mut app = App::default();
 //! # #[derive(Component)] struct C;
-//! app.add_systems(Update,
-//!     component_animator_system::<C>
-//!         .in_set(AnimationSystem::AnimationUpdate));
+//! app.add_systems(
+//!     Update,
+//!     component_animator_system::<C>.in_set(AnimationSystem::AnimationUpdate),
+//! );
 //! ```
 //!
 //! Similarly for an asset `A`, use the `asset_animator_system`. This is only
@@ -207,14 +208,13 @@
 use std::time::Duration;
 
 use bevy::prelude::*;
-
 pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
 use slotmap::{new_key_type, SlotMap};
 #[cfg(feature = "bevy_asset")]
 pub use tweenable::AssetTarget;
 pub use tweenable::{
-    BoxedTweenable, ComponentTarget, Delay, Sequence, Targetable, TotalDuration, Tracks, Tween,
+    BoxedTweenable, ComponentTarget, Delay, Sequence, Targetable, TotalDuration, Tween,
     TweenAssetExtensions, TweenCompleted, TweenState, Tweenable,
 };
 
@@ -636,9 +636,9 @@ impl TweenAnimator {
             let ent_mut = &mut world.get_entity_mut([anim.target]).unwrap()[0];
 
             // Apply the animation tweenable
-            let (_progress, state) =
+            let state =
                 anim.tweenable
-                    .tick(tween_id, delta_time, ent_mut.reborrow(), events.reborrow());
+                    .step(tween_id, delta_time, ent_mut.reborrow(), events.reborrow());
 
             // Raise completed event
             if state == TweenState::Completed {
@@ -718,7 +718,6 @@ mod tests {
     use slotmap::Key as _;
 
     use self::tweenable::ComponentTarget;
-
     use super::*;
     use crate::test_utils::*;
 
diff --git a/src/plugin.rs b/src/plugin.rs
index 941dafc..7b59f9b 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -209,7 +209,7 @@ mod tests {
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.state, PlaybackState::Playing);
-        assert_eq!(anim.tweenable.times_completed(), 0);
+        assert_eq!(anim.tweenable.cycles_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
@@ -220,7 +220,7 @@ mod tests {
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.state, PlaybackState::Playing);
-        assert_eq!(anim.tweenable.times_completed(), 0);
+        assert_eq!(anim.tweenable.cycles_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.5), 1e-5));
@@ -297,7 +297,7 @@ mod tests {
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.state, PlaybackState::Playing);
-        assert_eq!(anim.tweenable.times_completed(), 0);
+        assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!(((*component).value - 0.).abs() <= 1e-5);
@@ -308,7 +308,7 @@ mod tests {
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.state, PlaybackState::Playing);
-        assert_eq!(anim.tweenable.times_completed(), 0);
+        assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!(((*component).value - 0.).abs() <= 1e-5);
@@ -319,7 +319,7 @@ mod tests {
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.state, PlaybackState::Playing);
-        assert_eq!(anim.tweenable.times_completed(), 0);
+        assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!(((*component).value - 0.).abs() <= 1e-5);
@@ -335,7 +335,7 @@ mod tests {
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.state, PlaybackState::Playing);
-        assert_eq!(anim.tweenable.times_completed(), 0);
+        assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(component.is_changed());
         assert!(((*component).value - 0.2).abs() <= 1e-5);
@@ -349,7 +349,7 @@ mod tests {
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.state, PlaybackState::Playing);
-        assert_eq!(anim.tweenable.times_completed(), 0);
+        assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(component.is_changed());
         assert!(((*component).value - 0.7).abs() <= 1e-5);
diff --git a/src/test_utils.rs b/src/test_utils.rs
index f525fd3..7df33d7 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -1,6 +1,53 @@
-/// Utility to compare floating-point values with a tolerance.
-pub(crate) fn abs_diff_eq(a: f32, b: f32, tol: f32) -> bool {
-    (a - b).abs() < tol
+use bevy::{
+    math::{Quat, Vec3, Vec4},
+    transform::components::Transform,
+};
+
+pub(crate) trait AbsDiffEq: std::fmt::Debug {
+    fn abs_diff_eq(a: Self, b: Self, tol: f32) -> bool;
+    fn delta(a: Self, b: Self) -> Self;
+}
+
+impl AbsDiffEq for f32 {
+    fn abs_diff_eq(a: Self, b: Self, tol: f32) -> bool {
+        (a - b).abs() < tol
+    }
+    fn delta(a: Self, b: Self) -> Self {
+        (a - b).abs()
+    }
+}
+
+impl AbsDiffEq for Vec3 {
+    fn abs_diff_eq(a: Self, b: Self, tol: f32) -> bool {
+        Vec3::abs_diff_eq(a, b, tol)
+    }
+    fn delta(a: Self, b: Self) -> Self {
+        (a - b).abs()
+    }
+}
+
+impl AbsDiffEq for Quat {
+    fn abs_diff_eq(a: Self, b: Self, tol: f32) -> bool {
+        Quat::abs_diff_eq(a, b, tol)
+    }
+    fn delta(a: Self, b: Self) -> Self {
+        Quat::from_vec4((Vec4::from(a) - Vec4::from(b)).abs())
+    }
+}
+
+impl AbsDiffEq for Transform {
+    fn abs_diff_eq(a: Self, b: Self, tol: f32) -> bool {
+        a.translation.abs_diff_eq(b.translation, tol)
+            && a.rotation.abs_diff_eq(b.rotation, tol)
+            && a.scale.abs_diff_eq(b.scale, tol)
+    }
+    fn delta(a: Self, b: Self) -> Self {
+        Transform {
+            translation: AbsDiffEq::delta(a.translation, b.translation),
+            rotation: AbsDiffEq::delta(a.rotation, b.rotation),
+            scale: AbsDiffEq::delta(a.scale, b.scale),
+        }
+    }
 }
 
 /// Assert that two floating-point quantities are approximately equal.
@@ -13,7 +60,7 @@ pub(crate) fn abs_diff_eq(a: f32, b: f32, tol: f32) -> bool {
 ///
 /// ```
 /// let x = 3.500009;
-/// assert_approx_eq!(x, 3.5);       // default tolerance 1e-5
+/// assert_approx_eq!(x, 3.5); // default tolerance 1e-5
 ///
 /// let x = 3.509;
 /// assert_approx_eq!(x, 3.5, 0.01); // explicit tolerance
@@ -23,11 +70,11 @@ macro_rules! assert_approx_eq {
         match (&$left, &$right) {
             (left_val, right_val) => {
                 assert!(
-                    abs_diff_eq(*left_val, *right_val, 1e-5),
-                    "assertion failed: expected={} actual={} delta={} tol=1e-5(default)",
+                    crate::test_utils::AbsDiffEq::abs_diff_eq(*left_val, *right_val, 1e-5),
+                    "assertion failed: expected={:?} actual={:?} delta={:?} tol=1e-5(default)",
                     left_val,
                     right_val,
-                    (left_val - right_val).abs(),
+                    crate::test_utils::AbsDiffEq::delta(*left_val, *right_val),
                 );
             }
         }
@@ -36,11 +83,11 @@ macro_rules! assert_approx_eq {
         match (&$left, &$right, &$tol) {
             (left_val, right_val, tol_val) => {
                 assert!(
-                    abs_diff_eq(*left_val, *right_val, *tol_val),
-                    "assertion failed: expected={} actual={} delta={} tol={}",
+                    crate::test_utils::AbsDiffEq::abs_diff_eq(*left_val, *right_val, *tol_val),
+                    "assertion failed: expected={:?} actual={:?} delta={:?} tol={}",
                     left_val,
                     right_val,
-                    (left_val - right_val).abs(),
+                    crate::test_utils::AbsDiffEq::delta(*left_val, *right_val),
                     tol_val
                 );
             }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index acf5043..0c65d1e 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1,4 +1,5 @@
 use std::{
+    cmp::Ordering,
     ops::{Deref, DerefMut},
     time::Duration,
 };
@@ -36,7 +37,7 @@ use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweenId, TweeningDire
 /// #
 /// # struct MyTweenable;
 /// # impl Tweenable for MyTweenable {
-/// #     fn duration(&self) -> Duration  { unimplemented!() }
+/// #     fn cycle_duration(&self) -> Duration  { unimplemented!() }
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
@@ -116,39 +117,55 @@ fn fraction_progress(n: Duration, d: Duration) -> f32 {
 #[derive(Debug)]
 struct AnimClock {
     elapsed: Duration,
-    duration: Duration,
+    cycle_duration: Duration,
     total_duration: TotalDuration,
     strategy: RepeatStrategy,
 }
 
 impl AnimClock {
-    fn new(duration: Duration) -> Self {
+    fn new(cycle_duration: Duration) -> Self {
         Self {
             elapsed: Duration::ZERO,
-            duration,
-            total_duration: compute_total_duration(duration, RepeatCount::default()),
+            cycle_duration,
+            total_duration: TotalDuration::from_cycles(cycle_duration, RepeatCount::default()),
             strategy: RepeatStrategy::default(),
         }
     }
 
     fn tick(&mut self, tick: Duration) -> (TweenState, i32) {
-        self.set_elapsed(self.elapsed.saturating_add(tick))
+        self.set_elapsed(
+            self.elapsed.saturating_add(tick),
+            TweeningDirection::Forward,
+        )
+    }
+
+    fn tick_back(&mut self, tick: Duration) -> (TweenState, i32) {
+        self.set_elapsed(
+            self.elapsed.saturating_sub(tick),
+            TweeningDirection::Backward,
+        )
     }
 
     fn times_completed(&self) -> u32 {
-        (self.elapsed.as_nanos() / self.duration.as_nanos()) as u32
+        self.elapsed.div_duration_f64(self.cycle_duration) as u32
     }
 
-    fn set_elapsed(&mut self, elapsed: Duration) -> (TweenState, i32) {
+    fn set_elapsed(
+        &mut self,
+        elapsed: Duration,
+        direction: TweeningDirection,
+    ) -> (TweenState, i32) {
         let old_times_completed = self.times_completed();
 
         self.elapsed = elapsed;
 
         let state = match self.total_duration {
             TotalDuration::Finite(total_duration) => {
-                if self.elapsed >= total_duration {
+                if direction.is_forward() && self.elapsed >= total_duration {
                     self.elapsed = total_duration;
                     TweenState::Completed
+                } else if direction.is_backward() && self.elapsed == Duration::ZERO {
+                    TweenState::Completed
                 } else {
                     TweenState::Active
                 }
@@ -166,10 +183,12 @@ impl AnimClock {
         self.elapsed
     }
 
-    fn state(&self) -> TweenState {
+    fn state(&self, playback_direction: TweeningDirection) -> TweenState {
         match self.total_duration {
             TotalDuration::Finite(total_duration) => {
-                if self.elapsed >= total_duration {
+                if playback_direction.is_forward() && self.elapsed >= total_duration {
+                    TweenState::Completed
+                } else if playback_direction.is_backward() && self.elapsed == Duration::ZERO {
                     TweenState::Completed
                 } else {
                     TweenState::Active
@@ -179,8 +198,11 @@ impl AnimClock {
         }
     }
 
-    fn reset(&mut self) {
-        self.elapsed = Duration::ZERO;
+    fn rewind(&mut self, direction: TweeningDirection) {
+        self.elapsed = match direction {
+            TweeningDirection::Forward => Duration::ZERO,
+            TweeningDirection::Backward => self.total_duration.as_finite().unwrap(),
+        };
     }
 }
 
@@ -195,11 +217,78 @@ pub enum TotalDuration {
     Infinite,
 }
 
-fn compute_total_duration(duration: Duration, count: RepeatCount) -> TotalDuration {
-    match count {
-        RepeatCount::Finite(times) => TotalDuration::Finite(duration.saturating_mul(times)),
-        RepeatCount::For(duration) => TotalDuration::Finite(duration),
-        RepeatCount::Infinite => TotalDuration::Infinite,
+impl TotalDuration {
+    /// Create a [`TotalDuration`] from single cycle duration and a
+    /// [`RepeatCount`].
+    pub fn from_cycles(cycle_duration: Duration, repeat_count: RepeatCount) -> Self {
+        match repeat_count {
+            RepeatCount::Finite(times) => {
+                TotalDuration::Finite(cycle_duration.saturating_mul(times))
+            }
+            RepeatCount::For(duration) => TotalDuration::Finite(duration),
+            RepeatCount::Infinite => TotalDuration::Infinite,
+        }
+    }
+
+    /// Return `true` if this is a [`TotalDuration::Finite`].
+    pub fn is_finite(&self) -> bool {
+        matches!(self, TotalDuration::Finite(_))
+    }
+
+    /// Return this duration as a [`Duration`] if it's finite.
+    pub fn as_finite(&self) -> Option<Duration> {
+        match self {
+            Self::Finite(duration) => Some(*duration),
+            Self::Infinite => None,
+        }
+    }
+}
+
+impl From<Duration> for TotalDuration {
+    fn from(value: Duration) -> Self {
+        TotalDuration::Finite(value)
+    }
+}
+
+impl std::ops::Add for TotalDuration {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (TotalDuration::Finite(d0), TotalDuration::Finite(d1)) => {
+                TotalDuration::Finite(d0 + d1)
+            }
+            _ => TotalDuration::Infinite,
+        }
+    }
+}
+
+impl std::iter::Sum for TotalDuration {
+    fn sum<I: Iterator<Item = Self>>(mut iter: I) -> Self {
+        let Some(mut acc) = iter.next() else {
+            return TotalDuration::Finite(Duration::ZERO);
+        };
+        while let Some(td) = iter.next() {
+            acc = acc + td;
+        }
+        acc
+    }
+}
+
+impl PartialOrd for TotalDuration {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for TotalDuration {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (TotalDuration::Finite(d0), TotalDuration::Finite(d1)) => d0.cmp(d1),
+            (TotalDuration::Finite(_), TotalDuration::Infinite) => Ordering::Less,
+            (TotalDuration::Infinite, TotalDuration::Finite(_)) => Ordering::Greater,
+            (TotalDuration::Infinite, TotalDuration::Infinite) => Ordering::Equal,
+        }
     }
 }
 
@@ -301,67 +390,64 @@ impl<T: Asset> Targetable<T> for AssetTarget<'_, T> {
 
 /// An animatable entity, either a single [`Tween`] or a collection of them.
 pub trait Tweenable: Send + Sync {
-    /// Get the duration of a single iteration of the animation.
+    /// Get the duration of a single cycle of the animation.
     ///
     /// Note that for [`RepeatStrategy::MirroredRepeat`], this is the duration
     /// of a single way, either from start to end or back from end to start.
     /// The total "loop" duration start -> end -> start to reach back the
-    /// same state in this case is the double of the returned value.
-    fn duration(&self) -> Duration;
+    /// same state in this case is the double of the cycle duration.
+    fn cycle_duration(&self) -> Duration;
 
-    /// Get the total duration of the entire animation, including looping.
+    /// Get the total duration of the entire animation, including repeating.
     ///
     /// For [`TotalDuration::Finite`], this is the number of repeats times the
-    /// duration of a single iteration ([`duration()`]).
+    /// duration of a single cycle ([`cycle_duration()`]).
     ///
-    /// [`duration()`]: Tweenable::duration
+    /// [`cycle_duration()`]: Tweenable::cycle_duration
     fn total_duration(&self) -> TotalDuration;
 
     /// Set the current animation playback elapsed time.
     ///
-    /// See [`elapsed()`] for details on the meaning. If `elapsed` is greater
-    /// than or equal to [`duration()`], then the animation completes.
+    /// See [`elapsed()`] for details on the meaning. For finite durations, if
+    /// `elapsed` is greater than or equal to [`total_duration()`], then the
+    /// animation completes. Animations with infinite duration never complete.
     ///
     /// Setting the elapsed time seeks the animation to a new position, but does
-    /// not apply that change to the underlying component being animated. To
+    /// not apply that change to the underlying component being animated yet. To
     /// force the change to apply, call [`tick()`] with a `delta` of
     /// `Duration::ZERO`.
     ///
     /// [`elapsed()`]: Tweenable::elapsed
-    /// [`duration()`]: Tweenable::duration
+    /// [`total_duration()`]: Tweenable::total_duration
     /// [`tick()`]: Tweenable::tick
     fn set_elapsed(&mut self, elapsed: Duration);
 
     /// Get the current elapsed duration.
     ///
-    /// While looping, the exact value returned by [`duration()`] is never
-    /// reached, since the tweenable loops over to zero immediately when it
-    /// changes direction at either endpoint. Upon completion, the tweenable
-    /// always reports the same value as [`duration()`].
+    /// If the animation repeats (has more than one cycle), the value can be
+    /// greater than one [`cycle_duration()`].
     ///
-    /// [`duration()`]: Tweenable::duration
+    /// [`cycle_duration()`]: Tweenable::cycle_duration
     fn elapsed(&self) -> Duration;
 
-    /// Tick the tweenable.
+    /// Step the tweenable.
     ///
     /// Advance the internal clock of the animation by the specified amount of
-    /// time. This doesn't apply the new state to the tweenable target; use
-    /// [`apply_state()`] after this call to ensure the state of the animation
-    /// target reflects the current animation progress.
+    /// time. If the animation is currently playing backward
+    /// ([`TweeningDirection::Backward`]), the clock moves backward and the
+    /// `delta` duration is subtracted from the [`elapsed()`] time instead of
+    /// being added to it.
     ///
     /// # Returns
     ///
-    /// Returns the new progress factor in `0..=1`, and the state of the
-    /// tweenable.
-    ///
-    /// [`apply_state()`]: Tweenable::apply_state
-    fn tick(
+    /// Returns the state of the tweenable after the step.
+    fn step(
         &mut self,
         tween_id: TweenId,
         delta: Duration,
         ent_mut: EntityMut,
         events: Mut<Events<TweenCompleted>>,
-    ) -> (f32, TweenState);
+    ) -> TweenState;
 
     /// Rewind the animation to its starting state.
     ///
@@ -370,59 +456,15 @@ pub trait Tweenable: Send + Sync {
     /// whereas for [`TweeningDirection::Backward`] this is the end one.
     fn rewind(&mut self);
 
-    /// Set the current animation playback progress.
-    ///
-    /// See [`progress()`] for details on the exact meaning of "progress".
-    ///
-    /// Similar to [`tick()`], setting the progress seeks the animation to a new
-    /// position, but does not apply that change to the underlying component
-    /// being animated. To apply the change to the animation target (component
-    /// or asset), call [`apply_state()`].
-    ///
-    /// This is a shortcut to [`set_elapsed()`]. In general, prefer
-    /// [`set_elapsed()`] if you can, to avoid rounding errors due to the use of
-    /// floating points.
-    ///
-    /// [`progress()`]: Tweenable::progress
-    /// [`tick()`]: Tweenable::tick
-    /// [`apply_state()`]: Tweenable::apply_state
-    /// [`set_elapsed()`]: Tweenable::set_elapsed
-    fn set_progress(&mut self, progress: f32) {
-        self.set_elapsed(self.duration().mul_f32(progress.max(0.)));
-    }
-
-    /// Get the current progress in `0..=1` of the animation.
-    ///
-    /// In general, this is equal to the fractional part of the ratio of
-    /// [`elapsed()`] over [`duration()`].
-    ///
-    /// For looping animations (repeat count > 1), the exact value `1.` is never
-    /// reached while active, since the tweenable immediately loops over to `0.`
-    /// to start a new loop when it reaches the end of the current loop.
-    ///
-    /// Upon completion ([`TweenState::Completed`]), this returns exactly `1.`.
-    ///
-    /// [`elapsed()`]: Tweenable::elapsed
-    /// [`duration()`]: Tweenable::duration
-    fn progress(&self) -> f32 {
-        let elapsed = self.elapsed();
-        if let TotalDuration::Finite(total_duration) = self.total_duration() {
-            if elapsed >= total_duration {
-                return 1.;
-            }
-        }
-        fraction_progress(elapsed, self.duration())
-    }
-
-    /// Get the number of times this tweenable completed.
+    /// Get the number of cycles completed.
     ///
-    /// For looping animations, this returns the number of times a single
-    /// playback was completed. In the case of
+    /// For repeating animations, this returns the number of times a single
+    /// playback cycle was completed. In the case of
     /// [`RepeatStrategy::MirroredRepeat`] this corresponds to a playback in
     /// a single direction, so tweening from start to end and back to start
-    /// counts as two completed times (one forward, one backward).
-    fn times_completed(&self) -> u32 {
-        (self.elapsed().as_nanos() / self.duration().as_nanos()) as u32
+    /// counts as two completed cycles (one forward, one backward).
+    fn cycles_completed(&self) -> u32 {
+        self.elapsed().div_duration_f32(self.cycle_duration()) as u32
     }
 }
 
@@ -438,7 +480,7 @@ macro_rules! impl_boxed {
 
 impl_boxed!(Tween);
 impl_boxed!(Sequence);
-impl_boxed!(Tracks);
+//impl_boxed!(Tracks);
 impl_boxed!(Delay);
 
 type ComponentAction = dyn FnMut(EntityMut, f32) + Send + Sync + 'static;
@@ -463,7 +505,11 @@ enum TweenAction {
 pub struct Tween {
     ease_function: EaseMethod,
     clock: AnimClock,
-    direction: TweeningDirection,
+    /// Direction of playback the user asked for.
+    playback_direction: TweeningDirection,
+    /// Direction the playback moves in the current cycle. This may be different
+    /// from the playback direction when using MirroredRepeat.
+    cycle_direction: TweeningDirection,
     action: TweenAction,
     system_id: Option<SystemId>,
     send_completed_event: bool,
@@ -533,7 +579,8 @@ impl Tween {
         Self {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
-            direction: TweeningDirection::Forward,
+            playback_direction: TweeningDirection::Forward,
+            cycle_direction: TweeningDirection::Forward,
             action: TweenAction::Component(Box::new(action)),
             system_id: None,
             send_completed_event: false,
@@ -567,11 +614,12 @@ impl Tween {
     /// .with_completed_event(true);
     ///
     /// fn my_system(mut reader: EventReader<TweenCompleted>) {
-    ///   for ev in reader.read() {
-    ///     println!(
-    ///       "Tween animation {:?} raised TweenCompleted for target entity {:?}!",
-    ///       ev.id, ev.entity);
-    ///   }
+    ///     for ev in reader.read() {
+    ///         println!(
+    ///             "Tween animation {:?} raised TweenCompleted for target entity {:?}!",
+    ///             ev.id, ev.entity
+    ///         );
+    ///     }
     /// }
     /// ```
     #[must_use]
@@ -581,7 +629,7 @@ impl Tween {
     }
 
     ///
-    pub fn send_completed_event(&mut self, send: bool) {
+    pub fn set_completed_event(&mut self, send: bool) {
         self.send_completed_event = send;
     }
 
@@ -637,42 +685,61 @@ impl Tween {
 
     /// 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.
+    /// The playback direction controls whether the internal animation clock,
+    /// and therefore the elapsed time, move forward or backward.
     ///
-    /// 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 set_direction(&mut self, direction: TweeningDirection) {
-        self.direction = direction;
+    /// Changing the direction doesn't change any target state, nor the elapsed
+    /// time of the tween. Only the direction of playback from this moment
+    /// potentially changes.
+    pub fn set_playback_direction(&mut self, direction: TweeningDirection) {
+        if self.playback_direction != direction {
+            self.playback_direction = direction;
+            // Reverse the current cycle too for consistency
+            self.cycle_direction = !self.cycle_direction;
+        }
     }
 
     /// Set the playback direction of the tween.
     ///
-    /// See [`Tween::set_direction()`].
+    /// See [`Tween::set_playback_direction()`].
     #[must_use]
-    pub fn with_direction(mut self, direction: TweeningDirection) -> Self {
-        self.direction = direction;
+    pub fn with_playback_direction(mut self, direction: TweeningDirection) -> Self {
+        self.playback_direction = direction;
+        self.cycle_direction = direction;
         self
     }
 
-    /// The current animation direction.
+    /// The current animation playback direction.
+    ///
+    /// This is the value set by the user with [`with_playback_direction()`] and
+    /// [`set_playback_direction()`]. This is never changed by the playback.
+    ///
+    /// See [`TweeningDirection`] for details.
+    ///
+    /// [`with_playback_direction()`]: Self::with_playback_direction
+    /// [`set_playback_direction()`]: Self::set_playback_direction
+    #[must_use]
+    pub fn playback_direction(&self) -> TweeningDirection {
+        self.playback_direction
+    }
+
+    /// The direction of the current playback cycle.
+    ///
+    /// Unlike [`playback_direction()`], which is controlled by the user, this
+    /// simply gives the direction of the current cycle. It depends on the
+    /// current elapsed time and the playback direction requested by the user.
     ///
     /// See [`TweeningDirection`] for details.
     #[must_use]
-    pub fn direction(&self) -> TweeningDirection {
-        self.direction
+    pub fn cycle_direction(&self) -> TweeningDirection {
+        self.cycle_direction
     }
 
     /// Set the number of times to repeat the animation.
     #[must_use]
     pub fn with_repeat_count(mut self, count: impl Into<RepeatCount>) -> Self {
-        self.clock.total_duration = compute_total_duration(self.clock.duration, count.into());
+        self.clock.total_duration =
+            TotalDuration::from_cycles(self.clock.cycle_duration, count.into());
         self
     }
 
@@ -701,7 +768,8 @@ impl TweenAssetExtensions for Tween {
         Self {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
-            direction: TweeningDirection::Forward,
+            playback_direction: TweeningDirection::Forward,
+            cycle_direction: TweeningDirection::Forward,
             action: TweenAction::Asset(Box::new(action)),
             system_id: None,
             send_completed_event: false,
@@ -710,8 +778,8 @@ impl TweenAssetExtensions for Tween {
 }
 
 impl Tweenable for Tween {
-    fn duration(&self) -> Duration {
-        self.clock.duration
+    fn cycle_duration(&self) -> Duration {
+        self.clock.cycle_duration
     }
 
     fn total_duration(&self) -> TotalDuration {
@@ -719,48 +787,75 @@ impl Tweenable for Tween {
     }
 
     fn set_elapsed(&mut self, elapsed: Duration) {
-        self.clock.set_elapsed(elapsed);
+        self.clock.set_elapsed(elapsed, self.playback_direction);
     }
 
     fn elapsed(&self) -> Duration {
         self.clock.elapsed()
     }
 
-    fn tick(
+    fn step(
         &mut self,
         tween_id: TweenId,
         delta: Duration,
         ent_mut: EntityMut,
         mut events: Mut<Events<TweenCompleted>>,
-    ) -> (f32, TweenState) {
-        if self.clock.state() == TweenState::Completed {
-            return (1., TweenState::Completed);
+    ) -> TweenState {
+        if self.clock.state(self.playback_direction) == TweenState::Completed {
+            return TweenState::Completed;
         }
 
         // Advance the animation clock
-        let (state, times_completed) = self.clock.tick(delta);
-        let (progress, times_completed_for_direction) = match state {
-            TweenState::Active => (self.progress(), times_completed),
-            TweenState::Completed => (1., times_completed.max(1) - 1), // ignore last
+        let (state, times_completed) = if self.playback_direction.is_forward() {
+            self.clock.tick(delta)
+        } else {
+            self.clock.tick_back(delta)
         };
-        if self.clock.strategy == RepeatStrategy::MirroredRepeat
-            && times_completed_for_direction & 1 != 0
-        {
-            self.direction = !self.direction;
+
+        // Check for reversing
+        if self.clock.strategy == RepeatStrategy::MirroredRepeat {
+            let times_completed_for_direction = match state {
+                TweenState::Active => times_completed.abs(),
+                // If completed, ignore last completion for the sake of direction reversing
+                TweenState::Completed => (times_completed.abs() - 1).max(0),
+            } as u32;
+            if times_completed_for_direction & 1 != 0 {
+                self.cycle_direction = !self.cycle_direction;
+            }
         }
 
         let entity = ent_mut.id();
 
-        let factor = self.ease_function.sample(progress);
+        // Apply the lens, even if the animation completed, to ensure the state is
+        // consistent.
+        let progress = if state == TweenState::Completed {
+            if self.cycle_direction.is_forward() {
+                1.0
+            } else {
+                0.0
+            }
+        } else {
+            let factor = self
+                .clock
+                .elapsed
+                .div_duration_f32(self.clock.cycle_duration)
+                .fract();
+            if self.cycle_direction == self.playback_direction {
+                factor
+            } else {
+                1.0 - factor
+            }
+        };
+        let progress = self.ease_function.sample(progress);
         match &mut self.action {
             TweenAction::Component(action) => {
-                action(ent_mut, factor);
+                action(ent_mut, progress);
             }
             _ => (), //debug!("Ignoring call to tick() a component with an asset action."),
         };
 
         // If completed at least once this frame, notify the user
-        if times_completed > 0 {
+        if times_completed != 0 {
             if self.send_completed_event {
                 let event = TweenCompleted {
                     id: tween_id,
@@ -768,48 +863,25 @@ impl Tweenable for Tween {
                     progress,
                 };
 
-                // send regular event
+                // Send completion event
                 events.send(event);
-
-                // trigger all entity-scoped observers
-                //commands.trigger_targets(event, entity);
             }
+
+            // Trigger all entity-scoped observers
+            //commands.trigger_targets(event, entity);
+
+            // Run one-shot completion system
             // if let Some(system_id) = &self.system_id {
             //     commands.run_system(*system_id);
             // }
         }
 
-        // Send completion event
-        if self.send_completed_event && times_completed > 0 {
-            events.send(TweenCompleted {
-                id: tween_id,
-                entity,
-                progress,
-            });
-        }
-
-        (progress, state)
+        state
     }
 
     fn rewind(&mut self) {
-        if self.clock.strategy == RepeatStrategy::MirroredRepeat {
-            // In mirrored mode, direction alternates each loop. To reset to the original
-            // direction on Tween creation, we count the number of completions, ignoring the
-            // last one if the Tween is currently in TweenState::Completed because that one
-            // freezes all parameters.
-            let mut times_completed = self.clock.times_completed();
-            if self.clock.state() == TweenState::Completed {
-                debug_assert!(times_completed > 0);
-                times_completed -= 1;
-            }
-            if times_completed & 1 != 0 {
-                self.direction = !self.direction;
-            }
-            // if let Some(system_id) = &self.system_id {
-            //     commands.run_system(*system_id);
-            // }
-        }
-        self.clock.reset();
+        self.cycle_direction = self.playback_direction;
+        self.clock.rewind(self.playback_direction);
     }
 }
 
@@ -817,7 +889,8 @@ impl Tweenable for Tween {
 pub struct Sequence {
     tweens: Vec<BoxedTweenable>,
     index: usize,
-    duration: Duration,
+    cycle_duration: TotalDuration,
+    total_duration: TotalDuration,
     elapsed: Duration,
 }
 
@@ -830,20 +903,13 @@ impl Sequence {
         let tweens: Vec<_> = items.into_iter().map(Into::into).collect();
         assert!(!tweens.is_empty());
 
-        let duration = tweens
-            .iter()
-            .map(|tween| match tween.total_duration() {
-                TotalDuration::Finite(duration) => duration,
-                TotalDuration::Infinite => {
-                    unimplemented!("Infinite durations are not supported in Sequence")
-                }
-            })
-            .sum();
+        let total_duration = tweens.iter().map(|tween| tween.total_duration()).sum();
 
         Self {
             tweens,
             index: 0,
-            duration,
+            cycle_duration: total_duration,
+            total_duration,
             elapsed: Duration::ZERO,
         }
     }
@@ -851,12 +917,13 @@ impl Sequence {
     /// Create a new sequence containing a single tween.
     #[must_use]
     pub fn from_single(tween: impl Tweenable + 'static) -> Self {
-        let duration = tween.duration();
+        let total_duration = tween.total_duration();
         let boxed: BoxedTweenable = Box::new(tween);
         Self {
             tweens: vec![boxed],
             index: 0,
-            duration,
+            cycle_duration: total_duration,
+            total_duration,
             elapsed: Duration::ZERO,
         }
     }
@@ -864,10 +931,12 @@ impl Sequence {
     /// Create a new sequence with the specified capacity.
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
+        let total_duration = TotalDuration::Finite(Duration::ZERO);
         Self {
             tweens: Vec::with_capacity(capacity),
             index: 0,
-            duration: Duration::ZERO,
+            cycle_duration: total_duration,
+            total_duration,
             elapsed: Duration::ZERO,
         }
     }
@@ -875,7 +944,8 @@ impl Sequence {
     /// Append a [`Tweenable`] to this sequence.
     #[must_use]
     pub fn then(mut self, tween: impl Tweenable + 'static) -> Self {
-        self.duration += tween.duration();
+        self.total_duration = self.total_duration + tween.total_duration();
+        self.cycle_duration = self.cycle_duration + tween.total_duration();
         self.tweens.push(Box::new(tween));
         self
     }
@@ -894,32 +964,49 @@ impl Sequence {
 }
 
 impl Tweenable for Sequence {
-    fn duration(&self) -> Duration {
-        self.duration
+    fn cycle_duration(&self) -> Duration {
+        // FIXME - unwrap() because we can cycle over an infinite child, but that's
+        // undefined behavior
+        self.cycle_duration.as_finite().unwrap()
     }
 
     fn total_duration(&self) -> TotalDuration {
-        TotalDuration::Finite(self.duration)
+        self.total_duration
     }
 
     fn set_elapsed(&mut self, elapsed: Duration) {
-        // Set the total sequence progress
+        // Set the total sequence elapsed time
         self.elapsed = elapsed;
 
-        // Find which tween is active in the sequence
+        // Find which tween is active in the sequence at that time
         let mut accum_duration = Duration::ZERO;
-        for index in 0..self.tweens.len() {
-            let tween = &mut self.tweens[index];
-            let tween_duration = tween.duration();
-            if elapsed < accum_duration + tween_duration {
-                self.index = index;
-                let local_duration = elapsed - accum_duration;
-                tween.set_elapsed(local_duration);
-                // TODO?? set progress of other tweens after that one to 0. ??
-                return;
+        for (index, tween) in self.tweens.iter_mut().enumerate() {
+            // Get the total duration of this child
+            let tween_duration = tween.total_duration();
+
+            // If the child is of finite duration, and elapsed is still bigger, then set
+            // that child as completed and move to the next.
+            if let TotalDuration::Finite(duration) = tween_duration {
+                if elapsed >= accum_duration + duration {
+                    accum_duration += duration;
+                    tween.set_elapsed(duration);
+                    continue;
+                }
+            };
+
+            // Found a non-completed child (either infinite, or just elapsed not large
+            // enough to complete it). Set its partially-elapsed state.
+            self.index = index;
+            let local_duration = elapsed - accum_duration;
+            tween.set_elapsed(local_duration);
+
+            // For all subsequent children, reset them to zero, so that the state is
+            // consistent
+            for i in (index + 1)..self.tweens.len() {
+                self.tweens[i].set_elapsed(Duration::ZERO);
             }
-            tween.set_elapsed(tween.duration()); // ?? to prepare for next loop/rewind?
-            accum_duration += tween_duration;
+
+            return;
         }
 
         // None found; sequence ended
@@ -930,35 +1017,46 @@ impl Tweenable for Sequence {
         self.elapsed
     }
 
-    fn tick(
+    fn step(
         &mut self,
         tween_id: TweenId,
         mut delta: Duration,
         mut ent_mut: EntityMut,
         mut events: Mut<Events<TweenCompleted>>,
-    ) -> (f32, TweenState) {
+    ) -> TweenState {
         // Calculate the new elapsed time at the end of this tick
-        self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
+        self.elapsed = self.elapsed.saturating_add(delta);
+        if let TotalDuration::Finite(total_duration) = self.total_duration {
+            self.elapsed = self.elapsed.min(total_duration);
+        }
 
         // Tick one or more tweenables until the new elapsed time is reached.
         while self.index < self.tweens.len() {
             // Tick the current tweenable
             let tween = &mut self.tweens[self.index];
 
-            let tween_remaining = tween.duration().saturating_sub(tween.elapsed());
+            let prev_elapsed = tween.elapsed();
 
-            if let (progress, TweenState::Active) =
-                tween.tick(tween_id, delta, ent_mut.reborrow(), events.reborrow())
+            if tween.step(tween_id, delta, ent_mut.reborrow(), events.reborrow())
+                == TweenState::Active
             {
-                return (progress, TweenState::Active);
+                return TweenState::Active;
             }
 
-            // Current tween done; consume and move to next one
-            delta -= tween_remaining;
+            let TotalDuration::Finite(total_duration) = tween.total_duration() else {
+                // Note: Rust can't figure it out, but this can never happen, because infinite
+                // children will always return TweenState::Active. Just add this for safety.
+                return TweenState::Active;
+            };
+
+            // Child tween has completed. So it was finite, and consumed all the time left
+            // between its previous elapsed time and its total duration.
+            let consumed_duration = total_duration.saturating_sub(prev_elapsed);
+            delta -= consumed_duration;
             self.index += 1;
         }
 
-        (1., TweenState::Completed)
+        TweenState::Completed
     }
 
     fn rewind(&mut self) {
@@ -971,83 +1069,83 @@ impl Tweenable for Sequence {
     }
 }
 
-/// A collection of [`Tweenable`] executing in parallel.
-pub struct Tracks {
-    tracks: Vec<BoxedTweenable>,
-    duration: Duration,
-    elapsed: Duration,
-}
-
-impl Tracks {
-    /// Create a new [`Tracks`] from an iterator over a collection of
-    /// [`Tweenable`].
-    #[must_use]
-    pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable>>) -> Self {
-        let tracks: Vec<_> = items.into_iter().map(Into::into).collect();
-        let duration = tracks
-            .iter()
-            .map(AsRef::as_ref)
-            .map(Tweenable::duration)
-            .max()
-            .unwrap();
-        Self {
-            tracks,
-            duration,
-            elapsed: Duration::ZERO,
-        }
-    }
-}
-
-impl Tweenable for Tracks {
-    fn duration(&self) -> Duration {
-        self.duration
-    }
-
-    fn total_duration(&self) -> TotalDuration {
-        TotalDuration::Finite(self.duration)
-    }
-
-    fn set_elapsed(&mut self, elapsed: Duration) {
-        self.elapsed = elapsed;
-
-        for tweenable in &mut self.tracks {
-            tweenable.set_elapsed(elapsed);
-        }
-    }
-
-    fn elapsed(&self) -> Duration {
-        self.elapsed
-    }
-
-    fn tick(
-        &mut self,
-        tween_id: TweenId,
-        delta: Duration,
-        mut ent_mut: EntityMut,
-        mut events: Mut<Events<TweenCompleted>>,
-    ) -> (f32, TweenState) {
-        self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
-        let mut any_active = false;
-        for tweenable in &mut self.tracks {
-            let (_, state) = tweenable.tick(tween_id, delta, ent_mut.reborrow(), events.reborrow());
-            any_active = any_active || (state == TweenState::Active);
-        }
-        if any_active {
-            // FIXME(nightly): Duration::div_duration_f32()
-            let ratio = self.elapsed.as_secs_f32() / self.duration.as_secs_f32();
-            (ratio, TweenState::Active) // TODO
-        } else {
-            (1., TweenState::Completed)
-        }
-    }
-
-    fn rewind(&mut self) {
-        self.elapsed = Duration::ZERO;
-        for tween in &mut self.tracks {
-            tween.rewind();
-        }
-    }
-}
+// /// A collection of [`Tweenable`] executing in parallel.
+// pub struct Tracks {
+//     tracks: Vec<BoxedTweenable>,
+//     duration: Duration,
+//     elapsed: Duration,
+// }
+
+// impl Tracks {
+//     /// Create a new [`Tracks`] from an iterator over a collection of
+//     /// [`Tweenable`].
+//     #[must_use]
+//     pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable>>) ->
+// Self {         let tracks: Vec<_> =
+// items.into_iter().map(Into::into).collect();         let duration = tracks
+//             .iter()
+//             .map(AsRef::as_ref)
+//             .map(Tweenable::total_duration)
+//             .max()
+//             .unwrap();
+//         Self {
+//             tracks,
+//             duration,
+//             elapsed: Duration::ZERO,
+//         }
+//     }
+// }
+
+// impl Tweenable for Tracks {
+//     fn cycle_duration(&self) -> Duration {
+//         self.duration
+//     }
+
+//     fn total_duration(&self) -> TotalDuration {
+//         TotalDuration::Finite(self.duration)
+//     }
+
+//     fn set_elapsed(&mut self, elapsed: Duration) {
+//         self.elapsed = elapsed;
+
+//         for tweenable in &mut self.tracks {
+//             tweenable.set_elapsed(elapsed);
+//         }
+//     }
+
+//     fn elapsed(&self) -> Duration {
+//         self.elapsed
+//     }
+
+//     fn step(
+//         &mut self,
+//         tween_id: TweenId,
+//         delta: Duration,
+//         mut ent_mut: EntityMut,
+//         mut events: Mut<Events<TweenCompleted>>,
+//     ) -> (f32, TweenState) {
+//         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
+//         let mut any_active = false;
+//         for tweenable in &mut self.tracks {
+//             let (_, state) = tweenable.step(tween_id, delta,
+// ent_mut.reborrow(), events.reborrow());             any_active = any_active
+// || (state == TweenState::Active);         }
+//         if any_active {
+//             // FIXME(nightly): Duration::div_duration_f32()
+//             let ratio = self.elapsed.as_secs_f32() /
+// self.duration.as_secs_f32();             (ratio, TweenState::Active) // TODO
+//         } else {
+//             (1., TweenState::Completed)
+//         }
+//     }
+
+//     fn rewind(&mut self) {
+//         self.elapsed = Duration::ZERO;
+//         for tween in &mut self.tracks {
+//             tween.rewind();
+//         }
+//     }
+// }
 
 /// A time delay that doesn't animate anything.
 ///
@@ -1139,12 +1237,12 @@ impl Delay {
 }
 
 impl Tweenable for Delay {
-    fn duration(&self) -> Duration {
+    fn cycle_duration(&self) -> Duration {
         self.timer.duration()
     }
 
     fn total_duration(&self) -> TotalDuration {
-        TotalDuration::Finite(self.duration())
+        TotalDuration::Finite(self.cycle_duration())
     }
 
     fn set_elapsed(&mut self, elapsed: Duration) {
@@ -1159,16 +1257,16 @@ impl Tweenable for Delay {
         self.timer.elapsed()
     }
 
-    fn tick(
+    fn step(
         &mut self,
         _tween_id: TweenId,
         delta: Duration,
         _ent_mut: EntityMut,
         _events: Mut<Events<TweenCompleted>>,
-    ) -> (f32, TweenState) {
+    ) -> TweenState {
         self.timer.tick(delta);
 
-        let progress = fraction_progress(self.elapsed(), self.duration());
+        let _progress = fraction_progress(self.elapsed(), self.cycle_duration());
         let state = self.state();
 
         // // If completed this frame, notify the user
@@ -1191,7 +1289,7 @@ impl Tweenable for Delay {
         //     }
         // }
 
-        (progress, state)
+        state
     }
 
     fn rewind(&mut self) {
@@ -1209,7 +1307,7 @@ mod tests {
     use slotmap::Key as _;
 
     use super::*;
-    use crate::{lens::*, test_utils::*};
+    use crate::{lens::*, test_utils::assert_approx_eq};
 
     // #[derive(Default, Copy, Clone)]
     // struct CallbackMonitor {
@@ -1253,8 +1351,7 @@ mod tests {
         let state =
             world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
-                let (_, state) = tween.tick(tween_id, duration, entity_mut.reborrow(), events);
-                state
+                tween.step(tween_id, duration, entity_mut.reborrow(), events)
             });
 
         // Propagate events
@@ -1304,8 +1401,8 @@ mod tests {
 
     #[test]
     fn anim_clock_precision() {
-        let duration = Duration::from_millis(1);
-        let mut clock = AnimClock::new(duration);
+        let cycle_duration = Duration::from_millis(1);
+        let mut clock = AnimClock::new(cycle_duration);
         clock.total_duration = TotalDuration::Infinite;
 
         let test_ticks = [
@@ -1321,14 +1418,15 @@ mod tests {
 
         let mut times_completed = 0;
         let mut total_duration = Duration::ZERO;
-        for i in 0..10_000_000 {
+        let num_iter = 100_000_000; // 100m ms, >27h
+        for i in 0..num_iter {
             let tick = test_ticks[i % test_ticks.len()];
             times_completed += clock.tick(tick).1;
             total_duration += tick;
         }
 
         assert_eq!(
-            (total_duration.as_secs_f64() / duration.as_secs_f64()) as i32,
+            total_duration.div_duration_f64(cycle_duration) as i32,
             times_completed
         );
     }
@@ -1367,7 +1465,9 @@ mod tests {
     /// Test ticking of a single tween in isolation.
     #[test]
     fn tween_tick() {
-        for tweening_direction in [TweeningDirection::Forward, TweeningDirection::Backward] {
+        for playback_direction in [
+            /*TweeningDirection::Forward,*/ TweeningDirection::Backward,
+        ] {
             for (count, strategy) in [
                 (RepeatCount::Finite(1), RepeatStrategy::default()),
                 (RepeatCount::Infinite, RepeatStrategy::Repeat),
@@ -1376,16 +1476,21 @@ mod tests {
                 (RepeatCount::Finite(2), RepeatStrategy::MirroredRepeat),
             ] {
                 println!(
-                    "TweeningType: count={count:?} strategy={strategy:?} dir={tweening_direction:?}",
+                    "TweeningType: count={count:?} strategy={strategy:?} playback={playback_direction:?}",
                 );
 
                 // Create a linear tween over 1 second
                 let mut tween = make_test_tween()
-                    .with_direction(tweening_direction)
+                    .with_playback_direction(playback_direction)
                     .with_repeat_count(count)
                     .with_repeat_strategy(strategy)
                     .with_completed_event(true);
-                assert_eq!(tween.direction(), tweening_direction);
+                assert_eq!(tween.playback_direction(), playback_direction);
+
+                if playback_direction == TweeningDirection::Backward {
+                    // Seek to end, so that backward playback actually does something
+                    tween.set_elapsed(tween.total_duration().as_finite().unwrap());
+                }
 
                 let (mut world, entity, system_id) = make_test_env();
                 let mut event_reader_system_state: SystemState<EventReader<TweenCompleted>> =
@@ -1398,23 +1503,26 @@ mod tests {
                 assert!(tween.system_id.is_some());
                 assert_eq!(tween.system_id.unwrap(), system_id);
 
-                // Loop over 2.2 seconds, so greater than one ping-pong loop
+                // Loop over 2.2 seconds, so greater than one ping-pong loop (2 cycles in
+                // MirroredRepeat)
                 let tick_duration = Duration::from_millis(200);
+                let tween_duration = Duration::from_secs(1);
                 for i in 1..=11 {
                     // Calculate expected values
-                    let (progress, times_completed, mut direction, expected_state, just_completed) =
+                    let mut elapsed = tick_duration * i;
+                    let (factor, times_completed, mut direction, expected_state, just_completed) =
                         match count {
                             RepeatCount::Finite(1) => {
-                                let progress = (i as f32 * 0.2).min(1.0);
+                                elapsed = elapsed.min(tween_duration);
                                 let times_completed = u32::from(i >= 5);
-                                let state = if i < 5 {
-                                    TweenState::Active
+                                let (factor, state) = if i < 5 {
+                                    (i as f32 * 0.2, TweenState::Active)
                                 } else {
-                                    TweenState::Completed
+                                    (1.0, TweenState::Completed)
                                 };
                                 let just_completed = i == 5;
                                 (
-                                    progress,
+                                    factor,
                                     times_completed,
                                     TweeningDirection::Forward,
                                     state,
@@ -1422,56 +1530,46 @@ mod tests {
                                 )
                             }
                             RepeatCount::Finite(count) => {
-                                let total_progress = i as f32 * 0.2;
-                                let progress = if total_progress >= count as f32 {
-                                    1.
-                                } else {
-                                    total_progress.fract()
-                                };
+                                elapsed = elapsed.min(tween_duration * count);
                                 if strategy == RepeatStrategy::Repeat {
                                     let times_completed = i / 5;
                                     let just_completed = i % 5 == 0;
+                                    let (factor, state) = if i < 10 {
+                                        ((i as f32 * 0.2).fract(), TweenState::Active)
+                                    } else {
+                                        (1.0, TweenState::Completed)
+                                    };
                                     (
-                                        progress,
+                                        factor,
                                         times_completed,
                                         TweeningDirection::Forward,
-                                        if i < 10 {
-                                            TweenState::Active
-                                        } else {
-                                            TweenState::Completed
-                                        },
+                                        state,
                                         just_completed,
                                     )
                                 } else {
                                     let i5 = i % 5;
                                     let times_completed = i / 5;
+                                    let just_completed = i5 == 0;
+                                    let (factor, state) = if i < 10 {
+                                        ((i as f32 * 0.2).fract(), TweenState::Active)
+                                    } else {
+                                        (1.0, TweenState::Completed)
+                                    };
                                     // Once Completed, the direction doesn't change
                                     let direction = if i >= 5 {
                                         TweeningDirection::Backward
                                     } else {
                                         TweeningDirection::Forward
                                     };
-                                    let just_completed = i5 == 0;
-                                    (
-                                        progress,
-                                        times_completed,
-                                        direction,
-                                        if i < 10 {
-                                            TweenState::Active
-                                        } else {
-                                            TweenState::Completed
-                                        },
-                                        just_completed,
-                                    )
+                                    (factor, times_completed, direction, state, just_completed)
                                 }
                             }
                             RepeatCount::Infinite => {
-                                let progress = (i as f32 * 0.2).fract();
                                 if strategy == RepeatStrategy::Repeat {
                                     let times_completed = i / 5;
                                     let just_completed = i % 5 == 0;
                                     (
-                                        progress,
+                                        (i as f32 * 0.2).fract(),
                                         times_completed,
                                         TweeningDirection::Forward,
                                         TweenState::Active,
@@ -1481,14 +1579,20 @@ mod tests {
                                     let i5 = i % 5;
                                     let times_completed = i / 5;
                                     let i10 = i % 10;
-                                    let direction = if i10 >= 5 {
-                                        TweeningDirection::Backward
+                                    let factor = i5 as f32 * 0.2;
+                                    let factor = if times_completed & 1 != 0 {
+                                        1.0 - factor
                                     } else {
-                                        TweeningDirection::Forward
+                                        factor
+                                    };
+                                    let (direction, factor) = if i10 >= 5 {
+                                        (TweeningDirection::Backward, 1.0 - factor)
+                                    } else {
+                                        (TweeningDirection::Forward, factor)
                                     };
                                     let just_completed = i5 == 0;
                                     (
-                                        progress,
+                                        factor,
                                         times_completed,
                                         direction,
                                         TweenState::Active,
@@ -1498,20 +1602,17 @@ mod tests {
                             }
                             RepeatCount::For(_) => panic!("Untested"),
                         };
-                    let factor = if tweening_direction.is_backward() {
+                    if playback_direction.is_backward() {
                         direction = !direction;
-                        1. - progress
-                    } else {
-                        progress
-                    };
+                    }
                     let expected_translation = if direction.is_forward() {
-                        Vec3::splat(progress)
+                        Vec3::splat(factor)
                     } else {
-                        Vec3::splat(1. - progress)
+                        Vec3::splat(1. - factor)
                     };
                     println!(
-                        "Expected: progress={} factor={} times_completed={} direction={:?} state={:?} just_completed={} translation={:?}",
-                        progress, factor, times_completed, direction, expected_state, just_completed, expected_translation
+                        "Expected: elapsed={:?} factor={} times_completed={} direction={:?} state={:?} just_completed={} translation={:?}",
+                        elapsed, factor, times_completed, direction, expected_state, just_completed, expected_translation
                     );
 
                     // Tick the tween
@@ -1524,15 +1625,20 @@ mod tests {
                     );
 
                     // Check actual values
-                    assert_eq!(tween.direction(), direction);
+                    assert_eq!(tween.cycle_direction(), direction);
                     assert_eq!(actual_state, expected_state);
-                    assert_approx_eq!(tween.progress(), progress);
-                    assert_eq!(tween.times_completed(), times_completed);
+                    if playback_direction.is_forward() {
+                        assert_eq!(tween.elapsed(), elapsed);
+                    } else {
+                        assert_eq!(
+                            tween.elapsed(),
+                            tween.total_duration().as_finite().unwrap() - elapsed
+                        );
+                    }
+                    assert_eq!(tween.cycles_completed(), times_completed);
                     let transform = world.entity(entity).get::<Transform>().unwrap();
-                    assert!(transform
-                        .translation
-                        .abs_diff_eq(expected_translation, 1e-5));
-                    assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
+                    assert_approx_eq!(expected_translation, transform.translation, 1e-5);
+                    assert_approx_eq!(Quat::IDENTITY, transform.rotation, 1e-5);
                     {
                         let mut event_reader = event_reader_system_state.get_mut(&mut world);
                         let event = event_reader.read().next();
@@ -1549,9 +1655,9 @@ mod tests {
 
                 // Rewind
                 tween.rewind();
-                assert_eq!(tween.direction(), tweening_direction); // does not change
-                assert_approx_eq!(tween.progress(), 0.);
-                assert_eq!(tween.times_completed(), 0);
+                assert_eq!(tween.playback_direction(), playback_direction); // does not change
+                assert_eq!(tween.elapsed(), Duration::ZERO);
+                assert_eq!(tween.cycles_completed(), 0);
 
                 // Dummy tick to update target
                 let actual_state = manual_tick_component(
@@ -1562,7 +1668,7 @@ mod tests {
                     entity,
                 );
                 assert_eq!(actual_state, TweenState::Active);
-                let expected_translation = if tweening_direction.is_backward() {
+                let expected_translation = if playback_direction.is_backward() {
                     Vec3::ONE
                 } else {
                     Vec3::ZERO
@@ -1574,7 +1680,7 @@ mod tests {
                 assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
 
                 // Clear event sending
-                tween.send_completed_event(false);
+                tween.set_completed_event(false);
                 assert!(!tween.send_completed_event);
 
                 // Clear oneshot system
@@ -1589,33 +1695,32 @@ mod tests {
         let mut tween = make_test_tween();
 
         // Default
-        assert_eq!(tween.direction(), TweeningDirection::Forward);
-        assert_approx_eq!(tween.progress(), 0.0);
+        assert_eq!(tween.playback_direction(), TweeningDirection::Forward);
+        assert_eq!(tween.elapsed(), Duration::ZERO);
 
         // no-op
-        tween.set_direction(TweeningDirection::Forward);
-        assert_eq!(tween.direction(), TweeningDirection::Forward);
-        assert_approx_eq!(tween.progress(), 0.0);
+        tween.set_playback_direction(TweeningDirection::Forward);
+        assert_eq!(tween.playback_direction(), TweeningDirection::Forward);
+        assert_eq!(tween.elapsed(), Duration::ZERO);
 
         // Backward
-        tween.set_direction(TweeningDirection::Backward);
-        assert_eq!(tween.direction(), TweeningDirection::Backward);
-        // progress is independent of direction
-        assert_approx_eq!(tween.progress(), 0.0);
-
-        // Progress-invariant
-        tween.set_direction(TweeningDirection::Forward);
-        tween.set_progress(0.3);
-        assert_approx_eq!(tween.progress(), 0.3);
-        tween.set_direction(TweeningDirection::Backward);
-        // progress is independent of direction
-        assert_approx_eq!(tween.progress(), 0.3);
+        tween.set_playback_direction(TweeningDirection::Backward);
+        assert_eq!(tween.playback_direction(), TweeningDirection::Backward);
+        assert_eq!(tween.elapsed(), Duration::ZERO);
+
+        // Elapsed-invariant
+        let d300 = Duration::from_millis(300);
+        tween.set_playback_direction(TweeningDirection::Forward);
+        tween.set_elapsed(d300);
+        assert_eq!(tween.elapsed(), d300);
+        tween.set_playback_direction(TweeningDirection::Backward);
+        assert_eq!(tween.elapsed(), d300);
 
         let (mut world, entity, _system_id) = make_test_env();
 
         // Progress always increases alongside the current direction
-        tween.set_direction(TweeningDirection::Backward);
-        assert_approx_eq!(tween.progress(), 0.3);
+        tween.set_playback_direction(TweeningDirection::Backward);
+        assert_eq!(tween.elapsed(), d300);
         manual_tick_component(
             TweenId::null(), // unused in this test
             Duration::from_millis(100),
@@ -1623,31 +1728,28 @@ mod tests {
             &mut world,
             entity,
         );
-        assert_approx_eq!(tween.progress(), 0.4);
+        assert_eq!(tween.elapsed(), Duration::from_millis(200)); // 300 - 100
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.6), 1e-5));
+        assert_approx_eq!(Vec3::splat(0.2), transform.translation, 1e-5);
     }
 
     #[test]
     fn tween_elapsed() {
         let mut tween = make_test_tween();
 
-        let duration = tween.duration();
+        let cycle_duration = tween.cycle_duration();
         let elapsed = tween.elapsed();
 
         assert_eq!(elapsed, Duration::ZERO);
-        assert_eq!(duration, Duration::from_secs(1));
+        assert_eq!(cycle_duration, Duration::from_secs(1));
 
         for ms in [0, 1, 500, 100, 300, 999, 847, 1000, 900] {
             let elapsed = Duration::from_millis(ms);
             tween.set_elapsed(elapsed);
             assert_eq!(tween.elapsed(), elapsed);
 
-            let progress = (elapsed.as_secs_f64() / duration.as_secs_f64()) as f32;
-            assert_approx_eq!(tween.progress(), progress);
-
             let times_completed = u32::from(ms == 1000);
-            assert_eq!(tween.times_completed(), times_completed);
+            assert_eq!(tween.cycles_completed(), times_completed);
         }
     }
 
@@ -1686,20 +1788,22 @@ mod tests {
             if i < 5 {
                 assert_eq!(state, TweenState::Active);
                 let r = i as f32 * 0.2;
-                assert_eq!(*transform, Transform::from_translation(Vec3::splat(r)));
+                assert_approx_eq!(Transform::from_translation(Vec3::splat(r)), *transform);
             } else if i < 10 {
                 assert_eq!(state, TweenState::Active);
                 let alpha_deg = (18 * (i - 5)) as f32;
-                assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
-                assert!(transform
-                    .rotation
-                    .abs_diff_eq(Quat::from_rotation_x(alpha_deg.to_radians()), 1e-5));
+                assert_approx_eq!(Vec3::ONE, transform.translation);
+                assert_approx_eq!(
+                    Quat::from_rotation_x(alpha_deg.to_radians()),
+                    transform.rotation
+                );
             } else {
                 assert_eq!(state, TweenState::Completed);
-                assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
-                assert!(transform
-                    .rotation
-                    .abs_diff_eq(Quat::from_rotation_x(90_f32.to_radians()), 1e-5));
+                assert_approx_eq!(Vec3::ONE, transform.translation);
+                assert_approx_eq!(
+                    Quat::from_rotation_x(90_f32.to_radians()),
+                    transform.rotation
+                );
             }
         }
     }
@@ -1753,28 +1857,29 @@ mod tests {
             )
         }));
 
-        let mut progress = 0.;
+        let mut time = Duration::ZERO;
         for i in 1..5 {
             assert_eq!(seq.index(), i - 1);
-            assert_approx_eq!(seq.progress(), progress);
-            let duration = Duration::from_millis(200 * i as u64);
-            assert_eq!(seq.current().duration(), duration);
-            progress += 0.25;
-            seq.set_progress(progress);
-            assert_eq!(seq.times_completed(), u32::from(i == 4));
+            assert_eq!(time, seq.elapsed());
+            let dt = Duration::from_millis(200 * i as u64);
+            assert_eq!(dt, seq.current().cycle_duration());
+            time += dt;
+            seq.set_elapsed(time);
+            assert_eq!(seq.cycles_completed(), u32::from(i == 4));
         }
 
         seq.rewind();
-        assert_eq!(seq.progress(), 0.);
-        assert_eq!(seq.times_completed(), 0);
+        assert_eq!(Duration::ZERO, seq.elapsed());
+        assert_eq!(0, seq.cycles_completed());
     }
 
     /// Sequence::from_single()
     #[test]
     fn seq_from_single() {
+        let dt = Duration::from_secs(1);
         let tween = Tween::new(
             EaseMethod::default(),
-            Duration::from_secs(1),
+            dt,
             TransformPositionLens {
                 start: Vec3::ZERO,
                 end: Vec3::ONE,
@@ -1782,7 +1887,9 @@ mod tests {
         );
         let seq = Sequence::from_single(tween);
 
-        assert_eq!(seq.duration(), Duration::from_secs(1));
+        assert_eq!(1, seq.tweens.len());
+        assert_eq!(dt, seq.cycle_duration());
+        assert_eq!(TotalDuration::Finite(dt), seq.total_duration());
     }
 
     #[test]
@@ -1803,144 +1910,152 @@ mod tests {
             assert_eq!(seq.index(), i - 1);
             assert_eq!(seq.elapsed(), elapsed);
             let duration = Duration::from_millis(200 * i as u64);
-            assert_eq!(seq.current().duration(), duration);
+            assert_eq!(seq.current().cycle_duration(), duration);
             elapsed += duration;
             seq.set_elapsed(elapsed);
-            assert_eq!(seq.times_completed(), u32::from(i == 4));
+            assert_eq!(seq.cycles_completed(), u32::from(i == 4));
         }
     }
 
-    /// Test ticking parallel tracks of tweens.
-    #[test]
-    fn tracks_tick() {
-        let tween1 = Tween::new(
-            EaseMethod::default(),
-            Duration::from_millis(1000),
-            TransformPositionLens {
-                start: Vec3::ZERO,
-                end: Vec3::ONE,
-            },
-        );
-        let tween2 = Tween::new(
-            EaseMethod::default(),
-            Duration::from_millis(800), // shorter
-            TransformRotationLens {
-                start: Quat::IDENTITY,
-                end: Quat::from_rotation_x(90_f32.to_radians()),
-            },
-        );
-        let mut tracks = Tracks::new([tween1, tween2]);
-        assert_eq!(tracks.duration(), Duration::from_secs(1)); // max(1., 0.8)
-
-        let (mut world, entity, _system_id) = make_test_env();
-
-        for i in 1..=6 {
-            let state = manual_tick_component(
-                TweenId::null(), // unused in this test
-                Duration::from_millis(200),
-                &mut tracks,
-                &mut world,
-                entity,
-            );
-            let transform = world.entity(entity).get::<Transform>().unwrap();
-            if i < 5 {
-                assert_eq!(state, TweenState::Active);
-                assert_eq!(tracks.times_completed(), 0);
-                let r = i as f32 * 0.2;
-                assert_approx_eq!(tracks.progress(), r);
-                let alpha_deg = 22.5 * i as f32;
-                assert!(transform.translation.abs_diff_eq(Vec3::splat(r), 1e-5));
-                assert!(transform
-                    .rotation
-                    .abs_diff_eq(Quat::from_rotation_x(alpha_deg.to_radians()), 1e-5));
-            } else {
-                assert_eq!(state, TweenState::Completed);
-                assert_eq!(tracks.times_completed(), 1);
-                assert_approx_eq!(tracks.progress(), 1.);
-                assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
-                assert!(transform
-                    .rotation
-                    .abs_diff_eq(Quat::from_rotation_x(90_f32.to_radians()), 1e-5));
-            }
-        }
-
-        tracks.rewind();
-        assert_eq!(tracks.times_completed(), 0);
-        assert_approx_eq!(tracks.progress(), 0.);
-
-        tracks.set_progress(0.9);
-        assert_approx_eq!(tracks.progress(), 0.9);
-        // tick to udpate state (set_progress() does not update state)
-        let state = manual_tick_component(
-            TweenId::null(), // unused in this test
-            Duration::ZERO,
-            &mut tracks,
-            &mut world,
-            entity,
-        );
-        assert_eq!(state, TweenState::Active);
-        assert_eq!(tracks.times_completed(), 0);
-
-        tracks.set_progress(3.2);
-        assert_approx_eq!(tracks.progress(), 1.);
-        // tick to udpate state (set_progress() does not update state)
-        let state = manual_tick_component(
-            TweenId::null(), // unused in this test
-            Duration::ZERO,
-            &mut tracks,
-            &mut world,
-            entity,
-        );
-        assert_eq!(state, TweenState::Completed);
-        assert_eq!(tracks.times_completed(), 1); // no looping
-
-        tracks.set_progress(-0.5);
-        assert_approx_eq!(tracks.progress(), 0.);
-        // tick to udpate state (set_progress() does not update state)
-        let state = manual_tick_component(
-            TweenId::null(), // unused in this test
-            Duration::ZERO,
-            &mut tracks,
-            &mut world,
-            entity,
-        );
-        assert_eq!(state, TweenState::Active);
-        assert_eq!(tracks.times_completed(), 0); // no looping
-    }
+    // /// Test ticking parallel tracks of tweens.
+    // #[test]
+    // fn tracks_tick() {
+    //     let tween1 = Tween::new(
+    //         EaseMethod::default(),
+    //         Duration::from_millis(1000),
+    //         TransformPositionLens {
+    //             start: Vec3::ZERO,
+    //             end: Vec3::ONE,
+    //         },
+    //     );
+    //     let tween2 = Tween::new(
+    //         EaseMethod::default(),
+    //         Duration::from_millis(800), // shorter
+    //         TransformRotationLens {
+    //             start: Quat::IDENTITY,
+    //             end: Quat::from_rotation_x(90_f32.to_radians()),
+    //         },
+    //     );
+    //     let mut tracks = Tracks::new([tween1, tween2]);
+    //     assert_eq!(tracks.duration(), Duration::from_secs(1)); // max(1.,
+    // 0.8)
+
+    //     let (mut world, entity, _system_id) = make_test_env();
+
+    //     for i in 1..=6 {
+    //         let state = manual_tick_component(
+    //             TweenId::null(), // unused in this test
+    //             Duration::from_millis(200),
+    //             &mut tracks,
+    //             &mut world,
+    //             entity,
+    //         );
+    //         let transform = world.entity(entity).get::<Transform>().unwrap();
+    //         if i < 5 {
+    //             assert_eq!(state, TweenState::Active);
+    //             assert_eq!(tracks.cycles_completed(), 0);
+    //             let r = i as f32 * 0.2;
+    //             assert_approx_eq!(tracks.progress(), r);
+    //             let alpha_deg = 22.5 * i as f32;
+    //             assert!(transform.translation.abs_diff_eq(Vec3::splat(r),
+    // 1e-5));             assert!(transform
+    //                 .rotation
+    //
+    // .abs_diff_eq(Quat::from_rotation_x(alpha_deg.to_radians()), 1e-5));
+    //         } else {
+    //             assert_eq!(state, TweenState::Completed);
+    //             assert_eq!(tracks.cycles_completed(), 1);
+    //             assert_approx_eq!(tracks.progress(), 1.);
+    //             assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
+    //             assert!(transform
+    //                 .rotation
+    //                 .abs_diff_eq(Quat::from_rotation_x(90_f32.to_radians()),
+    // 1e-5));         }
+    //     }
+
+    //     tracks.rewind();
+    //     assert_eq!(tracks.cycles_completed(), 0);
+    //     assert_approx_eq!(tracks.progress(), 0.);
+
+    //     tracks.set_progress(0.9);
+    //     assert_approx_eq!(tracks.progress(), 0.9);
+    //     // tick to udpate state (set_progress() does not update state)
+    //     let state = manual_tick_component(
+    //         TweenId::null(), // unused in this test
+    //         Duration::ZERO,
+    //         &mut tracks,
+    //         &mut world,
+    //         entity,
+    //     );
+    //     assert_eq!(state, TweenState::Active);
+    //     assert_eq!(tracks.cycles_completed(), 0);
+
+    //     tracks.set_progress(3.2);
+    //     assert_approx_eq!(tracks.progress(), 1.);
+    //     // tick to udpate state (set_progress() does not update state)
+    //     let state = manual_tick_component(
+    //         TweenId::null(), // unused in this test
+    //         Duration::ZERO,
+    //         &mut tracks,
+    //         &mut world,
+    //         entity,
+    //     );
+    //     assert_eq!(state, TweenState::Completed);
+    //     assert_eq!(tracks.cycles_completed(), 1); // no looping
+
+    //     tracks.set_progress(-0.5);
+    //     assert_approx_eq!(tracks.progress(), 0.);
+    //     // tick to udpate state (set_progress() does not update state)
+    //     let state = manual_tick_component(
+    //         TweenId::null(), // unused in this test
+    //         Duration::ZERO,
+    //         &mut tracks,
+    //         &mut world,
+    //         entity,
+    //     );
+    //     assert_eq!(state, TweenState::Active);
+    //     assert_eq!(tracks.cycles_completed(), 0); // no looping
+    // }
 
     /// Delay::then()
     #[test]
     fn delay_then() {
-        let seq: Sequence =
-            Delay::new(Duration::from_secs(1)).then(Delay::new(Duration::from_secs(2)));
-        assert_eq!(seq.duration(), Duration::from_secs(3));
-        assert_eq!(seq.tweens.len(), 2);
-        for (i, t) in seq.tweens.iter().enumerate() {
-            assert_eq!(t.duration(), Duration::from_secs(i as u64 + 1));
+        let dt1 = Duration::from_secs(1);
+        let dt2 = Duration::from_secs(2);
+        let seq: Sequence = Delay::new(dt1).then(Delay::new(dt2));
+        assert_eq!(2, seq.tweens.len());
+        assert_eq!(dt1 + dt2, seq.cycle_duration());
+        assert_eq!(TotalDuration::Finite(dt1 + dt2), seq.total_duration());
+        for (i, tweenable) in seq.tweens.iter().enumerate() {
+            let dt = Duration::from_secs(i as u64 + 1);
+            assert_eq!(dt, tweenable.cycle_duration());
+            assert_eq!(TotalDuration::Finite(dt), tweenable.total_duration());
         }
     }
 
     /// Test ticking a delay.
     #[test]
     fn delay_tick() {
-        let duration = Duration::from_secs(1);
-
-        let mut delay = Delay::new(duration);
+        let total_dt = Duration::from_secs(1);
+        let mut delay = Delay::new(total_dt);
 
         {
             let tweenable: &dyn Tweenable = &delay;
-            assert_eq!(tweenable.duration(), duration);
-            assert_approx_eq!(tweenable.progress(), 0.);
-            assert_eq!(tweenable.elapsed(), Duration::ZERO);
+            assert_eq!(total_dt, tweenable.cycle_duration());
+            assert_eq!(TotalDuration::Finite(total_dt), tweenable.total_duration());
+            assert_eq!(Duration::ZERO, tweenable.elapsed());
         }
 
         // Dummy world and event writer
         let (mut world, entity, _system_id) = make_test_env();
 
+        let mut time = Duration::ZERO;
         for i in 1..=6 {
+            let dt = Duration::from_millis(200);
+            time += dt;
             let state = manual_tick_component(
                 TweenId::null(), // unused in this test
-                Duration::from_millis(200),
+                dt,
                 &mut delay,
                 &mut world,
                 entity,
@@ -1955,54 +2070,54 @@ mod tests {
                 if i < 5 {
                     assert_eq!(state, TweenState::Active);
                     assert!(!delay.is_completed());
-                    assert_eq!(tweenable.times_completed(), 0);
-                    let r = i as f32 * 0.2;
-                    assert_approx_eq!(tweenable.progress(), r);
+                    assert_eq!(0, tweenable.cycles_completed());
+                    assert_eq!(dt * i, tweenable.elapsed());
                 } else {
                     assert_eq!(state, TweenState::Completed);
                     assert!(delay.is_completed());
-                    assert_eq!(tweenable.times_completed(), 1);
-                    assert_approx_eq!(tweenable.progress(), 1.);
+                    assert_eq!(1, tweenable.cycles_completed());
+                    assert_eq!(total_dt, tweenable.elapsed());
                 }
             }
         }
 
         delay.rewind();
-        assert_eq!(delay.times_completed(), 0);
-        assert_approx_eq!(delay.progress(), 0.);
-        let state = manual_tick_component(
+        assert_eq!(0, delay.cycles_completed());
+        assert_eq!(Duration::ZERO, delay.elapsed());
+        let state: TweenState = manual_tick_component(
             TweenId::null(), // unused in this test
             Duration::ZERO,
             &mut delay,
             &mut world,
             entity,
         );
-        assert_eq!(state, TweenState::Active);
+        assert_eq!(TweenState::Active, state);
 
-        delay.set_progress(0.3);
-        assert_eq!(delay.times_completed(), 0);
-        assert_approx_eq!(delay.progress(), 0.3);
-        delay.set_progress(1.);
-        assert_eq!(delay.times_completed(), 1);
-        assert_approx_eq!(delay.progress(), 1.);
+        let dt = Duration::from_millis(300);
+        delay.set_elapsed(dt);
+        assert_eq!(0, delay.cycles_completed());
+        assert_eq!(dt, delay.elapsed());
+        let dt = Duration::from_millis(1200);
+        delay.set_elapsed(dt);
+        assert_eq!(1, delay.cycles_completed());
+        assert_eq!(total_dt, delay.elapsed());
     }
 
     #[test]
     fn delay_elapsed() {
-        let mut delay = Delay::new(Duration::from_secs(1));
-        let duration = delay.duration();
+        let dt = Duration::from_secs(1);
+        let mut delay = Delay::new(dt);
+        assert_eq!(dt, delay.cycle_duration());
+        assert_eq!(TotalDuration::Finite(dt), delay.total_duration());
         for ms in [0, 1, 500, 100, 300, 999, 847, 1000, 900] {
             let elapsed = Duration::from_millis(ms);
             delay.set_elapsed(elapsed);
-            assert_eq!(delay.elapsed(), elapsed);
-
-            let progress = (elapsed.as_secs_f64() / duration.as_secs_f64()) as f32;
-            assert_approx_eq!(delay.progress(), progress);
+            assert_eq!(elapsed, delay.elapsed());
 
             let times_completed = u32::from(ms == 1000);
-            assert_eq!(delay.times_completed(), times_completed);
+            assert_eq!(times_completed, delay.cycles_completed());
 
-            assert_eq!(delay.is_completed(), ms >= 1000);
+            assert_eq!(ms >= 1000, delay.is_completed());
             assert_eq!(
                 delay.state(),
                 if ms >= 1000 {
@@ -2026,65 +2141,75 @@ mod tests {
             .with_repeat_count(RepeatCount::Finite(5))
             .with_repeat_strategy(RepeatStrategy::Repeat);
 
-        assert_approx_eq!(tween.progress(), 0.);
+        assert_eq!(Duration::ZERO, tween.elapsed());
 
         let (mut world, entity, _system_id) = make_test_env();
 
+        let mut time = Duration::ZERO;
+
         // 10%
+        let dt = Duration::from_millis(100);
+        time += dt;
         let state = manual_tick_component(
             TweenId::null(), // unused in this test
-            Duration::from_millis(100),
+            dt,
             &mut tween,
             &mut world,
             entity,
         );
         assert_eq!(TweenState::Active, state);
-        assert_eq!(0, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.1);
+        assert_eq!(0, tween.cycles_completed());
+        assert_eq!(time, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.1), 1e-5));
+        assert_approx_eq!(Vec3::splat(0.1), transform.translation, 1e-5);
 
         // 130%
+        let dt = Duration::from_millis(1200);
+        time += dt;
         let state = manual_tick_component(
             TweenId::null(), // unused in this test
-            Duration::from_millis(1200),
+            dt,
             &mut tween,
             &mut world,
             entity,
         );
         assert_eq!(TweenState::Active, state);
-        assert_eq!(1, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.3);
+        assert_eq!(1, tween.cycles_completed());
+        assert_eq!(time, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.3), 1e-5));
+        assert_approx_eq!(Vec3::splat(0.3), transform.translation, 1e-5);
 
         // 480%
+        let dt = Duration::from_millis(3500);
+        time += dt;
         let state = manual_tick_component(
             TweenId::null(), // unused in this test
-            Duration::from_millis(3500),
+            dt,
             &mut tween,
             &mut world,
             entity,
         );
         assert_eq!(TweenState::Active, state);
-        assert_eq!(4, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.8);
+        assert_eq!(4, tween.cycles_completed());
+        assert_eq!(time, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.8), 1e-5));
+        assert_approx_eq!(Vec3::splat(0.8), transform.translation, 1e-5);
 
         // 500% - done
+        let dt = Duration::from_millis(200);
+        time += dt;
         let state = manual_tick_component(
             TweenId::null(), // unused in this test
-            Duration::from_millis(200),
+            dt,
             &mut tween,
             &mut world,
             entity,
         );
         assert_eq!(TweenState::Completed, state);
-        assert_eq!(5, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 1.0);
+        assert_eq!(5, tween.cycles_completed());
+        assert_eq!(time, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
+        assert_approx_eq!(Vec3::ONE, transform.translation, 1e-5);
     }
 
     #[test]
@@ -2093,77 +2218,82 @@ mod tests {
             .with_repeat_count(RepeatCount::Finite(4))
             .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        assert_approx_eq!(tween.progress(), 0.);
+        assert_eq!(Duration::ZERO, tween.elapsed());
 
         let (mut world, entity, _system_id) = make_test_env();
 
         // 10%
+        let dt = Duration::from_millis(100);
         let state = manual_tick_component(
             TweenId::null(), // unused in this test
-            Duration::from_millis(100),
+            dt,
             &mut tween,
             &mut world,
             entity,
         );
         assert_eq!(TweenState::Active, state);
-        assert_eq!(TweeningDirection::Forward, tween.direction());
-        assert_eq!(0, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.1);
+        assert_eq!(TweeningDirection::Forward, tween.cycle_direction());
+        assert_eq!(0, tween.cycles_completed());
+        assert_eq!(dt, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.1), 1e-5));
+        assert_approx_eq!(Vec3::splat(0.1), transform.translation, 1e-5);
 
         // rewind
         tween.rewind();
-        assert_eq!(TweeningDirection::Forward, tween.direction());
-        assert_eq!(0, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.);
+        assert_eq!(TweeningDirection::Forward, tween.cycle_direction());
+        assert_eq!(0, tween.cycles_completed());
+        assert_eq!(Duration::ZERO, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.1), 1e-5)); // no-op, rewind doesn't apply Lens
+        assert_approx_eq!(Vec3::splat(0.1), transform.translation, 1e-5); // no-op, rewind doesn't apply Lens
 
         // 120% - mirror
+        let dt = Duration::from_millis(1200);
         let state = manual_tick_component(
             TweenId::null(), // unused in this test
-            Duration::from_millis(1200),
+            dt,
             &mut tween,
             &mut world,
             entity,
         );
-        assert_eq!(TweeningDirection::Backward, tween.direction());
+        assert_eq!(TweeningDirection::Backward, tween.cycle_direction());
         assert_eq!(TweenState::Active, state);
-        assert_eq!(1, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.2);
+        assert_eq!(1, tween.cycles_completed());
+        assert_eq!(dt, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.8), 1e-5));
+        assert_approx_eq!(Vec3::splat(0.8), transform.translation, 1e-5);
 
         // rewind
+        assert_eq!(TweeningDirection::Backward, tween.cycle_direction());
         tween.rewind();
-        assert_eq!(TweeningDirection::Forward, tween.direction()); // restored
-        assert_eq!(0, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.);
+        assert_eq!(TweeningDirection::Forward, tween.cycle_direction()); //restored
+        assert_eq!(0, tween.cycles_completed());
+        assert_eq!(Duration::ZERO, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::splat(0.8), 1e-5)); // no-op, rewind doesn't apply Lens
+        assert_approx_eq!(Vec3::splat(0.8), transform.translation, 1e-5); // no-op, rewind doesn't apply Lens
 
         // 400% - done mirror (because Completed freezes the state)
+        let dt = Duration::from_millis(4000);
         let state = manual_tick_component(
             TweenId::null(), // unused in this test
-            Duration::from_millis(4000),
+            dt,
             &mut tween,
             &mut world,
             entity,
         );
         assert_eq!(TweenState::Completed, state);
-        assert_eq!(TweeningDirection::Backward, tween.direction()); // frozen from last loop
-        assert_eq!(4, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 1.); // Completed
+        assert_eq!(TweeningDirection::Backward, tween.cycle_direction()); // frozen from last loop
+        assert_eq!(4, tween.cycles_completed());
+        assert_eq!(dt, tween.elapsed()); // Completed
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
+        assert_approx_eq!(Vec3::ZERO, transform.translation, 1e-5);
 
         // rewind
+        assert_eq!(TweeningDirection::Backward, tween.cycle_direction());
         tween.rewind();
-        assert_eq!(TweeningDirection::Forward, tween.direction()); // restored
-        assert_eq!(0, tween.times_completed());
-        assert_approx_eq!(tween.progress(), 0.);
+        assert_eq!(TweeningDirection::Forward, tween.cycle_direction()); // restored
+        assert_eq!(0, tween.cycles_completed());
+        assert_eq!(Duration::ZERO, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
-        assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5)); // no-op, rewind doesn't apply Lens
+        assert_approx_eq!(Vec3::ZERO, transform.translation, 1e-5); // no-op, rewind doesn't apply Lens
     }
 }

From 176065ab0e19b5220748c196a3d8302fbf43ee3b Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 28 Jun 2025 15:53:39 +0100
Subject: [PATCH 10/66] Stateless mirroring split from tween state

---
 src/tweenable.rs | 538 +++++++++++++++++++++++++++++------------------
 1 file changed, 329 insertions(+), 209 deletions(-)

diff --git a/src/tweenable.rs b/src/tweenable.rs
index 0c65d1e..8b066bf 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -108,12 +108,6 @@ pub struct TweenCompleted {
     pub progress: f32,
 }
 
-/// Calculate the progress fraction in \[0:1\] of the ratio between two
-/// [`Duration`]s.
-fn fraction_progress(n: Duration, d: Duration) -> f32 {
-    n.div_duration_f32(d)
-}
-
 #[derive(Debug)]
 struct AnimClock {
     elapsed: Duration,
@@ -146,6 +140,61 @@ impl AnimClock {
         )
     }
 
+    /// Get the elapsed cycle index, accounting for finite clock endpoint.
+    fn cycle_index(&self) -> u32 {
+        let index = self.elapsed.div_duration_f64(self.cycle_duration) as u32;
+        if let TotalDuration::Finite(total_duration) = self.total_duration {
+            if self.elapsed >= total_duration {
+                return index - 1;
+            }
+        }
+        index
+    }
+
+    /// Get the elapsed cycle fraction, accounting for finite clock endpoint.
+    fn cycle_fraction(&self) -> f32 {
+        let factor = self.elapsed.div_duration_f64(self.cycle_duration).fract() as f32;
+        if let TotalDuration::Finite(total_duration) = self.total_duration {
+            if self.elapsed >= total_duration {
+                return 1.0;
+            }
+        }
+        factor
+    }
+
+    /// Get the mirroring-aware cycle fraction, accounting for finite clock
+    /// endpoint.
+    fn mirrored_cycle_fraction(&self) -> f32 {
+        let ratio = self.elapsed.div_duration_f64(self.cycle_duration);
+        let index = ratio as u32;
+        let factor = ratio.fract() as f32;
+        if let TotalDuration::Finite(total_duration) = self.total_duration {
+            if self.elapsed >= total_duration {
+                if self.is_cycle_mirrored(index - 1) {
+                    return 0.0;
+                } else {
+                    return 1.0;
+                }
+            }
+        }
+        if self.is_cycle_mirrored(index) {
+            1.0 - factor
+        } else {
+            factor
+        }
+    }
+
+    /// Check if the current cycle is a mirrored cycle.
+    #[must_use]
+    #[inline]
+    pub fn is_cycle_mirrored(&self, index: u32) -> bool {
+        if self.strategy == RepeatStrategy::MirroredRepeat {
+            (index & 1) != 0
+        } else {
+            false
+        }
+    }
+
     fn times_completed(&self) -> u32 {
         self.elapsed.div_duration_f64(self.cycle_duration) as u32
     }
@@ -161,8 +210,10 @@ impl AnimClock {
 
         let state = match self.total_duration {
             TotalDuration::Finite(total_duration) => {
+                // Always clamp
+                self.elapsed = self.elapsed.min(total_duration);
+
                 if direction.is_forward() && self.elapsed >= total_duration {
-                    self.elapsed = total_duration;
                     TweenState::Completed
                 } else if direction.is_backward() && self.elapsed == Duration::ZERO {
                     TweenState::Completed
@@ -464,7 +515,7 @@ pub trait Tweenable: Send + Sync {
     /// a single direction, so tweening from start to end and back to start
     /// counts as two completed cycles (one forward, one backward).
     fn cycles_completed(&self) -> u32 {
-        self.elapsed().div_duration_f32(self.cycle_duration()) as u32
+        self.elapsed().div_duration_f64(self.cycle_duration()) as u32
     }
 }
 
@@ -507,9 +558,6 @@ pub struct Tween {
     clock: AnimClock,
     /// Direction of playback the user asked for.
     playback_direction: TweeningDirection,
-    /// Direction the playback moves in the current cycle. This may be different
-    /// from the playback direction when using MirroredRepeat.
-    cycle_direction: TweeningDirection,
     action: TweenAction,
     system_id: Option<SystemId>,
     send_completed_event: bool,
@@ -580,7 +628,6 @@ impl Tween {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
             playback_direction: TweeningDirection::Forward,
-            cycle_direction: TweeningDirection::Forward,
             action: TweenAction::Component(Box::new(action)),
             system_id: None,
             send_completed_event: false,
@@ -692,11 +739,7 @@ impl Tween {
     /// time of the tween. Only the direction of playback from this moment
     /// potentially changes.
     pub fn set_playback_direction(&mut self, direction: TweeningDirection) {
-        if self.playback_direction != direction {
-            self.playback_direction = direction;
-            // Reverse the current cycle too for consistency
-            self.cycle_direction = !self.cycle_direction;
-        }
+        self.playback_direction = direction;
     }
 
     /// Set the playback direction of the tween.
@@ -705,7 +748,6 @@ impl Tween {
     #[must_use]
     pub fn with_playback_direction(mut self, direction: TweeningDirection) -> Self {
         self.playback_direction = direction;
-        self.cycle_direction = direction;
         self
     }
 
@@ -723,16 +765,46 @@ impl Tween {
         self.playback_direction
     }
 
-    /// The direction of the current playback cycle.
+    /// Get the elapsed cycle index (numbered from 0), accounting for finite
+    /// endpoint.
     ///
-    /// Unlike [`playback_direction()`], which is controlled by the user, this
-    /// simply gives the direction of the current cycle. It depends on the
-    /// current elapsed time and the playback direction requested by the user.
+    /// If the elapsed time is equal to the total (finite) duration of the
+    /// tween, then the cycle index is capped at the total number of cycles
+    /// minus 1 (the tween doesn't loop when reaching the end of its last
+    /// cycle). This means that for a tween with N cycles, the index is always
+    /// in `0..N`, and therefore always `index < N`.
+    #[must_use]
+    #[inline]
+    pub fn cycle_index(&self) -> u32 {
+        self.clock.cycle_index()
+    }
+
+    /// Get the elapsed cycle fraction, accounting for finite endpoint.
     ///
-    /// See [`TweeningDirection`] for details.
+    /// The elapsed cycle fraction is the fraction alonside one cycle where the
+    /// tween currently is. This ignores any mirroring. If the elapsed time is
+    /// equal to the total (finite) duration of the tween, then the cycle
+    /// fraction is capped at `1.0` (the tween doesn't loop when reaching
+    /// the end of its last cycle).
+    ///
+    /// The returned value is always in `[0:1]` for finite tweens, and `[0:1)`
+    /// for infinite ones.
     #[must_use]
-    pub fn cycle_direction(&self) -> TweeningDirection {
-        self.cycle_direction
+    #[inline]
+    pub fn cycle_fraction(&self) -> f32 {
+        self.clock.cycle_fraction()
+    }
+
+    /// Check if the current cycle is a mirrored cycle.
+    ///
+    /// When the repeat strategy is [`RepeatStrategy::MirroredRepeat`], every
+    /// odd cycle index (numbered from 0) is mirrored when applying the tween's
+    /// lens. For any other strategy or single-cycle tween, this is always
+    /// `false`.
+    #[must_use]
+    #[inline]
+    pub fn is_cycle_mirrored(&self) -> bool {
+        self.clock.is_cycle_mirrored(self.clock.cycle_index())
     }
 
     /// Set the number of times to repeat the animation.
@@ -769,7 +841,6 @@ impl TweenAssetExtensions for Tween {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
             playback_direction: TweeningDirection::Forward,
-            cycle_direction: TweeningDirection::Forward,
             action: TweenAction::Asset(Box::new(action)),
             system_id: None,
             send_completed_event: false,
@@ -812,44 +883,15 @@ impl Tweenable for Tween {
             self.clock.tick_back(delta)
         };
 
-        // Check for reversing
-        if self.clock.strategy == RepeatStrategy::MirroredRepeat {
-            let times_completed_for_direction = match state {
-                TweenState::Active => times_completed.abs(),
-                // If completed, ignore last completion for the sake of direction reversing
-                TweenState::Completed => (times_completed.abs() - 1).max(0),
-            } as u32;
-            if times_completed_for_direction & 1 != 0 {
-                self.cycle_direction = !self.cycle_direction;
-            }
-        }
-
         let entity = ent_mut.id();
 
         // Apply the lens, even if the animation completed, to ensure the state is
         // consistent.
-        let progress = if state == TweenState::Completed {
-            if self.cycle_direction.is_forward() {
-                1.0
-            } else {
-                0.0
-            }
-        } else {
-            let factor = self
-                .clock
-                .elapsed
-                .div_duration_f32(self.clock.cycle_duration)
-                .fract();
-            if self.cycle_direction == self.playback_direction {
-                factor
-            } else {
-                1.0 - factor
-            }
-        };
-        let progress = self.ease_function.sample(progress);
+        let fraction = self.clock.mirrored_cycle_fraction();
+        let fraction = self.ease_function.sample(fraction);
         match &mut self.action {
             TweenAction::Component(action) => {
-                action(ent_mut, progress);
+                action(ent_mut, fraction);
             }
             _ => (), //debug!("Ignoring call to tick() a component with an asset action."),
         };
@@ -860,7 +902,7 @@ impl Tweenable for Tween {
                 let event = TweenCompleted {
                     id: tween_id,
                     entity,
-                    progress,
+                    progress: fraction,
                 };
 
                 // Send completion event
@@ -880,7 +922,6 @@ impl Tweenable for Tween {
     }
 
     fn rewind(&mut self) {
-        self.cycle_direction = self.playback_direction;
         self.clock.rewind(self.playback_direction);
     }
 }
@@ -1131,7 +1172,7 @@ impl Tweenable for Sequence {
 // ent_mut.reborrow(), events.reborrow());             any_active = any_active
 // || (state == TweenState::Active);         }
 //         if any_active {
-//             // FIXME(nightly): Duration::div_duration_f32()
+//             // FIXME(nightly): Duration::div_duration_f64()
 //             let ratio = self.elapsed.as_secs_f32() /
 // self.duration.as_secs_f32();             (ratio, TweenState::Active) // TODO
 //         } else {
@@ -1266,7 +1307,7 @@ impl Tweenable for Delay {
     ) -> TweenState {
         self.timer.tick(delta);
 
-        let _progress = fraction_progress(self.elapsed(), self.cycle_duration());
+        let _progress = self.elapsed().div_duration_f64(self.cycle_duration());
         let state = self.state();
 
         // // If completed this frame, notify the user
@@ -1315,6 +1356,113 @@ mod tests {
     //     last_reported_count: u32,
     // }
 
+    // Check the behavior of the functions calculating cycle information
+    #[test]
+    fn anim_clock_cycles() {
+        // The direction passed to AnimClock::set_elapsed() only affects the returned
+        // state, which is not tested in this test, so passing any value should produce
+        // the same test result here.
+        for dummy in [TweeningDirection::Forward, TweeningDirection::Backward] {
+            let cycle_duration = Duration::from_millis(100);
+            let repeat_count = 4;
+            let total_duration = cycle_duration * repeat_count;
+            let mut clock = AnimClock::new(cycle_duration);
+            clock.total_duration = TotalDuration::Finite(total_duration);
+
+            assert_eq!(cycle_duration, clock.cycle_duration);
+            assert_eq!(RepeatStrategy::Repeat, clock.strategy);
+
+            assert_eq!(Duration::ZERO, clock.elapsed());
+            assert_eq!(0, clock.cycle_index());
+            assert_approx_eq!(0.0, clock.cycle_fraction());
+            assert_approx_eq!(0.0, clock.mirrored_cycle_fraction());
+
+            let dt = Duration::from_millis(30);
+            clock.set_elapsed(dt, dummy);
+            assert_eq!(dt, clock.elapsed());
+            assert_eq!(0, clock.cycle_index());
+            assert_approx_eq!(0.3, clock.cycle_fraction());
+            assert_approx_eq!(0.3, clock.mirrored_cycle_fraction());
+
+            let dt = Duration::from_millis(110);
+            clock.set_elapsed(dt, dummy);
+            assert_eq!(dt, clock.elapsed());
+            assert_eq!(1, clock.cycle_index());
+            assert_approx_eq!(0.1, clock.cycle_fraction());
+            assert_approx_eq!(0.1, clock.mirrored_cycle_fraction());
+
+            let dt = Duration::from_millis(400);
+            clock.set_elapsed(dt, dummy);
+            assert_eq!(dt, clock.elapsed());
+            assert_eq!(3, clock.cycle_index()); // doesn't loop at end
+            assert_approx_eq!(1.0, clock.cycle_fraction()); // doesn't loop at end
+            assert_approx_eq!(1.0, clock.mirrored_cycle_fraction());
+
+            let dt = Duration::from_millis(410); // > total_duration; clamped
+            clock.set_elapsed(dt, dummy);
+            assert_eq!(total_duration, clock.elapsed()); // clamped
+            assert_eq!(3, clock.cycle_index()); // doesn't loop at end
+            assert_approx_eq!(1.0, clock.cycle_fraction()); // doesn't loop at end
+            assert_approx_eq!(1.0, clock.mirrored_cycle_fraction());
+
+            clock.strategy = RepeatStrategy::MirroredRepeat;
+
+            let dt = Duration::from_millis(110);
+            clock.set_elapsed(dt, dummy);
+            assert_eq!(dt, clock.elapsed());
+            assert_eq!(1, clock.cycle_index());
+            assert_approx_eq!(0.1, clock.cycle_fraction());
+            assert_approx_eq!(0.9, clock.mirrored_cycle_fraction()); // mirrored
+
+            let dt = Duration::from_millis(400);
+            clock.set_elapsed(dt, dummy);
+            assert_eq!(dt, clock.elapsed());
+            assert_eq!(3, clock.cycle_index()); // doesn't loop at end
+            assert_approx_eq!(1.0, clock.cycle_fraction()); // doesn't loop at end
+            assert_approx_eq!(0.0, clock.mirrored_cycle_fraction()); // mirrored
+
+            let dt = Duration::from_millis(410); // > total_duration; clamped
+            clock.set_elapsed(dt, dummy);
+            assert_eq!(total_duration, clock.elapsed()); // clamped
+            assert_eq!(3, clock.cycle_index()); // doesn't loop at end
+            assert_approx_eq!(1.0, clock.cycle_fraction()); // doesn't loop at end
+            assert_approx_eq!(0.0, clock.mirrored_cycle_fraction()); // mirrored
+        }
+    }
+
+    // Check the accumulated error of the clock over a long period
+    #[test]
+    fn anim_clock_precision() {
+        let cycle_duration = Duration::from_millis(1);
+        let mut clock = AnimClock::new(cycle_duration);
+        clock.total_duration = TotalDuration::Infinite;
+
+        let test_ticks = [
+            Duration::from_micros(123),
+            Duration::from_millis(1),
+            Duration::from_secs_f32(1. / 24.),
+            Duration::from_secs_f32(1. / 30.),
+            Duration::from_secs_f32(1. / 60.),
+            Duration::from_secs_f32(1. / 120.),
+            Duration::from_secs_f32(1. / 144.),
+            Duration::from_secs_f32(1. / 240.),
+        ];
+
+        let mut times_completed = 0;
+        let mut total_duration = Duration::ZERO;
+        let num_iter = 100_000_000; // 100m ms, >27h
+        for i in 0..num_iter {
+            let tick = test_ticks[i % test_ticks.len()];
+            times_completed += clock.tick(tick).1;
+            total_duration += tick;
+        }
+
+        assert_eq!(
+            total_duration.div_duration_f64(cycle_duration) as i32,
+            times_completed
+        );
+    }
+
     /// Utility to create a tween for testing.
     fn make_test_tween() -> Tween {
         Tween::new(
@@ -1399,38 +1547,6 @@ mod tests {
         assert!(target.is_changed());
     }
 
-    #[test]
-    fn anim_clock_precision() {
-        let cycle_duration = Duration::from_millis(1);
-        let mut clock = AnimClock::new(cycle_duration);
-        clock.total_duration = TotalDuration::Infinite;
-
-        let test_ticks = [
-            Duration::from_micros(123),
-            Duration::from_millis(1),
-            Duration::from_secs_f32(1. / 24.),
-            Duration::from_secs_f32(1. / 30.),
-            Duration::from_secs_f32(1. / 60.),
-            Duration::from_secs_f32(1. / 120.),
-            Duration::from_secs_f32(1. / 144.),
-            Duration::from_secs_f32(1. / 240.),
-        ];
-
-        let mut times_completed = 0;
-        let mut total_duration = Duration::ZERO;
-        let num_iter = 100_000_000; // 100m ms, >27h
-        for i in 0..num_iter {
-            let tick = test_ticks[i % test_ticks.len()];
-            times_completed += clock.tick(tick).1;
-            total_duration += tick;
-        }
-
-        assert_eq!(
-            total_duration.div_duration_f64(cycle_duration) as i32,
-            times_completed
-        );
-    }
-
     #[test]
     fn into_repeat_count() {
         let tween = Tween::new(
@@ -1465,9 +1581,7 @@ mod tests {
     /// Test ticking of a single tween in isolation.
     #[test]
     fn tween_tick() {
-        for playback_direction in [
-            /*TweeningDirection::Forward,*/ TweeningDirection::Backward,
-        ] {
+        for playback_direction in [TweeningDirection::Forward, TweeningDirection::Backward] {
             for (count, strategy) in [
                 (RepeatCount::Finite(1), RepeatStrategy::default()),
                 (RepeatCount::Infinite, RepeatStrategy::Repeat),
@@ -1476,7 +1590,7 @@ mod tests {
                 (RepeatCount::Finite(2), RepeatStrategy::MirroredRepeat),
             ] {
                 println!(
-                    "TweeningType: count={count:?} strategy={strategy:?} playback={playback_direction:?}",
+                    "TweeningType: playback={playback_direction:?} count={count:?} strategy={strategy:?}",
                 );
 
                 // Create a linear tween over 1 second
@@ -1487,9 +1601,17 @@ mod tests {
                     .with_completed_event(true);
                 assert_eq!(tween.playback_direction(), playback_direction);
 
+                // Note: for infinite duration playing backward, we need to start *somewhere*
+                // since we can't start at infinity. So pick t=1s which is shorter than 11
+                // iterations of the 100ms test tween created by make_test_tween(), to ensure we
+                // reach t=0.
+                let backward_duration = tween
+                    .total_duration()
+                    .as_finite()
+                    .unwrap_or(Duration::from_secs(1));
                 if playback_direction == TweeningDirection::Backward {
                     // Seek to end, so that backward playback actually does something
-                    tween.set_elapsed(tween.total_duration().as_finite().unwrap());
+                    tween.set_elapsed(backward_duration);
                 }
 
                 let (mut world, entity, system_id) = make_test_env();
@@ -1510,98 +1632,87 @@ mod tests {
                 for i in 1..=11 {
                     // Calculate expected values
                     let mut elapsed = tick_duration * i;
-                    let (factor, times_completed, mut direction, expected_state, just_completed) =
-                        match count {
-                            RepeatCount::Finite(1) => {
-                                elapsed = elapsed.min(tween_duration);
-                                let times_completed = u32::from(i >= 5);
-                                let (factor, state) = if i < 5 {
-                                    (i as f32 * 0.2, TweenState::Active)
+                    let effectively_elapsed = if playback_direction.is_forward() {
+                        elapsed
+                    } else {
+                        backward_duration.saturating_sub(elapsed)
+                    };
+                    let cycles_completed = match count {
+                        RepeatCount::Infinite => effectively_elapsed,
+                        RepeatCount::Finite(count) => {
+                            effectively_elapsed.min(tween_duration * count)
+                        }
+                        RepeatCount::For(time) => effectively_elapsed.min(time),
+                    }
+                    .div_duration_f64(tween_duration)
+                        as u32;
+                    let (factor, mut direction, expected_state, just_completed) = match count {
+                        RepeatCount::Finite(1) => {
+                            elapsed = elapsed.min(tween_duration);
+                            let (factor, state) = if i < 5 {
+                                (i as f32 * 0.2, TweenState::Active)
+                            } else {
+                                (1.0, TweenState::Completed)
+                            };
+                            let just_completed = i == 5;
+                            (factor, TweeningDirection::Forward, state, just_completed)
+                        }
+                        RepeatCount::Finite(count) => {
+                            elapsed = elapsed.min(tween_duration * count);
+                            if strategy == RepeatStrategy::Repeat {
+                                let just_completed = i % 5 == 0;
+                                let (factor, state) = if i < 10 {
+                                    ((i as f32 * 0.2).fract(), TweenState::Active)
                                 } else {
                                     (1.0, TweenState::Completed)
                                 };
-                                let just_completed = i == 5;
+                                (factor, TweeningDirection::Forward, state, just_completed)
+                            } else {
+                                let i5 = i % 5;
+                                let just_completed = i5 == 0;
+                                let (factor, state) = if i < 10 {
+                                    ((i as f32 * 0.2).fract(), TweenState::Active)
+                                } else {
+                                    (1.0, TweenState::Completed)
+                                };
+                                // Once Completed, the direction doesn't change
+                                let direction = if i >= 5 {
+                                    TweeningDirection::Backward
+                                } else {
+                                    TweeningDirection::Forward
+                                };
+                                (factor, direction, state, just_completed)
+                            }
+                        }
+                        RepeatCount::Infinite => {
+                            if strategy == RepeatStrategy::Repeat {
+                                let just_completed = i % 5 == 0;
                                 (
-                                    factor,
-                                    times_completed,
+                                    (i as f32 * 0.2).fract(),
                                     TweeningDirection::Forward,
-                                    state,
+                                    TweenState::Active,
                                     just_completed,
                                 )
-                            }
-                            RepeatCount::Finite(count) => {
-                                elapsed = elapsed.min(tween_duration * count);
-                                if strategy == RepeatStrategy::Repeat {
-                                    let times_completed = i / 5;
-                                    let just_completed = i % 5 == 0;
-                                    let (factor, state) = if i < 10 {
-                                        ((i as f32 * 0.2).fract(), TweenState::Active)
-                                    } else {
-                                        (1.0, TweenState::Completed)
-                                    };
-                                    (
-                                        factor,
-                                        times_completed,
-                                        TweeningDirection::Forward,
-                                        state,
-                                        just_completed,
-                                    )
+                            } else {
+                                let i5 = i % 5;
+                                let i10 = i % 10;
+                                let factor = i5 as f32 * 0.2;
+                                let factor = if cycles_completed & 1 != 0 {
+                                    1.0 - factor
                                 } else {
-                                    let i5 = i % 5;
-                                    let times_completed = i / 5;
-                                    let just_completed = i5 == 0;
-                                    let (factor, state) = if i < 10 {
-                                        ((i as f32 * 0.2).fract(), TweenState::Active)
-                                    } else {
-                                        (1.0, TweenState::Completed)
-                                    };
-                                    // Once Completed, the direction doesn't change
-                                    let direction = if i >= 5 {
-                                        TweeningDirection::Backward
-                                    } else {
-                                        TweeningDirection::Forward
-                                    };
-                                    (factor, times_completed, direction, state, just_completed)
-                                }
-                            }
-                            RepeatCount::Infinite => {
-                                if strategy == RepeatStrategy::Repeat {
-                                    let times_completed = i / 5;
-                                    let just_completed = i % 5 == 0;
-                                    (
-                                        (i as f32 * 0.2).fract(),
-                                        times_completed,
-                                        TweeningDirection::Forward,
-                                        TweenState::Active,
-                                        just_completed,
-                                    )
+                                    factor
+                                };
+                                let (direction, factor) = if i10 >= 5 {
+                                    (TweeningDirection::Backward, 1.0 - factor)
                                 } else {
-                                    let i5 = i % 5;
-                                    let times_completed = i / 5;
-                                    let i10 = i % 10;
-                                    let factor = i5 as f32 * 0.2;
-                                    let factor = if times_completed & 1 != 0 {
-                                        1.0 - factor
-                                    } else {
-                                        factor
-                                    };
-                                    let (direction, factor) = if i10 >= 5 {
-                                        (TweeningDirection::Backward, 1.0 - factor)
-                                    } else {
-                                        (TweeningDirection::Forward, factor)
-                                    };
-                                    let just_completed = i5 == 0;
-                                    (
-                                        factor,
-                                        times_completed,
-                                        direction,
-                                        TweenState::Active,
-                                        just_completed,
-                                    )
-                                }
+                                    (TweeningDirection::Forward, factor)
+                                };
+                                let just_completed = i5 == 0;
+                                (factor, direction, TweenState::Active, just_completed)
                             }
-                            RepeatCount::For(_) => panic!("Untested"),
-                        };
+                        }
+                        RepeatCount::For(_) => panic!("Untested"),
+                    };
                     if playback_direction.is_backward() {
                         direction = !direction;
                     }
@@ -1610,9 +1721,14 @@ mod tests {
                     } else {
                         Vec3::splat(1. - factor)
                     };
+                    let elapsed = if playback_direction.is_forward() {
+                        elapsed
+                    } else {
+                        backward_duration.saturating_sub(elapsed)
+                    };
                     println!(
-                        "Expected: elapsed={:?} factor={} times_completed={} direction={:?} state={:?} just_completed={} translation={:?}",
-                        elapsed, factor, times_completed, direction, expected_state, just_completed, expected_translation
+                        "+ Expected: elapsed={:?} factor={} times_completed={} direction={:?} state={:?} just_completed={} translation={:?}",
+                        elapsed, factor, cycles_completed, direction, expected_state, just_completed, expected_translation
                     );
 
                     // Tick the tween
@@ -1625,21 +1741,15 @@ mod tests {
                     );
 
                     // Check actual values
-                    assert_eq!(tween.cycle_direction(), direction);
+                    assert_eq!(tween.is_cycle_mirrored(), direction != playback_direction);
                     assert_eq!(actual_state, expected_state);
-                    if playback_direction.is_forward() {
-                        assert_eq!(tween.elapsed(), elapsed);
-                    } else {
-                        assert_eq!(
-                            tween.elapsed(),
-                            tween.total_duration().as_finite().unwrap() - elapsed
-                        );
-                    }
-                    assert_eq!(tween.cycles_completed(), times_completed);
+                    assert_eq!(tween.elapsed(), elapsed);
+                    assert_eq!(tween.cycles_completed(), cycles_completed);
                     let transform = world.entity(entity).get::<Transform>().unwrap();
                     assert_approx_eq!(expected_translation, transform.translation, 1e-5);
                     assert_approx_eq!(Quat::IDENTITY, transform.rotation, 1e-5);
-                    {
+                    // FIXME - decide what to do with events when playing backward
+                    if playback_direction.is_forward() {
                         let mut event_reader = event_reader_system_state.get_mut(&mut world);
                         let event = event_reader.read().next();
                         if just_completed {
@@ -1656,8 +1766,20 @@ mod tests {
                 // Rewind
                 tween.rewind();
                 assert_eq!(tween.playback_direction(), playback_direction); // does not change
-                assert_eq!(tween.elapsed(), Duration::ZERO);
-                assert_eq!(tween.cycles_completed(), 0);
+                if playback_direction.is_forward() {
+                    assert_eq!(tween.elapsed(), Duration::ZERO);
+                    assert_eq!(tween.cycles_completed(), 0);
+                } else {
+                    assert_eq!(tween.elapsed(), backward_duration);
+                    let cycles_completed = match count {
+                        RepeatCount::Infinite => backward_duration,
+                        RepeatCount::Finite(count) => backward_duration.min(tween_duration * count),
+                        RepeatCount::For(time) => backward_duration.min(time),
+                    }
+                    .div_duration_f64(tween_duration)
+                        as u32;
+                    assert_eq!(cycles_completed, tween.cycles_completed());
+                }
 
                 // Dummy tick to update target
                 let actual_state = manual_tick_component(
@@ -1667,17 +1789,15 @@ mod tests {
                     &mut world,
                     entity,
                 );
-                assert_eq!(actual_state, TweenState::Active);
+                assert_eq!(TweenState::Active, actual_state);
                 let expected_translation = if playback_direction.is_backward() {
                     Vec3::ONE
                 } else {
                     Vec3::ZERO
                 };
                 let transform = world.entity(entity).get::<Transform>().unwrap();
-                assert!(transform
-                    .translation
-                    .abs_diff_eq(expected_translation, 1e-5));
-                assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
+                assert_approx_eq!(expected_translation, transform.translation, 1e-5);
+                assert_approx_eq!(Quat::IDENTITY, transform.rotation, 1e-5);
 
                 // Clear event sending
                 tween.set_completed_event(false);
@@ -2232,7 +2352,7 @@ mod tests {
             entity,
         );
         assert_eq!(TweenState::Active, state);
-        assert_eq!(TweeningDirection::Forward, tween.cycle_direction());
+        assert!(!tween.is_cycle_mirrored());
         assert_eq!(0, tween.cycles_completed());
         assert_eq!(dt, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
@@ -2240,7 +2360,7 @@ mod tests {
 
         // rewind
         tween.rewind();
-        assert_eq!(TweeningDirection::Forward, tween.cycle_direction());
+        assert!(!tween.is_cycle_mirrored());
         assert_eq!(0, tween.cycles_completed());
         assert_eq!(Duration::ZERO, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
@@ -2255,7 +2375,7 @@ mod tests {
             &mut world,
             entity,
         );
-        assert_eq!(TweeningDirection::Backward, tween.cycle_direction());
+        assert!(tween.is_cycle_mirrored());
         assert_eq!(TweenState::Active, state);
         assert_eq!(1, tween.cycles_completed());
         assert_eq!(dt, tween.elapsed());
@@ -2263,9 +2383,9 @@ mod tests {
         assert_approx_eq!(Vec3::splat(0.8), transform.translation, 1e-5);
 
         // rewind
-        assert_eq!(TweeningDirection::Backward, tween.cycle_direction());
+        assert!(tween.is_cycle_mirrored());
         tween.rewind();
-        assert_eq!(TweeningDirection::Forward, tween.cycle_direction()); //restored
+        assert!(!tween.is_cycle_mirrored()); //restored
         assert_eq!(0, tween.cycles_completed());
         assert_eq!(Duration::ZERO, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();
@@ -2281,16 +2401,16 @@ mod tests {
             entity,
         );
         assert_eq!(TweenState::Completed, state);
-        assert_eq!(TweeningDirection::Backward, tween.cycle_direction()); // frozen from last loop
+        assert!(tween.is_cycle_mirrored()); // frozen from last loop
         assert_eq!(4, tween.cycles_completed());
         assert_eq!(dt, tween.elapsed()); // Completed
         let transform = world.entity(entity).get::<Transform>().unwrap();
         assert_approx_eq!(Vec3::ZERO, transform.translation, 1e-5);
 
         // rewind
-        assert_eq!(TweeningDirection::Backward, tween.cycle_direction());
+        assert!(tween.is_cycle_mirrored());
         tween.rewind();
-        assert_eq!(TweeningDirection::Forward, tween.cycle_direction()); // restored
+        assert!(!tween.is_cycle_mirrored()); // restored
         assert_eq!(0, tween.cycles_completed());
         assert_eq!(Duration::ZERO, tween.elapsed());
         let transform = world.entity(entity).get::<Transform>().unwrap();

From dc46592b9a1c14515758b630eb93d887555f8c38 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 29 Jun 2025 12:21:35 +0100
Subject: [PATCH 11/66] Fix backward tests

---
 src/tweenable.rs | 412 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 282 insertions(+), 130 deletions(-)

diff --git a/src/tweenable.rs b/src/tweenable.rs
index 8b066bf..bdded1f 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -127,17 +127,65 @@ impl AnimClock {
     }
 
     fn tick(&mut self, tick: Duration) -> (TweenState, i32) {
-        self.set_elapsed(
-            self.elapsed.saturating_add(tick),
-            TweeningDirection::Forward,
-        )
+        let mut next_elapsed = self.elapsed.saturating_add(tick);
+
+        if !self.total_duration.is_finite() {
+            // Infinite tweens loops around...
+            let period = if self.strategy == RepeatStrategy::MirroredRepeat {
+                // ...over 2 cycles if mirrored
+                self.cycle_duration * 2
+            } else {
+                // ...over 1 cycle if not
+                self.cycle_duration
+            };
+            if next_elapsed >= period {
+                // Common case, just loop once
+                next_elapsed -= period;
+
+                // In case of very large jumps, handle arbitrary cycle count
+                if next_elapsed >= period {
+                    let count = next_elapsed.div_duration_f64(period) as u32;
+                    next_elapsed -= period * count;
+                    debug_assert!(next_elapsed < period);
+                }
+            }
+        };
+
+        self.set_elapsed(next_elapsed, TweeningDirection::Forward)
     }
 
-    fn tick_back(&mut self, tick: Duration) -> (TweenState, i32) {
-        self.set_elapsed(
-            self.elapsed.saturating_sub(tick),
-            TweeningDirection::Backward,
-        )
+    fn tick_back(&mut self, mut tick: Duration) -> (TweenState, i32) {
+        let mut next_elapsed = self.elapsed.saturating_sub(tick);
+
+        if !self.total_duration.is_finite() && (tick >= self.elapsed) {
+            // Infinite tweens loops around...
+            let period = if self.strategy == RepeatStrategy::MirroredRepeat {
+                // ...over 2 cycles if mirrored
+                self.cycle_duration * 2
+            } else {
+                // ...over 1 cycle if not
+                self.cycle_duration
+            };
+
+            // Consume some time to move back to t=0
+            tick -= self.elapsed;
+
+            // In case of very large jumps, handle arbitrary cycle count
+            if tick >= period {
+                let count = tick.div_duration_f64(period) as u32;
+                tick -= period * count;
+            }
+
+            // Common case, just loop once
+            debug_assert!(tick < period);
+            next_elapsed = if tick == Duration::ZERO {
+                Duration::ZERO
+            } else {
+                period - tick
+            };
+        };
+
+        self.set_elapsed(next_elapsed, TweeningDirection::Backward)
     }
 
     /// Get the elapsed cycle index, accounting for finite clock endpoint.
@@ -1600,26 +1648,25 @@ mod tests {
                     .with_repeat_strategy(strategy)
                     .with_completed_event(true);
                 assert_eq!(tween.playback_direction(), playback_direction);
+                assert!(tween.send_completed_event);
 
                 // Note: for infinite duration playing backward, we need to start *somewhere*
                 // since we can't start at infinity. So pick t=1s which is shorter than 11
                 // iterations of the 100ms test tween created by make_test_tween(), to ensure we
                 // reach t=0.
-                let backward_duration = tween
+                let backward_start_time = tween
                     .total_duration()
                     .as_finite()
                     .unwrap_or(Duration::from_secs(1));
                 if playback_direction == TweeningDirection::Backward {
                     // Seek to end, so that backward playback actually does something
-                    tween.set_elapsed(backward_duration);
+                    tween.set_elapsed(backward_start_time);
                 }
 
                 let (mut world, entity, system_id) = make_test_env();
                 let mut event_reader_system_state: SystemState<EventReader<TweenCompleted>> =
                     SystemState::new(&mut world);
 
-                assert!(tween.send_completed_event);
-
                 // Activate oneshot system
                 tween.set_completed_system(system_id);
                 assert!(tween.system_id.is_some());
@@ -1631,101 +1678,195 @@ mod tests {
                 let tween_duration = Duration::from_secs(1);
                 for i in 1..=11 {
                     // Calculate expected values
-                    let mut elapsed = tick_duration * i;
-                    let effectively_elapsed = if playback_direction.is_forward() {
-                        elapsed
-                    } else {
-                        backward_duration.saturating_sub(elapsed)
-                    };
-                    let cycles_completed = match count {
-                        RepeatCount::Infinite => effectively_elapsed,
-                        RepeatCount::Finite(count) => {
-                            effectively_elapsed.min(tween_duration * count)
-                        }
-                        RepeatCount::For(time) => effectively_elapsed.min(time),
-                    }
-                    .div_duration_f64(tween_duration)
-                        as u32;
-                    let (factor, mut direction, expected_state, just_completed) = match count {
-                        RepeatCount::Finite(1) => {
-                            elapsed = elapsed.min(tween_duration);
-                            let (factor, state) = if i < 5 {
-                                (i as f32 * 0.2, TweenState::Active)
-                            } else {
-                                (1.0, TweenState::Completed)
-                            };
-                            let just_completed = i == 5;
-                            (factor, TweeningDirection::Forward, state, just_completed)
-                        }
-                        RepeatCount::Finite(count) => {
-                            elapsed = elapsed.min(tween_duration * count);
-                            if strategy == RepeatStrategy::Repeat {
-                                let just_completed = i % 5 == 0;
-                                let (factor, state) = if i < 10 {
-                                    ((i as f32 * 0.2).fract(), TweenState::Active)
-                                } else {
-                                    (1.0, TweenState::Completed)
-                                };
-                                (factor, TweeningDirection::Forward, state, just_completed)
-                            } else {
-                                let i5 = i % 5;
-                                let just_completed = i5 == 0;
-                                let (factor, state) = if i < 10 {
-                                    ((i as f32 * 0.2).fract(), TweenState::Active)
-                                } else {
-                                    (1.0, TweenState::Completed)
-                                };
-                                // Once Completed, the direction doesn't change
-                                let direction = if i >= 5 {
-                                    TweeningDirection::Backward
+                    let (elapsed_ms, factor, mut direction, expected_state, just_completed) =
+                        match count {
+                            RepeatCount::Finite(1) => {
+                                let (elapsed_ms, state) = if playback_direction.is_forward() {
+                                    if i < 5 {
+                                        (i * 200i32, TweenState::Active)
+                                    } else {
+                                        (1000i32, TweenState::Completed)
+                                    }
                                 } else {
-                                    TweeningDirection::Forward
+                                    if i < 5 {
+                                        (1000i32 - i * 200i32, TweenState::Active)
+                                    } else {
+                                        (0i32, TweenState::Completed)
+                                    }
                                 };
-                                (factor, direction, state, just_completed)
-                            }
-                        }
-                        RepeatCount::Infinite => {
-                            if strategy == RepeatStrategy::Repeat {
-                                let just_completed = i % 5 == 0;
+                                let just_completed = i == 5;
                                 (
-                                    (i as f32 * 0.2).fract(),
+                                    elapsed_ms,
+                                    elapsed_ms as f32 / 1000.0,
                                     TweeningDirection::Forward,
-                                    TweenState::Active,
+                                    state,
                                     just_completed,
                                 )
-                            } else {
-                                let i5 = i % 5;
-                                let i10 = i % 10;
-                                let factor = i5 as f32 * 0.2;
-                                let factor = if cycles_completed & 1 != 0 {
-                                    1.0 - factor
+                            }
+                            RepeatCount::Finite(count) => {
+                                if strategy == RepeatStrategy::Repeat {
+                                    let just_completed = i % 5 == 0;
+                                    let elapsed_ms = if playback_direction.is_forward() {
+                                        // 0.2, 0.4, 0.6, 0.8, 0.0, 0.2, 0.4, ... (x count)
+                                        (i * 200) % 1000
+                                    } else {
+                                        // 0.8, 0.6, 0.4, 0.2, 0.0, 0.8, 0.6, ... (x count)
+                                        800 - (((i - 1) * 200 - 1000) % 1000 + 1000) % 1000
+                                    };
+                                    let factor = if i >= 10 {
+                                        if playback_direction.is_forward() {
+                                            1.0
+                                        } else {
+                                            0.0
+                                        }
+                                    } else {
+                                        elapsed_ms as f32 / 1000.0
+                                    };
+                                    let total_duration_ms = count as i32 * 1000;
+                                    let elapsed_ms = if playback_direction.is_forward() {
+                                        (i * 200).min(total_duration_ms)
+                                    } else {
+                                        (total_duration_ms - i * 200).max(0)
+                                    };
+                                    // The test is calibrates such that at i==10 the forward tick
+                                    // reaches the total duration, and the backward tick reaches
+                                    // t=0, both of which yield a Completed state
+                                    let state = if i >= 10 {
+                                        TweenState::Completed
+                                    } else {
+                                        TweenState::Active
+                                    };
+                                    (
+                                        elapsed_ms,
+                                        factor,
+                                        TweeningDirection::Forward,
+                                        state,
+                                        just_completed,
+                                    )
                                 } else {
-                                    factor
-                                };
-                                let (direction, factor) = if i10 >= 5 {
-                                    (TweeningDirection::Backward, 1.0 - factor)
+                                    let i5 = i % 5;
+                                    let just_completed = i5 == 0;
+
+                                    // Inifinite-repeat unclamped value
+                                    let elapsed_ms = if playback_direction.is_forward() {
+                                        // 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0, 0.2,
+                                        // 0.4, ...
+                                        (((i - 5000) * 200) % 2000) - 1000
+                                    } else {
+                                        // 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0, ...
+                                        (((i + 5) * 200) % 2000) - 1000
+                                    }
+                                    .abs();
+
+                                    // Now clamp to 'count' repeats
+                                    let (elapsed_ms, state) = if i < 10 {
+                                        (elapsed_ms, TweenState::Active)
+                                    } else {
+                                        (0, TweenState::Completed)
+                                    };
+                                    let ratio = elapsed_ms as f32 / 1000.;
+
+                                    let total_duration_ms = count as i32 * 1000;
+                                    let elapsed_ms = if playback_direction.is_forward() {
+                                        (i * 200).min(total_duration_ms)
+                                    } else {
+                                        (total_duration_ms - i * 200).max(0)
+                                    };
+
+                                    // Once Completed, the direction doesn't change
+                                    let direction = if playback_direction.is_forward() {
+                                        // 2468X 86420 00
+                                        // ffffb bbbbf ff
+                                        if (i % 10) >= 5 && i < 10 {
+                                            TweeningDirection::Backward
+                                        } else {
+                                            TweeningDirection::Forward
+                                        }
+                                    } else {
+                                        // 86420 2468X XX
+                                        // bbbbb fffff ff
+                                        if i <= 5 {
+                                            TweeningDirection::Backward
+                                        } else {
+                                            TweeningDirection::Forward
+                                        }
+                                    };
+
+                                    (elapsed_ms, ratio, direction, state, just_completed)
+                                }
+                            }
+                            RepeatCount::Infinite => {
+                                if strategy == RepeatStrategy::Repeat {
+                                    let just_completed = i % 5 == 0;
+                                    let elapsed_ms = if playback_direction.is_forward() {
+                                        // 0.2, 0.4, 0.6, 0.8, 0.0, 0.2, 0.4, ...
+                                        (i * 200) % 1000
+                                    } else {
+                                        // 0.8, 0.6, 0.4, 0.2, 0.0, 0.8, 0.6, ...
+                                        800 - (((i - 1) * 200 - 1000) % 1000 + 1000) % 1000
+                                    };
+                                    (
+                                        elapsed_ms,
+                                        elapsed_ms as f32 / 1000.0,
+                                        TweeningDirection::Forward,
+                                        TweenState::Active,
+                                        just_completed,
+                                    )
                                 } else {
-                                    (TweeningDirection::Forward, factor)
-                                };
-                                let just_completed = i5 == 0;
-                                (factor, direction, TweenState::Active, just_completed)
+                                    let elapsed_ms = if playback_direction.is_forward() {
+                                        // 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0, 0.2,
+                                        // 0.4, ...
+                                        (((i - 5000) * 200) % 2000) - 1000
+                                    } else {
+                                        // 0.8, 0.6, 0.4, 0.2, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 0.8,
+                                        // 0.6, ...
+                                        ((i * 200) % 2000) - 1000
+                                    }
+                                    .abs();
+                                    let factor = elapsed_ms as f32 / 1000.0;
+                                    // 0.8, 0.6, 0.4, 0.2, 0.0, 1.8, 1.6, 1.4, ... (seconds)
+                                    let elapsed_ms = (2000i32 - (i - 5) * 200).rem_euclid(2000);
+                                    let direction = if playback_direction.is_forward() {
+                                        // 2468X 86420 24
+                                        // ffffb bbbbf ff
+                                        if (i % 10) >= 5 {
+                                            TweeningDirection::Backward
+                                        } else {
+                                            TweeningDirection::Forward
+                                        }
+                                    } else {
+                                        // 86420 2468X 86
+                                        // bbbbb fffff bb
+                                        if ((i - 1) % 10) >= 5 {
+                                            TweeningDirection::Backward
+                                        } else {
+                                            TweeningDirection::Forward
+                                        }
+                                    };
+                                    let just_completed = (i % 5) == 0;
+                                    (
+                                        elapsed_ms,
+                                        factor,
+                                        direction,
+                                        TweenState::Active,
+                                        just_completed,
+                                    )
+                                }
                             }
-                        }
-                        RepeatCount::For(_) => panic!("Untested"),
-                    };
+                            RepeatCount::For(_) => panic!("Untested"),
+                        };
                     if playback_direction.is_backward() {
                         direction = !direction;
                     }
-                    let expected_translation = if direction.is_forward() {
-                        Vec3::splat(factor)
-                    } else {
-                        Vec3::splat(1. - factor)
-                    };
-                    let elapsed = if playback_direction.is_forward() {
-                        elapsed
-                    } else {
-                        backward_duration.saturating_sub(elapsed)
-                    };
+                    let expected_translation = Vec3::splat(factor);
+                    let elapsed = Duration::from_millis(elapsed_ms as u64);
+                    let cycles_completed = match count {
+                        RepeatCount::Infinite => elapsed,
+                        RepeatCount::Finite(count) => elapsed.min(tween_duration * count),
+                        RepeatCount::For(time) => elapsed.min(time),
+                    }
+                    .div_duration_f64(tween_duration)
+                        as u32;
                     println!(
                         "+ Expected: elapsed={:?} factor={} times_completed={} direction={:?} state={:?} just_completed={} translation={:?}",
                         elapsed, factor, cycles_completed, direction, expected_state, just_completed, expected_translation
@@ -1748,7 +1889,8 @@ mod tests {
                     let transform = world.entity(entity).get::<Transform>().unwrap();
                     assert_approx_eq!(expected_translation, transform.translation, 1e-5);
                     assert_approx_eq!(Quat::IDENTITY, transform.rotation, 1e-5);
-                    // FIXME - decide what to do with events when playing backward
+
+                    // Events are only sent when playing forward
                     if playback_direction.is_forward() {
                         let mut event_reader = event_reader_system_state.get_mut(&mut world);
                         let event = event_reader.read().next();
@@ -1763,41 +1905,51 @@ mod tests {
                     }
                 }
 
-                // Rewind
-                tween.rewind();
-                assert_eq!(tween.playback_direction(), playback_direction); // does not change
-                if playback_direction.is_forward() {
-                    assert_eq!(tween.elapsed(), Duration::ZERO);
-                    assert_eq!(tween.cycles_completed(), 0);
-                } else {
-                    assert_eq!(tween.elapsed(), backward_duration);
-                    let cycles_completed = match count {
-                        RepeatCount::Infinite => backward_duration,
-                        RepeatCount::Finite(count) => backward_duration.min(tween_duration * count),
-                        RepeatCount::For(time) => backward_duration.min(time),
+                // Can't rewind infinite tweens moving backward, they don't have an endpoint
+                if tween.total_duration().is_finite()
+                    || (playback_direction != TweeningDirection::Backward)
+                {
+                    // Rewind
+                    println!("+ Rewind");
+                    tween.rewind();
+                    assert_eq!(tween.playback_direction(), playback_direction); // does not change
+                    if playback_direction.is_forward() {
+                        assert_eq!(tween.elapsed(), Duration::ZERO);
+                        assert_eq!(tween.cycles_completed(), 0);
+                    } else {
+                        assert_eq!(tween.elapsed(), backward_start_time);
+                        let cycles_completed = match count {
+                            RepeatCount::Infinite => backward_start_time,
+                            RepeatCount::Finite(count) => {
+                                backward_start_time.min(tween_duration * count)
+                            }
+                            RepeatCount::For(time) => backward_start_time.min(time),
+                        }
+                        .div_duration_f64(tween_duration)
+                            as u32;
+                        assert_eq!(cycles_completed, tween.cycles_completed());
                     }
-                    .div_duration_f64(tween_duration)
-                        as u32;
-                    assert_eq!(cycles_completed, tween.cycles_completed());
-                }
 
-                // Dummy tick to update target
-                let actual_state = manual_tick_component(
-                    TweenId::null(), // unused in this test
-                    Duration::ZERO,
-                    &mut tween,
-                    &mut world,
-                    entity,
-                );
-                assert_eq!(TweenState::Active, actual_state);
-                let expected_translation = if playback_direction.is_backward() {
-                    Vec3::ONE
-                } else {
-                    Vec3::ZERO
-                };
-                let transform = world.entity(entity).get::<Transform>().unwrap();
-                assert_approx_eq!(expected_translation, transform.translation, 1e-5);
-                assert_approx_eq!(Quat::IDENTITY, transform.rotation, 1e-5);
+                    // Dummy tick to update target
+                    let actual_state = manual_tick_component(
+                        TweenId::null(), // unused in this test
+                        Duration::ZERO,
+                        &mut tween,
+                        &mut world,
+                        entity,
+                    );
+                    assert_eq!(TweenState::Active, actual_state);
+                    let expected_translation = if playback_direction.is_backward()
+                        && strategy != RepeatStrategy::MirroredRepeat
+                    {
+                        Vec3::ONE
+                    } else {
+                        Vec3::ZERO
+                    };
+                    let transform = world.entity(entity).get::<Transform>().unwrap();
+                    assert_approx_eq!(expected_translation, transform.translation, 1e-5);
+                    assert_approx_eq!(Quat::IDENTITY, transform.rotation, 1e-5);
+                }
 
                 // Clear event sending
                 tween.set_completed_event(false);

From b3b7e8d0c255fb28e1ac84f76e80587e1984fe03 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 29 Jun 2025 14:21:00 +0100
Subject: [PATCH 12/66] Fix infinite repeat test

---
 src/tweenable.rs | 69 +++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 53 insertions(+), 16 deletions(-)

diff --git a/src/tweenable.rs b/src/tweenable.rs
index bdded1f..d4aba05 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -129,6 +129,7 @@ impl AnimClock {
     fn tick(&mut self, tick: Duration) -> (TweenState, i32) {
         let mut next_elapsed = self.elapsed.saturating_add(tick);
 
+        let mut extra_completed: i32 = 0;
         if !self.total_duration.is_finite() {
             // Infinite tweens loops around...
             let period = if self.strategy == RepeatStrategy::MirroredRepeat {
@@ -141,17 +142,30 @@ impl AnimClock {
             if next_elapsed >= period {
                 // Common case, just loop once
                 next_elapsed -= period;
+                extra_completed += 1;
 
                 // In case of very large jumps, handle arbitrary cycle count
                 if next_elapsed >= period {
                     let count = next_elapsed.div_duration_f64(period) as u32;
                     next_elapsed -= period * count;
+                    extra_completed += count as i32;
                     debug_assert!(next_elapsed < period);
                 }
             }
         };
 
-        self.set_elapsed(next_elapsed, TweeningDirection::Forward)
+        let (state, mut times_completed) =
+            self.set_elapsed(next_elapsed, TweeningDirection::Forward);
+
+        if extra_completed > 0 && (times_completed < 0) {
+            // The clock looped around, so returns -1. But we're already counting that loop
+            // in the extra cycles calculated above. It can't return anything else than -1
+            // or 0 because we clamped next_elapsed.
+            debug_assert_eq!(-1, times_completed);
+            times_completed = 0;
+        }
+
+        (state, times_completed + extra_completed)
     }
 
     fn tick_back(&mut self, mut tick: Duration) -> (TweenState, i32) {
@@ -502,7 +516,7 @@ pub trait Tweenable: Send + Sync {
     /// For [`TotalDuration::Finite`], this is the number of repeats times the
     /// duration of a single cycle ([`cycle_duration()`]).
     ///
-    /// [`cycle_duration()`]: Tweenable::cycle_duration
+    /// [`cycle_duration()`]: Self::cycle_duration
     fn total_duration(&self) -> TotalDuration;
 
     /// Set the current animation playback elapsed time.
@@ -513,20 +527,31 @@ pub trait Tweenable: Send + Sync {
     ///
     /// Setting the elapsed time seeks the animation to a new position, but does
     /// not apply that change to the underlying component being animated yet. To
-    /// force the change to apply, call [`tick()`] with a `delta` of
-    /// `Duration::ZERO`.
+    /// force the change to apply, call [`step()`] with a `delta` of
+    /// `Duration::ZERO`, or wait for it to be automatically called.
     ///
     /// [`elapsed()`]: Tweenable::elapsed
     /// [`total_duration()`]: Tweenable::total_duration
-    /// [`tick()`]: Tweenable::tick
+    /// [`step()`]: Tweenable::step
     fn set_elapsed(&mut self, elapsed: Duration);
 
     /// Get the current elapsed duration.
     ///
-    /// If the animation repeats (has more than one cycle), the value can be
-    /// greater than one [`cycle_duration()`].
+    /// The elapsed duration is the time from the start of the tweening
+    /// animation. It includes all cycles; if the animation repeats (has more
+    /// than one cycle), the value can be greater than one
+    /// [`cycle_duration()`]. The value differs depending on whether the
+    /// animation repeat infinitely or not:
+    /// - For **finite** repeat counts, including no repeat at all (count = 1),
+    ///   the value is always between `0` and [`total_duration()`]. It
+    ///   represents the absolute position over the timeline of all cycles.
+    /// - For **infinite** repeat, the value loops around after either 1 cycle
+    ///   (for [`RepeatStrategy::Repeat`]) or 2 cycles (for
+    ///   [`RepeatStrategy::MirroredRepeat`]). The latter is necessary to
+    ///   account for one non-mirrored cycle and one mirrored one.
     ///
     /// [`cycle_duration()`]: Tweenable::cycle_duration
+    /// [`total_duration()`]: Tweenable::total_duration
     fn elapsed(&self) -> Duration;
 
     /// Step the tweenable.
@@ -537,9 +562,15 @@ pub trait Tweenable: Send + Sync {
     /// `delta` duration is subtracted from the [`elapsed()`] time instead of
     /// being added to it.
     ///
+    /// Note that `delta = Duration::ZERO` is valid, and is sometimes useful to
+    /// force applying the result of a state change to the underlying
+    /// animation target.
+    ///
     /// # Returns
     ///
     /// Returns the state of the tweenable after the step.
+    ///
+    /// [`elapsed()`]: Tweenable::elapsed
     fn step(
         &mut self,
         tween_id: TweenId,
@@ -1631,10 +1662,10 @@ mod tests {
     fn tween_tick() {
         for playback_direction in [TweeningDirection::Forward, TweeningDirection::Backward] {
             for (count, strategy) in [
-                (RepeatCount::Finite(1), RepeatStrategy::default()),
-                (RepeatCount::Infinite, RepeatStrategy::Repeat),
-                (RepeatCount::Finite(2), RepeatStrategy::Repeat),
-                (RepeatCount::Infinite, RepeatStrategy::MirroredRepeat),
+                //(RepeatCount::Finite(1), RepeatStrategy::default()),
+                //(RepeatCount::Infinite, RepeatStrategy::Repeat),
+                //(RepeatCount::Finite(2), RepeatStrategy::Repeat),
+                //(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat),
                 (RepeatCount::Finite(2), RepeatStrategy::MirroredRepeat),
             ] {
                 println!(
@@ -1753,7 +1784,8 @@ mod tests {
                                         // 0.4, ...
                                         (((i - 5000) * 200) % 2000) - 1000
                                     } else {
-                                        // 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0, ...
+                                        // 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0,
+                                        // ...
                                         (((i + 5) * 200) % 2000) - 1000
                                     }
                                     .abs();
@@ -1816,16 +1848,21 @@ mod tests {
                                     let elapsed_ms = if playback_direction.is_forward() {
                                         // 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0, 0.2,
                                         // 0.4, ...
-                                        (((i - 5000) * 200) % 2000) - 1000
+                                        ((i - 5) * 200).rem_euclid(2000) - 1000
                                     } else {
                                         // 0.8, 0.6, 0.4, 0.2, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 0.8,
                                         // 0.6, ...
-                                        ((i * 200) % 2000) - 1000
+                                        (i * 200).rem_euclid(2000) - 1000
                                     }
                                     .abs();
                                     let factor = elapsed_ms as f32 / 1000.0;
-                                    // 0.8, 0.6, 0.4, 0.2, 0.0, 1.8, 1.6, 1.4, ... (seconds)
-                                    let elapsed_ms = (2000i32 - (i - 5) * 200).rem_euclid(2000);
+                                    let elapsed_ms = if playback_direction.is_forward() {
+                                        // 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, ... (seconds)
+                                        (i * 200).rem_euclid(2000)
+                                    } else {
+                                        // 0.8, 0.6, 0.4, 0.2, 0.0, 1.8, 1.6, 1.4, ... (seconds)
+                                        (2000i32 - (i - 5) * 200).rem_euclid(2000)
+                                    };
                                     let direction = if playback_direction.is_forward() {
                                         // 2468X 86420 24
                                         // ffffb bbbbf ff

From 53f6018ea1076bfec71b3797307b21f3f12f130e Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 29 Jun 2025 15:05:26 +0100
Subject: [PATCH 13/66] Fix last test cases

---
 src/tweenable.rs | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/tweenable.rs b/src/tweenable.rs
index d4aba05..834b9fb 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1662,10 +1662,10 @@ mod tests {
     fn tween_tick() {
         for playback_direction in [TweeningDirection::Forward, TweeningDirection::Backward] {
             for (count, strategy) in [
-                //(RepeatCount::Finite(1), RepeatStrategy::default()),
-                //(RepeatCount::Infinite, RepeatStrategy::Repeat),
-                //(RepeatCount::Finite(2), RepeatStrategy::Repeat),
-                //(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat),
+                (RepeatCount::Finite(1), RepeatStrategy::default()),
+                (RepeatCount::Infinite, RepeatStrategy::Repeat),
+                (RepeatCount::Finite(2), RepeatStrategy::Repeat),
+                (RepeatCount::Infinite, RepeatStrategy::MirroredRepeat),
                 (RepeatCount::Finite(2), RepeatStrategy::MirroredRepeat),
             ] {
                 println!(
@@ -1780,13 +1780,13 @@ mod tests {
 
                                     // Inifinite-repeat unclamped value
                                     let elapsed_ms = if playback_direction.is_forward() {
-                                        // 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0, 0.2,
-                                        // 0.4, ...
-                                        (((i - 5000) * 200) % 2000) - 1000
+                                        // i    | 1    2    3    4    5    6    7    8    9    10   11
+                                        // t(s) | 0.2  0.4  0.6  0.8  1.0  0.8  0.6  0.4  0.2  0.0  0.2
+                                        ((i - 5) * 200).rem_euclid(2000) - 1000
                                     } else {
                                         // 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0,
                                         // ...
-                                        (((i + 5) * 200) % 2000) - 1000
+                                        ((i + 5) * 200).rem_euclid(2000) - 1000
                                     }
                                     .abs();
 
@@ -1807,14 +1807,16 @@ mod tests {
 
                                     // Once Completed, the direction doesn't change
                                     let direction = if playback_direction.is_forward() {
+                                        //           v [completion]
                                         // 2468X 86420 00
-                                        // ffffb bbbbf ff
-                                        if (i % 10) >= 5 && i < 10 {
+                                        // ffffb bbbbb bb
+                                        if i >= 5 {
                                             TweeningDirection::Backward
                                         } else {
                                             TweeningDirection::Forward
                                         }
                                     } else {
+                                        //           v [completion]
                                         // 86420 2468X XX
                                         // bbbbb fffff ff
                                         if i <= 5 {

From f5c0bcef8091c08fa8dc37d141dbc982027e0130 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 29 Jun 2025 15:46:50 +0100
Subject: [PATCH 14/66] Fix sequence example

---
 examples/sequence.rs | 240 ++++++++++++++++++++++++++-----------------
 src/tweenable.rs     |  12 ++-
 2 files changed, 154 insertions(+), 98 deletions(-)

diff --git a/examples/sequence.rs b/examples/sequence.rs
index bf6342b..79ab1e5 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -30,10 +30,23 @@ struct RedProgress;
 struct BlueProgress;
 
 #[derive(Component)]
-struct RedSprite(pub TweenId);
+struct RedSprite {
+    /// ID of the tween making the red sprite move along a path around the
+    /// screen.
+    pub path_tween_id: TweenId,
+    /// ID of the tween making the red sprite rotate on itself back and forth.
+    #[allow(unused)]
+    pub rotate_tween_id: TweenId,
+}
 
 #[derive(Component)]
-struct BlueSprite(pub TweenId);
+struct BlueSprite {
+    /// ID of the tween making the blue sprite move along a path, then rotate.
+    pub move_and_rotate_tween_id: TweenId,
+    /// ID of the tween making the blue sprite scale.
+    #[allow(unused)]
+    pub scale_tween_id: TweenId,
+}
 
 #[derive(Component)]
 struct ProgressValue;
@@ -43,7 +56,7 @@ fn setup(
     asset_server: Res<AssetServer>,
     mut animator: ResMut<TweenAnimator>,
 ) {
-    commands.spawn(Camera2dBundle::default());
+    commands.spawn(Camera2d::default());
 
     let font = asset_server.load("fonts/FiraMono-Regular.ttf");
     let text_font = TextFont {
@@ -53,7 +66,7 @@ fn setup(
     };
 
     let text_color_red = TextColor(RED.into());
-    let text_color_blue = TextColor(BLUE.into());
+    let text_color_blue = TextColor(AQUA.into());
 
     let justify = JustifyText::Center;
 
@@ -116,20 +129,19 @@ fn setup(
         Vec3::new(margin, screen_y - margin, 0.),
         Vec3::new(margin, margin, 0.),
     ];
-    // Build a sequence from an iterator over a Tweenable (here, a
-    // Tracks<Transform>)
-    let seq = Sequence::new(dests.windows(2).enumerate().map(|(index, pair)| {
-        Tracks::new([
-            Tween::new(
-                EaseFunction::QuadraticInOut,
-                Duration::from_millis(250),
-                TransformRotateZLens {
-                    start: 0.,
-                    end: 180_f32.to_radians(),
-                },
-            )
-            .with_repeat_count(RepeatCount::Finite(4))
-            .with_repeat_strategy(RepeatStrategy::MirroredRepeat),
+
+    // Red sprite
+    {
+        let entity = commands
+            .spawn(Sprite {
+                color: RED.into(),
+                custom_size: Some(Vec2::new(size, size)),
+                ..default()
+            })
+            .id();
+
+        // Build a sequence from an iterator over a Tweenable
+        let anim_move_along_path = Sequence::new(dests.windows(2).map(|pair| {
             Tween::new(
                 EaseFunction::QuadraticInOut,
                 Duration::from_secs(1),
@@ -139,105 +151,141 @@ fn setup(
                 },
             )
             // Get an event after each segment
-            ,//.with_completed_event(index as u64),
-        ])
-    }));
-
-    // Because we want to monitor the progress of the animations, we need to fetch
-    // their TweenId. This requires inserting them manually in the TweenAnimator
-    // resource, instead of using the extensions of EntityCommands.
-    let entity = commands
-        .spawn(SpriteBundle {
-            sprite: Sprite {
-                color: RED.into(),
-                custom_size: Some(Vec2::new(size, size)),
-                ..default()
+            //.with_completed_event(index as u64),
+        }));
+
+        // Rotate over self, forever. This will continue even after the move along path
+        // above finished.
+        let anim_rotate_back_and_forth = Tween::new(
+            EaseFunction::QuadraticInOut,
+            Duration::from_millis(250),
+            TransformRotateZLens {
+                start: 0.,
+                end: 180_f32.to_radians(),
             },
-            ..default()
-        })
-        .id();
-    let tween_id = animator.add(entity, seq);
-    commands.entity(entity).insert(RedSprite(tween_id));
-
-    // First move from left to right, then rotate around self 180 degrees while
-    // scaling size at the same time.
-    let tween_move = Tween::new(
-        EaseFunction::QuadraticInOut,
-        Duration::from_secs(1),
-        TransformPositionLens {
-            start: Vec3::new(-200., 100., 0.),
-            end: Vec3::new(200., 100., 0.),
-        },
-    ); //.with_completed_event(99); // Get an event once move completed
-    let tween_rotate = Tween::new(
-        EaseFunction::QuadraticInOut,
-        Duration::from_secs(1),
-        TransformRotationLens {
-            start: Quat::IDENTITY,
-            end: Quat::from_rotation_z(180_f32.to_radians()),
-        },
-    );
-    let tween_scale = Tween::new(
-        EaseFunction::QuadraticInOut,
-        Duration::from_secs(1),
-        TransformScaleLens {
-            start: Vec3::ONE,
-            end: Vec3::splat(2.0),
-        },
-    );
-    // Build parallel tracks executing two tweens at the same time: rotate and
-    // scale.
-    let tracks = Tracks::new([tween_rotate, tween_scale]);
-    // Build a sequence from an heterogeneous list of tweenables by casting them
-    // manually to a BoxedTweenable: first move, then { rotate + scale }.
-    let seq2 = Sequence::new([Box::new(tween_move) as BoxedTweenable, tracks.into()]);
-
-    // Because we want to monitor the progress of the animations, we need to fetch
-    // their TweenId. This requires inserting them manually in the TweenAnimator
-    // resource, instead of using the extensions of EntityCommands.
-    let entity = commands
-        .spawn((SpriteBundle {
-            sprite: Sprite {
-                color: Color::BLUE,
+        )
+        .with_repeat_count(RepeatCount::Infinite)
+        .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
+
+        // Because we want to monitor the progress of the animations, we need to fetch
+        // their TweenId. This requires inserting them manually in the TweenAnimator
+        // resource, instead of using the extensions of EntityCommands.
+        let path_tween_id = animator.add(entity, anim_move_along_path);
+        let rotate_tween_id = animator.add(entity, anim_rotate_back_and_forth);
+        commands.entity(entity).insert(RedSprite {
+            path_tween_id,
+            rotate_tween_id,
+        });
+    }
+
+    // Blue sprite
+    {
+        let entity = commands
+            .spawn(Sprite {
+                color: AQUA.into(),
                 custom_size: Some(Vec2::new(size * 3., size)),
                 ..default()
+            })
+            .id();
+
+        // First move from left to right, then rotate around self 180 degrees while
+        // scaling size at the same time.
+
+        // In previous versions of bevy_tweening, this could be accomplished with a
+        // Tracks, which allowed to run in parallel animations of different duration.
+        // That interface was confusing and had too many corner cases, so was removed.
+        //
+        // Instead, we have 2 solutions:
+        // 1. Insert one sequence which moves then rotates, and another which waits
+        //    (Delay tweenable) then starts to scale at the same time the first sequence
+        //    starts to rotate. In most cases this is the simplest, but requires
+        //    controlling the timings of the animations.
+        // 2. Insert a single sequence which moves then {rotates+scales}, using a custom
+        //    Lens which can apply both the rotation and scale with a single Tween. This
+        //    guarantees perfect timing alignment, and doesn't require knowing the
+        //    duration of the first (move) animation. A minor drawback is that we have
+        //    to write a custom Lens.
+        //
+        // Here we show how option 1. is implemented, which is often the simplest.
+
+        let move_duration = Duration::from_secs(1);
+        let tween_move = Tween::new(
+            EaseFunction::QuadraticInOut,
+            move_duration,
+            TransformPositionLens {
+                start: Vec3::new(-200., 100., 0.),
+                end: Vec3::new(200., 100., 0.),
+            },
+        ); //.with_completed_event(99); // Get an event once move completed
+
+        let tween_delay = Delay::new(move_duration);
+
+        let tween_rotate = Tween::new(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            TransformRotationLens {
+                start: Quat::IDENTITY,
+                end: Quat::from_rotation_z(180_f32.to_radians()),
             },
-            ..Default::default()
-        },))
-        .id();
-    let tween_id = animator.add(entity, seq2);
-    commands.entity(entity).insert(BlueSprite(tween_id));
+        );
+
+        let tween_scale = Tween::new(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            TransformScaleLens {
+                start: Vec3::ONE,
+                end: Vec3::splat(2.0),
+            },
+        );
+
+        // Build a sequence from an heterogeneous list of tweenables by casting them
+        // manually to a BoxedTweenable. This is only to demonstrate how it's done; in
+        // general prefer using then() as below.
+        let seq1 = Sequence::new([Box::new(tween_move) as BoxedTweenable, tween_rotate.into()]);
+        let seq2 = tween_delay.then(tween_scale);
+
+        // Because we want to monitor the progress of the animations, we need to fetch
+        // their TweenId. This requires inserting them manually in the TweenAnimator
+        // resource, instead of using the extensions of EntityCommands.
+        let move_and_rotate_tween_id = animator.add(entity, seq1);
+        let scale_tween_id = animator.add(entity, seq2);
+        commands.entity(entity).insert(BlueSprite {
+            move_and_rotate_tween_id,
+            scale_tween_id,
+        });
+    }
 }
 
 fn update_text(
     animator: Res<TweenAnimator>,
-    mut query_text_red: Query<&mut Text, (With<RedProgress>, Without<BlueProgress>)>,
-    mut query_text_blue: Query<&mut Text, (With<BlueProgress>, Without<RedProgress>)>,
-    query_anim_red: Query<&RedSprite>,
-    query_anim_blue: Query<&BlueSprite>,
-    mut query_event: EventReader<TweenCompleted>,
+    red_text_children: Single<&Children, With<RedProgress>>,
+    blue_text_children: Single<&Children, With<BlueProgress>>,
+    mut q_textspans: Query<&mut TextSpan, With<ProgressValue>>,
+    q_anim_red: Query<&RedSprite>,
+    q_anim_blue: Query<&BlueSprite>,
+    mut q_event_completed: EventReader<TweenCompleted>,
 ) {
-    let anim_red = query_anim_red.single();
-    let progress_red = if let Some(anim) = animator.get(anim_red.0) {
-        anim.tweenable.progress()
+    let anim_red = q_anim_red.single().unwrap();
+    let progress_red = if let Some(anim) = animator.get(anim_red.path_tween_id) {
+        anim.tweenable.cycle_fraction()
     } else {
         1.
     };
 
-    let anim_blue = query_anim_blue.single();
-    let progress_blue = if let Some(anim) = animator.get(anim_blue.0) {
-        anim.tweenable.progress()
+    let anim_blue = q_anim_blue.single().unwrap();
+    let progress_blue = if let Some(anim) = animator.get(anim_blue.move_and_rotate_tween_id) {
+        anim.tweenable.cycle_fraction()
     } else {
         1.
     };
 
-    let mut red_text = text_spans.get_mut(red_text_children[1]).unwrap();
+    let mut red_text = q_textspans.get_mut(red_text_children[1]).unwrap();
     red_text.0 = format!("{:5.1}%", progress_red * 100.);
 
-    let mut blue_text = text_spans.get_mut(blue_text_children[1]).unwrap();
+    let mut blue_text = q_textspans.get_mut(blue_text_children[1]).unwrap();
     blue_text.0 = format!("{:5.1}%", progress_blue * 100.);
 
-    for ev in query_event.read() {
+    for ev in q_event_completed.read() {
         println!(
             "Event: TweenCompleted tween_id={:?} entity={:?}",
             ev.id, ev.entity
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 834b9fb..5bc77f9 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -596,6 +596,13 @@ pub trait Tweenable: Send + Sync {
     fn cycles_completed(&self) -> u32 {
         self.elapsed().div_duration_f64(self.cycle_duration()) as u32
     }
+
+    /// Get the completion fraction in `[0:1]` of the current cycle.
+    fn cycle_fraction(&self) -> f32 {
+        self.elapsed()
+            .div_duration_f64(self.cycle_duration())
+            .fract() as f32
+    }
 }
 
 macro_rules! impl_boxed {
@@ -902,6 +909,7 @@ impl Tween {
     }
 }
 
+#[cfg(feature = "bevy_asset")]
 impl TweenAssetExtensions for Tween {
     #[must_use]
     fn new<A, L>(ease_function: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
@@ -1780,8 +1788,8 @@ mod tests {
 
                                     // Inifinite-repeat unclamped value
                                     let elapsed_ms = if playback_direction.is_forward() {
-                                        // i    | 1    2    3    4    5    6    7    8    9    10   11
-                                        // t(s) | 0.2  0.4  0.6  0.8  1.0  0.8  0.6  0.4  0.2  0.0  0.2
+                                        // i    | 1    2    3    4    5    6    7    8    9    10
+                                        // t(s) | 0.2  0.4  0.6  0.8  1.0  0.8  0.6  0.4  0.2  0.0
                                         ((i - 5) * 200).rem_euclid(2000) - 1000
                                     } else {
                                         // 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 0.8, 0.6, 0.4, 0.2, 0.0,

From 6754fd2d1aa7f61f6df91db38dae428943b93ac3 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 29 Jun 2025 16:05:15 +0100
Subject: [PATCH 15/66] Fix all non-asset examples

---
 examples/menu.rs                  | 81 ++++++++++++-------------------
 examples/sprite_color.rs          |  9 ++--
 examples/text_color.rs            | 50 ++++++++++---------
 examples/transform_rotation.rs    | 19 +++-----
 examples/transform_translation.rs | 19 +++-----
 examples/ui_position.rs           | 44 +++++++++--------
 src/lib.rs                        |  4 ++
 7 files changed, 103 insertions(+), 123 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index 4537d82..c0f273b 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -53,6 +53,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
     let font = asset_server.load("fonts/FiraMono-Regular.ttf");
 
+    // The menu "container" node, parent of all menu buttons
     commands
         .spawn((
             Name::new("menu"),
@@ -73,6 +74,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
             },
         ))
         .with_children(|container| {
+            // The individual menu buttons
             let mut start_time_ms = 0;
             for (text, label) in [
                 ("Continue", ButtonLabel::Continue),
@@ -91,65 +93,42 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 .with_completed_event(true);
 
                 let mut ec = container.spawn((
-                    ButtonBundle {
-                        style: Style {
-                            min_width: Val::Px(300.),
-                            min_height: Val::Px(80.),
-                            margin: UiRect::all(Val::Px(8.)),
-                            padding: UiRect::all(Val::Px(8.)),
-                            align_content: AlignContent::Center,
-                            align_items: AlignItems::Center,
-                            align_self: AlignSelf::Center,
-                            justify_content: JustifyContent::Center,
-                            ..default()
-                        },
-                        background_color: BackgroundColor(NORMAL_COLOR),
-                        transform: Transform::from_scale(Vec3::splat(0.01)),
+                    Name::new(format!("button:{}", text)),
+                    Button,
+                    Node {
+                        min_width: Val::Px(300.),
+                        min_height: Val::Px(80.),
+                        margin: UiRect::all(Val::Px(8.)),
+                        padding: UiRect::all(Val::Px(8.)),
+                        align_content: AlignContent::Center,
+                        align_items: AlignItems::Center,
+                        align_self: AlignSelf::Center,
+                        justify_content: JustifyContent::Center,
                         ..default()
                     },
-                    Name::new(format!("button:{}", text)),
+                    BackgroundColor(NORMAL_COLOR),
+                    Transform::from_scale(Vec3::splat(0.01)),
                     label,
+                    children![(
+                        Text::new(text.to_string()),
+                        TextFont {
+                            font: font.clone(),
+                            font_size: 48.0,
+                            ..default()
+                        },
+                        TextColor(TEXT_COLOR),
+                        TextLayout::new_with_justify(JustifyText::Center),
+                    )],
                 ));
 
-                let ec = if start_time_ms > 0 {
+                if start_time_ms > 0 {
                     let delay = Delay::new(Duration::from_millis(start_time_ms));
-                    ec.tween(delay.then(tween_scale))
+                    ec.tween(delay.then(tween_scale));
                 } else {
-                    ec.tween(tween_scale)
-                };
+                    ec.tween(tween_scale);
+                }
+
                 start_time_ms += 500;
-                container
-                    .spawn((
-                        Name::new(format!("button:{}", text)),
-                        Button,
-                        Node {
-                            min_width: Val::Px(300.),
-                            min_height: Val::Px(80.),
-                            margin: UiRect::all(Val::Px(8.)),
-                            padding: UiRect::all(Val::Px(8.)),
-                            align_content: AlignContent::Center,
-                            align_items: AlignItems::Center,
-                            align_self: AlignSelf::Center,
-                            justify_content: JustifyContent::Center,
-                            ..default()
-                        },
-                        BackgroundColor(NORMAL_COLOR),
-                        Transform::from_scale(Vec3::splat(0.01)),
-                        animator,
-                        label,
-                    ))
-                    .with_children(|parent| {
-                        parent.spawn((
-                            Text::new(text.to_string()),
-                            TextFont {
-                                font: font.clone(),
-                                font_size: 48.0,
-                                ..default()
-                            },
-                            TextColor(TEXT_COLOR),
-                            TextLayout::new_with_justify(JustifyText::Center),
-                        ));
-                    });
             }
         });
 }
diff --git a/examples/sprite_color.rs b/examples/sprite_color.rs
index c6c8a8c..71182f1 100644
--- a/examples/sprite_color.rs
+++ b/examples/sprite_color.rs
@@ -75,15 +75,14 @@ fn setup(mut commands: Commands) {
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
         commands
-            .spawn((SpriteBundle {
-                transform: Transform::from_translation(Vec3::new(x, y, 0.)),
-                sprite: Sprite {
+            .spawn((
+                Transform::from_translation(Vec3::new(x, y, 0.)),
+                Sprite {
                     color: Color::BLACK,
                     custom_size: Some(Vec2::new(size, size)),
                     ..default()
                 },
-                ..default()
-            },))
+            ))
             .tween(tween);
 
         y -= size * spacing;
diff --git a/examples/text_color.rs b/examples/text_color.rs
index 9f51a93..209797f 100644
--- a/examples/text_color.rs
+++ b/examples/text_color.rs
@@ -81,30 +81,32 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands.spawn((
-            Text::new(*ease_name),
-            TextFont {
-                font: font.clone(),
-                font_size: 24.0,
-                ..default()
-            },
-            TextColor(Color::WHITE),
-            Node {
-                width: Val::Px(size_x),
-                height: Val::Px(size_y),
-                left: Val::Px(x),
-                top: Val::Px(y),
-                right: Val::Auto,
-                bottom: Val::Auto,
-                position_type: PositionType::Absolute,
-                align_content: AlignContent::Center,
-                align_items: AlignItems::Center,
-                align_self: AlignSelf::Center,
-                justify_content: JustifyContent::Center,
-                ..default()
-            },
-            TweenAnimator::new(tween),
-        ));
+        commands
+            .spawn((
+                Text::new(*ease_name),
+                TextFont {
+                    font: font.clone(),
+                    font_size: 24.0,
+                    ..default()
+                },
+                TextColor(Color::WHITE),
+                Node {
+                    width: Val::Px(size_x),
+                    height: Val::Px(size_y),
+                    left: Val::Px(x),
+                    top: Val::Px(y),
+                    right: Val::Auto,
+                    bottom: Val::Auto,
+                    position_type: PositionType::Absolute,
+                    align_content: AlignContent::Center,
+                    align_items: AlignItems::Center,
+                    align_self: AlignSelf::Center,
+                    justify_content: JustifyContent::Center,
+                    ..default()
+                },
+            ))
+            // Automatically insert the animation via the entity command queue
+            .tween(tween);
 
         y += delta_y;
         iy += 1;
diff --git a/examples/transform_rotation.rs b/examples/transform_rotation.rs
index 6b3565c..a2ca3e8 100644
--- a/examples/transform_rotation.rs
+++ b/examples/transform_rotation.rs
@@ -103,14 +103,14 @@ fn setup(mut commands: Commands) {
                 Visibility::default(),
             ))
             .with_children(|parent| {
-                parent.spawn((
-                    Sprite {
+                parent
+                    .spawn((Sprite {
                         color: RED.into(),
                         custom_size: Some(Vec2::new(size, size * 0.5)),
                         ..default()
-                    },
-                    TweenAnimator::new(tween),
-                ));
+                    },))
+                    // Automatically insert the animation via the entity command queue
+                    .tween(tween);
             });
 
         y -= size * spacing;
@@ -121,15 +121,12 @@ fn setup(mut commands: Commands) {
     }
 }
 
-fn update_animation_speed(
-    options: Res<Options>,
-    mut animators: Query<&mut TweenAnimator<Transform>>,
-) {
+fn update_animation_speed(options: Res<Options>, mut animators: ResMut<TweenAnimator>) {
     if !options.is_changed() {
         return;
     }
 
-    for mut animator in animators.iter_mut() {
-        animator.set_speed(options.speed);
+    for (_id, anim) in animators.iter_mut() {
+        anim.speed = options.speed;
     }
 }
diff --git a/examples/transform_translation.rs b/examples/transform_translation.rs
index 1052fa8..11ac628 100644
--- a/examples/transform_translation.rs
+++ b/examples/transform_translation.rs
@@ -97,28 +97,25 @@ fn setup(mut commands: Commands) {
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands.spawn((
-            Sprite {
+        commands
+            .spawn((Sprite {
                 color: RED.into(),
                 custom_size: Some(Vec2::new(size, size)),
                 ..default()
-            },
-            TweenAnimator::new(tween),
-        ));
+            },))
+            // Automatically insert the animation via the entity command queue
+            .tween(tween);
 
         x += size * spacing;
     }
 }
 
-fn update_animation_speed(
-    options: Res<Options>,
-    mut animators: Query<&mut TweenAnimator<Transform>>,
-) {
+fn update_animation_speed(options: Res<Options>, mut animators: ResMut<TweenAnimator>) {
     if !options.is_changed() {
         return;
     }
 
-    for mut animator in animators.iter_mut() {
-        animator.set_speed(options.speed);
+    for (_id, anim) in animators.iter_mut() {
+        anim.speed = options.speed;
     }
 }
diff --git a/examples/ui_position.rs b/examples/ui_position.rs
index 23bc747..16feb95 100644
--- a/examples/ui_position.rs
+++ b/examples/ui_position.rs
@@ -106,35 +106,37 @@ fn setup(mut commands: Commands) {
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands.spawn((
-            Node {
-                width: Val::Px(size),
-                height: Val::Px(size),
-                left: Val::Px(x),
-                top: Val::Px(10.),
-                right: Val::Auto,
-                bottom: Val::Auto,
-                position_type: PositionType::Absolute,
-                align_content: AlignContent::Center,
-                align_items: AlignItems::Center,
-                align_self: AlignSelf::Center,
-                justify_content: JustifyContent::Center,
-                ..default()
-            },
-            BackgroundColor(RED.into()),
-            TweenAnimator::new(tween),
-        ));
+        commands
+            .spawn((
+                Node {
+                    width: Val::Px(size),
+                    height: Val::Px(size),
+                    left: Val::Px(x),
+                    top: Val::Px(10.),
+                    right: Val::Auto,
+                    bottom: Val::Auto,
+                    position_type: PositionType::Absolute,
+                    align_content: AlignContent::Center,
+                    align_items: AlignItems::Center,
+                    align_self: AlignSelf::Center,
+                    justify_content: JustifyContent::Center,
+                    ..default()
+                },
+                BackgroundColor(RED.into()),
+            ))
+            // Automatically insert the animation via the entity command queue
+            .tween(tween);
 
         x += offset_x;
     }
 }
 
-fn update_animation_speed(options: Res<Options>, mut animators: Query<&mut TweenAnimator<Style>>) {
+fn update_animation_speed(options: Res<Options>, mut animators: ResMut<TweenAnimator>) {
     if !options.is_changed() {
         return;
     }
 
-    for mut animator in animators.iter_mut() {
-        animator.set_speed(options.speed);
+    for (_id, anim) in animators.iter_mut() {
+        anim.speed = options.speed;
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 434d1f0..8cde45a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -635,6 +635,10 @@ impl TweenAnimator {
             // done with EntityWorldMut has it has exclusive World access).
             let ent_mut = &mut world.get_entity_mut([anim.target]).unwrap()[0];
 
+            // Scale delta time by this animation's speed. Reject negative speeds; use
+            // backward playback to play in reverse direction.
+            let delta_time = delta_time.mul_f32(anim.speed.max(0.));
+
             // Apply the animation tweenable
             let state =
                 anim.tweenable

From df01c5a9dc91f141ca1038135e615940df3315c5 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 29 Jun 2025 16:05:29 +0100
Subject: [PATCH 16/66] Fix example build script

---
 run_examples.bat | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/run_examples.bat b/run_examples.bat
index beef613..4836009 100644
--- a/run_examples.bat
+++ b/run_examples.bat
@@ -1,15 +1,15 @@
 @echo on
 echo Run all examples
 REM Default
-cargo r --example menu --no-default-features --features="bevy_ui bevy_text bevy/bevy_winit"
-cargo r --example transform_translation --no-default-features --features="bevy_sprite bevy/bevy_winit"
-cargo r --example transform_rotation --no-default-features --features="bevy_sprite bevy/bevy_winit"
-cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit"
+cargo r --example menu --no-default-features --features="bevy_ui bevy_text bevy/bevy_winit bevy/bevy_picking"
+cargo r --example transform_translation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
+cargo r --example transform_rotation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
+cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
 REM bevy_sprite
-cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit"
+cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 REM bevy_ui
-cargo r --example ui_position --no-default-features --features="bevy_sprite bevy_ui bevy/bevy_winit"
+cargo r --example ui_position --no-default-features --features="bevy_sprite bevy_ui bevy/bevy_winit bevy/bevy_picking"
 REM bevy_text
-cargo r --example text_color --no-default-features --features="bevy_text bevy_ui bevy/bevy_winit"
+cargo r --example text_color --no-default-features --features="bevy_text bevy_ui bevy/bevy_winit bevy/bevy_picking"
 REM bevy_sprite + bevy_asset
-cargo r --example colormaterial_color --no-default-features --features="bevy_asset bevy_sprite bevy/bevy_winit"
\ No newline at end of file
+cargo r --example colormaterial_color --no-default-features --features="bevy_asset bevy_sprite bevy/bevy_winit bevy/bevy_picking"
\ No newline at end of file

From 89c1f7e5fd7e31887dafb249b66892c9d9d63005 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 29 Jun 2025 22:23:25 +0100
Subject: [PATCH 17/66] Finish implementing asset animation

---
 examples/colormaterial_color.rs |   5 +-
 src/lens.rs                     |  15 +--
 src/lib.rs                      | 221 +++++++++++++++++++++++++++++---
 src/tweenable.rs                | 167 +++++++++++++++++-------
 4 files changed, 333 insertions(+), 75 deletions(-)

diff --git a/examples/colormaterial_color.rs b/examples/colormaterial_color.rs
index 8b6e54e..4c60fa7 100644
--- a/examples/colormaterial_color.rs
+++ b/examples/colormaterial_color.rs
@@ -26,6 +26,7 @@ fn setup(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    mut animator: ResMut<TweenAnimator>,
 ) {
     commands.spawn(Camera2d::default());
 
@@ -88,12 +89,14 @@ fn setup(
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
+        animator.add_asset(unique_material.id(), tween);
+
         commands.spawn((
             Mesh2d(quad_mesh.clone()),
             MeshMaterial2d(unique_material),
             Transform::from_translation(Vec3::new(x, y, 0.)).with_scale(Vec3::splat(size)),
-            AssetAnimator::new(tween),
         ));
+
         y -= size * spacing;
         if y < -screen_y {
             x += size * spacing;
diff --git a/src/lens.rs b/src/lens.rs
index 5c9afde..432f370 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -995,16 +995,15 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
+            let asset = assets.get_mut(handle.id()).unwrap();
             let mut target = AssetTarget::new(Mut::new(
-                &mut assets,
+                asset,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
             ));
-            target.handle = handle.clone();
-
             lens.lerp(&mut target, 0.);
         }
         assert_eq!(assets.get(handle.id()).unwrap().color, RED.into());
@@ -1013,16 +1012,15 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
+            let asset = assets.get_mut(handle.id()).unwrap();
             let mut target = AssetTarget::new(Mut::new(
-                &mut assets,
+                asset,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
             ));
-            target.handle = handle.clone();
-
             lens.lerp(&mut target, 1.);
         }
         assert_eq!(assets.get(handle.id()).unwrap().color, BLUE.into());
@@ -1031,16 +1029,15 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
+            let asset = assets.get_mut(handle.id()).unwrap();
             let mut target = AssetTarget::new(Mut::new(
-                &mut assets,
+                asset,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
             ));
-            target.handle = handle.clone();
-
             lens.lerp(&mut target, 0.3);
         }
         assert_eq!(
diff --git a/src/lib.rs b/src/lib.rs
index 8cde45a..3b76a7d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -205,9 +205,12 @@
 //! [`TextColor`]: https://docs.rs/bevy/0.16.0/bevy/text/struct.TextColor.html
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
 
-use std::time::Duration;
+use std::{any::TypeId, time::Duration};
 
-use bevy::prelude::*;
+use bevy::{
+    asset::UntypedAssetId, ecs::change_detection::MutUntyped, platform::collections::HashMap,
+    prelude::*,
+};
 pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
 use slotmap::{new_key_type, SlotMap};
@@ -498,10 +501,54 @@ pub struct AnimCompleted {
     pub entity: Entity,
 }
 
+///
+#[derive(Debug, Clone, Copy)]
+pub enum AnimTarget {
+    ///
+    Entity {
+        ///
+        type_id: TypeId,
+        ///
+        entity: Entity,
+    },
+    ///
+    Asset {
+        ///
+        type_id: TypeId,
+        ///
+        asset_id: UntypedAssetId,
+    },
+}
+
+// impl AnimTarget {
+//     pub fn resolve<'w>(&self, world: &'w mut World) ->
+// Result<AnimResolvedTarget<'w>, ()> {         match self {
+//             AnimTarget::Entity(target) => {
+//                 let ent_mut = &mut
+// world.get_entity_mut([*target]).unwrap()[0];
+// Ok(AnimResolvedTarget::Entity(ent_mut))             }
+//             AnimTarget::Asset(asset_id) => {
+//                 if let Some(comp_id) =
+// world.components().get_resource_id(asset_id.type_id()) {
+// if let Some(mut_untyped) = world.get_resource_mut_by_id(comp_id) {
+//                         return Ok(AnimResolvedTarget::Asset(mut_untyped));
+//                     }
+//                 }
+//                 Err(())
+//             }
+//         }
+//     }
+// }
+
+// pub enum AnimResolvedTarget<'w> {
+//     Entity(&'w mut EntityMut<'w>),
+//     Asset(MutUntyped<'w>),
+// }
+
 /// A [`Tweenable`]-based animation.
 pub struct TweenAnim {
-    /// Target [`Entity`] containing the component to animate.
-    pub target: Entity,
+    /// Target [`Entity`] containing the component to animate, or target asset.
+    pub target: AnimTarget,
     /// Animation description.
     pub tweenable: BoxedTweenable,
     /// Control if the animation is played or not.
@@ -513,8 +560,37 @@ pub struct TweenAnim {
 impl TweenAnim {
     /// Create a new tween animation.
     pub fn new(target: Entity, tweenable: impl Tweenable + 'static) -> Self {
+        let type_id = tweenable.type_id().expect(
+            "Typeless tweenable like Delay can't be inserted as root tweenable in an animation.",
+        );
         Self {
-            target,
+            //target: AnimTarget::Entity(target),
+            target: AnimTarget::Entity {
+                type_id,
+                entity: target,
+            },
+            tweenable: Box::new(tweenable),
+            state: PlaybackState::Playing,
+            speed: 1.,
+        }
+    }
+
+    /// Create a new tween animation for an asset.
+    pub fn new_asset(
+        type_id: TypeId,
+        asset_id: UntypedAssetId,
+        tweenable: impl Tweenable + 'static,
+    ) -> Self {
+        let tween_type_id = tweenable.type_id().expect(
+            "Typeless tweenable like Delay can't be inserted as root tweenable in an animation.",
+        );
+        assert_eq!(
+            type_id, tween_type_id,
+            "The tweenable type doesn't match the Assets<A> type of the target asset."
+        );
+        Self {
+            //target: AnimTarget::Entity(target),
+            target: AnimTarget::Asset { type_id, asset_id },
             tweenable: Box::new(tweenable),
             state: PlaybackState::Playing,
             speed: 1.,
@@ -532,16 +608,36 @@ impl TweenAnim {
 }
 
 /// Animator for tween-based animations.
+///
+/// This resource stores all the active tweening animations for the entire
+/// application. It's essentially a hash map from a [`TweenId`] uniquely
+/// identifying an active animation, to the [`TweenAnim`] runtime data of that
+/// animation. Use this resource to lookup animations by ID and modify their
+/// runtime data, for example their playback speed.
 #[derive(Resource)]
 pub struct TweenAnimator {
     /// Queue of animations currently playing.
     anims: SlotMap<TweenId, TweenAnim>,
+    /// Asset resolver allowing to convert a pair of { untyped pointer to
+    /// Assets<A>, untyped AssetId } into an untyped pointer to the asset A
+    /// itself. This is necessary because there's no UntypedAssets interface in
+    /// Bevy. The TypeId key must be the type of the Assets<A> type itself.
+    asset_resolver: HashMap<
+        TypeId,
+        Box<
+            dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> MutUntyped<'w>
+                + Send
+                + Sync
+                + 'static,
+        >,
+    >,
 }
 
 impl Default for TweenAnimator {
     fn default() -> Self {
         Self {
             anims: Default::default(),
+            asset_resolver: Default::default(),
         }
     }
 }
@@ -569,6 +665,10 @@ impl TweenAnimator {
     /// );
     /// world.entity_mut(entity).tween(tween);
     /// ```
+    ///
+    /// This function is still useful if you want to store the [`TweenId`] of
+    /// the new animation, to later access it to dynamically modify the playback
+    /// (e.g. speed).
     #[inline]
     pub fn add<T>(&mut self, target: Entity, tweenable: T) -> TweenId
     where
@@ -577,6 +677,58 @@ impl TweenAnimator {
         self.anims.insert(TweenAnim::new(target, tweenable))
     }
 
+    /// Add a new asset animation to the animator queue.
+    ///
+    /// This creates a new animation with the given tweenable, targeting the
+    /// asset with the given ID.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the target type of the tweenable (which can be queried with
+    /// [`Tweenable::type_id()`]) is different from `Assets<A>`. In general if
+    /// the tweenable was created with _e.g._ [`Tween::new_asset<A>()`] then
+    /// [`Tweenable::type_id()`] correctly returns `Assets<A>`. Note that the
+    /// type is **NOT** the asset type `A` itself, but rather `Assets<A>`.
+    #[inline]
+    pub fn add_asset<A, T, I>(&mut self, asset_id: I, tweenable: T) -> TweenId
+    where
+        A: Asset,
+        T: Tweenable + 'static,
+        I: Into<AssetId<A>>,
+    {
+        let type_id = TypeId::of::<Assets<A>>();
+        assert_eq!(
+            Some(type_id),
+            tweenable.type_id(),
+            "Tweenable has different target type than Assets<A>."
+        );
+
+        self.asset_resolver.entry(type_id).or_insert_with(|| {
+            Box::new(
+                // Convert ( Mut<Assets<A>>, AssetId<A> ) -> Mut<A>
+                |assets: MutUntyped, asset_id: UntypedAssetId| -> MutUntyped {
+                    // SAFETY: The type ID was checked above with an assert to make sure the one
+                    // stored in the Tweenable (which is where the untyped value comes from) is
+                    // the same as Assets<A>.
+                    #[allow(unsafe_code)]
+                    let assets = unsafe { assets.with_type::<Assets<A>>() };
+
+                    let asset_id = asset_id.typed::<A>();
+                    let asset: Mut<A> = assets.map_unchanged(|a| {
+                        // FIXME - replace with get_mut_untracked() to skip ECS change detection; see https://github.com/bevyengine/bevy/issues/13104
+                        a.get_mut(asset_id).unwrap()
+                    });
+
+                    asset.into()
+                },
+            )
+        });
+
+        let asset_id: AssetId<A> = asset_id.into();
+        self.anims
+            .insert(TweenAnim::new_asset(type_id, asset_id.untyped(), tweenable))
+    }
+
     /// Queue a prepared tweenable animation.
     ///
     /// See [`make()`] to prepare the animation closure.
@@ -629,26 +781,62 @@ impl TweenAnimator {
         // Loop over active animations, tick them, and retain those which are still
         // active after that
         self.anims.retain(|tween_id, anim| {
-            // Note: we use get_entity_mut() to get an EntityMut instead of an
-            // EntityWorldMut, as the former is enough. This can allow
-            // optimizing by parallelizing tweening of separate entities (which can't be
-            // done with EntityWorldMut has it has exclusive World access).
-            let ent_mut = &mut world.get_entity_mut([anim.target]).unwrap()[0];
+            // Note: we use get_entity_mut([Entity; 1]) with an array of a single element to
+            // get an EntityMut instead of an EntityWorldMut, as the former is
+            // enough. This can allow optimizing by parallelizing tweening of
+            // separate entities (which can't be done with EntityWorldMut has it
+            // has exclusive World access). For now this has no consequence except
+            // simplifying some borrow checker complications with World.
+            //let ent_mut = &mut world.get_entity_mut([anim.target]).unwrap()[0];
+
+            // FIXME
+            let mut target_entity = Entity::PLACEHOLDER;
+
+            let Some(mut mut_untyped) = (match &anim.target {
+                AnimTarget::Entity { entity, type_id } => {
+                    target_entity = *entity;
+                    if let Some(component_id) = world.components().get_id(*type_id) {
+                        world.get_mut_by_id(*entity, component_id)
+                    } else {
+                        None
+                    }
+                }
+                AnimTarget::Asset { type_id, asset_id } => {
+                    if let Some(resource_id) = world.components().get_resource_id(*type_id) {
+                        if let Some(assets) = world.get_resource_mut_by_id(resource_id) {
+                            if let Some(resolver) = self.asset_resolver.get(type_id) {
+                                Some(resolver(assets, *asset_id))
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                }
+            }) else {
+                return false;
+            };
 
             // Scale delta time by this animation's speed. Reject negative speeds; use
             // backward playback to play in reverse direction.
             let delta_time = delta_time.mul_f32(anim.speed.max(0.));
 
             // Apply the animation tweenable
-            let state =
-                anim.tweenable
-                    .step(tween_id, delta_time, ent_mut.reborrow(), events.reborrow());
+            let state = anim.tweenable.step(
+                tween_id,
+                delta_time,
+                mut_untyped.reborrow(),
+                events.reborrow(),
+            );
 
             // Raise completed event
             if state == TweenState::Completed {
                 anim_events.send(AnimCompleted {
                     id: tween_id,
-                    entity: anim.target,
+                    entity: target_entity,
                 });
             }
 
@@ -795,16 +983,15 @@ mod tests {
                 let mut added = Tick::new(0);
                 let mut last_changed = Tick::new(0);
                 let mut caller = MaybeLocation::caller();
+                let asset = assets.get_mut(handle.id()).unwrap();
                 let mut target = AssetTarget::new(Mut::new(
-                    &mut assets,
+                    asset,
                     &mut added,
                     &mut last_changed,
                     Tick::new(0),
                     Tick::new(0),
                     caller.as_mut(),
                 ));
-                target.handle = handle.clone();
-
                 l.lerp(&mut target, r);
             }
             assert_approx_eq!(assets.get(handle.id()).unwrap().value, r);
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 5bc77f9..087c69b 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1,11 +1,12 @@
 use std::{
+    any::TypeId,
     cmp::Ordering,
     ops::{Deref, DerefMut},
     time::Duration,
 };
 
 use bevy::{
-    ecs::{component::Mutable, system::SystemId},
+    ecs::{change_detection::MutUntyped, component::Mutable, system::SystemId},
     prelude::*,
 };
 
@@ -466,38 +467,26 @@ impl<T: Component> Targetable<T> for ComponentTarget<'_, T> {
 
 /// Implementation of [`Targetable`] for an [`Asset`].
 #[cfg(feature = "bevy_asset")]
-pub struct AssetTarget<'a, T: Asset> {
-    assets: Mut<'a, Assets<T>>,
-    /// Handle to the asset to mutate.
-    pub handle: Handle<T>,
+pub struct AssetTarget<'a, A: Asset> {
+    target: Mut<'a, A>,
 }
 
 #[cfg(feature = "bevy_asset")]
-impl<'a, T: Asset> AssetTarget<'a, T> {
+impl<'a, A: Asset> AssetTarget<'a, A> {
     /// Create a new instance from an [`Assets`].
-    pub fn new(assets: Mut<'a, Assets<T>>) -> Self {
-        Self {
-            assets,
-            handle: Handle::Weak(AssetId::default()),
-        }
-    }
-
-    /// Check if the current target is valid given the value of [`handle`].
-    ///
-    /// [`handle`]: AssetTarget::handle
-    pub fn is_valid(&self) -> bool {
-        self.assets.contains(&self.handle)
+    pub fn new(target: Mut<'a, A>) -> Self {
+        Self { target }
     }
 }
 
 #[cfg(feature = "bevy_asset")]
-impl<T: Asset> Targetable<T> for AssetTarget<'_, T> {
-    fn target(&self) -> &T {
-        self.assets.get(&self.handle).unwrap()
+impl<A: Asset> Targetable<A> for AssetTarget<'_, A> {
+    fn target(&self) -> &A {
+        self.target.deref()
     }
 
-    fn target_mut(&mut self) -> &mut T {
-        self.assets.get_mut(&self.handle).unwrap()
+    fn target_mut(&mut self) -> &mut A {
+        self.target.deref_mut()
     }
 }
 
@@ -575,7 +564,7 @@ pub trait Tweenable: Send + Sync {
         &mut self,
         tween_id: TweenId,
         delta: Duration,
-        ent_mut: EntityMut,
+        target: MutUntyped,
         events: Mut<Events<TweenCompleted>>,
     ) -> TweenState;
 
@@ -603,6 +592,30 @@ pub trait Tweenable: Send + Sync {
             .div_duration_f64(self.cycle_duration())
             .fract() as f32
     }
+
+    /// Get the [`TypeId`] this tweenable targets.
+    ///
+    /// This returns the type of the component or resource that the
+    /// [`TweenAnimator`] needs to fetch from the ECS `World` in order to
+    /// resolve the animation target.
+    ///
+    /// - For components, this is the type of the component itself, _e.g._
+    ///   `TypeId::of::<C>()`.
+    /// - For assets, this is **NOT** the type of the asset `A`, but rather the
+    ///   type of the asset container `Assets<A>`. This is because the asset
+    ///   itself is not stored in the ECS `World`, but in the `Assets<A>`
+    ///   container. So we need to retrieve that container from the world, then
+    ///   find the asset by ID inside it.
+    ///
+    /// # Returns
+    ///
+    /// Returns the type of the target, if any, or `None` if this tweenable is
+    /// untyped. Typically only `Delay` is untyped, as this is the only
+    /// tweenable which doesn't actually mutate the target, so it doesn't
+    /// actually have any target associated with it.
+    ///
+    /// [`TweenAnimator`]: crate::TweenAnimator
+    fn type_id(&self) -> Option<TypeId>;
 }
 
 macro_rules! impl_boxed {
@@ -620,8 +633,7 @@ impl_boxed!(Sequence);
 //impl_boxed!(Tracks);
 impl_boxed!(Delay);
 
-type ComponentAction = dyn FnMut(EntityMut, f32) + Send + Sync + 'static;
-type AssetAction = dyn FnMut(&mut World, UntypedHandle, f32) + Send + Sync + 'static;
+type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 
 /// TODO
 pub trait TweenAssetExtensions {
@@ -633,9 +645,8 @@ pub trait TweenAssetExtensions {
 }
 
 enum TweenAction {
-    Component(Box<ComponentAction>),
-    #[allow(dead_code)]
-    Asset(Box<AssetAction>),
+    Component(Box<TargetAction>),
+    Asset(Box<TargetAction>),
 }
 
 /// Single tweening animation instance.
@@ -647,6 +658,8 @@ pub struct Tween {
     action: TweenAction,
     system_id: Option<SystemId>,
     send_completed_event: bool,
+    /// Type ID of the target component or `Assets<A>` resource.
+    type_id: TypeId,
 }
 
 impl Tween {
@@ -703,10 +716,10 @@ impl Tween {
         C: Component<Mutability = Mutable>,
         L: Lens<C> + Send + Sync + 'static,
     {
-        let action = move |mut ent_mut: EntityMut, ratio: f32| {
-            let Some(comp) = ent_mut.get_mut::<C>() else {
-                return; // TODO
-            };
+        let action = move |ptr: MutUntyped, ratio: f32| {
+            // SAFETY: ptr was obtained from the same component type.
+            #[allow(unsafe_code)]
+            let comp = unsafe { ptr.with_type::<C>() };
             let mut target = ComponentTarget::new(comp);
             lens.lerp(&mut target, ratio);
         };
@@ -717,6 +730,36 @@ impl Tween {
             action: TweenAction::Component(Box::new(action)),
             system_id: None,
             send_completed_event: false,
+            type_id: TypeId::of::<C>(),
+        }
+    }
+
+    ///
+    #[must_use]
+    pub fn new_asset<A, L>(
+        ease_function: impl Into<EaseMethod>,
+        duration: Duration,
+        mut lens: L,
+    ) -> Self
+    where
+        A: Asset,
+        L: Lens<A> + Send + Sync + 'static,
+    {
+        let action = move |ptr: MutUntyped, ratio: f32| {
+            // SAFETY: ptr was obtained from the same component type.
+            #[allow(unsafe_code)]
+            let asset = unsafe { ptr.with_type::<A>() };
+            let mut target = AssetTarget::new(asset);
+            lens.lerp(&mut target, ratio);
+        };
+        Self {
+            ease_function: ease_function.into(),
+            clock: AnimClock::new(duration),
+            playback_direction: TweeningDirection::Forward,
+            action: TweenAction::Asset(Box::new(action)),
+            system_id: None,
+            send_completed_event: false,
+            type_id: TypeId::of::<Assets<A>>(),
         }
     }
 
@@ -917,12 +960,12 @@ impl TweenAssetExtensions for Tween {
         A: Asset,
         L: Lens<A> + Send + Sync + 'static,
     {
-        let action = move |world: &mut World, handle: UntypedHandle, ratio: f32| {
-            if let Some(assets) = world.get_resource_mut::<Assets<A>>() {
-                let mut target = AssetTarget::new(assets);
-                target.handle = handle.typed::<A>();
-                lens.lerp(&mut target, ratio);
-            }
+        let action = move |ptr: MutUntyped, ratio: f32| {
+            // SAFETY: ptr was obtained from the same asset type.
+            #[allow(unsafe_code)]
+            let asset = unsafe { ptr.with_type::<A>() };
+            let mut target = AssetTarget::new(asset);
+            lens.lerp(&mut target, ratio);
         };
         Self {
             ease_function: ease_function.into(),
@@ -931,6 +974,7 @@ impl TweenAssetExtensions for Tween {
             action: TweenAction::Asset(Box::new(action)),
             system_id: None,
             send_completed_event: false,
+            type_id: TypeId::of::<Assets<A>>(),
         }
     }
 }
@@ -956,7 +1000,7 @@ impl Tweenable for Tween {
         &mut self,
         tween_id: TweenId,
         delta: Duration,
-        ent_mut: EntityMut,
+        target: MutUntyped,
         mut events: Mut<Events<TweenCompleted>>,
     ) -> TweenState {
         if self.clock.state(self.playback_direction) == TweenState::Completed {
@@ -970,7 +1014,7 @@ impl Tweenable for Tween {
             self.clock.tick_back(delta)
         };
 
-        let entity = ent_mut.id();
+        let target_entity = Entity::PLACEHOLDER; // TODO: ent_mut.id();
 
         // Apply the lens, even if the animation completed, to ensure the state is
         // consistent.
@@ -978,9 +1022,11 @@ impl Tweenable for Tween {
         let fraction = self.ease_function.sample(fraction);
         match &mut self.action {
             TweenAction::Component(action) => {
-                action(ent_mut, fraction);
+                action(target, fraction);
+            }
+            TweenAction::Asset(action) => {
+                action(target, fraction);
             }
-            _ => (), //debug!("Ignoring call to tick() a component with an asset action."),
         };
 
         // If completed at least once this frame, notify the user
@@ -988,7 +1034,7 @@ impl Tweenable for Tween {
             if self.send_completed_event {
                 let event = TweenCompleted {
                     id: tween_id,
-                    entity,
+                    entity: target_entity,
                     progress: fraction,
                 };
 
@@ -1011,6 +1057,10 @@ impl Tweenable for Tween {
     fn rewind(&mut self) {
         self.clock.rewind(self.playback_direction);
     }
+
+    fn type_id(&self) -> Option<TypeId> {
+        Some(self.type_id)
+    }
 }
 
 /// A sequence of tweens played back in order one after the other.
@@ -1149,7 +1199,7 @@ impl Tweenable for Sequence {
         &mut self,
         tween_id: TweenId,
         mut delta: Duration,
-        mut ent_mut: EntityMut,
+        mut target: MutUntyped,
         mut events: Mut<Events<TweenCompleted>>,
     ) -> TweenState {
         // Calculate the new elapsed time at the end of this tick
@@ -1165,7 +1215,7 @@ impl Tweenable for Sequence {
 
             let prev_elapsed = tween.elapsed();
 
-            if tween.step(tween_id, delta, ent_mut.reborrow(), events.reborrow())
+            if tween.step(tween_id, delta, target.reborrow(), events.reborrow())
                 == TweenState::Active
             {
                 return TweenState::Active;
@@ -1195,6 +1245,18 @@ impl Tweenable for Sequence {
             tween.rewind();
         }
     }
+
+    fn type_id(&self) -> Option<TypeId> {
+        // Loop over all children, because we want to skip all untyped ones (Delay).
+        // Otherwise the animator will panic, because we can't create an untyped
+        // animation.
+        for tween in &self.tweens {
+            if let Some(type_id) = tween.type_id() {
+                return Some(type_id);
+            }
+        }
+        None
+    }
 }
 
 // /// A collection of [`Tweenable`] executing in parallel.
@@ -1389,7 +1451,7 @@ impl Tweenable for Delay {
         &mut self,
         _tween_id: TweenId,
         delta: Duration,
-        _ent_mut: EntityMut,
+        _target: MutUntyped,
         _events: Mut<Events<TweenCompleted>>,
     ) -> TweenState {
         self.timer.tick(delta);
@@ -1423,6 +1485,10 @@ impl Tweenable for Delay {
     fn rewind(&mut self) {
         self.timer.reset();
     }
+
+    fn type_id(&self) -> Option<TypeId> {
+        None
+    }
 }
 
 #[cfg(test)]
@@ -1585,8 +1651,13 @@ mod tests {
         // Tick the given tween and apply its state to the given entity target
         let state =
             world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
+                let comp_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
-                tween.step(tween_id, duration, entity_mut.reborrow(), events)
+                if let Ok(mut target) = entity_mut.get_mut_by_id(comp_id) {
+                    tween.step(tween_id, duration, target.reborrow(), events)
+                } else {
+                    TweenState::Completed
+                }
             });
 
         // Propagate events

From c47956be88ab600bef24c2217d60728c793a4d06 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Tue, 1 Jul 2025 20:43:07 +0100
Subject: [PATCH 18/66] Remove `Targetable` and other unused bits

---
 src/lens.rs      | 207 +++++++++++++++++++++++------------------------
 src/lib.rs       |  27 +++----
 src/plugin.rs    |   2 +-
 src/tweenable.rs | 110 +++----------------------
 4 files changed, 123 insertions(+), 223 deletions(-)

diff --git a/src/lens.rs b/src/lens.rs
index 432f370..d274336 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -37,8 +37,6 @@
 
 use bevy::prelude::*;
 
-use crate::Targetable;
-
 /// A lens over a subset of a component.
 ///
 /// The lens takes a `target` component or asset from a query, as a mutable
@@ -62,7 +60,7 @@ use crate::Targetable;
 /// struct MyStruct(f32);
 ///
 /// impl Lens<MyStruct> for MyLens {
-///     fn lerp(&mut self, target: &mut dyn Targetable<MyStruct>, ratio: f32) {
+///     fn lerp(&mut self, mut target: Mut<MyStruct>, ratio: f32) {
 ///         target.0 = self.start + (self.end - self.start) * ratio;
 ///     }
 /// }
@@ -73,7 +71,7 @@ pub trait Lens<T> {
     /// `ratio`. The `target` component or asset is mutated in place. The
     /// implementation decides which fields are interpolated, and performs
     /// the animation in-place, overwriting the target.
-    fn lerp(&mut self, target: &mut dyn Targetable<T>, ratio: f32);
+    fn lerp(&mut self, target: Mut<'_, T>, ratio: f32);
 }
 
 /// A lens to manipulate the [`color`] field of a section of a [`Text`]
@@ -91,7 +89,7 @@ pub struct TextColorLens {
 
 #[cfg(feature = "bevy_text")]
 impl Lens<TextColor> for TextColorLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<TextColor>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<TextColor>, ratio: f32) {
         target.0 = self.start.mix(&self.end, ratio);
     }
 }
@@ -109,7 +107,7 @@ pub struct TransformPositionLens {
 }
 
 impl Lens<Transform> for TransformPositionLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
         let value = self.start + (self.end - self.start) * ratio;
         target.translation = value;
     }
@@ -141,7 +139,7 @@ pub struct TransformRotationLens {
 }
 
 impl Lens<Transform> for TransformRotationLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
         target.rotation = self.start.slerp(self.end, ratio);
     }
 }
@@ -167,7 +165,7 @@ pub struct TransformRotateXLens {
 }
 
 impl Lens<Transform> for TransformRotateXLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_rotation_x(angle);
     }
@@ -194,7 +192,7 @@ pub struct TransformRotateYLens {
 }
 
 impl Lens<Transform> for TransformRotateYLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_rotation_y(angle);
     }
@@ -221,7 +219,7 @@ pub struct TransformRotateZLens {
 }
 
 impl Lens<Transform> for TransformRotateZLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_rotation_z(angle);
     }
@@ -254,7 +252,7 @@ pub struct TransformRotateAxisLens {
 }
 
 impl Lens<Transform> for TransformRotateAxisLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_axis_angle(self.axis, angle);
     }
@@ -273,7 +271,7 @@ pub struct TransformScaleLens {
 }
 
 impl Lens<Transform> for TransformScaleLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
         target.scale = self.start + (self.end - self.start) * ratio;
     }
 }
@@ -308,7 +306,7 @@ fn lerp_val(start: &Val, end: &Val, ratio: f32) -> Val {
 
 #[cfg(feature = "bevy_ui")]
 impl Lens<Node> for UiPositionLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Node>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Node>, ratio: f32) {
         target.left = lerp_val(&self.start.left, &self.end.left, ratio);
         target.right = lerp_val(&self.start.right, &self.end.right, ratio);
         target.top = lerp_val(&self.start.top, &self.end.top, ratio);
@@ -328,7 +326,7 @@ pub struct UiBackgroundColorLens {
 
 #[cfg(feature = "bevy_ui")]
 impl Lens<BackgroundColor> for UiBackgroundColorLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<BackgroundColor>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<BackgroundColor>, ratio: f32) {
         target.0 = self.start.mix(&self.end, ratio);
     }
 }
@@ -348,7 +346,7 @@ pub struct ColorMaterialColorLens {
 
 #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
 impl Lens<ColorMaterial> for ColorMaterialColorLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<ColorMaterial>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<ColorMaterial>, ratio: f32) {
         target.color = self.start.mix(&self.end, ratio);
     }
 }
@@ -368,7 +366,7 @@ pub struct SpriteColorLens {
 
 #[cfg(feature = "bevy_sprite")]
 impl Lens<Sprite> for SpriteColorLens {
-    fn lerp(&mut self, target: &mut dyn Targetable<Sprite>, ratio: f32) {
+    fn lerp(&mut self, mut target: Mut<Sprite>, ratio: f32) {
         let value = self.start.mix(&self.end, ratio);
         target.color = value;
     }
@@ -383,9 +381,6 @@ mod tests {
     use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
 
     use super::*;
-    #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
-    use crate::tweenable::AssetTarget;
-    use crate::tweenable::ComponentTarget;
 
     #[cfg(feature = "bevy_text")]
     #[test]
@@ -401,16 +396,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut text_color,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.);
+            lens.lerp(target, 0.);
         }
         assert_eq!(text_color.0, RED.into());
 
@@ -418,16 +413,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut text_color,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 1.);
+            lens.lerp(target, 1.);
         }
         assert_eq!(text_color.0, BLUE.into());
 
@@ -435,16 +430,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut text_color,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.3);
+            lens.lerp(target, 0.3);
         }
         assert_eq!(text_color.0, Color::srgba(0.7, 0., 0.3, 1.0));
     }
@@ -461,16 +456,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.);
+            lens.lerp(target, 0.);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
@@ -480,16 +475,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 1.);
+            lens.lerp(target, 1.);
         }
         assert!(transform
             .translation
@@ -501,16 +496,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.3);
+            lens.lerp(target, 0.3);
         }
         assert!(transform
             .translation
@@ -531,16 +526,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.);
+            lens.lerp(target, 0.);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
@@ -550,16 +545,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 1.);
+            lens.lerp(target, 1.);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
@@ -571,16 +566,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.3);
+            lens.lerp(target, 0.3);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
@@ -602,16 +597,16 @@ mod tests {
                 let mut added = Tick::new(0);
                 let mut last_changed = Tick::new(0);
                 let mut caller = MaybeLocation::caller();
-                let mut target = ComponentTarget::new(Mut::new(
+                let target = Mut::new(
                     &mut transform,
                     &mut added,
                     &mut last_changed,
                     Tick::new(0),
                     Tick::new(0),
                     caller.as_mut(),
-                ));
+                );
 
-                lens.lerp(&mut target, *ratio);
+                lens.lerp(target, *ratio);
             }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
@@ -631,16 +626,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.1);
+            lens.lerp(target, 0.1);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
@@ -662,16 +657,16 @@ mod tests {
                 let mut added = Tick::new(0);
                 let mut last_changed = Tick::new(0);
                 let mut caller = MaybeLocation::caller();
-                let mut target = ComponentTarget::new(Mut::new(
+                let target = Mut::new(
                     &mut transform,
                     &mut added,
                     &mut last_changed,
                     Tick::new(0),
                     Tick::new(0),
                     caller.as_mut(),
-                ));
+                );
 
-                lens.lerp(&mut target, *ratio);
+                lens.lerp(target, *ratio);
             }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
@@ -691,16 +686,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.1);
+            lens.lerp(target, 0.1);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
@@ -722,16 +717,16 @@ mod tests {
                 let mut added = Tick::new(0);
                 let mut last_changed = Tick::new(0);
                 let mut caller = MaybeLocation::caller();
-                let mut target = ComponentTarget::new(Mut::new(
+                let target = Mut::new(
                     &mut transform,
                     &mut added,
                     &mut last_changed,
                     Tick::new(0),
                     Tick::new(0),
                     caller.as_mut(),
-                ));
+                );
 
-                lens.lerp(&mut target, *ratio);
+                lens.lerp(target, *ratio);
             }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
@@ -751,16 +746,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.1);
+            lens.lerp(target, 0.1);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
@@ -784,16 +779,16 @@ mod tests {
                 let mut added = Tick::new(0);
                 let mut last_changed = Tick::new(0);
                 let mut caller = MaybeLocation::caller();
-                let mut target = ComponentTarget::new(Mut::new(
+                let target = Mut::new(
                     &mut transform,
                     &mut added,
                     &mut last_changed,
                     Tick::new(0),
                     Tick::new(0),
                     caller.as_mut(),
-                ));
+                );
 
-                lens.lerp(&mut target, *ratio);
+                lens.lerp(target, *ratio);
             }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
@@ -813,16 +808,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.1);
+            lens.lerp(target, 0.1);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
@@ -843,16 +838,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.);
+            lens.lerp(target, 0.);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
@@ -862,16 +857,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 1.);
+            lens.lerp(target, 1.);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
@@ -881,16 +876,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut transform,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.3);
+            lens.lerp(target, 0.3);
         }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
@@ -920,16 +915,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut node,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.);
+            lens.lerp(target, 0.);
         }
         assert_eq!(node.left, Val::Px(0.));
         assert_eq!(node.top, Val::Px(0.));
@@ -940,16 +935,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut node,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 1.);
+            lens.lerp(target, 1.);
         }
         assert_eq!(node.left, Val::Px(1.));
         assert_eq!(node.top, Val::Px(5.));
@@ -960,16 +955,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut node,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.3);
+            lens.lerp(target, 0.3);
         }
         assert_eq!(node.left, Val::Px(0.3));
         assert_eq!(node.top, Val::Px(1.5));
@@ -996,15 +991,15 @@ mod tests {
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
             let asset = assets.get_mut(handle.id()).unwrap();
-            let mut target = AssetTarget::new(Mut::new(
+            let target = Mut::new(
                 asset,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
-            lens.lerp(&mut target, 0.);
+            );
+            lens.lerp(target, 0.);
         }
         assert_eq!(assets.get(handle.id()).unwrap().color, RED.into());
 
@@ -1013,15 +1008,15 @@ mod tests {
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
             let asset = assets.get_mut(handle.id()).unwrap();
-            let mut target = AssetTarget::new(Mut::new(
+            let target = Mut::new(
                 asset,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
-            lens.lerp(&mut target, 1.);
+            );
+            lens.lerp(target, 1.);
         }
         assert_eq!(assets.get(handle.id()).unwrap().color, BLUE.into());
 
@@ -1030,15 +1025,15 @@ mod tests {
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
             let asset = assets.get_mut(handle.id()).unwrap();
-            let mut target = AssetTarget::new(Mut::new(
+            let target = Mut::new(
                 asset,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
-            lens.lerp(&mut target, 0.3);
+            );
+            lens.lerp(target, 0.3);
         }
         assert_eq!(
             assets.get(handle.id()).unwrap().color,
@@ -1062,16 +1057,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut sprite,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.);
+            lens.lerp(target, 0.);
         }
         assert_eq!(sprite.color, RED.into());
 
@@ -1079,16 +1074,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut sprite,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 1.);
+            lens.lerp(target, 1.);
         }
         assert_eq!(sprite.color, BLUE.into());
 
@@ -1096,16 +1091,16 @@ mod tests {
             let mut added = Tick::new(0);
             let mut last_changed = Tick::new(0);
             let mut caller = MaybeLocation::caller();
-            let mut target = ComponentTarget::new(Mut::new(
+            let target = Mut::new(
                 &mut sprite,
                 &mut added,
                 &mut last_changed,
                 Tick::new(0),
                 Tick::new(0),
                 caller.as_mut(),
-            ));
+            );
 
-            lens.lerp(&mut target, 0.3);
+            lens.lerp(target, 0.3);
         }
         assert_eq!(sprite.color, Color::srgba(0.7, 0., 0.3, 1.0));
     }
diff --git a/src/lib.rs b/src/lib.rs
index 3b76a7d..2bdfa69 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -214,11 +214,9 @@ use bevy::{
 pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
 use slotmap::{new_key_type, SlotMap};
-#[cfg(feature = "bevy_asset")]
-pub use tweenable::AssetTarget;
 pub use tweenable::{
-    BoxedTweenable, ComponentTarget, Delay, Sequence, Targetable, TotalDuration, Tween,
-    TweenAssetExtensions, TweenCompleted, TweenState, Tweenable,
+    BoxedTweenable, Delay, Sequence, TotalDuration, Tween, TweenAssetExtensions, TweenCompleted,
+    TweenState, Tweenable,
 };
 
 pub mod lens;
@@ -909,7 +907,6 @@ mod tests {
     use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
     use slotmap::Key as _;
 
-    use self::tweenable::ComponentTarget;
     use super::*;
     use crate::test_utils::*;
 
@@ -930,7 +927,7 @@ mod tests {
     }
 
     impl Lens<DummyComponent> for DummyLens {
-        fn lerp(&mut self, target: &mut dyn Targetable<DummyComponent>, ratio: f32) {
+        fn lerp(&mut self, mut target: Mut<DummyComponent>, ratio: f32) {
             target.value = self.start.lerp(self.end, ratio);
         }
     }
@@ -944,18 +941,18 @@ mod tests {
                 let mut added = Tick::new(0);
                 let mut last_changed = Tick::new(0);
                 let mut caller = MaybeLocation::caller();
-                let mut target = ComponentTarget::new(Mut::new(
+                let mut target = Mut::new(
                     &mut c,
                     &mut added,
                     &mut last_changed,
                     Tick::new(0),
                     Tick::new(1),
                     caller.as_mut(),
-                ));
+                );
 
-                l.lerp(&mut target, r);
+                l.lerp(target.reborrow(), r);
 
-                assert!(target.to_mut().is_changed());
+                assert!(target.is_changed());
             }
 
             assert_approx_eq!(c.value, r);
@@ -964,7 +961,7 @@ mod tests {
 
     #[cfg(feature = "bevy_asset")]
     impl Lens<DummyAsset> for DummyLens {
-        fn lerp(&mut self, target: &mut dyn Targetable<DummyAsset>, ratio: f32) {
+        fn lerp(&mut self, mut target: Mut<DummyAsset>, ratio: f32) {
             target.value = self.start.lerp(self.end, ratio);
         }
     }
@@ -972,8 +969,6 @@ mod tests {
     #[cfg(feature = "bevy_asset")]
     #[test]
     fn dummy_lens_asset() {
-        use self::tweenable::AssetTarget;
-
         let mut assets = Assets::<DummyAsset>::default();
         let handle = assets.add(DummyAsset::default());
 
@@ -984,15 +979,15 @@ mod tests {
                 let mut last_changed = Tick::new(0);
                 let mut caller = MaybeLocation::caller();
                 let asset = assets.get_mut(handle.id()).unwrap();
-                let mut target = AssetTarget::new(Mut::new(
+                let target = Mut::new(
                     asset,
                     &mut added,
                     &mut last_changed,
                     Tick::new(0),
                     Tick::new(0),
                     caller.as_mut(),
-                ));
-                l.lerp(&mut target, r);
+                );
+                l.lerp(target, r);
             }
             assert_approx_eq!(assets.get(handle.id()).unwrap().value, r);
         }
diff --git a/src/plugin.rs b/src/plugin.rs
index 7b59f9b..25a648b 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -261,7 +261,7 @@ mod tests {
     }
 
     impl Lens<DummyComponent> for ConditionalDeferLens {
-        fn lerp(&mut self, target: &mut dyn Targetable<DummyComponent>, ratio: f32) {
+        fn lerp(&mut self, mut target: Mut<DummyComponent>, ratio: f32) {
             if self.defer.load(Ordering::SeqCst) {
                 target.deref_mut().value += ratio;
             }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 087c69b..f89b0b8 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1,9 +1,4 @@
-use std::{
-    any::TypeId,
-    cmp::Ordering,
-    ops::{Deref, DerefMut},
-    time::Duration,
-};
+use std::{any::TypeId, cmp::Ordering, time::Duration};
 
 use bevy::{
     ecs::{change_detection::MutUntyped, component::Mutable, system::SystemId},
@@ -406,90 +401,6 @@ impl Ord for TotalDuration {
     }
 }
 
-// TODO - Targetable et al. should be replaced with Mut->Mut from Bevy 0.9
-// https://github.com/bevyengine/bevy/pull/6199
-// However this is blocked on the impossibility to get a Mut<R: Resource> from a
-// ResMut<Assets<R>> without triggering change detection.
-// https://github.com/bevyengine/bevy/issues/13104
-
-/// Trait to workaround the discrepancies of the change detection mechanisms of
-/// assets and components.
-pub trait Targetable<T> {
-    /// Dereference the target and return a reference.
-    fn target(&self) -> &T;
-
-    /// Dereference the target, triggering any change detection, and return a
-    /// mutable reference.
-    fn target_mut(&mut self) -> &mut T;
-}
-
-impl<'a, T: 'a> Deref for dyn Targetable<T> + 'a {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.target()
-    }
-}
-
-impl<'a, T: 'a> DerefMut for dyn Targetable<T> + 'a {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.target_mut()
-    }
-}
-
-/// Implementation of [`Targetable`] for a [`Component`].
-pub struct ComponentTarget<'a, T: Component> {
-    target: Mut<'a, T>,
-}
-
-impl<'a, T: Component> ComponentTarget<'a, T> {
-    /// Create a new instance from a [`Component`].
-    pub fn new(target: Mut<'a, T>) -> Self {
-        Self { target }
-    }
-
-    /// Get a [`Mut`] for the current target.
-    #[allow(dead_code)] // used mainly in tests
-    pub fn to_mut(&mut self) -> Mut<'_, T> {
-        self.target.reborrow()
-    }
-}
-
-impl<T: Component> Targetable<T> for ComponentTarget<'_, T> {
-    fn target(&self) -> &T {
-        self.target.deref()
-    }
-
-    fn target_mut(&mut self) -> &mut T {
-        self.target.deref_mut()
-    }
-}
-
-/// Implementation of [`Targetable`] for an [`Asset`].
-#[cfg(feature = "bevy_asset")]
-pub struct AssetTarget<'a, A: Asset> {
-    target: Mut<'a, A>,
-}
-
-#[cfg(feature = "bevy_asset")]
-impl<'a, A: Asset> AssetTarget<'a, A> {
-    /// Create a new instance from an [`Assets`].
-    pub fn new(target: Mut<'a, A>) -> Self {
-        Self { target }
-    }
-}
-
-#[cfg(feature = "bevy_asset")]
-impl<A: Asset> Targetable<A> for AssetTarget<'_, A> {
-    fn target(&self) -> &A {
-        self.target.deref()
-    }
-
-    fn target_mut(&mut self) -> &mut A {
-        self.target.deref_mut()
-    }
-}
-
 /// An animatable entity, either a single [`Tween`] or a collection of them.
 pub trait Tweenable: Send + Sync {
     /// Get the duration of a single cycle of the animation.
@@ -717,11 +628,11 @@ impl Tween {
         L: Lens<C> + Send + Sync + 'static,
     {
         let action = move |ptr: MutUntyped, ratio: f32| {
-            // SAFETY: ptr was obtained from the same component type.
+            // SAFETY: ptr was obtained from the same component type, via the type_id saved
+            // below.
             #[allow(unsafe_code)]
             let comp = unsafe { ptr.with_type::<C>() };
-            let mut target = ComponentTarget::new(comp);
-            lens.lerp(&mut target, ratio);
+            lens.lerp(comp, ratio);
         };
         Self {
             ease_function: ease_function.into(),
@@ -749,8 +660,7 @@ impl Tween {
             // SAFETY: ptr was obtained from the same component type.
             #[allow(unsafe_code)]
             let asset = unsafe { ptr.with_type::<A>() };
-            let mut target = AssetTarget::new(asset);
-            lens.lerp(&mut target, ratio);
+            lens.lerp(asset, ratio);
         };
         Self {
             ease_function: ease_function.into(),
@@ -964,8 +874,7 @@ impl TweenAssetExtensions for Tween {
             // SAFETY: ptr was obtained from the same asset type.
             #[allow(unsafe_code)]
             let asset = unsafe { ptr.with_type::<A>() };
-            let mut target = AssetTarget::new(asset);
-            lens.lerp(&mut target, ratio);
+            lens.lerp(asset, ratio);
         };
         Self {
             ease_function: ease_function.into(),
@@ -1495,6 +1404,8 @@ impl Tweenable for Delay {
 mod tests {
     // use std::sync::{Arc, Mutex};
 
+    use std::ops::{Deref as _, DerefMut as _};
+
     use bevy::ecs::{
         change_detection::MaybeLocation, component::Tick, event::Events, system::SystemState,
     };
@@ -1680,15 +1591,14 @@ mod tests {
         let mut added = Tick::new(0);
         let mut last_changed = Tick::new(0);
         let mut caller = MaybeLocation::caller();
-        let mut target = ComponentTarget::new(Mut::new(
+        let mut target = Mut::new(
             &mut c,
             &mut added,
             &mut last_changed,
             Tick::new(0),
             Tick::new(1),
             caller.as_mut(),
-        ));
-        let mut target = target.to_mut();
+        );
 
         // No-op at start
         assert!(!target.is_added());

From 99ee28ae26a3875dd9e5ed629289d651aa7e018c Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 2 Jul 2025 18:56:53 +0100
Subject: [PATCH 19/66] Fix some docs, add first draft of migration guide

---
 CHANGELOG.md                 |  58 ++++++++++++++
 docs/migration-guide-0.14.md |  91 ++++++++++++++++++++++
 src/lib.rs                   | 145 ++++++++++++++++++++++-------------
 src/tweenable.rs             |  90 ++++++++++++----------
 4 files changed, 287 insertions(+), 97 deletions(-)
 create mode 100644 docs/migration-guide-0.14.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 06ec7c6..9f27b5e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+_This change introduces a major API redesign, which removes the need for generics,
+and unifies all animations of all components and assets._
+
+### Added
+
+- Added `TweenId`, a unique identifier for a currently active animation.
+- Added `TotalDuration::from_cycles()` to simply creating an animation duration
+  from a number of individual cycles and their duration.
+- Added `TotalDuration::is_finite()` helper to check an animation duration is finite.
+- Added `TotalDuration::as_finite()` helper to convert an animation duration into
+  a `Duration` type if it's finite.
+- Implemented various operations on `TotalDuration`: `From<Duration>`, `Add`, `Sum`,
+  `PartialOrd`, `Ord`.
+- Added `Tweenable::cycle_fraction()` to query the current position of the animation
+  inside a cycle. This is roughly equivalent to the previous `progress()`.
+- Added `Tween::cycle_fraction()` and `Tween::cycle_index()` to query the position
+  of the animation inside a cycle and the cycle number, respectively.
+- Added helper `Tween::is_cycle_mirrored()`, which returns `true` if the playback
+  of the current cycle the animation is at is mirrored.
+  This always returns `false` unless `RepeatStrategy::MirroredRepeat` is used,
+  and the animation contains more than 1 cycle.
+
+### Changed
+
+- The `Lens<T>` trait now takes its target as `Mut<T>` instead of `&mut dyn Targetable<T>`.
+
+  ```rust
+  fn lerp(&mut self, target: Mut<T>, ratio: f32)
+  ```
+
+- The following types lost their generic parameter:
+  - `Tweenable`
+  - `Tween`
+  - `Sequence`
+  - `Delay`
+- `Tweenable::duration()` was renamed to `Tweenable::cycle_duration()` for clarity.
+- `Tweenable::times_completed()` was renamed to `Tweenable::cycles_completed()` for clarity.
+- `Tweenable::tick()` was renamed to `Tweenable::step()`, to insist on the fact
+  the step computes a new state, but doesn't necessarily moves any time back or forth.
+- `Tween::with_completed_event()` doesn't take `user_data` anymore, which was removed.
+  Instead it takes a `bool` indicating whether to send completion events or not.
+- Renamed `Tween<T>::set_direction()` into `Tween::set_playback_direction()` for clarity,
+  and `Tween<T>::direction()` into `Tween::playback_direction()`.
+  Note the clarified semantic of playback direction vs. mirroring repeat;
+  see the migration guide for details.
+- Renamed `AnimatorState` into `PlaybackState` for clarity.
+- Renamed `TweeningDirection` into `PlaybackDirection` to clarify the fact it only affects
+  animation playback, and is completely unrelated to cycle mirroring repeat.
+
+### Removed
+
+- Removed `Tracks<T>`. Use multiple animations instead.
+- Removed `Targetable`, `ComponentTarget`, `AssetTarget`. Those were workarounds
+  for the inability to use `Mut<T>` directly. In Bevy 0.16 they're not necessary.
+- Removed all references to "progress" in all APIs, in favor of `Duration`s.
+- Removed the `user_data` value from completed events.
+- Removed callback-based completion events. Use Bevy-style events or one-shot systems instead.
+
 ## [0.13.0] - 2025-04-28
 
 ### Changed
diff --git a/docs/migration-guide-0.14.md b/docs/migration-guide-0.14.md
new file mode 100644
index 0000000..6409b18
--- /dev/null
+++ b/docs/migration-guide-0.14.md
@@ -0,0 +1,91 @@
+# 🍃 Bevy Tweening 0.14 migration guide
+
+This migration guide describes the major changes to the 🍃 Bevy Tweening API
+operated in v0.14, and how to upgrade code using previous versions.
+
+## Semantic
+
+The new version 0.14 introduces new and/or clarified semantics for many concepts.
+
+### Animation timeline and `Duration`
+
+In previous verisons, the mental model for time related quantities was often poorly defined,
+and led to various confusions and edge cases.
+
+In v0.14, we removed all references to "progress", which was a floating-point value
+loosely defined as the fraction of the animation already performed, over its total duration.
+Instead, all time-related operations are performed directly with the `Duration` Rust type.
+
+Users should now adopt the following mental model for animation time:
+
+- Each animation has a _timeline_ starting at `t=0` and extending to the _total duration_
+  of the animation, which can be infinite if _e.g._ the animation loops forever.
+  The timeline is a concept to help build a mental model; there's no timeline type in code.
+- The animation is composed of one or more _cycles_, which repeat eith a given number of times,
+  or until a duration is elapsed. This is configured by the `RepeatCount` type.
+- The _elapsed_ time of an animation is the position on its timeline. It ranges from `0`
+  to its total duration (except for infinitely repeating animations; see details below).
+- In general, cycles are repeated identically. However, as an alternative, the user can configure
+  the _repeat strategy_ to mirror every other cycle. Mirrored cycles animate their target
+  in reverse order. However, note that **the elapsed time value is unaffected by mirroring,
+  and continues to be expressed as an absolute time position** on the animation timeline.
+  This is a major semantic change compared to previous versions, and greatly clarifies
+  the implementation and the timeline mental model.
+
+Standard (non-mirrored) repeating of cycles:
+
+```txt
+  ratio           cycle duration
+  ^                   |<->|
+1 |  /   /   /   /   /|  /|  /   /   /   /
+  | /   /   /   /   / | / | /   /   /   /
+  |/   /   /   /   /  |/  |/   /   /   /   /
+0 *-----------------------------------------*------> timeline
+  0     <------ total duration ------>      |
+```
+
+Mirrored repeating of cycles:
+
+```txt
+  ratio          cycle duration
+  ^                  |<->|
+1 |  /\    /\    /\  |  /|\    /\    /\    /\
+  | /  \  /  \  /  \ | / | \  /  \  /  \  /  
+  |/    \/    \/    \|/  |  \/    \/    \/   
+0 *-----------------------------------------*-----> timeline
+  0     <------ total duration ------>      |
+```
+
+Note that **the cycle duration is half the duration of the "loop" formed by the mirroring**.
+For this reason, 🍃 Bevy Tweening now avoids using the term "loop", to prevent confusion.
+
+In the above, the `ratio` is a value in `[0:1]` which gets passed to the easing function.
+The output is then fed to `Lens::lerp()` to calculate the animation target state.
+When using a linear easing function, `ratio` is exactly the lerp fraction.
+
+Consequence of the above, functions like `Tweenable::set_elapsed()` operate on the timeline,
+using absolute duration. This means that calling `set_elapsed(2.5s)` on an animation composed
+of 3 cycles of 1s each effectively puts the animation position at half of the third cycle.
+
+### Playback direction
+
+Related to the animation timeline and absolute duration position,
+the _playback direction_ determines whether calls to `Tweenable::step()` move the animation
+time forward or backward **on the animation timeline**.
+
+**This means the playback direction is completely unrelated to cycles mirroring.**
+
+This is a major clarification over the confusing semantic of previous versions, which tended
+to mix the two concepts and produced often unexpected results.
+
+### Completion events and completed state
+
+_Completion events_ are emitted when an animation complete a cycle.
+
+To prevent any confusion, the reversed playback direction is considerd to be an editing tool,
+not typical of normal use in a game or other application, and therefore **completion events are
+never emitted in reverse playback**.
+
+Related but distinct, the _completion state_ of the animation determines if the animation
+can continue playback or not. The animation is said to be completed when its elapsed time
+reaches its total duration, at the end of its timeline. Infinite animations never complete.
diff --git a/src/lib.rs b/src/lib.rs
index 2bdfa69..32f5b80 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -266,38 +266,35 @@ impl From<Duration> for RepeatCount {
     }
 }
 
-/// What to do when a tween animation needs to be repeated.
+/// Repeat strategy for animation cycles.
 ///
-/// Only applicable when [`RepeatCount`] is greater than the animation duration.
+/// Only applicable when [`RepeatCount`] is greater than the total duration of
+/// the tweenable animation.
 ///
 /// Default: `Repeat`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
 pub enum RepeatStrategy {
-    /// Reset the animation back to its starting position.
+    /// Reset the cycle back to its starting position.
     ///
-    /// When playback reaches the end of the animation, it jumps directly back
-    /// to the animation start. This can create discontinuities if the animation
-    /// is not authored to be looping.
+    /// When playback reaches the end of the animation cycle, it jumps directly
+    /// back to the cycle start. This can create discontinuities if the
+    /// animation is not authored to be looping.
+    #[default]
     Repeat,
-    /// Follow a ping-pong pattern, changing the direction each time an endpoint
-    /// is reached.
+
+    /// Follow a ping-pong pattern, changing the cycle direction each time an
+    /// endpoint is reached.
     ///
-    /// A complete cycle start -> end -> start always counts as 2 loop
-    /// iterations for the various operations where looping matters. That
-    /// is, a 1 second animation will take 2 seconds to end up back where it
-    /// started.
+    /// A complete loop start -> end -> start always counts as 2 cycles for the
+    /// various operations where cycle count matters. That is, an animation with
+    /// a 1-second cycle and a mirrored repeat strategy will take 2 seconds
+    /// to end up back in the state where it started.
     ///
     /// This strategy ensures that there's no discontinuity in the animation,
     /// since there's no jump.
     MirroredRepeat,
 }
 
-impl Default for RepeatStrategy {
-    fn default() -> Self {
-        Self::Repeat
-    }
-}
-
 /// Playback state of a [`TweenAnim`].
 ///
 /// Default: `Playing`.
@@ -323,16 +320,16 @@ impl std::ops::Not for PlaybackState {
 
 /// Describe how eased value should be computed.
 ///
-/// This function is applied to the animation fraction `t` representing the
-/// playback position over the animation duration. The result is used to
-/// interpolate the animator target.
+/// This function is applied to the cycle fraction `t` representing the playback
+/// position over the cycle duration. The result is used to interpolate the
+/// animation target.
 ///
 /// In general a [`Lens`] should perform a linear interpolation over its target,
 /// and the non-linear behavior (for example, bounciness, etc.) comes from this
 /// function. This ensures the same [`Lens`] can be reused in multiple contexts,
 /// while the "shape" of the animation is controlled independently.
 ///
-/// Default: `Linear`.
+/// Default: `EaseFunction::Linear`.
 #[derive(Clone, Copy)]
 pub enum EaseMethod {
     /// Follow [`EaseFunction`].
@@ -340,7 +337,11 @@ pub enum EaseMethod {
     /// Discrete interpolation. The eased value will jump from start to end when
     /// stepping over the discrete limit, which must be value between 0 and 1.
     Discrete(f32),
-    /// Use a custom function to interpolate the value.
+    /// Use a custom function to interpolate the value. The function is called
+    /// with the cycle ratio, in `[0:1]`, as parameter, and must return the
+    /// easing factor, typically also in `[0:1]`. Note that values outside this
+    /// unit range may not work well with some animations; for example if
+    /// animating a color, a negative red values have no meaning.
     CustomFunction(fn(f32) -> f32),
 }
 
@@ -375,51 +376,43 @@ impl From<EaseFunction> for EaseMethod {
 
 /// Direction a tweening animation is playing.
 ///
-/// When playing a tweenable forward, the progress values `0` and `1` are
-/// respectively mapped to the start and end bounds of the lens(es) being used.
-/// Conversely, when playing backward, this mapping is reversed, such that a
-/// progress value of `0` corresponds to the state of the target at the end
-/// bound of the lens, while a progress value of `1` corresponds to the state of
-/// that target at the start bound of the lens, effectively making the animation
-/// play backward.
+/// The playback direction determines if the delta animation time passed to
+/// [`Tweenable::step()`], generally by the [`TweenAnimator`], is added or
+/// subtracted to the current time position on the animation's timeline.
+/// - In `Forward` direction, time passes forward from `t=0` to the total
+///   duration of the animation.
+/// - Conversely, in `Backward` direction, time passes backward from the total
+///   duration back to `t=0`.
 ///
-/// For all but [`RepeatStrategy::MirroredRepeat`] this is always
-/// [`TweeningDirection::Forward`], unless manually configured with
-/// [`Tween::set_direction()`] in which case the value is constant equal to the
-/// value set. When using [`RepeatStrategy::MirroredRepeat`], this is either
-/// forward (from start to end; ping) or backward (from end to start; pong),
-/// depending on the current iteration of the loop.
+/// Note that backward playback is supported for infinite animations (when the
+/// repeat count is [`RepeatCount::Infinite`]), but [`Tweenable::rewind()`] is
+/// not supported and will panic.
 ///
 /// Default: `Forward`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum TweeningDirection {
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum PlaybackDirection {
     /// Animation playing from start to end.
+    #[default]
     Forward,
     /// Animation playing from end to start, in reverse.
     Backward,
 }
 
-impl TweeningDirection {
-    /// Is the direction equal to [`TweeningDirection::Forward`]?
+impl PlaybackDirection {
+    /// Is the direction equal to [`PlaybackDirection::Forward`]?
     #[must_use]
     pub fn is_forward(&self) -> bool {
         *self == Self::Forward
     }
 
-    /// Is the direction equal to [`TweeningDirection::Backward`]?
+    /// Is the direction equal to [`PlaybackDirection::Backward`]?
     #[must_use]
     pub fn is_backward(&self) -> bool {
         *self == Self::Backward
     }
 }
 
-impl Default for TweeningDirection {
-    fn default() -> Self {
-        Self::Forward
-    }
-}
-
-impl std::ops::Not for TweeningDirection {
+impl std::ops::Not for PlaybackDirection {
     type Output = Self;
 
     fn not(self) -> Self::Output {
@@ -431,13 +424,18 @@ impl std::ops::Not for TweeningDirection {
 }
 
 new_key_type! {
-    /// Unique identifier for a tweenable.
+    /// Unique identifier for a tweenable animation currently registered with the [`TweenAnimator`].
     pub struct TweenId;
 }
 
 /// Extensions for [`EntityCommands`] to queue tween-based animations.
 pub trait EntityCommandsTweeningExtensions<'a> {
     /// Queue the given [`Tweenable`].
+    ///
+    /// This calls [`TweenAnimator::add()`] on the current entity, deriving the
+    /// proper component to animate based on the type of the lens stored in the
+    /// tweenable (see [`Tweenable::type_id()`]). That component must exists on
+    /// the entity.
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
     where
         T: Tweenable + 'static;
@@ -446,12 +444,18 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     ///
     /// The entity must have a [`Transform`] component. The tween animation will
     /// be initialized with the current [`Transform::translation`] as its
-    /// starting point, and the given endpoint and duration.
+    /// starting point, and the given endpoint and duration. The ease mode is
+    /// linear.
     ///
     /// Note that the starting point position is saved when the command is
     /// applied, generally after the current system when [`apply_deferred()`]
     /// runs. So any change to [`Transform::translation`] between this call and
     /// [`apply_deferred()`] will be taken into account.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// the animation playback, directly add the tweenable via
+    /// [`TweenAnimator::add()`].
     fn move_to(&mut self, end: Vec3, duration: Duration) -> &mut Self;
 }
 
@@ -557,12 +561,20 @@ pub struct TweenAnim {
 
 impl TweenAnim {
     /// Create a new tween animation.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the tweenable is "typeless", that is [`Tweenable::type_id()`]
+    /// returns `None`. Root animations enqueued in the [`TweenAnimator`] must
+    /// target a concrete component or asset type. This means in particular
+    /// that you can't insert a single [`Delay`]. You can however use a
+    /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
+    /// provided there's at least one other typed tweenable in the sequence.
     pub fn new(target: Entity, tweenable: impl Tweenable + 'static) -> Self {
         let type_id = tweenable.type_id().expect(
             "Typeless tweenable like Delay can't be inserted as root tweenable in an animation.",
         );
         Self {
-            //target: AnimTarget::Entity(target),
             target: AnimTarget::Entity {
                 type_id,
                 entity: target,
@@ -574,6 +586,23 @@ impl TweenAnim {
     }
 
     /// Create a new tween animation for an asset.
+    ///
+    /// The `type_id` must be `TypeId::of::<Assets<A>>`, where `A: Asset` is the
+    /// asset type to animate. The `asset_id` is the type-erased ID of the
+    /// actual asset, as stored in the `Assets<A>` container.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the tweenable is "typeless", that is [`Tweenable::type_id()`]
+    /// returns `None`. Root animations enqueued in the [`TweenAnimator`] must
+    /// target a concrete component or asset type. This means in particular
+    /// that you can't insert a single [`Delay`]. You can however use a
+    /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
+    /// provided there's at least one other typed tweenable in the sequence.
+    ///
+    /// Panics if the tweenable type is different from the `type_id` parameter,
+    /// which identified the type of the [`Assets`] container storing the asset
+    /// to animate.
     pub fn new_asset(
         type_id: TypeId,
         asset_id: UntypedAssetId,
@@ -597,8 +626,14 @@ impl TweenAnim {
 
     /// Stop animation playback and rewind the animation.
     ///
-    /// This changes the animator state to [`AnimatorState::Paused`] and  rewind
+    /// This changes the animator state to [`PlaybackState::Paused`] and rewinds
     /// its tweenable.
+    ///
+    /// # Panics
+    ///
+    /// Like [`Tweenable::rewind()`], this panics if the current playback
+    /// direction is [`PlaybackDirection::Backward`] and the animation is
+    /// infinitely repeating.
     pub fn stop(&mut self) {
         self.state = PlaybackState::Paused;
         self.tweenable.rewind();
@@ -1007,8 +1042,8 @@ mod tests {
 
     #[test]
     fn tweening_direction() {
-        let tweening_direction = TweeningDirection::default();
-        assert_eq!(tweening_direction, TweeningDirection::Forward);
+        let tweening_direction = PlaybackDirection::default();
+        assert_eq!(tweening_direction, PlaybackDirection::Forward);
     }
 
     #[test]
diff --git a/src/tweenable.rs b/src/tweenable.rs
index f89b0b8..498229b 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -5,7 +5,7 @@ use bevy::{
     prelude::*,
 };
 
-use crate::{EaseMethod, Lens, RepeatCount, RepeatStrategy, TweenId, TweeningDirection};
+use crate::{EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy, TweenId};
 
 /// The dynamic tweenable type.
 ///
@@ -151,7 +151,7 @@ impl AnimClock {
         };
 
         let (state, mut times_completed) =
-            self.set_elapsed(next_elapsed, TweeningDirection::Forward);
+            self.set_elapsed(next_elapsed, PlaybackDirection::Forward);
 
         if extra_completed > 0 && (times_completed < 0) {
             // The clock looped around, so returns -1. But we're already counting that loop
@@ -195,7 +195,7 @@ impl AnimClock {
             };
         };
 
-        self.set_elapsed(next_elapsed, TweeningDirection::Backward)
+        self.set_elapsed(next_elapsed, PlaybackDirection::Backward)
     }
 
     /// Get the elapsed cycle index, accounting for finite clock endpoint.
@@ -260,7 +260,7 @@ impl AnimClock {
     fn set_elapsed(
         &mut self,
         elapsed: Duration,
-        direction: TweeningDirection,
+        direction: PlaybackDirection,
     ) -> (TweenState, i32) {
         let old_times_completed = self.times_completed();
 
@@ -292,7 +292,7 @@ impl AnimClock {
         self.elapsed
     }
 
-    fn state(&self, playback_direction: TweeningDirection) -> TweenState {
+    fn state(&self, playback_direction: PlaybackDirection) -> TweenState {
         match self.total_duration {
             TotalDuration::Finite(total_duration) => {
                 if playback_direction.is_forward() && self.elapsed >= total_duration {
@@ -307,10 +307,10 @@ impl AnimClock {
         }
     }
 
-    fn rewind(&mut self, direction: TweeningDirection) {
+    fn rewind(&mut self, direction: PlaybackDirection) {
         self.elapsed = match direction {
-            TweeningDirection::Forward => Duration::ZERO,
-            TweeningDirection::Backward => self.total_duration.as_finite().unwrap(),
+            PlaybackDirection::Forward => Duration::ZERO,
+            PlaybackDirection::Backward => self.total_duration.as_finite().unwrap(),
         };
     }
 }
@@ -458,7 +458,7 @@ pub trait Tweenable: Send + Sync {
     ///
     /// Advance the internal clock of the animation by the specified amount of
     /// time. If the animation is currently playing backward
-    /// ([`TweeningDirection::Backward`]), the clock moves backward and the
+    /// ([`PlaybackDirection::Backward`]), the clock moves backward and the
     /// `delta` duration is subtracted from the [`elapsed()`] time instead of
     /// being added to it.
     ///
@@ -482,8 +482,14 @@ pub trait Tweenable: Send + Sync {
     /// Rewind the animation to its starting state.
     ///
     /// Note that the starting state depends on the current direction. For
-    /// [`TweeningDirection::Forward`] this is the start point of the lens,
-    /// whereas for [`TweeningDirection::Backward`] this is the end one.
+    /// [`PlaybackDirection::Forward`] this is the start point of the lens,
+    /// whereas for [`PlaybackDirection::Backward`] this is the end one.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the current playback direction is
+    /// [`PlaybackDirection::Backward`] and the animation is infinitely
+    /// repeating.
     fn rewind(&mut self);
 
     /// Get the number of cycles completed.
@@ -565,7 +571,7 @@ pub struct Tween {
     ease_function: EaseMethod,
     clock: AnimClock,
     /// Direction of playback the user asked for.
-    playback_direction: TweeningDirection,
+    playback_direction: PlaybackDirection,
     action: TweenAction,
     system_id: Option<SystemId>,
     send_completed_event: bool,
@@ -637,7 +643,7 @@ impl Tween {
         Self {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
-            playback_direction: TweeningDirection::Forward,
+            playback_direction: PlaybackDirection::Forward,
             action: TweenAction::Component(Box::new(action)),
             system_id: None,
             send_completed_event: false,
@@ -665,7 +671,7 @@ impl Tween {
         Self {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
-            playback_direction: TweeningDirection::Forward,
+            playback_direction: PlaybackDirection::Forward,
             action: TweenAction::Asset(Box::new(action)),
             system_id: None,
             send_completed_event: false,
@@ -777,7 +783,7 @@ impl Tween {
     /// Changing the direction doesn't change any target state, nor the elapsed
     /// time of the tween. Only the direction of playback from this moment
     /// potentially changes.
-    pub fn set_playback_direction(&mut self, direction: TweeningDirection) {
+    pub fn set_playback_direction(&mut self, direction: PlaybackDirection) {
         self.playback_direction = direction;
     }
 
@@ -785,7 +791,7 @@ impl Tween {
     ///
     /// See [`Tween::set_playback_direction()`].
     #[must_use]
-    pub fn with_playback_direction(mut self, direction: TweeningDirection) -> Self {
+    pub fn with_playback_direction(mut self, direction: PlaybackDirection) -> Self {
         self.playback_direction = direction;
         self
     }
@@ -795,12 +801,12 @@ impl Tween {
     /// This is the value set by the user with [`with_playback_direction()`] and
     /// [`set_playback_direction()`]. This is never changed by the playback.
     ///
-    /// See [`TweeningDirection`] for details.
+    /// See [`PlaybackDirection`] for details.
     ///
     /// [`with_playback_direction()`]: Self::with_playback_direction
     /// [`set_playback_direction()`]: Self::set_playback_direction
     #[must_use]
-    pub fn playback_direction(&self) -> TweeningDirection {
+    pub fn playback_direction(&self) -> PlaybackDirection {
         self.playback_direction
     }
 
@@ -879,7 +885,7 @@ impl TweenAssetExtensions for Tween {
         Self {
             ease_function: ease_function.into(),
             clock: AnimClock::new(duration),
-            playback_direction: TweeningDirection::Forward,
+            playback_direction: PlaybackDirection::Forward,
             action: TweenAction::Asset(Box::new(action)),
             system_id: None,
             send_completed_event: false,
@@ -1426,7 +1432,7 @@ mod tests {
         // The direction passed to AnimClock::set_elapsed() only affects the returned
         // state, which is not tested in this test, so passing any value should produce
         // the same test result here.
-        for dummy in [TweeningDirection::Forward, TweeningDirection::Backward] {
+        for dummy in [PlaybackDirection::Forward, PlaybackDirection::Backward] {
             let cycle_duration = Duration::from_millis(100);
             let repeat_count = 4;
             let total_duration = cycle_duration * repeat_count;
@@ -1649,7 +1655,7 @@ mod tests {
     /// Test ticking of a single tween in isolation.
     #[test]
     fn tween_tick() {
-        for playback_direction in [TweeningDirection::Forward, TweeningDirection::Backward] {
+        for playback_direction in [PlaybackDirection::Forward, PlaybackDirection::Backward] {
             for (count, strategy) in [
                 (RepeatCount::Finite(1), RepeatStrategy::default()),
                 (RepeatCount::Infinite, RepeatStrategy::Repeat),
@@ -1678,7 +1684,7 @@ mod tests {
                     .total_duration()
                     .as_finite()
                     .unwrap_or(Duration::from_secs(1));
-                if playback_direction == TweeningDirection::Backward {
+                if playback_direction == PlaybackDirection::Backward {
                     // Seek to end, so that backward playback actually does something
                     tween.set_elapsed(backward_start_time);
                 }
@@ -1718,7 +1724,7 @@ mod tests {
                                 (
                                     elapsed_ms,
                                     elapsed_ms as f32 / 1000.0,
-                                    TweeningDirection::Forward,
+                                    PlaybackDirection::Forward,
                                     state,
                                     just_completed,
                                 )
@@ -1759,7 +1765,7 @@ mod tests {
                                     (
                                         elapsed_ms,
                                         factor,
-                                        TweeningDirection::Forward,
+                                        PlaybackDirection::Forward,
                                         state,
                                         just_completed,
                                     )
@@ -1800,18 +1806,18 @@ mod tests {
                                         // 2468X 86420 00
                                         // ffffb bbbbb bb
                                         if i >= 5 {
-                                            TweeningDirection::Backward
+                                            PlaybackDirection::Backward
                                         } else {
-                                            TweeningDirection::Forward
+                                            PlaybackDirection::Forward
                                         }
                                     } else {
                                         //           v [completion]
                                         // 86420 2468X XX
                                         // bbbbb fffff ff
                                         if i <= 5 {
-                                            TweeningDirection::Backward
+                                            PlaybackDirection::Backward
                                         } else {
-                                            TweeningDirection::Forward
+                                            PlaybackDirection::Forward
                                         }
                                     };
 
@@ -1831,7 +1837,7 @@ mod tests {
                                     (
                                         elapsed_ms,
                                         elapsed_ms as f32 / 1000.0,
-                                        TweeningDirection::Forward,
+                                        PlaybackDirection::Forward,
                                         TweenState::Active,
                                         just_completed,
                                     )
@@ -1858,17 +1864,17 @@ mod tests {
                                         // 2468X 86420 24
                                         // ffffb bbbbf ff
                                         if (i % 10) >= 5 {
-                                            TweeningDirection::Backward
+                                            PlaybackDirection::Backward
                                         } else {
-                                            TweeningDirection::Forward
+                                            PlaybackDirection::Forward
                                         }
                                     } else {
                                         // 86420 2468X 86
                                         // bbbbb fffff bb
                                         if ((i - 1) % 10) >= 5 {
-                                            TweeningDirection::Backward
+                                            PlaybackDirection::Backward
                                         } else {
-                                            TweeningDirection::Forward
+                                            PlaybackDirection::Forward
                                         }
                                     };
                                     let just_completed = (i % 5) == 0;
@@ -1935,7 +1941,7 @@ mod tests {
 
                 // Can't rewind infinite tweens moving backward, they don't have an endpoint
                 if tween.total_duration().is_finite()
-                    || (playback_direction != TweeningDirection::Backward)
+                    || (playback_direction != PlaybackDirection::Backward)
                 {
                     // Rewind
                     println!("+ Rewind");
@@ -1995,31 +2001,31 @@ mod tests {
         let mut tween = make_test_tween();
 
         // Default
-        assert_eq!(tween.playback_direction(), TweeningDirection::Forward);
+        assert_eq!(tween.playback_direction(), PlaybackDirection::Forward);
         assert_eq!(tween.elapsed(), Duration::ZERO);
 
         // no-op
-        tween.set_playback_direction(TweeningDirection::Forward);
-        assert_eq!(tween.playback_direction(), TweeningDirection::Forward);
+        tween.set_playback_direction(PlaybackDirection::Forward);
+        assert_eq!(tween.playback_direction(), PlaybackDirection::Forward);
         assert_eq!(tween.elapsed(), Duration::ZERO);
 
         // Backward
-        tween.set_playback_direction(TweeningDirection::Backward);
-        assert_eq!(tween.playback_direction(), TweeningDirection::Backward);
+        tween.set_playback_direction(PlaybackDirection::Backward);
+        assert_eq!(tween.playback_direction(), PlaybackDirection::Backward);
         assert_eq!(tween.elapsed(), Duration::ZERO);
 
         // Elapsed-invariant
         let d300 = Duration::from_millis(300);
-        tween.set_playback_direction(TweeningDirection::Forward);
+        tween.set_playback_direction(PlaybackDirection::Forward);
         tween.set_elapsed(d300);
         assert_eq!(tween.elapsed(), d300);
-        tween.set_playback_direction(TweeningDirection::Backward);
+        tween.set_playback_direction(PlaybackDirection::Backward);
         assert_eq!(tween.elapsed(), d300);
 
         let (mut world, entity, _system_id) = make_test_env();
 
         // Progress always increases alongside the current direction
-        tween.set_playback_direction(TweeningDirection::Backward);
+        tween.set_playback_direction(PlaybackDirection::Backward);
         assert_eq!(tween.elapsed(), d300);
         manual_tick_component(
             TweenId::null(), // unused in this test

From 5a1ef81672b13ad896795968d2e664f7a2043860 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 5 Jul 2025 11:14:44 +0100
Subject: [PATCH 20/66] Fix animation target in completion events

---
 examples/menu.rs |   6 +-
 src/lib.rs       | 340 ++++++++++++++++++++++++++++-------------------
 src/plugin.rs    |   8 +-
 src/tweenable.rs | 142 ++++++--------------
 4 files changed, 254 insertions(+), 242 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index c0f273b..ba922b9 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -138,7 +138,11 @@ fn enable_interaction_after_initial_animation(
     mut reader: EventReader<TweenCompleted>,
 ) {
     for event in reader.read() {
-        commands.entity(event.entity).insert(InitTransitionDone);
+        if let AnimTarget::Component(comp_target) = &event.target {
+            commands
+                .entity(comp_target.entity)
+                .insert(InitTransitionDone);
+        }
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 32f5b80..f52a744 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -205,10 +205,12 @@
 //! [`TextColor`]: https://docs.rs/bevy/0.16.0/bevy/text/struct.TextColor.html
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
 
-use std::{any::TypeId, time::Duration};
+use std::time::Duration;
 
 use bevy::{
-    asset::UntypedAssetId, ecs::change_detection::MutUntyped, platform::collections::HashMap,
+    asset::UntypedAssetId,
+    ecs::{change_detection::MutUntyped, component::ComponentId},
+    platform::collections::HashMap,
     prelude::*,
 };
 pub use lens::Lens;
@@ -467,17 +469,41 @@ where
 {
     move |mut entity: EntityWorldMut| {
         let e = entity.id();
-        entity.resource_mut::<TweenAnimator>().queue(e, tweenable);
+        let type_id = tweenable
+            .type_id()
+            .expect("Can't add untyped tweenable as root animation.");
+        let component_id = entity
+            .world()
+            .components()
+            .get_id(type_id)
+            .expect("Tweenable component not registered with the World.");
+        let target = ComponentTarget {
+            entity: e,
+            component_id,
+        };
+        entity
+            .resource_mut::<TweenAnimator>()
+            .queue(target.into(), tweenable);
     }
 }
 
 fn make_transform_from_command(end: Vec3, duration: Duration) -> impl EntityCommand {
     move |mut entity: EntityWorldMut| {
+        let component_id = entity
+            .world()
+            .component_id::<Transform>()
+            .expect("Transform component not registered in the World");
         let start = entity.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(EaseFunction::Linear, duration, lens);
         let e = entity.id();
-        entity.resource_mut::<TweenAnimator>().queue(e, tween);
+        let target = ComponentTarget {
+            entity: e,
+            component_id,
+        };
+        entity
+            .resource_mut::<TweenAnimator>()
+            .queue(target.into(), tween);
     }
 }
 
@@ -499,53 +525,102 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
 pub struct AnimCompleted {
     /// The ID of the tween animation which completed.
     pub id: TweenId,
-    /// The [`Entity`] the animation which completed is attached to.
+    /// The animation target.
+    pub target: AnimTarget,
+}
+
+/// Component animation target.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ComponentTarget {
+    /// Component ID of the registered component being animated.
+    pub component_id: ComponentId,
+    /// Entity holding the component instance being animated.
     pub entity: Entity,
 }
 
-///
-#[derive(Debug, Clone, Copy)]
+/// Asset animation target.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct AssetTarget {
+    /// Resource ID of the registered [`Assets<A>`] asset container.
+    pub resource_id: ComponentId,
+    /// Asset ID of the target asset being animated.
+    pub asset_id: UntypedAssetId,
+}
+
+/// Animation target.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum AnimTarget {
-    ///
-    Entity {
-        ///
-        type_id: TypeId,
-        ///
-        entity: Entity,
-    },
-    ///
-    Asset {
-        ///
-        type_id: TypeId,
-        ///
-        asset_id: UntypedAssetId,
-    },
+    /// Component animation target.
+    Component(ComponentTarget),
+    /// Asset animation target.
+    Asset(AssetTarget),
 }
 
-// impl AnimTarget {
-//     pub fn resolve<'w>(&self, world: &'w mut World) ->
-// Result<AnimResolvedTarget<'w>, ()> {         match self {
-//             AnimTarget::Entity(target) => {
-//                 let ent_mut = &mut
-// world.get_entity_mut([*target]).unwrap()[0];
-// Ok(AnimResolvedTarget::Entity(ent_mut))             }
-//             AnimTarget::Asset(asset_id) => {
-//                 if let Some(comp_id) =
-// world.components().get_resource_id(asset_id.type_id()) {
-// if let Some(mut_untyped) = world.get_resource_mut_by_id(comp_id) {
-//                         return Ok(AnimResolvedTarget::Asset(mut_untyped));
-//                     }
-//                 }
-//                 Err(())
-//             }
-//         }
-//     }
-// }
+impl AnimTarget {
+    /// Check if the target is a component.
+    #[inline]
+    pub fn is_component(&self) -> bool {
+        matches!(*self, AnimTarget::Component(..))
+    }
 
-// pub enum AnimResolvedTarget<'w> {
-//     Entity(&'w mut EntityMut<'w>),
-//     Asset(MutUntyped<'w>),
-// }
+    /// Convert this target to a component target if possible.
+    #[inline]
+    pub fn as_component(&self) -> Option<&ComponentTarget> {
+        if let Self::Component(component) = self {
+            Some(component)
+        } else {
+            None
+        }
+    }
+
+    /// Convert this target to a component target if possible.
+    #[inline]
+    pub fn as_component_mut(&mut self) -> Option<&mut ComponentTarget> {
+        if let Self::Component(component) = self {
+            Some(component)
+        } else {
+            None
+        }
+    }
+
+    /// Check if the target is an asset.
+    #[inline]
+    pub fn is_asset(&self) -> bool {
+        matches!(*self, AnimTarget::Asset(..))
+    }
+
+    /// Convert this target to an asset target if possible.
+    #[inline]
+    pub fn as_asset(&self) -> Option<&AssetTarget> {
+        if let Self::Asset(asset) = self {
+            Some(asset)
+        } else {
+            None
+        }
+    }
+
+    /// Convert this target to an asset target if possible.
+    #[inline]
+    pub fn as_asset_mut(&mut self) -> Option<&mut AssetTarget> {
+        if let Self::Asset(asset) = self {
+            Some(asset)
+        } else {
+            None
+        }
+    }
+}
+
+impl From<ComponentTarget> for AnimTarget {
+    fn from(value: ComponentTarget) -> Self {
+        AnimTarget::Component(value)
+    }
+}
+
+impl From<AssetTarget> for AnimTarget {
+    fn from(value: AssetTarget) -> Self {
+        AnimTarget::Asset(value)
+    }
+}
 
 /// A [`Tweenable`]-based animation.
 pub struct TweenAnim {
@@ -570,15 +645,9 @@ impl TweenAnim {
     /// that you can't insert a single [`Delay`]. You can however use a
     /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
     /// provided there's at least one other typed tweenable in the sequence.
-    pub fn new(target: Entity, tweenable: impl Tweenable + 'static) -> Self {
-        let type_id = tweenable.type_id().expect(
-            "Typeless tweenable like Delay can't be inserted as root tweenable in an animation.",
-        );
+    pub fn new(target: AnimTarget, tweenable: impl Tweenable + 'static) -> Self {
         Self {
-            target: AnimTarget::Entity {
-                type_id,
-                entity: target,
-            },
+            target,
             tweenable: Box::new(tweenable),
             state: PlaybackState::Playing,
             speed: 1.,
@@ -603,26 +672,26 @@ impl TweenAnim {
     /// Panics if the tweenable type is different from the `type_id` parameter,
     /// which identified the type of the [`Assets`] container storing the asset
     /// to animate.
-    pub fn new_asset(
-        type_id: TypeId,
-        asset_id: UntypedAssetId,
-        tweenable: impl Tweenable + 'static,
-    ) -> Self {
-        let tween_type_id = tweenable.type_id().expect(
-            "Typeless tweenable like Delay can't be inserted as root tweenable in an animation.",
-        );
-        assert_eq!(
-            type_id, tween_type_id,
-            "The tweenable type doesn't match the Assets<A> type of the target asset."
-        );
-        Self {
-            //target: AnimTarget::Entity(target),
-            target: AnimTarget::Asset { type_id, asset_id },
-            tweenable: Box::new(tweenable),
-            state: PlaybackState::Playing,
-            speed: 1.,
-        }
-    }
+    // pub fn new_asset(
+    //     type_id: TypeId,
+    //     asset_id: UntypedAssetId,
+    //     tweenable: impl Tweenable + 'static,
+    // ) -> Self {
+    //     let tween_type_id = tweenable.type_id().expect(
+    //         "Typeless tweenable like Delay can't be inserted as root tweenable in an animation.",
+    //     );
+    //     assert_eq!(
+    //         type_id, tween_type_id,
+    //         "The tweenable type doesn't match the Assets<A> type of the target asset."
+    //     );
+    //     Self {
+    //         //target: AnimTarget::Entity(target),
+    //         target: AnimTarget::Asset { type_id, asset_id },
+    //         tweenable: Box::new(tweenable),
+    //         state: PlaybackState::Playing,
+    //         speed: 1.,
+    //     }
+    // }
 
     /// Stop animation playback and rewind the animation.
     ///
@@ -656,7 +725,7 @@ pub struct TweenAnimator {
     /// itself. This is necessary because there's no UntypedAssets interface in
     /// Bevy. The TypeId key must be the type of the Assets<A> type itself.
     asset_resolver: HashMap<
-        TypeId,
+        ComponentId,
         Box<
             dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> MutUntyped<'w>
                 + Send
@@ -703,11 +772,11 @@ impl TweenAnimator {
     /// the new animation, to later access it to dynamically modify the playback
     /// (e.g. speed).
     #[inline]
-    pub fn add<T>(&mut self, target: Entity, tweenable: T) -> TweenId
+    pub fn add<T>(&mut self, target: ComponentTarget, tweenable: T) -> TweenId
     where
         T: Tweenable + 'static,
     {
-        self.anims.insert(TweenAnim::new(target, tweenable))
+        self.anims.insert(TweenAnim::new(target.into(), tweenable))
     }
 
     /// Add a new asset animation to the animator queue.
@@ -722,45 +791,46 @@ impl TweenAnimator {
     /// the tweenable was created with _e.g._ [`Tween::new_asset<A>()`] then
     /// [`Tweenable::type_id()`] correctly returns `Assets<A>`. Note that the
     /// type is **NOT** the asset type `A` itself, but rather `Assets<A>`.
-    #[inline]
-    pub fn add_asset<A, T, I>(&mut self, asset_id: I, tweenable: T) -> TweenId
-    where
-        A: Asset,
-        T: Tweenable + 'static,
-        I: Into<AssetId<A>>,
-    {
-        let type_id = TypeId::of::<Assets<A>>();
-        assert_eq!(
-            Some(type_id),
-            tweenable.type_id(),
-            "Tweenable has different target type than Assets<A>."
-        );
-
-        self.asset_resolver.entry(type_id).or_insert_with(|| {
-            Box::new(
-                // Convert ( Mut<Assets<A>>, AssetId<A> ) -> Mut<A>
-                |assets: MutUntyped, asset_id: UntypedAssetId| -> MutUntyped {
-                    // SAFETY: The type ID was checked above with an assert to make sure the one
-                    // stored in the Tweenable (which is where the untyped value comes from) is
-                    // the same as Assets<A>.
-                    #[allow(unsafe_code)]
-                    let assets = unsafe { assets.with_type::<Assets<A>>() };
-
-                    let asset_id = asset_id.typed::<A>();
-                    let asset: Mut<A> = assets.map_unchanged(|a| {
-                        // FIXME - replace with get_mut_untracked() to skip ECS change detection; see https://github.com/bevyengine/bevy/issues/13104
-                        a.get_mut(asset_id).unwrap()
-                    });
-
-                    asset.into()
-                },
-            )
-        });
+    // #[inline]
+    // pub fn add_asset<A, T, I>(&mut self, asset_id: I, tweenable: T) -> TweenId
+    // where
+    //     A: Asset,
+    //     T: Tweenable + 'static,
+    //     I: Into<AssetId<A>>,
+    // {
+    //     let type_id = TypeId::of::<Assets<A>>();
+    //     assert_eq!(
+    //         Some(type_id),
+    //         tweenable.type_id(),
+    //         "Tweenable has different target type than Assets<A>."
+    //     );
 
-        let asset_id: AssetId<A> = asset_id.into();
-        self.anims
-            .insert(TweenAnim::new_asset(type_id, asset_id.untyped(), tweenable))
-    }
+    //     self.asset_resolver.entry(resource_id).or_insert_with(|| {
+    //         Box::new(
+    //             // Convert ( Mut<Assets<A>>, AssetId<A> ) -> Mut<A>
+    //             |assets: MutUntyped, asset_id: UntypedAssetId| -> MutUntyped {
+    //                 // SAFETY: The type ID was checked above with an assert to make sure the one
+    //                 // stored in the Tweenable (which is where the untyped value comes from) is
+    //                 // the same as Assets<A>.
+    //                 #[allow(unsafe_code)]
+    //                 let assets = unsafe { assets.with_type::<Assets<A>>() };
+
+    //                 let asset_id = asset_id.typed::<A>();
+    //                 let asset: Mut<A> = assets.map_unchanged(|a| {
+    //                     // FIXME - replace with get_mut_untracked() to skip ECS change detection; see https://github.com/bevyengine/bevy/issues/13104
+    //                     a.get_mut(asset_id).unwrap()
+    //                 });
+
+    //                 asset.into()
+    //             },
+    //         )
+    //     });
+
+    //     let asset_id: AssetId<A> = asset_id.into();
+    //     let target = WorldAssetTarget { resource_id, asset_id: asset_id.untyped() };
+    //     self.anims
+    //         .insert(TweenAnim::new(target.into(), tweenable))
+    // }
 
     /// Queue a prepared tweenable animation.
     ///
@@ -768,7 +838,7 @@ impl TweenAnimator {
     ///
     /// [`make()`]: Animator::make
     #[inline]
-    pub(crate) fn queue(&mut self, target: Entity, tweenable: impl Tweenable + 'static) {
+    pub(crate) fn queue(&mut self, target: AnimTarget, tweenable: impl Tweenable + 'static) {
         self.anims.insert(TweenAnim::new(target, tweenable));
     }
 
@@ -822,26 +892,18 @@ impl TweenAnimator {
             // simplifying some borrow checker complications with World.
             //let ent_mut = &mut world.get_entity_mut([anim.target]).unwrap()[0];
 
-            // FIXME
-            let mut target_entity = Entity::PLACEHOLDER;
-
             let Some(mut mut_untyped) = (match &anim.target {
-                AnimTarget::Entity { entity, type_id } => {
-                    target_entity = *entity;
-                    if let Some(component_id) = world.components().get_id(*type_id) {
-                        world.get_mut_by_id(*entity, component_id)
-                    } else {
-                        None
-                    }
-                }
-                AnimTarget::Asset { type_id, asset_id } => {
-                    if let Some(resource_id) = world.components().get_resource_id(*type_id) {
-                        if let Some(assets) = world.get_resource_mut_by_id(resource_id) {
-                            if let Some(resolver) = self.asset_resolver.get(type_id) {
-                                Some(resolver(assets, *asset_id))
-                            } else {
-                                None
-                            }
+                AnimTarget::Component(ComponentTarget {
+                    entity,
+                    component_id,
+                }) => world.get_mut_by_id(*entity, *component_id),
+                AnimTarget::Asset(AssetTarget {
+                    resource_id,
+                    asset_id,
+                }) => {
+                    if let Some(assets) = world.get_resource_mut_by_id(*resource_id) {
+                        if let Some(resolver) = self.asset_resolver.get(resource_id) {
+                            Some(resolver(assets, *asset_id))
                         } else {
                             None
                         }
@@ -857,19 +919,27 @@ impl TweenAnimator {
             // backward playback to play in reverse direction.
             let delta_time = delta_time.mul_f32(anim.speed.max(0.));
 
+            let mut notify_completed = |fraction: f32| {
+                events.send(TweenCompleted {
+                    id: tween_id,
+                    target: anim.target,
+                    progress: fraction,
+                });
+            };
+
             // Apply the animation tweenable
             let state = anim.tweenable.step(
                 tween_id,
                 delta_time,
                 mut_untyped.reborrow(),
-                events.reborrow(),
+                &mut notify_completed,
             );
 
             // Raise completed event
             if state == TweenState::Completed {
                 anim_events.send(AnimCompleted {
                     id: tween_id,
-                    entity: target_entity,
+                    target: anim.target,
                 });
             }
 
diff --git a/src/plugin.rs b/src/plugin.rs
index 25a648b..3d2a97e 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -100,8 +100,12 @@ mod tests {
             world.init_resource::<TweenAnimator>();
 
             let entity = world.spawn(T::default()).id();
-            let tween_id = world.resource_scope(|_, mut animator: Mut<'_, TweenAnimator>| {
-                animator.add(entity, tweenable)
+            let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
+                let target = ComponentTarget {
+                    component_id: world.component_id::<Transform>().unwrap(),
+                    entity,
+                };
+                animator.add(target, tweenable)
             });
 
             Self {
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 498229b..b74fb35 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -5,7 +5,9 @@ use bevy::{
     prelude::*,
 };
 
-use crate::{EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy, TweenId};
+use crate::{
+    AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy, TweenId,
+};
 
 /// The dynamic tweenable type.
 ///
@@ -99,7 +101,7 @@ pub struct TweenCompleted {
     pub id: TweenId,
     /// The [`Entity`] the tween which completed and the [`TweenAnim`] it's part
     /// of are attached to.
-    pub entity: Entity,
+    pub target: AnimTarget,
     /// Current progress of the owner [`TweenAnim`].
     pub progress: f32,
 }
@@ -476,7 +478,7 @@ pub trait Tweenable: Send + Sync {
         tween_id: TweenId,
         delta: Duration,
         target: MutUntyped,
-        events: Mut<Events<TweenCompleted>>,
+        notify_completed: &mut dyn FnMut(f32),
     ) -> TweenState;
 
     /// Rewind the animation to its starting state.
@@ -913,10 +915,10 @@ impl Tweenable for Tween {
 
     fn step(
         &mut self,
-        tween_id: TweenId,
+        _tween_id: TweenId,
         delta: Duration,
         target: MutUntyped,
-        mut events: Mut<Events<TweenCompleted>>,
+        notify_completed: &mut dyn FnMut(f32),
     ) -> TweenState {
         if self.clock.state(self.playback_direction) == TweenState::Completed {
             return TweenState::Completed;
@@ -929,8 +931,6 @@ impl Tweenable for Tween {
             self.clock.tick_back(delta)
         };
 
-        let target_entity = Entity::PLACEHOLDER; // TODO: ent_mut.id();
-
         // Apply the lens, even if the animation completed, to ensure the state is
         // consistent.
         let fraction = self.clock.mirrored_cycle_fraction();
@@ -947,14 +947,7 @@ impl Tweenable for Tween {
         // If completed at least once this frame, notify the user
         if times_completed != 0 {
             if self.send_completed_event {
-                let event = TweenCompleted {
-                    id: tween_id,
-                    entity: target_entity,
-                    progress: fraction,
-                };
-
-                // Send completion event
-                events.send(event);
+                notify_completed(fraction);
             }
 
             // Trigger all entity-scoped observers
@@ -1115,7 +1108,7 @@ impl Tweenable for Sequence {
         tween_id: TweenId,
         mut delta: Duration,
         mut target: MutUntyped,
-        mut events: Mut<Events<TweenCompleted>>,
+        notify_completed: &mut dyn FnMut(f32),
     ) -> TweenState {
         // Calculate the new elapsed time at the end of this tick
         self.elapsed = self.elapsed.saturating_add(delta);
@@ -1130,7 +1123,7 @@ impl Tweenable for Sequence {
 
             let prev_elapsed = tween.elapsed();
 
-            if tween.step(tween_id, delta, target.reborrow(), events.reborrow())
+            if tween.step(tween_id, delta, target.reborrow(), notify_completed)
                 == TweenState::Active
             {
                 return TweenState::Active;
@@ -1174,84 +1167,6 @@ impl Tweenable for Sequence {
     }
 }
 
-// /// A collection of [`Tweenable`] executing in parallel.
-// pub struct Tracks {
-//     tracks: Vec<BoxedTweenable>,
-//     duration: Duration,
-//     elapsed: Duration,
-// }
-
-// impl Tracks {
-//     /// Create a new [`Tracks`] from an iterator over a collection of
-//     /// [`Tweenable`].
-//     #[must_use]
-//     pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable>>) ->
-// Self {         let tracks: Vec<_> =
-// items.into_iter().map(Into::into).collect();         let duration = tracks
-//             .iter()
-//             .map(AsRef::as_ref)
-//             .map(Tweenable::total_duration)
-//             .max()
-//             .unwrap();
-//         Self {
-//             tracks,
-//             duration,
-//             elapsed: Duration::ZERO,
-//         }
-//     }
-// }
-
-// impl Tweenable for Tracks {
-//     fn cycle_duration(&self) -> Duration {
-//         self.duration
-//     }
-
-//     fn total_duration(&self) -> TotalDuration {
-//         TotalDuration::Finite(self.duration)
-//     }
-
-//     fn set_elapsed(&mut self, elapsed: Duration) {
-//         self.elapsed = elapsed;
-
-//         for tweenable in &mut self.tracks {
-//             tweenable.set_elapsed(elapsed);
-//         }
-//     }
-
-//     fn elapsed(&self) -> Duration {
-//         self.elapsed
-//     }
-
-//     fn step(
-//         &mut self,
-//         tween_id: TweenId,
-//         delta: Duration,
-//         mut ent_mut: EntityMut,
-//         mut events: Mut<Events<TweenCompleted>>,
-//     ) -> (f32, TweenState) {
-//         self.elapsed = self.elapsed.saturating_add(delta).min(self.duration);
-//         let mut any_active = false;
-//         for tweenable in &mut self.tracks {
-//             let (_, state) = tweenable.step(tween_id, delta,
-// ent_mut.reborrow(), events.reborrow());             any_active = any_active
-// || (state == TweenState::Active);         }
-//         if any_active {
-//             // FIXME(nightly): Duration::div_duration_f64()
-//             let ratio = self.elapsed.as_secs_f32() /
-// self.duration.as_secs_f32();             (ratio, TweenState::Active) // TODO
-//         } else {
-//             (1., TweenState::Completed)
-//         }
-//     }
-
-//     fn rewind(&mut self) {
-//         self.elapsed = Duration::ZERO;
-//         for tween in &mut self.tracks {
-//             tween.rewind();
-//         }
-//     }
-// }
-
 /// A time delay that doesn't animate anything.
 ///
 /// This is generally useful for combining with other tweenables into sequences
@@ -1367,7 +1282,7 @@ impl Tweenable for Delay {
         _tween_id: TweenId,
         delta: Duration,
         _target: MutUntyped,
-        _events: Mut<Events<TweenCompleted>>,
+        _notify_completed: &mut dyn FnMut(f32),
     ) -> TweenState {
         self.timer.tick(delta);
 
@@ -1418,7 +1333,7 @@ mod tests {
     use slotmap::Key as _;
 
     use super::*;
-    use crate::{lens::*, test_utils::assert_approx_eq};
+    use crate::{lens::*, test_utils::assert_approx_eq, ComponentTarget};
 
     // #[derive(Default, Copy, Clone)]
     // struct CallbackMonitor {
@@ -1566,16 +1481,29 @@ mod tests {
         entity: Entity,
     ) -> TweenState {
         // Tick the given tween and apply its state to the given entity target
-        let state =
-            world.resource_scope(|world: &mut World, events: Mut<Events<TweenCompleted>>| {
-                let comp_id = world.component_id::<Transform>().unwrap();
+        let state = world.resource_scope(
+            |world: &mut World, mut events: Mut<Events<TweenCompleted>>| {
+                let component_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
-                if let Ok(mut target) = entity_mut.get_mut_by_id(comp_id) {
-                    tween.step(tween_id, duration, target.reborrow(), events)
+                if let Ok(mut target) = entity_mut.get_mut_by_id(component_id) {
+                    let world_target = ComponentTarget {
+                        entity,
+                        component_id,
+                    }
+                    .into();
+                    let mut notify_completed = |fraction: f32| {
+                        events.send(TweenCompleted {
+                            id: tween_id,
+                            target: world_target,
+                            progress: fraction,
+                        });
+                    };
+                    tween.step(tween_id, duration, target.reborrow(), &mut notify_completed)
                 } else {
                     TweenState::Completed
                 }
-            });
+            },
+        );
 
         // Propagate events
         {
@@ -1926,12 +1854,18 @@ mod tests {
 
                     // Events are only sent when playing forward
                     if playback_direction.is_forward() {
+                        let component_id = world.component_id::<Transform>().unwrap();
                         let mut event_reader = event_reader_system_state.get_mut(&mut world);
                         let event = event_reader.read().next();
                         if just_completed {
                             assert!(event.is_some());
                             if let Some(event) = event {
-                                assert_eq!(event.entity, entity);
+                                let comp_target = event
+                                    .target
+                                    .as_component()
+                                    .expect("Expected a component target, got an asset one.");
+                                assert_eq!(comp_target.entity, entity);
+                                assert_eq!(comp_target.component_id, component_id);
                             }
                         } else {
                             assert!(event.is_none());

From 355c96e798c8157970f500c8be4d153c6b64be69 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 5 Jul 2025 21:03:33 +0100
Subject: [PATCH 21/66] Fix all tests

---
 src/lib.rs       | 265 +++++++++++++++++++++++++++++++++++------------
 src/plugin.rs    |  16 +--
 src/tweenable.rs |  28 ++---
 3 files changed, 218 insertions(+), 91 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index f52a744..6e4b550 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,10 +13,10 @@
 //! Tweening animation plugin for the Bevy game engine
 //!
 //! 🍃 Bevy Tweening provides interpolation-based animation between ("tweening")
-//! two values, for Bevy components and assets. Each field of a component or
-//! asset can be animated via a collection or predefined easing functions,
-//! or providing a custom animation curve. Custom components and assets are also
-//! supported.
+//! two values, for any component and asset, including both built-in Bevy ones
+//! and custom user-defined ones. Each field of a component or asset can be
+//! animated via a collection of predefined easing functions, or providing a
+//! custom animation curve.
 //!
 //! # Example
 //!
@@ -39,7 +39,6 @@
 //! # use bevy_tweening::{lens::*, *};
 //! # use std::time::Duration;
 //! # fn system(mut commands: Commands) {
-//! # let size = 16.;
 //! // Create a single animation (tween) to move an entity.
 //! let tween = Tween::new(
 //!     // Use a quadratic easing on both endpoints.
@@ -55,65 +54,43 @@
 //!     },
 //! );
 //!
-//! commands.spawn((
+//! commands
 //!     // Spawn an entity to animate the position of.
-//!     Transform::default(),
-//!     // Add an Animator component to control and execute the animation.
-//!     Animator::new(tween),
-//! ));
+//!     .spawn((Transform::default(),))
+//!     // Queue the tweenable animation
+//!     .tween(tween);
 //! # }
 //! ```
 //!
-//! Note that this example leverages the fact [`TweeningPlugin`] automatically
-//! adds the necessary system to animate [`Transform`] components. However, for
-//! most other components and assets, you need to manually add those systems to
-//! your `App`.
-//!
-//! # System setup
-//!
-//! Adding the [`TweeningPlugin`] to your app provides the basic setup for using
-//! 🍃 Bevy Tweening. However, additional setup is required depending on the
-//! components and assets you want to animate:
-//!
-//! - To ensure a component `C` is animated, the
-//!   [`component_animator_system::<C>`] system must run each frame, in addition
-//!   of adding an [`Animator::<C>`] component to the same Entity as `C`.
-//!
-//! - To ensure an asset `A` is animated, the [`asset_animator_system::<A>`]
-//!   system must run each frame, in addition of adding an [`AssetAnimator<A>`]
-//!   component to any Entity. Animating assets also requires the `bevy_asset`
-//!   feature (enabled by default).
-//!
-//! By default, 🍃 Bevy Tweening adopts a minimalist approach, and the
-//! [`TweeningPlugin`] will only add systems to animate components and assets
-//! for which a [`Lens`] is provided by 🍃 Bevy Tweening itself. This means that
-//! any other Bevy component or asset (either built-in from Bevy itself, or
-//! custom) requires manually scheduling the appropriate system.
-//!
-//! | Component or Asset | Animation system added by `TweeningPlugin`? |
-//! |---|---|
-//! | [`Transform`]          | Yes                           |
-//! | [`Sprite`]             | Only if `bevy_sprite` feature |
-//! | [`ColorMaterial`]      | Only if `bevy_sprite` feature |
-//! | [`Node`]               | Only if `bevy_ui` feature     |
-//! | [`Text`]               | Only if `bevy_text` feature   |
-//! | All other components   | No                            |
-//!
-//! To add a system for a component `C`, use:
+//! This example shows the general pattern to add animations for any component
+//! or asset. Since moving the position of an object is a very common
+//! task, 🍃 Bevy Tweening provides a shortcut for it. The above example can be
+//! rewritten more concicely as:
 //!
 //! ```
 //! # use bevy::prelude::*;
-//! # use bevy_tweening::*;
-//! # let mut app = App::default();
-//! # #[derive(Component)] struct C;
-//! app.add_systems(
-//!     Update,
-//!     component_animator_system::<C>.in_set(AnimationSystem::AnimationUpdate),
-//! );
+//! # use bevy_tweening::{lens::*, *};
+//! # use std::time::Duration;
+//! # fn system(mut commands: Commands) {
+//! commands
+//!     // Spawn an entity to animate the position of.
+//!     .spawn((Transform::default(),))
+//!     // Create-and-queue a new Transform::translation animation
+//!     .move_to(
+//!         Vec3::new(1., 2., -4.),
+//!         Duration::from_secs(1),
+//!         EaseFunction::QuadraticInOut,
+//!     );
+//! # }
 //! ```
 //!
-//! Similarly for an asset `A`, use the `asset_animator_system`. This is only
-//! available with the `bevy_asset` feature.
+//! # No system setup
+//!
+//! Unlike previous versions of 🍃 Bevy Tweening, you don't need any particular
+//! setup aside from adding the [`TweeningPlugin`] to your [`App`].
+//! In particular, per-component-type systems are gone. Instead, the
+//! [`TweenAnimator`] updates all tweenable animations for all components and
+//! assets at once, even for custom component and asset types.
 //!
 //! # Tweenables
 //!
@@ -124,7 +101,6 @@
 //! - [`Tween`] - A simple tween (easing) animation between two values.
 //! - [`Sequence`] - A series of tweenables executing in series, one after the
 //!   other.
-//! - [`Tracks`] - A collection of tweenables executing in parallel.
 //! - [`Delay`] - A time delay. This doesn't animate anything.
 //!
 //! ## Chaining animations
@@ -431,6 +407,53 @@ new_key_type! {
 }
 
 /// Extensions for [`EntityCommands`] to queue tween-based animations.
+///
+/// This trait provide extension functions to [`EntityCommands`], allowing
+/// convenient syntaxes like inserting a new component and immediately attaching
+/// a tweenable animation to it in a single call.
+///
+/// ```
+/// # use bevy::{prelude::*, ecs::world::CommandQueue};
+/// # use bevy_tweening::{*, lens::TransformPositionLens};
+/// # use std::time::Duration;
+/// # let mut queue = CommandQueue::default();
+/// # let mut world = World::default();
+/// # let mut commands = Commands::new(&mut queue, &mut world);
+/// let tween = Tween::new(
+///     EaseFunction::QuadraticIn,
+///     Duration::from_secs(1),
+///     TransformPositionLens {
+///         start: Vec3::ZERO,
+///         end: Vec3::new(3.5, 0., 0.),
+///     },
+/// );
+/// commands.spawn(Transform::default()).tween(tween);
+/// ```
+///
+/// or even more concisely:
+///
+/// ```
+/// # use bevy::{prelude::*, ecs::world::CommandQueue};
+/// # use bevy_tweening::*;
+/// # use std::time::Duration;
+/// # let mut queue = CommandQueue::default();
+/// # let mut world = World::default();
+/// # let mut commands = Commands::new(&mut queue, &mut world);
+/// commands.spawn(Transform::default()).move_to(
+///     Vec3::new(3.5, 0., 0.),
+///     Duration::from_secs(1),
+///     EaseFunction::QuadraticIn,
+/// );
+/// ```
+///
+/// This convenience comes at the price of reduced control and error checking.
+/// Additional information like the [`TweenId`] of a newly created [`TweenAnim`]
+/// cannot be retrieved. And any error (_e.g._ trying to insert an animation
+/// with a tweenable of a component type while the entity doesn't have that
+/// component) cannot be forwarded back to the caller, so will produce a panic
+/// instead. This is best used for cases where you know those conditions at
+/// build time. To avoid a panic, prefer manually queuing a new tweenable
+/// animation through the [`TweenAnimator`].
 pub trait EntityCommandsTweeningExtensions<'a> {
     /// Queue the given [`Tweenable`].
     ///
@@ -446,8 +469,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     ///
     /// The entity must have a [`Transform`] component. The tween animation will
     /// be initialized with the current [`Transform::translation`] as its
-    /// starting point, and the given endpoint and duration. The ease mode is
-    /// linear.
+    /// starting point, and the given endpoint, duration, and ease method.
     ///
     /// Note that the starting point position is saved when the command is
     /// applied, generally after the current system when [`apply_deferred()`]
@@ -458,7 +480,28 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// access to the [`TweenId`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
     /// [`TweenAnimator::add()`].
-    fn move_to(&mut self, end: Vec3, duration: Duration) -> &mut Self;
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands.spawn(Transform::default()).move_to(
+    ///     Vec3::new(3.5, 0., 0.),
+    ///     Duration::from_secs(1),
+    ///     EaseFunction::QuadraticIn,
+    /// );
+    /// ```
+    fn move_to(
+        &mut self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self;
 }
 
 /// Build an [`EntityCommand`] which queues the new tweenable into the
@@ -487,7 +530,11 @@ where
     }
 }
 
-fn make_transform_from_command(end: Vec3, duration: Duration) -> impl EntityCommand {
+fn make_transform_from_command(
+    end: Vec3,
+    duration: Duration,
+    ease_method: EaseMethod,
+) -> impl EntityCommand {
     move |mut entity: EntityWorldMut| {
         let component_id = entity
             .world()
@@ -495,7 +542,7 @@ fn make_transform_from_command(end: Vec3, duration: Duration) -> impl EntityComm
             .expect("Transform component not registered in the World");
         let start = entity.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
-        let tween = Tween::new(EaseFunction::Linear, duration, lens);
+        let tween = Tween::new(ease_method, duration, lens);
         let e = entity.id();
         let target = ComponentTarget {
             entity: e,
@@ -515,21 +562,84 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
         self.queue(make_tween_command(tweenable))
     }
 
-    fn move_to(&mut self, end: Vec3, duration: Duration) -> &mut EntityCommands<'a> {
-        self.queue(make_transform_from_command(end, duration))
+    fn move_to(
+        &mut self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut EntityCommands<'a> {
+        self.queue(make_transform_from_command(
+            end,
+            duration,
+            ease_method.into(),
+        ))
+    }
+}
+
+impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
+    fn tween<T>(&mut self, tweenable: T) -> &mut Self
+    where
+        T: Tweenable + 'static,
+    {
+        let type_id = tweenable.type_id().unwrap();
+        let component_id = self.world().components().get_id(type_id).unwrap();
+        let target = ComponentTarget {
+            component_id,
+            entity: self.id(),
+        };
+        self.world_scope(|world: &mut World| {
+            world.resource_mut::<TweenAnimator>().add(target, tweenable);
+        });
+        self
+    }
+
+    fn move_to(
+        &mut self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self {
+        let component_id = self.world().component_id::<Transform>().unwrap();
+        let start = self.get::<Transform>().unwrap().translation;
+        let lens = lens::TransformPositionLens { start, end };
+        let tween = Tween::new(ease_method, duration, lens);
+        let e = self.id();
+        let target = ComponentTarget {
+            entity: e,
+            component_id,
+        };
+        self.world_scope(|world: &mut World| {
+            world.resource_mut::<TweenAnimator>().add(target, tween);
+        });
+        self
     }
 }
 
 /// Event raised when a [`TweenAnim`] completed.
 #[derive(Copy, Clone, Event)]
-pub struct AnimCompleted {
-    /// The ID of the tween animation which completed.
+pub struct AnimCompletedEvent {
+    /// The ID of the tween animation which completed. Note that commonly the
+    /// [`TweenAnim`] is pruned out of the [`TweenAnimator`] on completion, so
+    /// can't be queried anymore with this ID. However animation IDs are unique,
+    /// so this can be used to identify the tweenable animation from an ID
+    /// stored by the user.
     pub id: TweenId,
-    /// The animation target.
+    /// The animation target. This is provided both as a convenience for
+    /// [`TweenAnim`]s not pruned from the [`TweenAnimator`] on completion, and
+    /// because for those animations which are pruned the information is not
+    /// available in anymore in another way.
     pub target: AnimTarget,
 }
 
 /// Component animation target.
+///
+/// References a component used as the target of a tweenable animation. The
+/// component is identified by the ID of the component type as registered in the
+/// [`World`] where the animation is queued, and the [`Entity`] holding the
+/// component instance of that type.
+///
+/// This is a lightweight reference (copyable) implicitly tied to a given
+/// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ComponentTarget {
     /// Component ID of the registered component being animated.
@@ -539,6 +649,14 @@ pub struct ComponentTarget {
 }
 
 /// Asset animation target.
+///
+/// References an asset used as the target of a tweenable animation. The asset
+/// is identified by the ID of the [`Assets<A>`] resource type registered in the
+/// [`World`] where the animation is queued, and the unique asset ID identifying
+/// the asset instance inside that [`Assets<A>`] resource.
+///
+/// This is a lightweight reference (copyable) implicitly tied to a given
+/// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct AssetTarget {
     /// Resource ID of the registered [`Assets<A>`] asset container.
@@ -548,6 +666,12 @@ pub struct AssetTarget {
 }
 
 /// Animation target.
+///
+/// References either a component or an asset used as the target of a tweenable
+/// animation. See [`ComponentTarget`] and [`AssetTarget`] for details.
+///
+/// This is a lightweight reference (copyable) implicitly tied to a given
+/// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum AnimTarget {
     /// Component animation target.
@@ -756,7 +880,10 @@ impl TweenAnimator {
     /// # use bevy_tweening::{lens::*, *};
     /// # use std::time::Duration;
     /// # let mut world = World::default();
-    /// # let entity = Entity::PLACEHOLDER;
+    /// # world.register_component::<Transform>();
+    /// # world.register_resource::<TweenAnimator>();
+    /// # world.init_resource::<TweenAnimator>();
+    /// # let entity = world.spawn_empty().id();
     /// let tween = Tween::new(
     ///     EaseFunction::QuadraticInOut,
     ///     Duration::from_secs(1),
@@ -879,7 +1006,7 @@ impl TweenAnimator {
         world: &mut World,
         delta_time: Duration,
         mut events: Mut<Events<TweenCompleted>>,
-        mut anim_events: Mut<Events<AnimCompleted>>,
+        mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) {
         // Loop over active animations, tick them, and retain those which are still
         // active after that
@@ -937,7 +1064,7 @@ impl TweenAnimator {
 
             // Raise completed event
             if state == TweenState::Completed {
-                anim_events.send(AnimCompleted {
+                anim_events.send(AnimCompletedEvent {
                     id: tween_id,
                     target: anim.target,
                 });
diff --git a/src/plugin.rs b/src/plugin.rs
index 3d2a97e..88f5fa0 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{AnimCompleted, TweenAnimator, TweenCompleted};
+use crate::{AnimCompletedEvent, TweenAnimator, TweenCompleted};
 
 /// Plugin to add systems related to tweening of common components and assets.
 ///
@@ -37,7 +37,7 @@ impl Plugin for TweeningPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<TweenAnimator>()
             .add_event::<TweenCompleted>()
-            .add_event::<AnimCompleted>()
+            .add_event::<AnimCompletedEvent>()
             .add_systems(
                 Update,
                 animator_system.in_set(AnimationSystem::AnimationUpdate),
@@ -57,7 +57,7 @@ pub fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
     // TODO: Use SystemState to cache all of that...
     world.resource_scope(|world, events: Mut<Events<TweenCompleted>>| {
-        world.resource_scope(|world, anim_events: Mut<Events<AnimCompleted>>| {
+        world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
             world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
                 animator.play(world, delta_time, events, anim_events);
             });
@@ -90,19 +90,19 @@ mod tests {
     }
 
     impl<T: Component + Default> TestEnv<T> {
-        /// Create a new test environment containing a single entity with a
-        /// [`Transform`], and add the given animator on that same entity.
+        /// Create a new test environment containing a single entity with a `T`
+        /// component, and add the given animator on that same entity.
         pub fn new(tweenable: impl Tweenable + 'static) -> Self {
             let mut world = World::new();
             world.init_resource::<Time>();
             world.init_resource::<Events<TweenCompleted>>();
-            world.init_resource::<Events<AnimCompleted>>();
+            world.init_resource::<Events<AnimCompletedEvent>>();
             world.init_resource::<TweenAnimator>();
 
             let entity = world.spawn(T::default()).id();
             let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
                 let target = ComponentTarget {
-                    component_id: world.component_id::<Transform>().unwrap(),
+                    component_id: world.component_id::<T>().unwrap(),
                     entity,
                 };
                 animator.add(target, tweenable)
@@ -142,7 +142,7 @@ mod tests {
             // Update events after system ticked, in case system emitted some events
             let mut events = self.world.resource_mut::<Events<TweenCompleted>>();
             events.update();
-            let mut events = self.world.resource_mut::<Events<AnimCompleted>>();
+            let mut events = self.world.resource_mut::<Events<AnimCompletedEvent>>();
             events.update();
         }
 
diff --git a/src/tweenable.rs b/src/tweenable.rs
index b74fb35..cdffb47 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -28,10 +28,10 @@ use crate::{
 /// implement [`From`]:
 ///
 /// ```no_run
-/// # use std::time::Duration;
-/// # use bevy::ecs::system::Commands;
+/// # use std::{any::TypeId, time::Duration};
+/// # use bevy::ecs::{system::Commands, change_detection::MutUntyped};
 /// # use bevy::prelude::*;
-/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompleted, TweenState, Targetable, TotalDuration};
+/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompleted, TweenState, TotalDuration};
 /// #
 /// # struct MyTweenable;
 /// # impl Tweenable for MyTweenable {
@@ -39,11 +39,11 @@ use crate::{
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
-/// #     fn tick(&mut self, tween_id: TweenId, delta: Duration, ent_mut: EntityMut, events: Mut<Events<TweenCompleted>>) -> (f32, TweenState)  { unimplemented!() }
+/// #     fn step(&mut self, _tween_id: TweenId, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(f32),) -> TweenState  { unimplemented!() }
 /// #     fn rewind(&mut self) { unimplemented!() }
-/// #     fn set_progress(&mut self, progress: f32) { unimplemented!() }
-/// #     fn progress(&self) -> f32 { unimplemented!() }
-/// #     fn times_completed(&self) -> u32 { unimplemented!() }
+/// #     fn cycles_completed(&self) -> u32 { unimplemented!() }
+/// #     fn cycle_fraction(&self) -> f32 { unimplemented!() }
+/// #     fn type_id(&self) -> Option<TypeId> { unimplemented!() }
 /// # }
 ///
 /// Sequence::new([Box::new(MyTweenable) as BoxedTweenable]);
@@ -570,7 +570,7 @@ enum TweenAction {
 
 /// Single tweening animation instance.
 pub struct Tween {
-    ease_function: EaseMethod,
+    ease_method: EaseMethod,
     clock: AnimClock,
     /// Direction of playback the user asked for.
     playback_direction: PlaybackDirection,
@@ -630,7 +630,7 @@ impl Tween {
     /// );
     /// ```
     #[must_use]
-    pub fn new<C, L>(ease_function: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
+    pub fn new<C, L>(ease_method: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
     where
         C: Component<Mutability = Mutable>,
         L: Lens<C> + Send + Sync + 'static,
@@ -643,7 +643,7 @@ impl Tween {
             lens.lerp(comp, ratio);
         };
         Self {
-            ease_function: ease_function.into(),
+            ease_method: ease_method.into(),
             clock: AnimClock::new(duration),
             playback_direction: PlaybackDirection::Forward,
             action: TweenAction::Component(Box::new(action)),
@@ -671,7 +671,7 @@ impl Tween {
             lens.lerp(asset, ratio);
         };
         Self {
-            ease_function: ease_function.into(),
+            ease_method: ease_function.into(),
             clock: AnimClock::new(duration),
             playback_direction: PlaybackDirection::Forward,
             action: TweenAction::Asset(Box::new(action)),
@@ -711,7 +711,7 @@ impl Tween {
     ///     for ev in reader.read() {
     ///         println!(
     ///             "Tween animation {:?} raised TweenCompleted for target entity {:?}!",
-    ///             ev.id, ev.entity
+    ///             ev.id, ev.target.as_component().unwrap().entity
     ///         );
     ///     }
     /// }
@@ -885,7 +885,7 @@ impl TweenAssetExtensions for Tween {
             lens.lerp(asset, ratio);
         };
         Self {
-            ease_function: ease_function.into(),
+            ease_method: ease_function.into(),
             clock: AnimClock::new(duration),
             playback_direction: PlaybackDirection::Forward,
             action: TweenAction::Asset(Box::new(action)),
@@ -934,7 +934,7 @@ impl Tweenable for Tween {
         // Apply the lens, even if the animation completed, to ensure the state is
         // consistent.
         let fraction = self.clock.mirrored_cycle_fraction();
-        let fraction = self.ease_function.sample(fraction);
+        let fraction = self.ease_method.sample(fraction);
         match &mut self.action {
             TweenAction::Component(action) => {
                 action(target, fraction);

From 5a6d3b652b9aa1930dfb565d26007376fdfc112c Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 6 Jul 2025 10:13:27 +0100
Subject: [PATCH 22/66] Fix all docs

---
 examples/menu.rs     |   2 +-
 examples/sequence.rs |   4 +-
 src/lens.rs          |   3 +-
 src/lib.rs           | 167 +++++++++++++++++++------------------------
 src/plugin.rs        |  52 +++++---------
 src/tweenable.rs     |  49 +++++++------
 6 files changed, 121 insertions(+), 156 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index ba922b9..0da93a6 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -135,7 +135,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 fn enable_interaction_after_initial_animation(
     mut commands: Commands,
-    mut reader: EventReader<TweenCompleted>,
+    mut reader: EventReader<TweenCompletedEvent>,
 ) {
     for event in reader.read() {
         if let AnimTarget::Component(comp_target) = &event.target {
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 79ab1e5..17ffd7a 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -263,7 +263,7 @@ fn update_text(
     mut q_textspans: Query<&mut TextSpan, With<ProgressValue>>,
     q_anim_red: Query<&RedSprite>,
     q_anim_blue: Query<&BlueSprite>,
-    mut q_event_completed: EventReader<TweenCompleted>,
+    mut q_event_completed: EventReader<TweenCompletedEvent>,
 ) {
     let anim_red = q_anim_red.single().unwrap();
     let progress_red = if let Some(anim) = animator.get(anim_red.path_tween_id) {
@@ -287,7 +287,7 @@ fn update_text(
 
     for ev in q_event_completed.read() {
         println!(
-            "Event: TweenCompleted tween_id={:?} entity={:?}",
+            "Event: TweenCompletedEvent tween_id={:?} entity={:?}",
             ev.id, ev.entity
         );
     }
diff --git a/src/lens.rs b/src/lens.rs
index d274336..0e04b4b 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -108,8 +108,7 @@ pub struct TransformPositionLens {
 
 impl Lens<Transform> for TransformPositionLens {
     fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
-        let value = self.start + (self.end - self.start) * ratio;
-        target.translation = value;
+        target.translation = self.start.lerp(self.end, ratio);
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 6e4b550..30f79b5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,11 +16,13 @@
 //! two values, for any component and asset, including both built-in Bevy ones
 //! and custom user-defined ones. Each field of a component or asset can be
 //! animated via a collection of predefined easing functions, or providing a
-//! custom animation curve.
+//! custom animation curve. The library supports any number of animations queued
+//! in parallel, even on the same component or asset type, and allows runtime
+//! control over playback and animation speed.
 //!
 //! # Example
 //!
-//! Add the tweening plugin to your app:
+//! Add the [`TweeningPlugin`] to your app:
 //!
 //! ```no_run
 //! use bevy::prelude::*;
@@ -46,7 +48,7 @@
 //!     // Animation time.
 //!     Duration::from_secs(1),
 //!     // The lens gives access to the Transform component of the Entity,
-//!     // for the Animator to animate it. It also contains the start and
+//!     // for the TweenAnimator to animate it. It also contains the start and
 //!     // end values respectively associated with the progress ratios 0. and 1.
 //!     TransformPositionLens {
 //!         start: Vec3::ZERO,
@@ -84,7 +86,7 @@
 //! # }
 //! ```
 //!
-//! # No system setup
+//! # Ready to animate
 //!
 //! Unlike previous versions of 🍃 Bevy Tweening, you don't need any particular
 //! setup aside from adding the [`TweeningPlugin`] to your [`App`].
@@ -103,6 +105,9 @@
 //!   other.
 //! - [`Delay`] - A time delay. This doesn't animate anything.
 //!
+//! To execute multiple animations in parallel, simply enqueue each animation
+//! independently. This require careful selection of timings.
+//!
 //! ## Chaining animations
 //!
 //! Most tweenables can be chained with the `then()` operator to produce a
@@ -134,43 +139,60 @@
 //! let seq = tween1.then(tween2);
 //! ```
 //!
-//! # Animators and lenses
-//!
-//! Bevy components and assets are animated with tweening _animator_ components,
-//! which take a tweenable and apply it to another component on the same
-//! [`Entity`]. Those animators determine that other component and its fields to
-//! animate using a _lens_.
-//!
-//! ## Components animation
+//! Note that some tweenable animations can be of infinite duration; this is the
+//! case for example when using [`RepeatCount::Infinite`]. If you add such an
+//! infinite animation in a sequence, and append more tweenable after it, those
+//! tweenable will never play because playback will be stuck forever repeating
+//! the first animation. You're responsible for creating sequences that make
+//! sense. In general, only use infinite tweenable animations alone or as the
+//! last element of a sequence.
 //!
-//! Components are animated with the [`Animator`] component, which is generic
-//! over the type of component it animates. This is a restriction imposed by
-//! Bevy, to access the animated component as a mutable reference via a
-//! [`Query`] and comply with the ECS rules.
+//! # `TweenAnimator` and lenses
 //!
-//! The [`Animator`] itself is not generic over the subset of fields of the
-//! components it animates. This limits the proliferation of generic types when
-//! animating e.g. both the position and rotation of an entity.
+//! Bevy components and assets are animated with the [`TweenAnimator`] resource.
+//! The animator determine the component or asset to animate via an
+//! [`AnimTarget`], and accesses its field(s) using a [`Lens`].
 //!
-//! ## Assets animation
-//!
-//! Assets are animated in a similar way to component, via the [`AssetAnimator`]
-//! component. This requires the `bevy_asset` feature (enabled by default).
+//! - Components are animated via the [`ComponentTarget`], which identifies a
+//!   component instance on an entity via the [`Entity`] itself and the
+//!   [`ComponentId`] of the registered component type.
+//! - Assets are animated in a similar way to component, via the [`AssetTarget`]
+//!   which identifies an asset via the type of its [`Assets`] collection and
+//!   the [`AssetId`] referencing that asset inside the collection.
 //!
 //! Because assets are typically shared, and the animation applies to the asset
 //! itself, all users of the asset see the animation. For example, animating the
 //! color of a [`ColorMaterial`] will change the color of all the
-//! 2D meshes using that material.
+//! 2D meshes using that material. If you want to animate the color of a single
+//! mesh, you have to duplicate the asset and assign a unique copy to that mesh,
+//! then animate that copy alone.
 //!
 //! ## Lenses
 //!
-//! Both [`Animator`] and [`AssetAnimator`] access the field(s) to animate via a
-//! lens, a type that implements the [`Lens`] trait.
+//! The [`AnimTarget`] references the container (component or asset) being
+//! animated. However only a part of that component or asset is generally
+//! animated. To that end, the [`TweenAnimator`] accesses the field(s) to
+//! animate via a _lens_, a type that implements the [`Lens`] trait and allows
+//! mapping a container to the actual value(s) animated.
+//!
+//! For example, the [`TransformPositionLens`] uses a [`Transform`] component as
+//! input, and animates its [`Transform::translation`] field only, leaving the
+//! rotation and scale unchanged.
 //!
-//! Several predefined lenses are provided in the [`lens`] module for the most
-//! commonly animated fields, like the components of a [`Transform`]. A custom
-//! lens can also be created by implementing the trait, allowing to animate
-//! virtually any field of any Bevy component or asset.
+//! ```no_run
+//! impl Lens<Transform> for TransformPositionLens {
+//!     fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
+//!         target.translation = self.start.lerp(self.end, ratio);
+//!     }
+//! }
+//! ```
+//!
+//! Several built-in lenses are provided in the [`lens`] module for the most
+//! commonly animated fields, like the components of a [`Transform`]. Those are
+//! provided for convenience and mainly as examples. In general 🍃 Bevy Tweening
+//! expects you to write your own lenses by implementing the trait, which as you
+//! can see above is very simple. This allows animating virtually any field of
+//! any component or asset, whether shipped with Bevy or defined by the user.
 //!
 //! [`Transform::translation`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html#structfield.translation
 //! [`Entity`]: https://docs.rs/bevy/0.16.0/bevy/ecs/entity/struct.Entity.html
@@ -180,6 +202,7 @@
 //! [`Node`]: https://docs.rs/bevy/0.16.0/bevy/ui/struct.Node.html#structfield.position
 //! [`TextColor`]: https://docs.rs/bevy/0.16.0/bevy/text/struct.TextColor.html
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
+//! [`TransformPositionLens`]: crate::lens::TransformPositionLens
 
 use std::time::Duration;
 
@@ -193,8 +216,8 @@ pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
 use slotmap::{new_key_type, SlotMap};
 pub use tweenable::{
-    BoxedTweenable, Delay, Sequence, TotalDuration, Tween, TweenAssetExtensions, TweenCompleted,
-    TweenState, Tweenable,
+    BoxedTweenable, Delay, Sequence, TotalDuration, Tween, TweenAssetExtensions,
+    TweenCompletedEvent, TweenState, Tweenable,
 };
 
 pub mod lens;
@@ -496,6 +519,8 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     ///     EaseFunction::QuadraticIn,
     /// );
     /// ```
+    ///
+    /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
     fn move_to(
         &mut self,
         end: Vec3,
@@ -651,15 +676,15 @@ pub struct ComponentTarget {
 /// Asset animation target.
 ///
 /// References an asset used as the target of a tweenable animation. The asset
-/// is identified by the ID of the [`Assets<A>`] resource type registered in the
+/// is identified by the ID of the [`Assets`] resource type registered in the
 /// [`World`] where the animation is queued, and the unique asset ID identifying
-/// the asset instance inside that [`Assets<A>`] resource.
+/// the asset instance inside that [`Assets`] resource.
 ///
 /// This is a lightweight reference (copyable) implicitly tied to a given
 /// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct AssetTarget {
-    /// Resource ID of the registered [`Assets<A>`] asset container.
+    /// Resource ID of the registered [`Assets`] asset container.
     pub resource_id: ComponentId,
     /// Asset ID of the target asset being animated.
     pub asset_id: UntypedAssetId,
@@ -845,9 +870,9 @@ pub struct TweenAnimator {
     /// Queue of animations currently playing.
     anims: SlotMap<TweenId, TweenAnim>,
     /// Asset resolver allowing to convert a pair of { untyped pointer to
-    /// Assets<A>, untyped AssetId } into an untyped pointer to the asset A
+    /// `Assets<A>`, untyped `AssetId` } into an untyped pointer to the asset A
     /// itself. This is necessary because there's no UntypedAssets interface in
-    /// Bevy. The TypeId key must be the type of the Assets<A> type itself.
+    /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
     asset_resolver: HashMap<
         ComponentId,
         Box<
@@ -872,8 +897,9 @@ impl TweenAnimator {
     /// Add a new component animation to the animator queue.
     ///
     /// In general you don't need to call this directly. Instead, use the
-    /// extensions provided by [`EntityCommandsTweening`] to directly create and
-    /// queue tweenable animations on a given [`EntityCommands`], like this:
+    /// extensions provided by [`EntityCommandsTweeningExtensions`] to directly
+    /// create and queue tweenable animations on a given [`EntityCommands`],
+    /// like this:
     ///
     /// ```
     /// # use bevy::prelude::*;
@@ -906,59 +932,6 @@ impl TweenAnimator {
         self.anims.insert(TweenAnim::new(target.into(), tweenable))
     }
 
-    /// Add a new asset animation to the animator queue.
-    ///
-    /// This creates a new animation with the given tweenable, targeting the
-    /// asset with the given ID.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the target type of the tweenable (which can be queried with
-    /// [`Tweenable::type_id()`]) is different from `Assets<A>`. In general if
-    /// the tweenable was created with _e.g._ [`Tween::new_asset<A>()`] then
-    /// [`Tweenable::type_id()`] correctly returns `Assets<A>`. Note that the
-    /// type is **NOT** the asset type `A` itself, but rather `Assets<A>`.
-    // #[inline]
-    // pub fn add_asset<A, T, I>(&mut self, asset_id: I, tweenable: T) -> TweenId
-    // where
-    //     A: Asset,
-    //     T: Tweenable + 'static,
-    //     I: Into<AssetId<A>>,
-    // {
-    //     let type_id = TypeId::of::<Assets<A>>();
-    //     assert_eq!(
-    //         Some(type_id),
-    //         tweenable.type_id(),
-    //         "Tweenable has different target type than Assets<A>."
-    //     );
-
-    //     self.asset_resolver.entry(resource_id).or_insert_with(|| {
-    //         Box::new(
-    //             // Convert ( Mut<Assets<A>>, AssetId<A> ) -> Mut<A>
-    //             |assets: MutUntyped, asset_id: UntypedAssetId| -> MutUntyped {
-    //                 // SAFETY: The type ID was checked above with an assert to make sure the one
-    //                 // stored in the Tweenable (which is where the untyped value comes from) is
-    //                 // the same as Assets<A>.
-    //                 #[allow(unsafe_code)]
-    //                 let assets = unsafe { assets.with_type::<Assets<A>>() };
-
-    //                 let asset_id = asset_id.typed::<A>();
-    //                 let asset: Mut<A> = assets.map_unchanged(|a| {
-    //                     // FIXME - replace with get_mut_untracked() to skip ECS change detection; see https://github.com/bevyengine/bevy/issues/13104
-    //                     a.get_mut(asset_id).unwrap()
-    //                 });
-
-    //                 asset.into()
-    //             },
-    //         )
-    //     });
-
-    //     let asset_id: AssetId<A> = asset_id.into();
-    //     let target = WorldAssetTarget { resource_id, asset_id: asset_id.untyped() };
-    //     self.anims
-    //         .insert(TweenAnim::new(target.into(), tweenable))
-    // }
-
     /// Queue a prepared tweenable animation.
     ///
     /// See [`make()`] to prepare the animation closure.
@@ -1000,12 +973,16 @@ impl TweenAnimator {
     /// Loop over the internal queue of tweenable animations, apply them to
     /// their respective target [`Entity`], and prune all the completed
     /// ones (the ones returning [`TweenState::Completed`]). In the later case,
-    /// send [`TweenCompleted`] events if enabled on each individual tweenable.
+    /// send [`TweenCompletedEvent`]s if enabled on each individual tweenable.
+    ///
+    /// If you use the [`TweeningPlugin`], this is automatically called by the
+    /// animation system the plugin registers. See the
+    /// [`AnimationSystem::AnimationUpdate`] system set.
     pub fn play(
         &mut self,
         world: &mut World,
         delta_time: Duration,
-        mut events: Mut<Events<TweenCompleted>>,
+        mut events: Mut<Events<TweenCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) {
         // Loop over active animations, tick them, and retain those which are still
@@ -1047,7 +1024,7 @@ impl TweenAnimator {
             let delta_time = delta_time.mul_f32(anim.speed.max(0.));
 
             let mut notify_completed = |fraction: f32| {
-                events.send(TweenCompleted {
+                events.send(TweenCompletedEvent {
                     id: tween_id,
                     target: anim.target,
                     progress: fraction,
diff --git a/src/plugin.rs b/src/plugin.rs
index 88f5fa0..e081dae 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,42 +1,21 @@
 use bevy::prelude::*;
 
-use crate::{AnimCompletedEvent, TweenAnimator, TweenCompleted};
+use crate::{AnimCompletedEvent, TweenAnimator, TweenCompletedEvent};
 
-/// Plugin to add systems related to tweening of common components and assets.
+/// Plugin to register the [`TweenAnimator`] and the systme playing animations.
 ///
-/// This plugin adds systems for a predefined set of components and assets, to
-/// allow their respective animators to be updated each frame:
-/// - [`Transform`]
-/// - [`TextColor`]
-/// - [`Node`]
-/// - [`Sprite`]
-/// - [`ColorMaterial`]
-///
-/// This ensures that all predefined lenses work as intended, as well as any
-/// custom lens animating the same component or asset type.
-///
-/// For other components and assets, including custom ones, the relevant system
-/// needs to be added manually by the application:
-/// - For components, add [`component_animator_system::<T>`] where `T:
-///   Component`
-/// - For assets, add [`asset_animator_system::<T>`] where `T: Asset`
-///
-/// This plugin is entirely optional. If you want more control, you can instead
-/// add manually the relevant systems for the exact set of components and assets
-/// actually animated.
-///
-/// [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
-/// [`TextColor`]: https://docs.rs/bevy/0.16.0/bevy/text/struct.TextColor.html
-/// [`Node`]: https://docs.rs/bevy/0.16.0/bevy/ui/struct.Node.html
-/// [`Sprite`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.Sprite.html
-/// [`ColorMaterial`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.ColorMaterial.html
+/// This plugin registers the common resources and events used by 🍃 Bevy
+/// Tweening as well as the core animation system which executes all pending
+/// tweenable animations. That system runs in the
+/// [`AnimationSystem::AnimationUpdate`] system set, during the [`Update`]
+/// schedule.
 #[derive(Debug, Clone, Copy)]
 pub struct TweeningPlugin;
 
 impl Plugin for TweeningPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<TweenAnimator>()
-            .add_event::<TweenCompleted>()
+            .add_event::<TweenCompletedEvent>()
             .add_event::<AnimCompletedEvent>()
             .add_systems(
                 Update,
@@ -47,16 +26,17 @@ impl Plugin for TweeningPlugin {
 
 /// Label enum for the systems relating to animations
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, SystemSet)]
+#[non_exhaustive]
 pub enum AnimationSystem {
-    /// Ticks animations
+    /// Ticks all animations. This executes during the [`Update`] schedule.
     AnimationUpdate,
 }
 
-/// TODO
-pub fn animator_system(world: &mut World) {
+/// Core animation systemt ticking the [`TweenAnimator`].
+pub(crate) fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
     // TODO: Use SystemState to cache all of that...
-    world.resource_scope(|world, events: Mut<Events<TweenCompleted>>| {
+    world.resource_scope(|world, events: Mut<Events<TweenCompletedEvent>>| {
         world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
             world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
                 animator.play(world, delta_time, events, anim_events);
@@ -95,7 +75,7 @@ mod tests {
         pub fn new(tweenable: impl Tweenable + 'static) -> Self {
             let mut world = World::new();
             world.init_resource::<Time>();
-            world.init_resource::<Events<TweenCompleted>>();
+            world.init_resource::<Events<TweenCompletedEvent>>();
             world.init_resource::<Events<AnimCompletedEvent>>();
             world.init_resource::<TweenAnimator>();
 
@@ -140,7 +120,7 @@ mod tests {
             system.run((), &mut self.world);
 
             // Update events after system ticked, in case system emitted some events
-            let mut events = self.world.resource_mut::<Events<TweenCompleted>>();
+            let mut events = self.world.resource_mut::<Events<TweenCompletedEvent>>();
             events.update();
             let mut events = self.world.resource_mut::<Events<AnimCompletedEvent>>();
             events.update();
@@ -158,7 +138,7 @@ mod tests {
 
         /// Get the emitted event count since last tick.
         pub fn event_count(&self) -> usize {
-            let events = self.world.resource::<Events<TweenCompleted>>();
+            let events = self.world.resource::<Events<TweenCompletedEvent>>();
             events.get_cursor().len(events)
         }
     }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index cdffb47..f60cd78 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -31,7 +31,7 @@ use crate::{
 /// # use std::{any::TypeId, time::Duration};
 /// # use bevy::ecs::{system::Commands, change_detection::MutUntyped};
 /// # use bevy::prelude::*;
-/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompleted, TweenState, TotalDuration};
+/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompletedEvent, TweenState, TotalDuration};
 /// #
 /// # struct MyTweenable;
 /// # impl Tweenable for MyTweenable {
@@ -62,7 +62,7 @@ pub type BoxedTweenable = Box<dyn Tweenable + 'static>;
 
 /// Playback state of a [`Tweenable`].
 ///
-/// This is returned by [`Tweenable::tick()`] to allow the caller to execute
+/// This is returned by [`Tweenable::step()`] to allow the caller to execute
 /// some logic based on the updated state of the tweenable, like advanding a
 /// sequence to its next child tweenable.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -90,19 +90,26 @@ pub enum TweenState {
 /// The semantic is slightly different from [`TweenState::Completed`], which
 /// indicates that the tweenable has finished ticking and do not need to be
 /// updated anymore, a state which is never reached for looping animation. Here
-/// the [`TweenCompleted`] event instead marks the end of a single loop
+/// the [`TweenCompletedEvent`] instead marks the end of a single loop
 /// iteration.
 #[derive(Copy, Clone, Event)]
-pub struct TweenCompleted {
+pub struct TweenCompletedEvent {
     /// The ID of the tween animation which completed.
     ///
     /// This is the ID of the top-level [`TweenAnim`] this tween is part of. It
-    /// can be used to retrieve the animation with [`TweenAnimator::get`].
+    /// can be used to retrieve the animation with [`TweenAnimator::get()`].
+    ///
+    /// [`TweenAnim`]: crate::TweenAnim
+    /// [`TweenAnimator::get()`]: crate::TweenAnimator::get
     pub id: TweenId,
     /// The [`Entity`] the tween which completed and the [`TweenAnim`] it's part
     /// of are attached to.
+    ///
+    /// [`TweenAnim`]: crate::TweenAnim
     pub target: AnimTarget,
     /// Current progress of the owner [`TweenAnim`].
+    ///
+    /// [`TweenAnim`]: crate::TweenAnim
     pub progress: f32,
 }
 
@@ -683,7 +690,7 @@ impl Tween {
 
     /// Enable raising a completed event on looping.
     ///
-    /// If enabled, the tween will raise a [`TweenCompleted`] event each time
+    /// If enabled, the tween will raise a [`TweenCompletedEvent`] each time
     /// the tween's progress reaches `1.`. In case of looping tweens (repeat
     /// count > 1), the event is raised once per loop. For mirrored repeats, a
     /// "loop" is one travel from start to end or end to start (so the full
@@ -704,14 +711,15 @@ impl Tween {
     /// #        end: Vec3::new(3.5, 0., 0.),
     /// #    },
     /// )
-    /// // Raise a TweenCompleted event each loop
+    /// // Raise a TweenCompletedEvent each loop
     /// .with_completed_event(true);
     ///
-    /// fn my_system(mut reader: EventReader<TweenCompleted>) {
+    /// fn my_system(mut reader: EventReader<TweenCompletedEvent>) {
     ///     for ev in reader.read() {
     ///         println!(
-    ///             "Tween animation {:?} raised TweenCompleted for target entity {:?}!",
-    ///             ev.id, ev.target.as_component().unwrap().entity
+    ///             "Tween animation {:?} raised TweenCompletedEvent for target entity {:?}!",
+    ///             ev.id,
+    ///             ev.target.as_component().unwrap().entity
     ///         );
     ///     }
     /// }
@@ -731,7 +739,7 @@ impl Tween {
     ///
     /// If enabled, the tween will run a system via a provided [`SystemId`] when
     /// the animation completes. This is similar to the
-    /// [`with_completed()`], but uses a system registered by
+    /// [`with_completed_event()`], but uses a system registered by
     /// [`register_system()`] instead of a callback.
     ///
     /// # Example
@@ -759,7 +767,8 @@ impl Tween {
     ///    }
     /// }
     /// ```
-    /// [`with_completed()`]: Tween::with_completed
+    ///
+    /// [`with_completed_event()`]: crate::Tween::with_completed_event
     /// [`register_system()`]: bevy::ecs::world::World::register_system
     #[must_use]
     pub fn with_completed_system(mut self, system_id: SystemId) -> Self {
@@ -1204,7 +1213,7 @@ impl Delay {
     ///
     /// If enabled, the tween will run a system via a provided [`SystemId`] when
     /// the animation completes. This is similar to the
-    /// [`with_completed()`], but uses a system registered by
+    /// [`with_completed_event()`], but uses a system registered by
     /// [`register_system()`] instead.
     ///
     /// # Example
@@ -1233,7 +1242,7 @@ impl Delay {
     /// }
     /// ```
     ///
-    /// [`with_completed()`]: Delay::with_completed
+    /// [`with_completed_event()`]: crate::Tween::with_completed_event
     /// [`register_system()`]: bevy::ecs::world::World::register_system
     #[must_use]
     pub fn with_completed_system(mut self, system_id: SystemId) -> Self {
@@ -1292,7 +1301,7 @@ impl Tweenable for Delay {
         // // If completed this frame, notify the user
         // if (state == TweenState::Completed) && !was_completed {
         //     if self.send_completed_events {
-        //         let event = TweenCompleted {
+        //         let event = TweenCompletedEvent {
         //             id: tween_id,
         //             entity,
         //             progress,
@@ -1463,7 +1472,7 @@ mod tests {
     /// Utility to create a test environment to tick a tween.
     fn make_test_env() -> (World, Entity, SystemId) {
         let mut world = World::new();
-        world.init_resource::<Events<TweenCompleted>>();
+        world.init_resource::<Events<TweenCompletedEvent>>();
         let entity = world.spawn(Transform::default()).id();
         let system_id = world.register_system(oneshot_test);
         (world, entity, system_id)
@@ -1482,7 +1491,7 @@ mod tests {
     ) -> TweenState {
         // Tick the given tween and apply its state to the given entity target
         let state = world.resource_scope(
-            |world: &mut World, mut events: Mut<Events<TweenCompleted>>| {
+            |world: &mut World, mut events: Mut<Events<TweenCompletedEvent>>| {
                 let component_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
                 if let Ok(mut target) = entity_mut.get_mut_by_id(component_id) {
@@ -1492,7 +1501,7 @@ mod tests {
                     }
                     .into();
                     let mut notify_completed = |fraction: f32| {
-                        events.send(TweenCompleted {
+                        events.send(TweenCompletedEvent {
                             id: tween_id,
                             target: world_target,
                             progress: fraction,
@@ -1507,7 +1516,7 @@ mod tests {
 
         // Propagate events
         {
-            let mut events = world.resource_mut::<Events<TweenCompleted>>();
+            let mut events = world.resource_mut::<Events<TweenCompletedEvent>>();
             events.update();
         }
 
@@ -1618,7 +1627,7 @@ mod tests {
                 }
 
                 let (mut world, entity, system_id) = make_test_env();
-                let mut event_reader_system_state: SystemState<EventReader<TweenCompleted>> =
+                let mut event_reader_system_state: SystemState<EventReader<TweenCompletedEvent>> =
                     SystemState::new(&mut world);
 
                 // Activate oneshot system

From 8d4d5b7531f856ff79de4083a8ec1c8d5d8c7711 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 6 Jul 2025 10:16:47 +0100
Subject: [PATCH 23/66] Fix doctest

---
 src/lib.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index 30f79b5..feff771 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -180,6 +180,9 @@
 //! rotation and scale unchanged.
 //!
 //! ```no_run
+//! # use bevy::{prelude::{Transform, Vec3}, ecs::change_detection::Mut};
+//! # use bevy_tweening::Lens;
+//! # struct TransformPositionLens { start: Vec3, end: Vec3 };
 //! impl Lens<Transform> for TransformPositionLens {
 //!     fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
 //!         target.translation = self.start.lerp(self.end, ratio);

From 32cabe122c60bed06908f50b56382a4b8c93953a Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 6 Jul 2025 10:37:07 +0100
Subject: [PATCH 24/66] Remove `bevy_asset` feature

---
 .github/workflows/ci.yaml |   5 --
 CHANGELOG.md              |   1 +
 Cargo.toml                |   8 ++-
 README.md                 | 108 +++++++++++++++++---------------------
 release.md                |   1 -
 run_examples.bat          |   3 +-
 src/lens.rs               |   6 +--
 src/lib.rs                |  42 +--------------
 src/tweenable.rs          |   1 -
 9 files changed, 58 insertions(+), 117 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index d041b81..a04e1f8 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -70,11 +70,6 @@ jobs:
         env:
           CARGO_INCREMENTAL: 1
           RUSTFLAGS: "-C debuginfo=0 -D warnings"
-      - name: Build & run tests (asset)
-        run: cargo test --no-default-features --features="bevy_asset"
-        env:
-          CARGO_INCREMENTAL: 1
-          RUSTFLAGS: "-C debuginfo=0 -D warnings"
       - name: Build & run tests (all)
         run: cargo test --all-features
         env:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f27b5e..32bd25e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,6 +29,7 @@ and unifies all animations of all components and assets._
 
 ### Changed
 
+- The `bevy_asset` feature was removed; `bevy_tweening` now depends on `bevy/bevy_asset` always.
 - The `Lens<T>` trait now takes its target as `Mut<T>` instead of `&mut dyn Targetable<T>`.
 
   ```rust
diff --git a/Cargo.toml b/Cargo.toml
index cea1f5e..5dc1294 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,9 +16,7 @@ readme = "README.md"
 exclude = ["examples/*.gif", ".github", "release.md", "run_examples.bat"]
 
 [features]
-default = ["bevy_sprite", "bevy_ui", "bevy_asset", "bevy_text"]
-# Enable support for Asset animation
-bevy_asset = ["bevy/bevy_asset"]
+default = ["bevy_sprite", "bevy_ui", "bevy_text"]
 # Enable built-in lenses for Bevy sprites
 bevy_sprite = ["bevy/bevy_sprite", "bevy/bevy_render"]
 # Enable built-in lenses for Bevy UI
@@ -28,7 +26,7 @@ bevy_text = ["bevy/bevy_text", "bevy/bevy_render", "bevy/bevy_sprite"]
 
 [dependencies]
 # Note: abuse 'bevy_color' to force 'bevy_math/curve' feature, which defines EaseFunction
-bevy = { version = "0.16", default-features = false, features = [ "bevy_color" ]}
+bevy = { version = "0.16", default-features = false, features = [ "bevy_color", "bevy_asset" ]}
 slotmap = "1.0"
 
 [dev-dependencies]
@@ -40,7 +38,7 @@ required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picki
 
 [[example]]
 name = "colormaterial_color"
-required-features = ["bevy_asset", "bevy_sprite", "bevy/bevy_winit", "bevy/bevy_picking"]
+required-features = ["bevy_sprite", "bevy/bevy_winit", "bevy/bevy_picking"]
 
 [[example]]
 name = "sprite_color"
diff --git a/README.md b/README.md
index d1ad9bb..cab513b 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ Tweening animation plugin for the Bevy game engine.
 - [x] Animate any field of any component or asset, including custom ones.
 - [x] Run multiple tweens (animations) per component/asset in parallel.
 - [x] Chain multiple tweens (animations) one after the other for complex animations.
-- [x] Raise a Bevy event or invoke a callback when an tween completed.
+- [x] Raise a Bevy event or invoke a one-shot system when an animation completed.
 
 ## Usage
 
@@ -24,14 +24,13 @@ Add to `Cargo.toml`:
 
 ```toml
 [dependencies]
-bevy_tweening = "0.13"
+bevy_tweening = "0.14-dev"
 ```
 
 This crate supports the following features:
 
 | Feature | Default | Description |
 |---|---|---|
-| `bevy_asset`  | Yes | Enable animating Bevy assets (`Asset`) in addition of components. |
 | `bevy_sprite` | Yes | Includes built-in lenses for some `Sprite`-related components. |
 | `bevy_ui`     | Yes | Includes built-in lenses for some UI-related components. |
 | `bevy_text`   | Yes | Includes built-in lenses for some `Text`-related components. |
@@ -47,48 +46,21 @@ App::default()
     .run();
 ```
 
-This provides the basic setup for using 🍃 Bevy Tweening. However, additional setup is required depending on the components and assets you want to animate:
-
-- To ensure a component `C` is animated, the `component_animator_system::<C>` system must run each frame, in addition of adding an `Animator::<C>` component to the same Entity as `C`.
-
-- To ensure an asset `A` is animated, the `asset_animator_system::<A>` system must run each frame, in addition of adding an `AssetAnimator<A>` component to any Entity. Animating assets also requires the `bevy_asset` feature (enabled by default).
-
-By default, 🍃 Bevy Tweening adopts a minimalist approach, and the `TweeningPlugin` will only add systems to animate components and assets for which a `Lens` is provided by 🍃 Bevy Tweening itself. This means that any other Bevy component or asset (either built-in from Bevy itself, or custom) requires manually scheduling the appropriate system.
-
-| Component or Asset | Animation system added by `TweeningPlugin`? |
-|---|---|
-| `Transform`          | Yes                           |
-| `Sprite`             | Only if `bevy_sprite` feature |
-| `ColorMaterial`      | Only if `bevy_sprite` feature |
-| `Node`               | Only if `bevy_ui` feature     |
-| `TextColor`          | Only if `bevy_text` feature   |
-| All other components | No                            |
-
-To add a system for a component `C`, use:
-
-```rust
-app.add_systems(Update, component_animator_system::<C>.in_set(AnimationSystem::AnimationUpdate));
-```
-
-Similarly for an asset `A`, use:
-
-```rust
-app.add_systems(Update, asset_animator_system::<A>.in_set(AnimationSystem::AnimationUpdate));
-```
+This provides enough setup for using 🍃 Bevy Tweening and animating any Bevy built-in or custom component or asset. Animations update as part of the `Update` schedule of Bevy.
 
 ### Animate a component
 
-Animate the transform position of an entity by creating a `Tween` animation for the transform, and adding an `Animator` component with that tween:
+Animate the transform position of an entity by creating a `Tween` animation for the transform, and enqueuing the animation with the `tween()` command extension:
 
 ```rust
-// Create a single animation (tween) to move an entity.
+// Create a single animation (tween) to move an entity back and forth.
 let tween = Tween::new(
     // Use a quadratic easing on both endpoints.
     EaseFunction::QuadraticInOut,
     // Animation time (one way only; for ping-pong it takes 2 seconds
     // to come back to start).
     Duration::from_secs(1),
-    // The lens gives the Animator access to the Transform component,
+    // The lens gives the TweenAnimator access to the Transform component,
     // to animate it. It also contains the start and end values associated
     // with the animation ratios 0. and 1.
     TransformPositionLens {
@@ -96,21 +68,33 @@ let tween = Tween::new(
         end: Vec3::new(1., 2., -4.),
     },
 )
-// Repeat twice (one per way)
+// Repeat twice (once per direction)
 .with_repeat_count(RepeatCount::Finite(2))
-// After each iteration, reverse direction (ping-pong)
+// After each cycle, reverse direction (ping-pong)
 .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-commands.spawn((
-    // Spawn a Sprite entity to animate the position of.
-    Sprite {
-        color: Color::RED,
-        custom_size: Some(Vec2::new(size, size)),
-        ..default()
-    },
-    // Add an Animator component to control and execute the animation.
-    Animator::new(tween),
-));
+commands
+    // Spawn an entity to animate the position of.
+    .spawn(Transform::default())
+    // Queue the tweenable animation
+    .tween(tween);
+```
+
+This example shows the general pattern to add animations for any component
+or asset. Since moving the position of an object is a very common
+task, 🍃 Bevy Tweening provides a shortcut for it. The above example can be
+rewritten more concicely as:
+
+```rust
+commands
+    // Spawn an entity to animate the position of.
+    .spawn((Transform::default(),))
+    // Create-and-queue a new Transform::translation animation
+    .move_to(
+        Vec3::new(1., 2., -4.),
+        Duration::from_secs(1),
+        EaseFunction::QuadraticInOut,
+    );
 ```
 
 ### Chaining animations
@@ -119,7 +103,6 @@ Bevy Tweening supports several types of _tweenables_, building blocks that can b
 
 - **`Tween`** - A simple tween (easing) animation between two values.
 - **`Sequence`** - A series of tweenables executing in series, one after the other.
-- **`Tracks`** - A collection of tweenables executing in parallel.
 - **`Delay`** - A time delay.
 
 Most tweenables can be chained with the `then()` operator:
@@ -131,6 +114,17 @@ let tween2 = Tween { [...] }
 let seq = tween1.then(tween2);
 ```
 
+To execute multiple animations in parallel, simply enqueue each animation
+independently. This require careful selection of timings.
+
+Note that some tweenable animations can be of infinite duration; this is the
+case for example when using `RepeatCount::Infinite`. If you add such an
+infinite animation in a sequence, and append more tweenable after it, those
+tweenable will never play because playback will be stuck forever repeating
+the first animation. You're responsible for creating sequences that make
+sense. In general, only use infinite tweenable animations alone or as the
+last element of a sequence.
+
 ## Predefined Lenses
 
 A small number of predefined lenses are available for the most common use cases, which also serve as examples. **Users are encouraged to write their own lens to tailor the animation to their use case.**
@@ -160,11 +154,9 @@ There are two ways to interpolate rotations. See the [comparison of rotation len
 
 ### Bevy Assets
 
-Asset animation always requires the `bevy_asset` feature.
-
 | Target Asset | Animated Field | Lens | Feature |
 |---|---|---|---|
-| [`ColorMaterial`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html) | [`color`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html#structfield.color) | [`ColorMaterialColorLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.ColorMaterialColorLens.html) | `bevy_asset` + `bevy_sprite` |
+| [`ColorMaterial`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html) | [`color`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html#structfield.color) | [`ColorMaterialColorLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.ColorMaterialColorLens.html) | `bevy_sprite` |
 
 ## Custom lens
 
@@ -178,9 +170,10 @@ struct MyXAxisLens {
 
 impl Lens<Transform> for MyXAxisLens {
     fn lerp(&mut self, target: &mut Transform, ratio: f32) {
-        let start = Vec3::new(self.start, 0., 0.);
-        let end = Vec3::new(self.end, 0., 0.);
-        target.translation = start + (end - start) * ratio;
+        let x = self.start * (1. - ratio) + self.end * ratio;
+        let y = target.translation.y;
+        let z = target.translation.z;
+        target.translation = Vec3::new(x, y, z);
     }
 }
 ```
@@ -192,7 +185,8 @@ The basic formula for lerp (linear interpolation) is either of:
 - `start + (end - start) * scalar`
 - `start * (1.0 - scalar) + end * scalar`
 
-The two formulations are mathematically equivalent, but one may be more suited than the other depending on the type interpolated and the operations available, and the potential floating-point precision errors.
+The two formulations are mathematically equivalent, but one may be more suited than the other depending on the type interpolated and the operations available, and the potential floating-point precision errors. Some types like `Vec3` also provide a `lerp()` function
+which can be used directly.
 
 ## Custom component support
 
@@ -214,11 +208,7 @@ impl Lens<MyCustomComponent> for MyCustomLens {
 }
 ```
 
-Then, in addition, the system `component_animator_system::<CustomComponent>` needs to be added to the application, as described in [System Setup](#system-setup). This system will extract each frame all `CustomComponent` instances with an `Animator<CustomComponent>` on the same entity, and animate the component via its animator.
-
-## Custom asset support
-
-The process is similar to custom components, creating a custom lens for the custom asset. The system to add is `asset_animator_system::<CustomAsset>`, as described in [System Setup](#system-setup). This requires the `bevy_asset` feature (enabled by default).
+Unlike previous versions of 🍃 Bevy Tweening, there's no other setup to animate custom components or assets.
 
 ## Examples
 
diff --git a/release.md b/release.md
index 96ace4c..8ef8fb2 100644
--- a/release.md
+++ b/release.md
@@ -10,7 +10,6 @@
 - `cargo test --no-default-features --features="bevy_ui"`
 - `cargo test --no-default-features --features="bevy_sprite"`
 - `cargo test --no-default-features --features="bevy_text"`
-- `cargo test --no-default-features --features="bevy_asset"`
 - `cargo test --all-features`
 - `cargo +nightly build --all-features` (for `docs.rs`)
 - `cargo +nightly doc --all-features --no-deps`
diff --git a/run_examples.bat b/run_examples.bat
index 4836009..45a3263 100644
--- a/run_examples.bat
+++ b/run_examples.bat
@@ -7,9 +7,8 @@ cargo r --example transform_rotation --no-default-features --features="bevy_spri
 cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
 REM bevy_sprite
 cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
+cargo r --example colormaterial_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 REM bevy_ui
 cargo r --example ui_position --no-default-features --features="bevy_sprite bevy_ui bevy/bevy_winit bevy/bevy_picking"
 REM bevy_text
 cargo r --example text_color --no-default-features --features="bevy_text bevy_ui bevy/bevy_winit bevy/bevy_picking"
-REM bevy_sprite + bevy_asset
-cargo r --example colormaterial_color --no-default-features --features="bevy_asset bevy_sprite bevy/bevy_winit bevy/bevy_picking"
\ No newline at end of file
diff --git a/src/lens.rs b/src/lens.rs
index 0e04b4b..89b81ab 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -334,7 +334,7 @@ impl Lens<BackgroundColor> for UiBackgroundColorLens {
 ///
 /// [`color`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.ColorMaterial.html#structfield.color
 /// [`ColorMaterial`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.ColorMaterial.html
-#[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
+#[cfg(feature = "bevy_sprite")]
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct ColorMaterialColorLens {
     /// Start color.
@@ -343,7 +343,7 @@ pub struct ColorMaterialColorLens {
     pub end: Color,
 }
 
-#[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
+#[cfg(feature = "bevy_sprite")]
 impl Lens<ColorMaterial> for ColorMaterialColorLens {
     fn lerp(&mut self, mut target: Mut<ColorMaterial>, ratio: f32) {
         target.color = self.start.mix(&self.end, ratio);
@@ -971,7 +971,7 @@ mod tests {
         assert_eq!(node.bottom, Val::Percent(31.));
     }
 
-    #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
+    #[cfg(feature = "bevy_sprite")]
     #[test]
     fn colormaterial_color() {
         let mut lens = ColorMaterialColorLens {
diff --git a/src/lib.rs b/src/lib.rs
index feff771..e819cd6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -58,7 +58,7 @@
 //!
 //! commands
 //!     // Spawn an entity to animate the position of.
-//!     .spawn((Transform::default(),))
+//!     .spawn(Transform::default())
 //!     // Queue the tweenable animation
 //!     .tween(tween);
 //! # }
@@ -1055,43 +1055,6 @@ impl TweenAnimator {
     }
 }
 
-// /// Component to control the animation of an asset.
-// ///
-// /// The animated asset is the asset referenced by a [`Handle<T>`] component
-// /// located on the same entity as the [`AssetAnimator<T>`] itself.
-// #[cfg(feature = "bevy_asset")]
-// #[derive(Component)]
-// pub struct AssetAnimator<T: Asset> {
-//     /// Control if this animation is played or not.
-//     pub state: AnimatorState,
-//     tweenable: BoxedTweenable<T>,
-//     speed: f32,
-// }
-
-// #[cfg(feature = "bevy_asset")]
-// impl<T: Asset + std::fmt::Debug> std::fmt::Debug for AssetAnimator<T> {
-//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-//         f.debug_struct("AssetAnimator")
-//             .field("state", &self.state)
-//             .finish()
-//     }
-// }
-
-// #[cfg(feature = "bevy_asset")]
-// impl<T: Asset> AssetAnimator<T> {
-//     /// Create a new asset animator component from a single tweenable.
-//     #[must_use]
-//     pub fn new(tween: impl Tweenable<T> + 'static) -> Self {
-//         Self {
-//             state: default(),
-//             tweenable: Box::new(tween),
-//             speed: 1.,
-//         }
-//     }
-
-//     //animator_impl!();
-// }
-
 /// Trait to interpolate between two values.
 /// Needed for color.
 #[allow(dead_code)]
@@ -1132,7 +1095,6 @@ mod tests {
         value: f32,
     }
 
-    #[cfg(feature = "bevy_asset")]
     #[derive(Asset, Debug, Default, Reflect)]
     struct DummyAsset {
         value: f32,
@@ -1171,14 +1133,12 @@ mod tests {
         }
     }
 
-    #[cfg(feature = "bevy_asset")]
     impl Lens<DummyAsset> for DummyLens {
         fn lerp(&mut self, mut target: Mut<DummyAsset>, ratio: f32) {
             target.value = self.start.lerp(self.end, ratio);
         }
     }
 
-    #[cfg(feature = "bevy_asset")]
     #[test]
     fn dummy_lens_asset() {
         let mut assets = Assets::<DummyAsset>::default();
diff --git a/src/tweenable.rs b/src/tweenable.rs
index f60cd78..b625c0e 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -879,7 +879,6 @@ impl Tween {
     }
 }
 
-#[cfg(feature = "bevy_asset")]
 impl TweenAssetExtensions for Tween {
     #[must_use]
     fn new<A, L>(ease_function: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self

From e30d05b748f20b06252e779a1e66743e78ff9d2d Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 6 Jul 2025 17:39:56 +0100
Subject: [PATCH 25/66] Clean-up extension traits, add more helpers

---
 run_examples.sh  |  13 ++
 src/lib.rs       | 533 ++++++++++++++++++++++++++++++++++++-----------
 src/plugin.rs    |  11 +-
 src/tweenable.rs |   1 +
 4 files changed, 428 insertions(+), 130 deletions(-)
 create mode 100755 run_examples.sh

diff --git a/run_examples.sh b/run_examples.sh
new file mode 100755
index 0000000..c32280e
--- /dev/null
+++ b/run_examples.sh
@@ -0,0 +1,13 @@
+echo Run all examples
+# Default
+cargo r --example menu --no-default-features --features="bevy_ui bevy_text bevy/bevy_winit bevy/bevy_picking"
+cargo r --example transform_translation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
+cargo r --example transform_rotation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
+cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
+# bevy_sprite
+cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
+cargo r --example colormaterial_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
+# bevy_ui
+cargo r --example ui_position --no-default-features --features="bevy_sprite bevy_ui bevy/bevy_winit bevy/bevy_picking"
+# bevy_text
+cargo r --example text_color --no-default-features --features="bevy_text bevy_ui bevy/bevy_winit bevy/bevy_picking"
diff --git a/src/lib.rs b/src/lib.rs
index e819cd6..fe0d4f8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -86,6 +86,8 @@
 //! # }
 //! ```
 //!
+//! See the [`EntityCommandsTweeningExtensions`] extension trait for details.
+//!
 //! # Ready to animate
 //!
 //! Unlike previous versions of 🍃 Bevy Tweening, you don't need any particular
@@ -147,7 +149,7 @@
 //! sense. In general, only use infinite tweenable animations alone or as the
 //! last element of a sequence.
 //!
-//! # `TweenAnimator` and lenses
+//! # `TweenAnimator`
 //!
 //! Bevy components and assets are animated with the [`TweenAnimator`] resource.
 //! The animator determine the component or asset to animate via an
@@ -167,6 +169,37 @@
 //! mesh, you have to duplicate the asset and assign a unique copy to that mesh,
 //! then animate that copy alone.
 //!
+//! Although you generally should prefer using the various extensions on
+//! commands, like the `.tween()` function on entity commands, under the hood
+//! the manual process of queuing a new animation involves calling
+//! `TweenAnimator::add()`.
+//!
+//! ```no_run
+//! # use bevy::prelude::*;
+//! # use bevy_tweening::*;
+//! # fn xxx() -> Option<()> {
+//! # let mut animator = TweenAnimator::default();
+//! # let entity = Entity::PLACEHOLDER;
+//! # let world = World::default();
+//! # fn make_tween() -> Tween { unimplemented!() }
+//! // Create a target referencing the Transform component of a given entity
+//! let target = world.get_component_target::<Transform>(entity)?;
+//! // Create a tween animation description
+//! let tween: Tween = make_tween();
+//! // Enqueue a new animation instance
+//! let tween_id = animator.add(target, tween);
+//! # None }
+//! ```
+//!
+//! After that, you can use the [`TweenId`] to control the animation playback:
+//!
+//! ```no_run
+//! # use bevy_tweening::*;
+//! # let mut animator = TweenAnimator::default();
+//! # let tween_id = TweenId::default();
+//! animator.get_mut(tween_id).unwrap().speed = 0.8; // 80% playback speed
+//! ```
+//!
 //! ## Lenses
 //!
 //! The [`AnimTarget`] references the container (component or asset) being
@@ -211,7 +244,10 @@ use std::time::Duration;
 
 use bevy::{
     asset::UntypedAssetId,
-    ecs::{change_detection::MutUntyped, component::ComponentId},
+    ecs::{
+        change_detection::MutUntyped,
+        component::{ComponentId, Mutable},
+    },
     platform::collections::HashMap,
     prelude::*,
 };
@@ -530,56 +566,126 @@ pub trait EntityCommandsTweeningExtensions<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self;
-}
 
-/// Build an [`EntityCommand`] which queues the new tweenable into the
-/// [`Animator`].
-fn make_tween_command<T>(tweenable: T) -> impl EntityCommand
-where
-    T: Tweenable + 'static,
-{
-    move |mut entity: EntityWorldMut| {
-        let e = entity.id();
-        let type_id = tweenable
-            .type_id()
-            .expect("Can't add untyped tweenable as root animation.");
-        let component_id = entity
-            .world()
-            .components()
-            .get_id(type_id)
-            .expect("Tweenable component not registered with the World.");
-        let target = ComponentTarget {
-            entity: e,
-            component_id,
-        };
-        entity
-            .resource_mut::<TweenAnimator>()
-            .queue(target.into(), tweenable);
-    }
-}
+    /// Queue a new tween animation to move the current entity.
+    ///
+    /// The entity must have a [`Transform`] component. The tween animation will
+    /// be initialized with the current [`Transform::translation`] as its
+    /// ending point, and the given starting point, duration, and ease method.
+    ///
+    /// Note that the ending point position is saved when the command is
+    /// applied, generally after the current system when [`apply_deferred()`]
+    /// runs. So any change to [`Transform::translation`] between this call and
+    /// [`apply_deferred()`] will be taken into account.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// the animation playback, directly add the tweenable via
+    /// [`TweenAnimator::add()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands.spawn(Transform::default()).move_from(
+    ///     Vec3::new(3.5, 0., 0.),
+    ///     Duration::from_secs(1),
+    ///     EaseFunction::QuadraticIn,
+    /// );
+    /// ```
+    ///
+    /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
+    fn move_from(
+        &mut self,
+        start: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self;
 
-fn make_transform_from_command(
-    end: Vec3,
-    duration: Duration,
-    ease_method: EaseMethod,
-) -> impl EntityCommand {
-    move |mut entity: EntityWorldMut| {
-        let component_id = entity
-            .world()
-            .component_id::<Transform>()
-            .expect("Transform component not registered in the World");
-        let start = entity.get::<Transform>().unwrap().translation;
-        let lens = lens::TransformPositionLens { start, end };
-        let tween = Tween::new(ease_method, duration, lens);
-        let e = entity.id();
-        let target = ComponentTarget {
-            entity: e,
-            component_id,
-        };
-        entity
-            .resource_mut::<TweenAnimator>()
-            .queue(target.into(), tween);
-    }
+    /// Queue a new tween animation to scale the current entity.
+    ///
+    /// The entity must have a [`Transform`] component. The tween animation will
+    /// be initialized with the current [`Transform::scale`] as its starting
+    /// point, and the given endpoint, duration, and ease method.
+    ///
+    /// Note that the starting point scale is saved when the command is applied,
+    /// generally after the current system when [`apply_deferred()`]
+    /// runs. So any change to [`Transform::scale`] between this call and
+    /// [`apply_deferred()`] will be taken into account.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// the animation playback, directly add the tweenable via
+    /// [`TweenAnimator::add()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands.spawn(Transform::default()).scale_to(
+    ///     Vec3::splat(2.), // 200% size
+    ///     Duration::from_secs(1),
+    ///     EaseFunction::QuadraticIn,
+    /// );
+    /// ```
+    ///
+    /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
+    fn scale_to(
+        &mut self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self;
+
+    /// Queue a new tween animation to scale the current entity.
+    ///
+    /// The entity must have a [`Transform`] component. The tween animation will
+    /// be initialized with the current [`Transform::scale`] as its ending
+    /// point, and the given start scale, duration, and ease method.
+    ///
+    /// Note that the ending point scale is saved when the command is applied,
+    /// generally after the current system when [`apply_deferred()`]
+    /// runs. So any change to [`Transform::scale`] between this call and
+    /// [`apply_deferred()`] will be taken into account.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// the animation playback, directly add the tweenable via
+    /// [`TweenAnimator::add()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands.spawn(Transform::default()).scale_from(
+    ///     Vec3::splat(0.8), // 80% size
+    ///     Duration::from_secs(1),
+    ///     EaseFunction::QuadraticIn,
+    /// );
+    /// ```
+    ///
+    /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
+    fn scale_from(
+        &mut self,
+        start: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self;
 }
 
 impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
@@ -587,7 +693,9 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     where
         T: Tweenable + 'static,
     {
-        self.queue(make_tween_command(tweenable))
+        self.queue(move |mut entity: EntityWorldMut| {
+            entity.tween(tweenable);
+        })
     }
 
     fn move_to(
@@ -596,11 +704,46 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut EntityCommands<'a> {
-        self.queue(make_transform_from_command(
-            end,
-            duration,
-            ease_method.into(),
-        ))
+        let ease_method = ease_method.into();
+        self.queue(move |mut entity: EntityWorldMut| {
+            entity.move_to(end, duration, ease_method);
+        })
+    }
+
+    fn move_from(
+        &mut self,
+        start: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut EntityCommands<'a> {
+        let ease_method = ease_method.into();
+        self.queue(move |mut entity: EntityWorldMut| {
+            entity.move_from(start, duration, ease_method);
+        })
+    }
+
+    fn scale_to(
+        &mut self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut EntityCommands<'a> {
+        let ease_method = ease_method.into();
+        self.queue(move |mut entity: EntityWorldMut| {
+            entity.scale_to(end, duration, ease_method);
+        })
+    }
+
+    fn scale_from(
+        &mut self,
+        start: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut EntityCommands<'a> {
+        let ease_method = ease_method.into();
+        self.queue(move |mut entity: EntityWorldMut| {
+            entity.scale_from(start, duration, ease_method);
+        })
     }
 }
 
@@ -616,7 +759,9 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
             entity: self.id(),
         };
         self.world_scope(|world: &mut World| {
-            world.resource_mut::<TweenAnimator>().add(target, tweenable);
+            world
+                .resource_mut::<TweenAnimator>()
+                .add(target.into(), tweenable);
         });
         self
     }
@@ -627,22 +772,93 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let component_id = self.world().component_id::<Transform>().unwrap();
-        let start = self.get::<Transform>().unwrap().translation;
+        let (start, target) =
+            make_component_tween_from_ent_world_mut(self, |transform: &Transform| {
+                transform.translation
+            });
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
-        let e = self.id();
-        let target = ComponentTarget {
-            entity: e,
-            component_id,
-        };
         self.world_scope(|world: &mut World| {
-            world.resource_mut::<TweenAnimator>().add(target, tween);
+            world
+                .resource_mut::<TweenAnimator>()
+                .add(target.into(), tween);
+        });
+        self
+    }
+
+    fn move_from(
+        &mut self,
+        start: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self {
+        let (end, target) =
+            make_component_tween_from_ent_world_mut(self, |transform: &Transform| {
+                transform.translation
+            });
+        let lens = lens::TransformPositionLens { start, end };
+        let tween = Tween::new(ease_method, duration, lens);
+        self.world_scope(|world: &mut World| {
+            world
+                .resource_mut::<TweenAnimator>()
+                .add(target.into(), tween);
+        });
+        self
+    }
+
+    fn scale_to(
+        &mut self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self {
+        let (start, target) =
+            make_component_tween_from_ent_world_mut(self, |transform: &Transform| transform.scale);
+        let lens = lens::TransformScaleLens { start, end };
+        let tween = Tween::new(ease_method, duration, lens);
+        self.world_scope(|world: &mut World| {
+            world
+                .resource_mut::<TweenAnimator>()
+                .add(target.into(), tween);
+        });
+        self
+    }
+
+    fn scale_from(
+        &mut self,
+        start: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> &mut Self {
+        let (end, target) =
+            make_component_tween_from_ent_world_mut(self, |transform: &Transform| transform.scale);
+        let lens = lens::TransformScaleLens { start, end };
+        let tween = Tween::new(ease_method, duration, lens);
+        self.world_scope(|world: &mut World| {
+            world
+                .resource_mut::<TweenAnimator>()
+                .add(target.into(), tween);
         });
         self
     }
 }
 
+#[inline]
+fn make_component_tween_from_ent_world_mut<'w, C: Component<Mutability = Mutable>, T>(
+    ent: &mut EntityWorldMut<'w>,
+    read: fn(&C) -> T,
+) -> (T, ComponentTarget) {
+    let component_id = ent.world().component_id::<C>().unwrap();
+    let component = ent.get::<C>().unwrap();
+    let value = read(component);
+    let e = ent.id();
+    let target = ComponentTarget {
+        entity: e,
+        component_id,
+    };
+    (value, target)
+}
+
 /// Event raised when a [`TweenAnim`] completed.
 #[derive(Copy, Clone, Event)]
 pub struct AnimCompletedEvent {
@@ -696,10 +912,11 @@ pub struct AssetTarget {
 /// Animation target.
 ///
 /// References either a component or an asset used as the target of a tweenable
-/// animation. See [`ComponentTarget`] and [`AssetTarget`] for details.
+/// animation. See [`ComponentTarget`] and [`AssetTarget`] for details. This is
+/// a lightweight reference (copyable) implicitly tied to a given [`World`].
 ///
-/// This is a lightweight reference (copyable) implicitly tied to a given
-/// [`World`].
+/// To create an animation target from a given component or asset, see the
+/// [`WorldTargetExtensions`] extension trait for [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum AnimTarget {
     /// Component animation target.
@@ -774,6 +991,74 @@ impl From<AssetTarget> for AnimTarget {
     }
 }
 
+/// Extension trait for [`World`].
+///
+/// This trait extends [`World`] with some helper functions.
+pub trait WorldTargetExtensions {
+    /// Get an [`AnimTarget`] for the given component type and entity pair.
+    ///
+    /// The target references the component instance held by the entity. The
+    /// entity must exist in the [`World`], and the component type must be
+    /// registered.
+    ///
+    /// # Returns
+    ///
+    /// Returns the animation target referencing the component instance, or
+    /// `None` if either the entity doesn't exist or the component type is not
+    /// registered.
+    fn get_component_target<C: Component<Mutability = Mutable>>(
+        &self,
+        entity: Entity,
+    ) -> Option<AnimTarget>;
+
+    /// Get an [`AnimTarget`] for the given asset type and ID pair.
+    ///
+    /// The target references the asset instance with the given ID. The
+    /// ID must be valid, that is reference an existing asset in the `Assets<A>`
+    /// collection, and the asset type `A` must be registered.
+    ///
+    /// # Returns
+    ///
+    /// Returns the animation target referencing the asset instance, or
+    /// `None` if either the ID doesn't reference an existing asset or the asset
+    /// type is not registered.
+    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AnimTarget>;
+}
+
+impl WorldTargetExtensions for World {
+    fn get_component_target<C: Component<Mutability = Mutable>>(
+        &self,
+        entity: Entity,
+    ) -> Option<AnimTarget> {
+        let component_id = self.component_id::<C>()?;
+        if !self.entities().contains(entity) {
+            return None;
+        }
+        Some(
+            ComponentTarget {
+                component_id,
+                entity,
+            }
+            .into(),
+        )
+    }
+
+    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AnimTarget> {
+        let id = id.into();
+        if !self.resource::<Assets<A>>().contains(id) {
+            return None;
+        }
+        let resource_id = self.resource_id::<Assets<A>>()?;
+        Some(
+            AssetTarget {
+                resource_id,
+                asset_id: id.untyped(),
+            }
+            .into(),
+        )
+    }
+}
+
 /// A [`Tweenable`]-based animation.
 pub struct TweenAnim {
     /// Target [`Entity`] containing the component to animate, or target asset.
@@ -806,45 +1091,6 @@ impl TweenAnim {
         }
     }
 
-    /// Create a new tween animation for an asset.
-    ///
-    /// The `type_id` must be `TypeId::of::<Assets<A>>`, where `A: Asset` is the
-    /// asset type to animate. The `asset_id` is the type-erased ID of the
-    /// actual asset, as stored in the `Assets<A>` container.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the tweenable is "typeless", that is [`Tweenable::type_id()`]
-    /// returns `None`. Root animations enqueued in the [`TweenAnimator`] must
-    /// target a concrete component or asset type. This means in particular
-    /// that you can't insert a single [`Delay`]. You can however use a
-    /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
-    /// provided there's at least one other typed tweenable in the sequence.
-    ///
-    /// Panics if the tweenable type is different from the `type_id` parameter,
-    /// which identified the type of the [`Assets`] container storing the asset
-    /// to animate.
-    // pub fn new_asset(
-    //     type_id: TypeId,
-    //     asset_id: UntypedAssetId,
-    //     tweenable: impl Tweenable + 'static,
-    // ) -> Self {
-    //     let tween_type_id = tweenable.type_id().expect(
-    //         "Typeless tweenable like Delay can't be inserted as root tweenable in an animation.",
-    //     );
-    //     assert_eq!(
-    //         type_id, tween_type_id,
-    //         "The tweenable type doesn't match the Assets<A> type of the target asset."
-    //     );
-    //     Self {
-    //         //target: AnimTarget::Entity(target),
-    //         target: AnimTarget::Asset { type_id, asset_id },
-    //         tweenable: Box::new(tweenable),
-    //         state: PlaybackState::Playing,
-    //         speed: 1.,
-    //     }
-    // }
-
     /// Stop animation playback and rewind the animation.
     ///
     /// This changes the animator state to [`PlaybackState::Paused`] and rewinds
@@ -868,6 +1114,32 @@ impl TweenAnim {
 /// identifying an active animation, to the [`TweenAnim`] runtime data of that
 /// animation. Use this resource to lookup animations by ID and modify their
 /// runtime data, for example their playback speed.
+///
+/// If you don't know the [`TweenId`] of an animation, you can also lookup the
+/// set of animations for a given target, either component on an entity or an
+/// asset.
+///
+/// ```
+/// # use bevy::prelude::*;
+/// # use bevy_tweening::*;
+/// # fn xxx() -> Option<()> {
+/// # let mut animator = TweenAnimator::default();
+/// # let entity = Entity::PLACEHOLDER;
+/// # let world = World::default();
+/// # fn make_tween() -> Tween { unimplemented!() }
+/// let target = world.get_component_target::<Transform>(entity)?;
+/// let animations = animator
+///     .iter()
+///     .filter_map(|(_, anim)| {
+///         if anim.target == target {
+///             Some(anim)
+///         } else {
+///             None
+///         }
+///     })
+///     .collect::<Vec<&TweenAnim>>();
+/// # None }
+/// ```
 #[derive(Resource)]
 pub struct TweenAnimator {
     /// Queue of animations currently playing.
@@ -926,29 +1198,41 @@ impl TweenAnimator {
     ///
     /// This function is still useful if you want to store the [`TweenId`] of
     /// the new animation, to later access it to dynamically modify the playback
-    /// (e.g. speed).
+    /// (e.g. speed). To create the target, you can use
+    /// [`WorldTargetExtensions::get_component_target()`].
+    ///
+    /// ```
+    /// # use bevy::prelude::*;
+    /// # use bevy_tweening::{lens::*, *};
+    /// # use std::time::Duration;
+    /// # fn xxx() -> Option<()> {
+    /// # let mut world = World::default();
+    /// # world.register_component::<Transform>();
+    /// # world.register_resource::<TweenAnimator>();
+    /// # world.init_resource::<TweenAnimator>();
+    /// # fn make_tween() -> Tween { unimplemented!() }
+    /// # let tween = make_tween();
+    /// let entity = world.spawn(Transform::default()).id();
+    /// let target = world.get_component_target::<Transform>(entity)?;
+    /// let mut animator = world.resource_mut::<TweenAnimator>();
+    /// let tween_id = animator.add(target.into(), tween);
+    /// // Later, possibly from different system, modify the playback:
+    /// animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
+    /// # None }
+    /// ```
     #[inline]
-    pub fn add<T>(&mut self, target: ComponentTarget, tweenable: T) -> TweenId
+    pub fn add<T>(&mut self, target: AnimTarget, tweenable: T) -> TweenId
     where
         T: Tweenable + 'static,
     {
-        self.anims.insert(TweenAnim::new(target.into(), tweenable))
-    }
-
-    /// Queue a prepared tweenable animation.
-    ///
-    /// See [`make()`] to prepare the animation closure.
-    ///
-    /// [`make()`]: Animator::make
-    #[inline]
-    pub(crate) fn queue(&mut self, target: AnimTarget, tweenable: impl Tweenable + 'static) {
-        self.anims.insert(TweenAnim::new(target, tweenable));
+        self.anims.insert(TweenAnim::new(target, tweenable))
     }
 
     /// Get a tweenable from its ID.
     ///
     /// This fails and returns `None` if the tweenable has completed and was
     /// removed from the animator's internal queue.
+    #[inline]
     pub fn get(&self, id: TweenId) -> Option<&TweenAnim> {
         self.anims.get(id)
     }
@@ -957,16 +1241,19 @@ impl TweenAnimator {
     ///
     /// This fails and returns `None` if the tweenable has completed and was
     /// removed from the animator's internal queue.
+    #[inline]
     pub fn get_mut(&mut self, id: TweenId) -> Option<&mut TweenAnim> {
         self.anims.get_mut(id)
     }
 
-    /// Get an iterator over the active tweens.
+    /// Get an iterator over the queued tweenable animations.
+    #[inline]
     pub fn iter(&self) -> impl Iterator<Item = (TweenId, &TweenAnim)> {
         self.anims.iter()
     }
 
-    /// Get a mutable iterator over the active tweens.
+    /// Get a mutable iterator over the queued tweenable animations.
+    #[inline]
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (TweenId, &mut TweenAnim)> {
         self.anims.iter_mut()
     }
@@ -981,7 +1268,7 @@ impl TweenAnimator {
     /// If you use the [`TweeningPlugin`], this is automatically called by the
     /// animation system the plugin registers. See the
     /// [`AnimationSystem::AnimationUpdate`] system set.
-    pub fn play(
+    pub fn play_all(
         &mut self,
         world: &mut World,
         delta_time: Duration,
diff --git a/src/plugin.rs b/src/plugin.rs
index e081dae..6700b57 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -39,7 +39,7 @@ pub(crate) fn animator_system(world: &mut World) {
     world.resource_scope(|world, events: Mut<Events<TweenCompletedEvent>>| {
         world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
             world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
-                animator.play(world, delta_time, events, anim_events);
+                animator.play_all(world, delta_time, events, anim_events);
             });
         });
     });
@@ -69,7 +69,7 @@ mod tests {
         _phantom: PhantomData<T>,
     }
 
-    impl<T: Component + Default> TestEnv<T> {
+    impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
         /// Create a new test environment containing a single entity with a `T`
         /// component, and add the given animator on that same entity.
         pub fn new(tweenable: impl Tweenable + 'static) -> Self {
@@ -81,11 +81,8 @@ mod tests {
 
             let entity = world.spawn(T::default()).id();
             let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
-                let target = ComponentTarget {
-                    component_id: world.component_id::<T>().unwrap(),
-                    entity,
-                };
-                animator.add(target, tweenable)
+                let target = world.get_component_target::<T>(entity).unwrap();
+                animator.add(target.into(), tweenable)
             });
 
             Self {
diff --git a/src/tweenable.rs b/src/tweenable.rs
index b625c0e..555b4c8 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -636,6 +636,7 @@ impl Tween {
     ///     },
     /// );
     /// ```
+    #[inline]
     #[must_use]
     pub fn new<C, L>(ease_method: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
     where

From 57256eacfa9d34dd154860242450926ccf9539db Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 6 Jul 2025 21:37:13 +0100
Subject: [PATCH 26/66] Create targets via `Components` only

---
 Cargo.toml           |   1 +
 examples/sequence.rs |   6 +-
 src/lib.rs           | 308 ++++++++++++++++++++++++++++++++++++++-----
 src/plugin.rs        |   2 +-
 src/tweenable.rs     |  15 ++-
 5 files changed, 298 insertions(+), 34 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 5dc1294..e0dc9b6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,6 +28,7 @@ bevy_text = ["bevy/bevy_text", "bevy/bevy_render", "bevy/bevy_sprite"]
 # Note: abuse 'bevy_color' to force 'bevy_math/curve' feature, which defines EaseFunction
 bevy = { version = "0.16", default-features = false, features = [ "bevy_color", "bevy_asset" ]}
 slotmap = "1.0"
+thiserror = "2.0.12"
 
 [dev-dependencies]
 bevy-inspector-egui = { version = "0.31" }
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 17ffd7a..3c7eeb1 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -54,6 +54,7 @@ struct ProgressValue;
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
+    components: &Components,
     mut animator: ResMut<TweenAnimator>,
 ) {
     commands.spawn(Camera2d::default());
@@ -170,8 +171,9 @@ fn setup(
         // Because we want to monitor the progress of the animations, we need to fetch
         // their TweenId. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
-        let path_tween_id = animator.add(entity, anim_move_along_path);
-        let rotate_tween_id = animator.add(entity, anim_rotate_back_and_forth);
+        let target = ComponentTarget::new::<Transform>(components, entity).into();
+        let path_tween_id = animator.add(target, anim_move_along_path);
+        let rotate_tween_id = animator.add(target, anim_rotate_back_and_forth);
         commands.entity(entity).insert(RedSprite {
             path_tween_id,
             rotate_tween_id,
diff --git a/src/lib.rs b/src/lib.rs
index fe0d4f8..47ce710 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -240,13 +240,13 @@
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
 //! [`TransformPositionLens`]: crate::lens::TransformPositionLens
 
-use std::time::Duration;
+use std::{any::TypeId, time::Duration};
 
 use bevy::{
     asset::UntypedAssetId,
     ecs::{
         change_detection::MutUntyped,
-        component::{ComponentId, Mutable},
+        component::{ComponentId, Components, Mutable},
     },
     platform::collections::HashMap,
     prelude::*,
@@ -254,6 +254,7 @@ use bevy::{
 pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
 use slotmap::{new_key_type, SlotMap};
+use thiserror::Error;
 pub use tweenable::{
     BoxedTweenable, Delay, Sequence, TotalDuration, Tween, TweenAssetExtensions,
     TweenCompletedEvent, TweenState, Tweenable,
@@ -370,7 +371,7 @@ impl std::ops::Not for PlaybackState {
 /// while the "shape" of the animation is controlled independently.
 ///
 /// Default: `EaseFunction::Linear`.
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 pub enum EaseMethod {
     /// Follow [`EaseFunction`].
     EaseFunction(EaseFunction),
@@ -875,6 +876,29 @@ pub struct AnimCompletedEvent {
     pub target: AnimTarget,
 }
 
+/// Errors returned by various animation functions.
+#[derive(Debug, Error)]
+pub enum TweeningError {
+    /// The component of the given type is not registered.
+    #[error("Component of type {0:?} is not registered in the World.")]
+    ComponentNotRegistered(TypeId),
+    /// The asset container for the given asset type is not registered.
+    #[error("Asset container Assets<A> for asset type A = {0:?} is not registered in the World.")]
+    AssetNotRegistered(TypeId),
+    /// The asset ID references a different type than expected.
+    #[error("Expected type of asset ID to be {expected:?} but got {actual:?} instead.")]
+    InvalidAssetIdType {
+        /// The expected asset type.
+        expected: TypeId,
+        /// The actual type the asset ID references.
+        actual: TypeId,
+    },
+    /// Expected [`Tweenable::type_id()`] to return a value, but it returned
+    /// `None`.
+    #[error("Expected a typed Tweenable, got {0:?} instead.")]
+    UntypedTweenable(BoxedTweenable),
+}
+
 /// Component animation target.
 ///
 /// References a component used as the target of a tweenable animation. The
@@ -892,6 +916,37 @@ pub struct ComponentTarget {
     pub entity: Entity,
 }
 
+impl ComponentTarget {
+    /// Create a new component target.
+    pub fn new<C: Component<Mutability = Mutable>>(
+        components: &Components,
+        entity: Entity,
+    ) -> Result<Self, TweeningError> {
+        let component_id = components
+            .component_id::<C>()
+            .ok_or(TweeningError::ComponentNotRegistered(TypeId::of::<C>()))?;
+        Ok(Self {
+            component_id,
+            entity,
+        })
+    }
+
+    /// Create a new component target from a component type ID.
+    pub fn new_untyped(
+        components: &Components,
+        type_id: TypeId,
+        entity: Entity,
+    ) -> Result<Self, TweeningError> {
+        let component_id = components
+            .get_id(type_id)
+            .ok_or(TweeningError::ComponentNotRegistered(type_id))?;
+        Ok(Self {
+            component_id,
+            entity,
+        })
+    }
+}
+
 /// Asset animation target.
 ///
 /// References an asset used as the target of a tweenable animation. The asset
@@ -909,6 +964,44 @@ pub struct AssetTarget {
     pub asset_id: UntypedAssetId,
 }
 
+impl AssetTarget {
+    /// Create a new asset target.
+    pub fn new<A: Asset>(
+        components: &Components,
+        asset_id: impl Into<AssetId<A>>,
+    ) -> Result<Self, TweeningError> {
+        let resource_id = components
+            .resource_id::<Assets<A>>()
+            .ok_or(TweeningError::AssetNotRegistered(TypeId::of::<A>()))?;
+        Ok(Self {
+            resource_id,
+            asset_id: asset_id.into().untyped(),
+        })
+    }
+
+    /// Create a new asset target from an `Assets<A>` type ID.
+    pub fn new_untyped(
+        components: &Components,
+        type_id: TypeId,
+        asset_id: impl Into<UntypedAssetId>,
+    ) -> Result<Self, TweeningError> {
+        let asset_id = asset_id.into();
+        if asset_id.type_id() != type_id {
+            return Err(TweeningError::InvalidAssetIdType {
+                expected: type_id,
+                actual: asset_id.type_id(),
+            });
+        }
+        let resource_id = components
+            .get_resource_id(type_id)
+            .ok_or(TweeningError::AssetNotRegistered(type_id))?;
+        Ok(Self {
+            resource_id,
+            asset_id,
+        })
+    }
+}
+
 /// Animation target.
 ///
 /// References either a component or an asset used as the target of a tweenable
@@ -1169,6 +1262,79 @@ impl Default for TweenAnimator {
 }
 
 impl TweenAnimator {
+    /// Add a new animation to the animator queue.
+    ///
+    /// This is the lowest level animation queueing function. In general you
+    /// don't need to call this directly. Instead, you have a few more
+    /// convenient options:
+    /// - use the extensions provided by [`EntityCommandsTweeningExtensions`] to
+    ///   directly create and queue tweenable animations on a given
+    ///   [`EntityCommands`], like this:
+    ///
+    ///   ```
+    ///   # use bevy::prelude::*;
+    ///   # use bevy_tweening::{lens::*, *};
+    ///   # use std::time::Duration;
+    ///   # let mut world = World::default();
+    ///   # world.register_component::<Transform>();
+    ///   # world.register_resource::<TweenAnimator>();
+    ///   # world.init_resource::<TweenAnimator>();
+    ///   # let entity = world.spawn_empty().id();
+    ///   let tween = Tween::new(
+    ///       EaseFunction::QuadraticInOut,
+    ///       Duration::from_secs(1),
+    ///       TransformPositionLens {
+    ///           start: Vec3::ZERO,
+    ///           end: Vec3::new(3.5, 0., 0.),
+    ///       },
+    ///   );
+    ///   world.entity_mut(entity).tween(tween);
+    ///   ```
+    ///
+    /// - use [`add_component()`] or [`add_asset()`], which take care of
+    ///   creating the [`AnimTarget`] for you.
+    ///
+    /// To create a component target, you can either use:
+    /// - [`get_component_target()`] if you have access to the [`World`]; or
+    /// - [`ComponentTarget::new()`] or [`ComponentTarget::new_untyped()`]
+    ///   otherwise.
+    ///
+    /// To create an asset target, you can either use:
+    /// - [`get_asset_target()`] if you have access to the [`World`]; or
+    /// - [`AssetTarget::new()`] or [`AssetTarget::new_untyped()`] otherwise.
+    ///
+    /// ```
+    /// # use bevy::prelude::*;
+    /// # use bevy_tweening::{lens::*, *};
+    /// # use std::time::Duration;
+    /// # fn xxx() -> Option<()> {
+    /// # let mut world = World::default();
+    /// # world.register_component::<Transform>();
+    /// # world.register_resource::<TweenAnimator>();
+    /// # world.init_resource::<TweenAnimator>();
+    /// # fn make_tween() -> Tween { unimplemented!() }
+    /// # let tween = make_tween();
+    /// let entity = world.spawn(Transform::default()).id();
+    /// let target = world.get_component_target::<Transform>(entity)?;
+    /// let mut animator = world.resource_mut::<TweenAnimator>();
+    /// let tween_id = animator.add(target.into(), tween);
+    /// // Later, possibly from different system, modify the playback:
+    /// animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
+    /// # None }
+    /// ```
+    ///
+    /// [`add_component()`]: Self::add_component
+    /// [`add_asset()`]: Self::add_asset
+    /// [`get_component_target()`]: WorldTargetExtensions::get_component_target
+    /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
+    #[inline]
+    pub fn add<T>(&mut self, target: AnimTarget, tweenable: T) -> TweenId
+    where
+        T: Tweenable + 'static,
+    {
+        self.anims.insert(TweenAnim::new(target, tweenable))
+    }
+
     /// Add a new component animation to the animator queue.
     ///
     /// In general you don't need to call this directly. Instead, use the
@@ -1198,48 +1364,130 @@ impl TweenAnimator {
     ///
     /// This function is still useful if you want to store the [`TweenId`] of
     /// the new animation, to later access it to dynamically modify the playback
-    /// (e.g. speed). To create the target, you can use
-    /// [`WorldTargetExtensions::get_component_target()`].
+    /// (e.g. speed).
     ///
     /// ```
-    /// # use bevy::prelude::*;
+    /// # use bevy::{prelude::*, ecs::component::Components};
     /// # use bevy_tweening::{lens::*, *};
     /// # use std::time::Duration;
-    /// # fn xxx() -> Option<()> {
-    /// # let mut world = World::default();
-    /// # world.register_component::<Transform>();
-    /// # world.register_resource::<TweenAnimator>();
-    /// # world.init_resource::<TweenAnimator>();
     /// # fn make_tween() -> Tween { unimplemented!() }
-    /// # let tween = make_tween();
-    /// let entity = world.spawn(Transform::default()).id();
-    /// let target = world.get_component_target::<Transform>(entity)?;
-    /// let mut animator = world.resource_mut::<TweenAnimator>();
-    /// let tween_id = animator.add(target.into(), tween);
-    /// // Later, possibly from different system, modify the playback:
-    /// animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
-    /// # None }
+    /// // Helper component to store a TweenId
+    /// #[derive(Component)]
+    /// struct MyTweenId(pub TweenId);
+    ///
+    /// // System which spawns the component and its animation
+    /// fn my_spawn_system(
+    ///     mut commands: Commands,
+    ///     components: &Components,
+    ///     mut animator: ResMut<TweenAnimator>,
+    /// ) -> Result<()> {
+    ///     # let tween = make_tween();
+    ///     let entity = commands.spawn(Transform::default()).id();
+    ///     // The component type is deducted from `tween` here
+    ///     let tween_id = animator.add_component(components, entity, tween)?;
+    ///     // Save the new TweenId for later use
+    ///     commands.entity(entity).insert(MyTweenId(tween_id));
+    ///     Ok(())
+    /// }
+    ///
+    /// // System which modifies the animation playback
+    /// fn my_use_system(mut animator: ResMut<TweenAnimator>, query: Query<&MyTweenId>) -> Option<()> {
+    ///     let tween_id = query.single().ok()?.0;
+    ///     animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
+    ///     Some(())
+    /// }
     /// ```
+    ///
+    /// [`add()`]: Self::add
     #[inline]
-    pub fn add<T>(&mut self, target: AnimTarget, tweenable: T) -> TweenId
+    pub fn add_component<T>(
+        &mut self,
+        components: &Components,
+        entity: Entity,
+        tweenable: T,
+    ) -> Result<TweenId, TweeningError>
     where
         T: Tweenable + 'static,
     {
-        self.anims.insert(TweenAnim::new(target, tweenable))
+        let Some(type_id) = tweenable.type_id() else {
+            return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
+        };
+        let target = ComponentTarget::new_untyped(components, type_id, entity)?.into();
+        Ok(self.add(target, tweenable))
+    }
+
+    /// Add a new asset animation to the animator queue.
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::{lens::*, *};
+    /// # use std::time::Duration;
+    /// # fn make_tween() -> Tween { unimplemented!() }
+    /// #[derive(Asset, TypePath)]
+    /// struct MyAsset;
+    ///
+    /// // Helper component to store a TweenId
+    /// #[derive(Resource)]
+    /// struct MyTweenId(pub TweenId);
+    ///
+    /// // System which spawns the asset animation
+    /// fn my_spawn_system(
+    ///     mut assets: ResMut<Assets<MyAsset>>,
+    ///     components: &Components,
+    ///     mut animator: ResMut<TweenAnimator>,
+    ///     mut my_tween_id: ResMut<MyTweenId>,
+    /// ) -> Result<()> {
+    ///     # let tween = make_tween();
+    ///     let handle = assets.add(MyAsset);
+    ///     // The asset type is deducted from `tween` here
+    ///     let tween_id = animator.add_asset(components, handle.id().untyped(), tween)?;
+    ///     // Save the new TweenId for later use
+    ///     my_tween_id.0 = tween_id;
+    ///     Ok(())
+    /// }
+    ///
+    /// // System which modifies the animation playback
+    /// fn my_use_system(
+    ///     mut animator: ResMut<TweenAnimator>,
+    ///     my_tween_id: Res<MyTweenId>,
+    /// ) -> Option<()> {
+    ///     let tween_id = my_tween_id.0;
+    ///     animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
+    ///     Some(())
+    /// }
+    /// ```
+    ///
+    /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
+    /// [`add()`]: Self::add
+    #[inline]
+    pub fn add_asset<T>(
+        &mut self,
+        components: &Components,
+        asset_id: UntypedAssetId,
+        tweenable: T,
+    ) -> Result<TweenId, TweeningError>
+    where
+        T: Tweenable + 'static,
+    {
+        let Some(type_id) = tweenable.type_id() else {
+            return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
+        };
+        let target = AssetTarget::new_untyped(components, type_id, asset_id)?.into();
+        Ok(self.add(target, tweenable))
     }
 
-    /// Get a tweenable from its ID.
+    /// Get a queued tweenable animation from its ID.
     ///
-    /// This fails and returns `None` if the tweenable has completed and was
+    /// This fails and returns `None` if the animation has completed and was
     /// removed from the animator's internal queue.
     #[inline]
     pub fn get(&self, id: TweenId) -> Option<&TweenAnim> {
         self.anims.get(id)
     }
 
-    /// Get a tweenable from its ID.
+    /// Get a queued tweenable animation from its ID.
     ///
-    /// This fails and returns `None` if the tweenable has completed and was
+    /// This fails and returns `None` if the animation has completed and was
     /// removed from the animator's internal queue.
     #[inline]
     pub fn get_mut(&mut self, id: TweenId) -> Option<&mut TweenAnim> {
@@ -1258,17 +1506,17 @@ impl TweenAnimator {
         self.anims.iter_mut()
     }
 
-    /// Play all queued animations.
+    /// Step all queued animations.
     ///
     /// Loop over the internal queue of tweenable animations, apply them to
-    /// their respective target [`Entity`], and prune all the completed
-    /// ones (the ones returning [`TweenState::Completed`]). In the later case,
-    /// send [`TweenCompletedEvent`]s if enabled on each individual tweenable.
+    /// their respective target, and prune all the completed ones (the ones
+    /// returning [`TweenState::Completed`]). In the later case, send
+    /// [`TweenCompletedEvent`]s if enabled on each individual tweenable.
     ///
     /// If you use the [`TweeningPlugin`], this is automatically called by the
     /// animation system the plugin registers. See the
     /// [`AnimationSystem::AnimationUpdate`] system set.
-    pub fn play_all(
+    pub fn step_all(
         &mut self,
         world: &mut World,
         delta_time: Duration,
diff --git a/src/plugin.rs b/src/plugin.rs
index 6700b57..990b719 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -39,7 +39,7 @@ pub(crate) fn animator_system(world: &mut World) {
     world.resource_scope(|world, events: Mut<Events<TweenCompletedEvent>>| {
         world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
             world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
-                animator.play_all(world, delta_time, events, anim_events);
+                animator.step_all(world, delta_time, events, anim_events);
             });
         });
     });
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 555b4c8..89d3284 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -33,6 +33,7 @@ use crate::{
 /// # use bevy::prelude::*;
 /// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompletedEvent, TweenState, TotalDuration};
 /// #
+/// # #[derive(Debug)]
 /// # struct MyTweenable;
 /// # impl Tweenable for MyTweenable {
 /// #     fn cycle_duration(&self) -> Duration  { unimplemented!() }
@@ -411,7 +412,7 @@ impl Ord for TotalDuration {
 }
 
 /// An animatable entity, either a single [`Tween`] or a collection of them.
-pub trait Tweenable: Send + Sync {
+pub trait Tweenable: std::fmt::Debug + Send + Sync {
     /// Get the duration of a single cycle of the animation.
     ///
     /// Note that for [`RepeatStrategy::MirroredRepeat`], this is the duration
@@ -575,7 +576,17 @@ enum TweenAction {
     Asset(Box<TargetAction>),
 }
 
+impl std::fmt::Debug for TweenAction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TweenAction::Component(..) => write!(f, "TweenAction::Component"),
+            TweenAction::Asset(..) => write!(f, "TweenAction::Asset"),
+        }
+    }
+}
+
 /// Single tweening animation instance.
+#[derive(Debug)]
 pub struct Tween {
     ease_method: EaseMethod,
     clock: AnimClock,
@@ -981,6 +992,7 @@ impl Tweenable for Tween {
 }
 
 /// A sequence of tweens played back in order one after the other.
+#[derive(Debug)]
 pub struct Sequence {
     tweens: Vec<BoxedTweenable>,
     index: usize,
@@ -1182,6 +1194,7 @@ impl Tweenable for Sequence {
 /// 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.
+#[derive(Debug)]
 pub struct Delay {
     timer: Timer,
     system_id: Option<SystemId>,

From 814b95189a0e8f74724e1030ea019d3a33d92489 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 12 Jul 2025 17:07:02 +0100
Subject: [PATCH 27/66] Fix asset resolver

---
 examples/colormaterial_color.rs |  7 ++++--
 examples/sequence.rs            | 20 +++++++++--------
 src/lib.rs                      | 40 +++++++++++++++++++++++----------
 3 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/examples/colormaterial_color.rs b/examples/colormaterial_color.rs
index 4c60fa7..e5b2352 100644
--- a/examples/colormaterial_color.rs
+++ b/examples/colormaterial_color.rs
@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use bevy::{color::palettes::css::*, prelude::*};
+use bevy::{color::palettes::css::*, ecs::component::Components, prelude::*};
 use bevy_tweening::{lens::*, *};
 
 mod utils;
@@ -23,6 +23,7 @@ fn main() {
 }
 
 fn setup(
+    components: &Components,
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
@@ -89,7 +90,9 @@ fn setup(
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        animator.add_asset(unique_material.id(), tween);
+        if let Err(err) = animator.add_asset(components, unique_material.id(), tween) {
+            println!("Failed to add asset animation: {err:?}");
+        }
 
         commands.spawn((
             Mesh2d(quad_mesh.clone()),
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 3c7eeb1..a527945 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use bevy::{color::palettes::css::*, prelude::*};
+use bevy::{color::palettes::css::*, ecs::component::Components, prelude::*};
 use bevy_tweening::{lens::*, *};
 
 mod utils;
@@ -56,7 +56,7 @@ fn setup(
     asset_server: Res<AssetServer>,
     components: &Components,
     mut animator: ResMut<TweenAnimator>,
-) {
+) -> Result<()> {
     commands.spawn(Camera2d::default());
 
     let font = asset_server.load("fonts/FiraMono-Regular.ttf");
@@ -171,9 +171,9 @@ fn setup(
         // Because we want to monitor the progress of the animations, we need to fetch
         // their TweenId. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
-        let target = ComponentTarget::new::<Transform>(components, entity).into();
-        let path_tween_id = animator.add(target, anim_move_along_path);
-        let rotate_tween_id = animator.add(target, anim_rotate_back_and_forth);
+        let path_tween_id = animator.add_component(components, entity, anim_move_along_path)?;
+        let rotate_tween_id =
+            animator.add_component(components, entity, anim_rotate_back_and_forth)?;
         commands.entity(entity).insert(RedSprite {
             path_tween_id,
             rotate_tween_id,
@@ -249,13 +249,15 @@ fn setup(
         // Because we want to monitor the progress of the animations, we need to fetch
         // their TweenId. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
-        let move_and_rotate_tween_id = animator.add(entity, seq1);
-        let scale_tween_id = animator.add(entity, seq2);
+        let move_and_rotate_tween_id = animator.add_component(components, entity, seq1)?;
+        let scale_tween_id = animator.add_component(components, entity, seq2)?;
         commands.entity(entity).insert(BlueSprite {
             move_and_rotate_tween_id,
             scale_tween_id,
         });
     }
+
+    Ok(())
 }
 
 fn update_text(
@@ -289,8 +291,8 @@ fn update_text(
 
     for ev in q_event_completed.read() {
         println!(
-            "Event: TweenCompletedEvent tween_id={:?} entity={:?}",
-            ev.id, ev.entity
+            "Event: TweenCompletedEvent tween_id={:?} target={:?}",
+            ev.id, ev.target
         );
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 47ce710..b95e797 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -986,12 +986,7 @@ impl AssetTarget {
         asset_id: impl Into<UntypedAssetId>,
     ) -> Result<Self, TweeningError> {
         let asset_id = asset_id.into();
-        if asset_id.type_id() != type_id {
-            return Err(TweeningError::InvalidAssetIdType {
-                expected: type_id,
-                actual: asset_id.type_id(),
-            });
-        }
+        // Note: asset_id.type_id() is A, whereas type_id is Assets<A>
         let resource_id = components
             .get_resource_id(type_id)
             .ok_or(TweeningError::AssetNotRegistered(type_id))?;
@@ -1244,7 +1239,7 @@ pub struct TweenAnimator {
     asset_resolver: HashMap<
         ComponentId,
         Box<
-            dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> MutUntyped<'w>
+            dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
                 + Send
                 + Sync
                 + 'static,
@@ -1460,10 +1455,10 @@ impl TweenAnimator {
     /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
     /// [`add()`]: Self::add
     #[inline]
-    pub fn add_asset<T>(
+    pub fn add_asset<T, A: Asset>(
         &mut self,
         components: &Components,
-        asset_id: UntypedAssetId,
+        asset_id: impl Into<AssetId<A>>,
         tweenable: T,
     ) -> Result<TweenId, TweeningError>
     where
@@ -1472,8 +1467,29 @@ impl TweenAnimator {
         let Some(type_id) = tweenable.type_id() else {
             return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
         };
-        let target = AssetTarget::new_untyped(components, type_id, asset_id)?.into();
-        Ok(self.add(target, tweenable))
+        if type_id != TypeId::of::<Assets<A>>() {
+            return Err(TweeningError::InvalidAssetIdType {
+                expected: TypeId::of::<Assets<A>>(),
+                actual: type_id,
+            });
+        }
+        let asset_id = asset_id.into();
+        let target = AssetTarget::new_untyped(components, type_id, asset_id.untyped())?;
+        self.asset_resolver.insert(
+            target.resource_id,
+            Box::new(
+                |assets: MutUntyped, asset_id: UntypedAssetId| -> Option<MutUntyped> {
+                    // SAFETY: The correct type is captured from the outer function
+                    #[allow(unsafe_code)]
+                    let assets = unsafe { assets.with_type::<Assets<A>>() };
+                    let asset_id = asset_id.try_typed::<A>().ok()?;
+                    assets
+                        .filter_map_unchanged(|assets| assets.get_mut(asset_id))
+                        .map(Into::into)
+                },
+            ),
+        );
+        Ok(self.add(target.into(), tweenable))
     }
 
     /// Get a queued tweenable animation from its ID.
@@ -1545,7 +1561,7 @@ impl TweenAnimator {
                 }) => {
                     if let Some(assets) = world.get_resource_mut_by_id(*resource_id) {
                         if let Some(resolver) = self.asset_resolver.get(resource_id) {
-                            Some(resolver(assets, *asset_id))
+                            resolver(assets, *asset_id)
                         } else {
                             None
                         }

From 535f425edb6fcb6a1a4b13d2f1b7d37768f58188 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 12 Jul 2025 17:29:10 +0100
Subject: [PATCH 28/66] Minor doc fix

---
 src/lib.rs | 46 ++++++++++++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 18 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index b95e797..8922eea 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1203,30 +1203,40 @@ impl TweenAnim {
 /// animation. Use this resource to lookup animations by ID and modify their
 /// runtime data, for example their playback speed.
 ///
+/// # Animation pruning
+///
+/// Animations queued into the [`TweenAnimator`] by default are pruned
+/// automatically on completion.
+///
+/// # Lookup without `TweenId`
+///
 /// If you don't know the [`TweenId`] of an animation, you can also lookup the
 /// set of animations for a given target, either component on an entity or an
 /// asset.
 ///
 /// ```
-/// # use bevy::prelude::*;
+/// # use bevy::{prelude::*, ecs::component::Components};
 /// # use bevy_tweening::*;
-/// # fn xxx() -> Option<()> {
-/// # let mut animator = TweenAnimator::default();
+/// fn my_system(components: &Components, animator: Res<TweenAnimator>) -> Result<()> {
 /// # let entity = Entity::PLACEHOLDER;
-/// # let world = World::default();
-/// # fn make_tween() -> Tween { unimplemented!() }
-/// let target = world.get_component_target::<Transform>(entity)?;
-/// let animations = animator
-///     .iter()
-///     .filter_map(|(_, anim)| {
-///         if anim.target == target {
-///             Some(anim)
-///         } else {
-///             None
-///         }
-///     })
-///     .collect::<Vec<&TweenAnim>>();
-/// # None }
+///     // Create an AnimTarget::Component() from an Entity and a component type
+///     // let entity = ...
+///     let target = ComponentTarget::new::<Transform>(components, entity)?.into();
+///
+///     // Lookup all active animations and filter by target
+///     let animations: Vec<&TweenAnim> = animator
+///         .iter()
+///         .filter_map(|(_id, anim)| {
+///             if anim.target == target {
+///                 Some(anim)
+///             } else {
+///                 None
+///             }
+///         })
+///         .collect::<_>();
+///
+///     Ok(())
+/// }
 /// ```
 #[derive(Resource)]
 pub struct TweenAnimator {
@@ -1435,7 +1445,7 @@ impl TweenAnimator {
     ///     # let tween = make_tween();
     ///     let handle = assets.add(MyAsset);
     ///     // The asset type is deducted from `tween` here
-    ///     let tween_id = animator.add_asset(components, handle.id().untyped(), tween)?;
+    ///     let tween_id = animator.add_asset(components, handle.id(), tween)?;
     ///     // Save the new TweenId for later use
     ///     my_tween_id.0 = tween_id;
     ///     Ok(())

From f1b608665caea2c54917ec343e17cae109d94804 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 12 Jul 2025 17:48:07 +0100
Subject: [PATCH 29/66] Remove dangerous `TweenAnimator::add()`

This doesn't work with assets because we can't register the asset resolver.
---
 src/lib.rs    | 144 +++++++++++++-------------------------------------
 src/plugin.rs |   2 +-
 2 files changed, 38 insertions(+), 108 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 8922eea..304ffc4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -172,7 +172,7 @@
 //! Although you generally should prefer using the various extensions on
 //! commands, like the `.tween()` function on entity commands, under the hood
 //! the manual process of queuing a new animation involves calling
-//! `TweenAnimator::add()`.
+//! `TweenAnimator::add_component()` or `TweenAnimator::add_asset()`.
 //!
 //! ```no_run
 //! # use bevy::prelude::*;
@@ -181,13 +181,12 @@
 //! # let mut animator = TweenAnimator::default();
 //! # let entity = Entity::PLACEHOLDER;
 //! # let world = World::default();
+//! # let components = world.components();
 //! # fn make_tween() -> Tween { unimplemented!() }
-//! // Create a target referencing the Transform component of a given entity
-//! let target = world.get_component_target::<Transform>(entity)?;
 //! // Create a tween animation description
 //! let tween: Tween = make_tween();
-//! // Enqueue a new animation instance
-//! let tween_id = animator.add(target, tween);
+//! // Enqueue a new component animation instance
+//! let tween_id = animator.add_component(components, entity, tween);
 //! # None }
 //! ```
 //!
@@ -520,10 +519,10 @@ new_key_type! {
 pub trait EntityCommandsTweeningExtensions<'a> {
     /// Queue the given [`Tweenable`].
     ///
-    /// This calls [`TweenAnimator::add()`] on the current entity, deriving the
-    /// proper component to animate based on the type of the lens stored in the
-    /// tweenable (see [`Tweenable::type_id()`]). That component must exists on
-    /// the entity.
+    /// This calls [`TweenAnimator::add_component()`] on the current entity,
+    /// deriving the proper component to animate based on the type of the
+    /// lens stored inside the tweenable (see [`Tweenable::type_id()`]). That
+    /// component must exists on the entity.
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
     where
         T: Tweenable + 'static;
@@ -542,7 +541,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`TweenId`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add()`].
+    /// [`TweenAnimator::add_component()`].
     ///
     /// # Example
     ///
@@ -582,7 +581,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`TweenId`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add()`].
+    /// [`TweenAnimator::add_component()`].
     ///
     /// # Example
     ///
@@ -622,7 +621,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`TweenId`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add()`].
+    /// [`TweenAnimator::add_component()`].
     ///
     /// # Example
     ///
@@ -662,7 +661,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`TweenId`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add()`].
+    /// [`TweenAnimator::add_component()`].
     ///
     /// # Example
     ///
@@ -762,7 +761,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add(target.into(), tweenable);
+                .add_component_impl(target.into(), tweenable);
         });
         self
     }
@@ -782,7 +781,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add(target.into(), tween);
+                .add_component_impl(target.into(), tween);
         });
         self
     }
@@ -802,7 +801,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add(target.into(), tween);
+                .add_component_impl(target.into(), tween);
         });
         self
     }
@@ -820,7 +819,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add(target.into(), tween);
+                .add_component_impl(target.into(), tween);
         });
         self
     }
@@ -838,7 +837,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add(target.into(), tween);
+                .add_component_impl(target.into(), tween);
         });
         self
     }
@@ -1097,7 +1096,7 @@ pub trait WorldTargetExtensions {
     fn get_component_target<C: Component<Mutability = Mutable>>(
         &self,
         entity: Entity,
-    ) -> Option<AnimTarget>;
+    ) -> Option<ComponentTarget>;
 
     /// Get an [`AnimTarget`] for the given asset type and ID pair.
     ///
@@ -1110,40 +1109,34 @@ pub trait WorldTargetExtensions {
     /// Returns the animation target referencing the asset instance, or
     /// `None` if either the ID doesn't reference an existing asset or the asset
     /// type is not registered.
-    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AnimTarget>;
+    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetTarget>;
 }
 
 impl WorldTargetExtensions for World {
     fn get_component_target<C: Component<Mutability = Mutable>>(
         &self,
         entity: Entity,
-    ) -> Option<AnimTarget> {
+    ) -> Option<ComponentTarget> {
         let component_id = self.component_id::<C>()?;
         if !self.entities().contains(entity) {
             return None;
         }
-        Some(
-            ComponentTarget {
-                component_id,
-                entity,
-            }
-            .into(),
-        )
+        Some(ComponentTarget {
+            component_id,
+            entity,
+        })
     }
 
-    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AnimTarget> {
+    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetTarget> {
         let id = id.into();
         if !self.resource::<Assets<A>>().contains(id) {
             return None;
         }
         let resource_id = self.resource_id::<Assets<A>>()?;
-        Some(
-            AssetTarget {
-                resource_id,
-                asset_id: id.untyped(),
-            }
-            .into(),
-        )
+        Some(AssetTarget {
+            resource_id,
+            asset_id: id.untyped(),
+        })
     }
 }
 
@@ -1203,10 +1196,10 @@ impl TweenAnim {
 /// animation. Use this resource to lookup animations by ID and modify their
 /// runtime data, for example their playback speed.
 ///
-/// # Animation pruning
+/// # Active animations
 ///
 /// Animations queued into the [`TweenAnimator`] by default are pruned
-/// automatically on completion.
+/// automatically on completion, and only active animations are retained.
 ///
 /// # Lookup without `TweenId`
 ///
@@ -1246,6 +1239,8 @@ pub struct TweenAnimator {
     /// `Assets<A>`, untyped `AssetId` } into an untyped pointer to the asset A
     /// itself. This is necessary because there's no UntypedAssets interface in
     /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
+    /// The resolver is allowed to fail (return `None`), for example when the
+    /// asset ID doesn't reference a valid asset.
     asset_resolver: HashMap<
         ComponentId,
         Box<
@@ -1267,77 +1262,12 @@ impl Default for TweenAnimator {
 }
 
 impl TweenAnimator {
-    /// Add a new animation to the animator queue.
-    ///
-    /// This is the lowest level animation queueing function. In general you
-    /// don't need to call this directly. Instead, you have a few more
-    /// convenient options:
-    /// - use the extensions provided by [`EntityCommandsTweeningExtensions`] to
-    ///   directly create and queue tweenable animations on a given
-    ///   [`EntityCommands`], like this:
-    ///
-    ///   ```
-    ///   # use bevy::prelude::*;
-    ///   # use bevy_tweening::{lens::*, *};
-    ///   # use std::time::Duration;
-    ///   # let mut world = World::default();
-    ///   # world.register_component::<Transform>();
-    ///   # world.register_resource::<TweenAnimator>();
-    ///   # world.init_resource::<TweenAnimator>();
-    ///   # let entity = world.spawn_empty().id();
-    ///   let tween = Tween::new(
-    ///       EaseFunction::QuadraticInOut,
-    ///       Duration::from_secs(1),
-    ///       TransformPositionLens {
-    ///           start: Vec3::ZERO,
-    ///           end: Vec3::new(3.5, 0., 0.),
-    ///       },
-    ///   );
-    ///   world.entity_mut(entity).tween(tween);
-    ///   ```
-    ///
-    /// - use [`add_component()`] or [`add_asset()`], which take care of
-    ///   creating the [`AnimTarget`] for you.
-    ///
-    /// To create a component target, you can either use:
-    /// - [`get_component_target()`] if you have access to the [`World`]; or
-    /// - [`ComponentTarget::new()`] or [`ComponentTarget::new_untyped()`]
-    ///   otherwise.
-    ///
-    /// To create an asset target, you can either use:
-    /// - [`get_asset_target()`] if you have access to the [`World`]; or
-    /// - [`AssetTarget::new()`] or [`AssetTarget::new_untyped()`] otherwise.
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use std::time::Duration;
-    /// # fn xxx() -> Option<()> {
-    /// # let mut world = World::default();
-    /// # world.register_component::<Transform>();
-    /// # world.register_resource::<TweenAnimator>();
-    /// # world.init_resource::<TweenAnimator>();
-    /// # fn make_tween() -> Tween { unimplemented!() }
-    /// # let tween = make_tween();
-    /// let entity = world.spawn(Transform::default()).id();
-    /// let target = world.get_component_target::<Transform>(entity)?;
-    /// let mut animator = world.resource_mut::<TweenAnimator>();
-    /// let tween_id = animator.add(target.into(), tween);
-    /// // Later, possibly from different system, modify the playback:
-    /// animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
-    /// # None }
-    /// ```
-    ///
-    /// [`add_component()`]: Self::add_component
-    /// [`add_asset()`]: Self::add_asset
-    /// [`get_component_target()`]: WorldTargetExtensions::get_component_target
-    /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
     #[inline]
-    pub fn add<T>(&mut self, target: AnimTarget, tweenable: T) -> TweenId
+    fn add_component_impl<T>(&mut self, target: ComponentTarget, tweenable: T) -> TweenId
     where
         T: Tweenable + 'static,
     {
-        self.anims.insert(TweenAnim::new(target, tweenable))
+        self.anims.insert(TweenAnim::new(target.into(), tweenable))
     }
 
     /// Add a new component animation to the animator queue.
@@ -1418,7 +1348,7 @@ impl TweenAnimator {
             return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
         };
         let target = ComponentTarget::new_untyped(components, type_id, entity)?.into();
-        Ok(self.add(target, tweenable))
+        Ok(self.anims.insert(TweenAnim::new(target, tweenable)))
     }
 
     /// Add a new asset animation to the animator queue.
@@ -1499,7 +1429,7 @@ impl TweenAnimator {
                 },
             ),
         );
-        Ok(self.add(target.into(), tweenable))
+        Ok(self.anims.insert(TweenAnim::new(target.into(), tweenable)))
     }
 
     /// Get a queued tweenable animation from its ID.
diff --git a/src/plugin.rs b/src/plugin.rs
index 990b719..6a12b40 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -82,7 +82,7 @@ mod tests {
             let entity = world.spawn(T::default()).id();
             let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
                 let target = world.get_component_target::<T>(entity).unwrap();
-                animator.add(target.into(), tweenable)
+                animator.add_component_impl(target, tweenable)
             });
 
             Self {

From 7976b5e1f2e538972a57b223ade247e3bfbd1acc Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 13 Jul 2025 12:12:55 +0200
Subject: [PATCH 30/66] Enable retaining completed animations

---
 src/lib.rs        | 226 +++++++++++++++++++++++++++++++---------------
 src/plugin.rs     | 129 ++++----------------------
 src/test_utils.rs | 131 +++++++++++++++++++++++++++
 src/tweenable.rs  |  39 ++++++--
 4 files changed, 335 insertions(+), 190 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 304ffc4..e5cb574 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -761,7 +761,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add_component_impl(target.into(), tweenable);
+                .add_component_target(target.into(), tweenable);
         });
         self
     }
@@ -781,7 +781,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add_component_impl(target.into(), tween);
+                .add_component_target(target.into(), tween);
         });
         self
     }
@@ -801,7 +801,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add_component_impl(target.into(), tween);
+                .add_component_target(target.into(), tween);
         });
         self
     }
@@ -819,7 +819,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add_component_impl(target.into(), tween);
+                .add_component_target(target.into(), tween);
         });
         self
     }
@@ -837,7 +837,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.world_scope(|world: &mut World| {
             world
                 .resource_mut::<TweenAnimator>()
-                .add_component_impl(target.into(), tween);
+                .add_component_target(target.into(), tween);
         });
         self
     }
@@ -1147,9 +1147,27 @@ pub struct TweenAnim {
     /// Animation description.
     pub tweenable: BoxedTweenable,
     /// Control if the animation is played or not.
-    pub state: PlaybackState,
-    /// Relative playback speed. Defaults to `1.` (normal speed).
-    pub speed: f32,
+    pub playback_state: PlaybackState,
+    /// Relative playback speed. Defaults to `1.` (normal speed; 100%).
+    ///
+    /// # Time precision
+    ///
+    /// _This note is an implementation detail which can usually be ignored._
+    ///
+    /// Despite the use of `f64`, setting a playback speed different from `1.`
+    /// (100% speed) may produce small inaccuracies in durations, especially
+    /// for longer animations. However those are often negligible.
+    /// This is due to the very large precision of `Duration` (typically 96
+    /// bits or more), even compared to `f64` (64 bits), and the fact this speed
+    /// factor is a multiplier whereas most other time quantities are added or
+    /// subtracted.
+    pub speed: f64,
+    /// Destroy the animation once completed. This defaults to `true`, and makes
+    /// [`TweenAnimator::step_all()`] destroy this [`TweenAnim`] once it
+    /// completed. To keep the animation queued, set this to `false`.
+    pub destroy_on_completion: bool,
+    /// Current tweening completion state.
+    tween_state: TweenState,
 }
 
 impl TweenAnim {
@@ -1167,8 +1185,10 @@ impl TweenAnim {
         Self {
             target,
             tweenable: Box::new(tweenable),
-            state: PlaybackState::Playing,
+            playback_state: PlaybackState::Playing,
             speed: 1.,
+            destroy_on_completion: true,
+            tween_state: TweenState::Active,
         }
     }
 
@@ -1183,8 +1203,20 @@ impl TweenAnim {
     /// direction is [`PlaybackDirection::Backward`] and the animation is
     /// infinitely repeating.
     pub fn stop(&mut self) {
-        self.state = PlaybackState::Paused;
+        self.playback_state = PlaybackState::Paused;
         self.tweenable.rewind();
+        self.tween_state = TweenState::Active;
+    }
+
+    /// Get the tweening completion state.
+    ///
+    /// In general this is [`TweenState::Active`], unless the animation
+    /// completed and [`destroy_on_completion`] is `false`.
+    ///
+    /// [`destroy_on_completion`]: Self::destroy_on_completion
+    #[inline]
+    pub fn tween_state(&self) -> TweenState {
+        self.tween_state
     }
 }
 
@@ -1262,14 +1294,6 @@ impl Default for TweenAnimator {
 }
 
 impl TweenAnimator {
-    #[inline]
-    fn add_component_impl<T>(&mut self, target: ComponentTarget, tweenable: T) -> TweenId
-    where
-        T: Tweenable + 'static,
-    {
-        self.anims.insert(TweenAnim::new(target.into(), tweenable))
-    }
-
     /// Add a new component animation to the animator queue.
     ///
     /// In general you don't need to call this directly. Instead, use the
@@ -1332,8 +1356,6 @@ impl TweenAnimator {
     ///     Some(())
     /// }
     /// ```
-    ///
-    /// [`add()`]: Self::add
     #[inline]
     pub fn add_component<T>(
         &mut self,
@@ -1348,7 +1370,22 @@ impl TweenAnimator {
             return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
         };
         let target = ComponentTarget::new_untyped(components, type_id, entity)?.into();
-        Ok(self.anims.insert(TweenAnim::new(target, tweenable)))
+        Ok(self.add_component_target(target, tweenable))
+    }
+
+    /// Add a new component animation via an existing component target.
+    ///
+    /// See [`add_component()`] for details. This variant is useful when you can
+    /// build in advance a [`ComponentTarget`], but at the same time don't have
+    /// readily access to the [`Components`] of the world.
+    ///
+    /// [`add_component()`]: Self::add_component
+    #[inline]
+    pub fn add_component_target<T>(&mut self, target: ComponentTarget, tweenable: T) -> TweenId
+    where
+        T: Tweenable + 'static,
+    {
+        self.anims.insert(TweenAnim::new(target.into(), tweenable))
     }
 
     /// Add a new asset animation to the animator queue.
@@ -1392,8 +1429,13 @@ impl TweenAnimator {
     /// }
     /// ```
     ///
+    /// Note that unlike [`add_component()`], this function depends on the asset
+    /// type. This is required to allow registering some internal resolver to
+    /// extract the typed animation from its typed `Assets<A>`, as this can't be
+    /// done via untyped references (unlike for components).
+    ///
     /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
-    /// [`add()`]: Self::add
+    /// [`add_component()`]: Self::add_component
     #[inline]
     pub fn add_asset<T, A: Asset>(
         &mut self,
@@ -1462,6 +1504,15 @@ impl TweenAnimator {
         self.anims.iter_mut()
     }
 
+    /// Remove a queued tweenable animation and return it.
+    ///
+    /// After the animation is removed, the `id` is invalid and will never be
+    /// reused.
+    #[inline]
+    pub fn remove(&mut self, id: TweenId) -> Option<TweenAnim> {
+        self.anims.remove(id)
+    }
+
     /// Step all queued animations.
     ///
     /// Loop over the internal queue of tweenable animations, apply them to
@@ -1482,14 +1533,17 @@ impl TweenAnimator {
         // Loop over active animations, tick them, and retain those which are still
         // active after that
         self.anims.retain(|tween_id, anim| {
-            // Note: we use get_entity_mut([Entity; 1]) with an array of a single element to
-            // get an EntityMut instead of an EntityWorldMut, as the former is
-            // enough. This can allow optimizing by parallelizing tweening of
-            // separate entities (which can't be done with EntityWorldMut has it
-            // has exclusive World access). For now this has no consequence except
-            // simplifying some borrow checker complications with World.
-            //let ent_mut = &mut world.get_entity_mut([anim.target]).unwrap()[0];
+            // Retain completed animations only if requested
+            if anim.tween_state == TweenState::Completed {
+                return !anim.destroy_on_completion;
+            }
 
+            // Skip paused animations (but retain them)
+            if anim.playback_state == PlaybackState::Paused {
+                return true;
+            }
+
+            // Resolve the (untyped) target as a MutUntyped<T>
             let Some(mut mut_untyped) = (match &anim.target {
                 AnimTarget::Component(ComponentTarget {
                     entity,
@@ -1515,8 +1569,10 @@ impl TweenAnimator {
 
             // Scale delta time by this animation's speed. Reject negative speeds; use
             // backward playback to play in reverse direction.
-            let delta_time = delta_time.mul_f32(anim.speed.max(0.));
+            // Note: must use f64 for precision; f32 produces visible roundings.
+            let delta_time = delta_time.mul_f64(anim.speed.max(0.));
 
+            // Step the tweenable animation
             let mut notify_completed = |fraction: f32| {
                 events.send(TweenCompletedEvent {
                     id: tween_id,
@@ -1524,14 +1580,13 @@ impl TweenAnimator {
                     progress: fraction,
                 });
             };
-
-            // Apply the animation tweenable
             let state = anim.tweenable.step(
                 tween_id,
                 delta_time,
                 mut_untyped.reborrow(),
                 &mut notify_completed,
             );
+            anim.tween_state = state;
 
             // Raise completed event
             if state == TweenState::Completed {
@@ -1541,13 +1596,21 @@ impl TweenAnimator {
                 });
             }
 
-            state == TweenState::Active
+            state == TweenState::Active || !anim.destroy_on_completion
         });
     }
 }
 
-/// Trait to interpolate between two values.
-/// Needed for color.
+/// Extension trait to interpolate between two colors.
+///
+/// This adds a [`Color::lerp()`] function which linearly interpolates the
+/// `LinearRgba` values component-wise.
+///
+/// Note that this is a convenience helper with naive color interpolation. In
+/// general, to get more accurrate colors, you should create your own [`Lens`]
+/// and apply a better interpolation, for example based on luminosity. There's
+/// no "canonical" color interpolation, and the best answer varies depending on
+/// the context.
 #[allow(dead_code)]
 #[cfg(any(feature = "bevy_sprite", feature = "bevy_ui", feature = "bevy_text"))]
 trait ColorLerper {
@@ -1719,27 +1782,46 @@ mod tests {
         assert!(animator.get(TweenId::null()).is_none());
         assert!(animator.iter().next().is_none());
         assert!(animator.iter_mut().next().is_none());
+        assert!(animator.remove(TweenId::null()).is_none());
     }
 
-    // #[test]
-    // fn animator_with_state() {
-    //     for state in [AnimatorState::Playing, AnimatorState::Paused] {
-    //         let tween = Tween::<DummyComponent>::new(
-    //             EaseFunction::QuadraticInOut,
-    //             Duration::from_secs(1),
-    //             DummyLens { start: 0., end: 1. },
-    //         );
-    //         let animator = Animator::new(tween).with_state(state);
-    //         assert_eq!(animator.state, state);
+    // TweenAnim::playback_state is entirely user-controlled
+    #[test]
+    fn animator_with_state() {
+        for state in [PlaybackState::Playing, PlaybackState::Paused] {
+            let tween = Tween::new::<DummyComponent, DummyLens>(
+                EaseFunction::QuadraticInOut,
+                Duration::from_secs(1),
+                DummyLens { start: 0., end: 1. },
+            );
+            let mut env = TestEnv::<DummyComponent>::new(tween);
+            env.anim_scope(|anim| {
+                anim.playback_state = state;
+                anim.destroy_on_completion = false;
+            });
 
-    //         // impl Debug
-    //         let debug_string = format!("{:?}", animator);
-    //         assert_eq!(
-    //             debug_string,
-    //             format!("Animator {{ state: {:?} }}", animator.state)
-    //         );
-    //     }
-    // }
+            // Tick once
+            let dt = Duration::from_millis(100);
+            env.step_all(dt);
+            assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
+            assert_eq!(env.anim().unwrap().playback_state, state);
+
+            // Check elapsed
+            let elapsed = match state {
+                PlaybackState::Playing => dt,
+                PlaybackState::Paused => Duration::ZERO,
+            };
+            assert_eq!(env.anim().unwrap().tweenable.elapsed(), elapsed);
+
+            // Force playback, otherwise we can't complete
+            env.anim_scope(|anim| anim.playback_state = PlaybackState::Playing);
+
+            // Even after completion, the playback state is untouched
+            env.step_all(Duration::from_secs(10) - elapsed);
+            assert_eq!(env.anim().unwrap().tween_state(), TweenState::Completed);
+            assert_eq!(env.anim().unwrap().playback_state, PlaybackState::Playing);
+        }
+    }
 
     // #[test]
     // fn animator_controls() {
@@ -1778,29 +1860,29 @@ mod tests {
     //     assert_approx_eq!(animator.tweenable().progress(), 0.);
     // }
 
-    // #[test]
-    // fn animator_speed() {
-    //     let tween = Tween::<DummyComponent>::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(1),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
+    #[test]
+    fn animation_speed() {
+        let tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
 
-    //     let mut animator = Animator::new(tween);
-    //     assert_approx_eq!(animator.speed(), 1.); // default speed
+        let mut env = TestEnv::<DummyComponent>::new(tween);
 
-    //     animator.set_speed(2.4);
-    //     assert_approx_eq!(animator.speed(), 2.4);
+        assert_approx_eq!(env.anim().unwrap().speed, 1.); // default speed
 
-    //     let tween = Tween::<DummyComponent>::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(1),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
+        env.anim_scope(|anim| anim.speed = 2.4);
+        assert_approx_eq!(env.anim().unwrap().speed, 2.4);
 
-    //     let animator = Animator::new(tween).with_speed(3.5);
-    //     assert_approx_eq!(animator.speed(), 3.5);
-    // }
+        env.step_all(Duration::from_millis(100));
+        // Here we have enough precision for exact equality, but that may not always be
+        // the case for larger durations or speed values.
+        assert_eq!(
+            env.anim().unwrap().tweenable.elapsed(),
+            Duration::from_millis(240)
+        );
+    }
 
     // #[test]
     // fn animator_set_tweenable() {
diff --git a/src/plugin.rs b/src/plugin.rs
index 6a12b40..cd2da6b 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -48,7 +48,6 @@ pub(crate) fn animator_system(world: &mut World) {
 #[cfg(test)]
 mod tests {
     use std::{
-        marker::PhantomData,
         ops::DerefMut,
         sync::{
             atomic::{AtomicBool, Ordering},
@@ -56,89 +55,7 @@ mod tests {
         },
     };
 
-    use bevy::ecs::component::Mutable;
-
-    use crate::{lens::TransformPositionLens, *};
-
-    /// A simple isolated test environment with a [`World`] and a single
-    /// [`Entity`] in it.
-    struct TestEnv<T: Component> {
-        world: World,
-        entity: Entity,
-        tween_id: TweenId,
-        _phantom: PhantomData<T>,
-    }
-
-    impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
-        /// Create a new test environment containing a single entity with a `T`
-        /// component, and add the given animator on that same entity.
-        pub fn new(tweenable: impl Tweenable + 'static) -> Self {
-            let mut world = World::new();
-            world.init_resource::<Time>();
-            world.init_resource::<Events<TweenCompletedEvent>>();
-            world.init_resource::<Events<AnimCompletedEvent>>();
-            world.init_resource::<TweenAnimator>();
-
-            let entity = world.spawn(T::default()).id();
-            let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
-                let target = world.get_component_target::<T>(entity).unwrap();
-                animator.add_component_impl(target, tweenable)
-            });
-
-            Self {
-                world,
-                entity,
-                tween_id,
-                _phantom: PhantomData,
-            }
-        }
-    }
-
-    impl<T: Component<Mutability = Mutable>> TestEnv<T> {
-        /// Get the test world.
-        pub fn world_mut(&mut self) -> &mut World {
-            &mut self.world
-        }
-
-        /// Tick the test environment, updating the simulation time and ticking
-        /// the given system.
-        pub fn tick(&mut self, duration: Duration, system: &mut dyn System<In = (), Out = ()>) {
-            // Simulate time passing by updating the simulation time resource
-            {
-                let mut time = self.world.resource_mut::<Time>();
-                time.advance_by(duration);
-            }
-
-            // Reset world-related change detection
-            self.world.clear_trackers();
-            assert!(!self.component_mut().is_changed());
-
-            // Tick system
-            system.run((), &mut self.world);
-
-            // Update events after system ticked, in case system emitted some events
-            let mut events = self.world.resource_mut::<Events<TweenCompletedEvent>>();
-            events.update();
-            let mut events = self.world.resource_mut::<Events<AnimCompletedEvent>>();
-            events.update();
-        }
-
-        /// Get the animator for the component.
-        pub fn animator(&self) -> &TweenAnimator {
-            self.world.resource::<TweenAnimator>()
-        }
-
-        /// Get the component.
-        pub fn component_mut(&mut self) -> Mut<T> {
-            self.world.get_mut::<T>(self.entity).unwrap()
-        }
-
-        /// Get the emitted event count since last tick.
-        pub fn event_count(&self) -> usize {
-            let events = self.world.resource::<Events<TweenCompletedEvent>>();
-            events.get_cursor().len(events)
-        }
-    }
+    use crate::{lens::TransformPositionLens, test_utils::TestEnv, *};
 
     #[test]
     fn custom_target_entity() {
@@ -152,14 +69,12 @@ mod tests {
         )
         .with_completed_event(true);
         let mut env = TestEnv::<Transform>::new(tween);
-        let mut system = IntoSystem::into_system(plugin::animator_system);
-        system.initialize(env.world_mut());
 
-        env.tick(Duration::ZERO, &mut system);
+        env.step_all(Duration::ZERO);
         let transform = env.component_mut();
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
 
-        env.tick(Duration::from_millis(500), &mut system);
+        env.step_all(Duration::from_millis(500));
         let transform = env.component_mut();
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.5), 1e-5));
     }
@@ -182,31 +97,28 @@ mod tests {
         let transform = env.component_mut();
         assert!(transform.is_changed());
 
-        let mut system = IntoSystem::into_system(plugin::animator_system);
-        system.initialize(env.world_mut());
-
-        env.tick(Duration::ZERO, &mut system);
+        env.step_all(Duration::ZERO);
 
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
 
-        env.tick(Duration::from_millis(500), &mut system);
+        env.step_all(Duration::from_millis(500));
 
         assert_eq!(env.event_count(), 0);
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.5), 1e-5));
 
-        env.tick(Duration::from_millis(500), &mut system);
+        env.step_all(Duration::from_millis(500));
 
         // The animation is done now, and was deleted from the animator queue.
         // The final state was still applied before deleting the animation,
@@ -220,7 +132,7 @@ mod tests {
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
 
         // We can continue to tick as much as we want, this doesn't change anything
-        env.tick(Duration::from_millis(100), &mut system);
+        env.step_all(Duration::from_millis(100));
 
         assert_eq!(env.event_count(), 0);
         let animator = env.animator();
@@ -267,39 +179,36 @@ mod tests {
         let component = env.component_mut();
         assert!(component.is_changed());
 
-        let mut system = IntoSystem::into_system(plugin::animator_system);
-        system.initialize(env.world_mut());
-
         assert!(!defer.load(Ordering::SeqCst));
 
         // Mutation disabled
-        env.tick(Duration::ZERO, &mut system);
+        env.step_all(Duration::ZERO);
 
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!(((*component).value - 0.).abs() <= 1e-5);
 
         // Zero-length tick should not change the component
-        env.tick(Duration::from_millis(0), &mut system);
+        env.step_all(Duration::ZERO);
 
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
         assert!(((*component).value - 0.).abs() <= 1e-5);
 
         // New tick, but lens mutation still disabled
-        env.tick(Duration::from_millis(200), &mut system);
+        env.step_all(Duration::from_millis(200));
 
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(!component.is_changed());
@@ -311,11 +220,11 @@ mod tests {
         // The current time is already at t=0.2s, so even if we don't increment it, for
         // a tween duration of 1s the ratio is t=0.2, so the lens will actually
         // increment the component's value.
-        env.tick(Duration::from_millis(0), &mut system);
+        env.step_all(Duration::ZERO);
 
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(component.is_changed());
@@ -325,11 +234,11 @@ mod tests {
         // t = 0.5s / 1s = 0.5
         // value += 0.5
         // value == 0.7
-        env.tick(Duration::from_millis(300), &mut system);
+        env.step_all(Duration::from_millis(300));
 
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
-        assert_eq!(anim.state, PlaybackState::Playing);
+        assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
         assert!(component.is_changed());
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 7df33d7..d3a57cb 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -1,5 +1,16 @@
+use std::{marker::PhantomData, time::Duration};
+
 use bevy::{
+    ecs::{
+        change_detection::DetectChanges as _,
+        component::{Component, Mutable},
+        entity::Entity,
+        event::Events,
+        system::{IntoSystem, System},
+        world::{Mut, World},
+    },
     math::{Quat, Vec3, Vec4},
+    time::Time,
     transform::components::Transform,
 };
 
@@ -17,6 +28,15 @@ impl AbsDiffEq for f32 {
     }
 }
 
+impl AbsDiffEq for f64 {
+    fn abs_diff_eq(a: Self, b: Self, tol: f32) -> bool {
+        (a - b).abs() < tol as f64
+    }
+    fn delta(a: Self, b: Self) -> Self {
+        (a - b).abs()
+    }
+}
+
 impl AbsDiffEq for Vec3 {
     fn abs_diff_eq(a: Self, b: Self, tol: f32) -> bool {
         Vec3::abs_diff_eq(a, b, tol)
@@ -96,3 +116,114 @@ macro_rules! assert_approx_eq {
 }
 
 pub(crate) use assert_approx_eq;
+
+use crate::{
+    AnimCompletedEvent, TweenAnim, TweenAnimator, TweenCompletedEvent, TweenId, Tweenable,
+    WorldTargetExtensions as _,
+};
+
+/// A simple isolated test environment with a [`World`] and a single
+/// [`Entity`] in it.
+pub(crate) struct TestEnv<T: Component> {
+    pub world: World,
+    pub entity: Entity,
+    pub tween_id: TweenId,
+    system: Box<dyn System<In = (), Out = ()>>,
+    _phantom: PhantomData<T>,
+}
+
+impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
+    /// Create a new test environment containing a single entity with a `T`
+    /// component, and add the given animator on that same entity.
+    pub fn new(tweenable: impl Tweenable + 'static) -> Self {
+        let mut world = World::new();
+        world.init_resource::<Time>();
+        world.init_resource::<Events<TweenCompletedEvent>>();
+        world.init_resource::<Events<AnimCompletedEvent>>();
+        world.init_resource::<TweenAnimator>();
+
+        let mut system = IntoSystem::into_system(crate::plugin::animator_system);
+        system.initialize(&mut world);
+
+        let entity = world.spawn(T::default()).id();
+        let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
+            let target = world.get_component_target::<T>(entity).unwrap();
+            animator.add_component_target(target, tweenable)
+        });
+
+        Self {
+            world,
+            entity,
+            tween_id,
+            system: Box::new(system),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<T: Component<Mutability = Mutable>> TestEnv<T> {
+    /// Get the test world.
+    #[allow(unused)]
+    pub fn world_mut(&mut self) -> &mut World {
+        &mut self.world
+    }
+
+    /// Tick the test environment, updating the simulation time and executing
+    /// the built-in system which calls [`TweenAnimator::step_all()`].
+    pub fn step_all(&mut self, duration: Duration) {
+        // Simulate time passing by updating the simulation time resource
+        {
+            let mut time = self.world.resource_mut::<Time>();
+            time.advance_by(duration);
+        }
+
+        // Reset world-related change detection
+        self.world.clear_trackers();
+        assert!(!self.component_mut().is_changed());
+
+        // Tick system
+        self.system.run((), &mut self.world);
+
+        // Update events after system ticked, in case system emitted some events
+        let mut events = self.world.resource_mut::<Events<TweenCompletedEvent>>();
+        events.update();
+        let mut events = self.world.resource_mut::<Events<AnimCompletedEvent>>();
+        events.update();
+    }
+
+    /// Get the animator for the component.
+    pub fn animator(&self) -> &TweenAnimator {
+        self.world.resource::<TweenAnimator>()
+    }
+
+    /// Get the animator for the component.
+    #[allow(dead_code)]
+    pub fn animator_mut(&mut self) -> Mut<TweenAnimator> {
+        self.world.resource_mut::<TweenAnimator>()
+    }
+
+    /// Get the animation.
+    pub fn anim(&self) -> Option<&TweenAnim> {
+        self.world.resource::<TweenAnimator>().get(self.tween_id)
+    }
+
+    /// Apply a mutating closure to the animation.
+    pub fn anim_scope(&mut self, func: impl FnOnce(&mut TweenAnim)) {
+        let tween_id = self.tween_id;
+        let mut animator = self.world.resource_mut::<TweenAnimator>();
+        if let Some(anim) = animator.get_mut(tween_id) {
+            func(anim);
+        }
+    }
+
+    /// Get the component.
+    pub fn component_mut(&mut self) -> Mut<T> {
+        self.world.get_mut::<T>(self.entity).unwrap()
+    }
+
+    /// Get the emitted event count since last tick.
+    pub fn event_count(&self) -> usize {
+        let events = self.world.resource::<Events<TweenCompletedEvent>>();
+        events.get_cursor().len(events)
+    }
+}
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 89d3284..fd37301 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -631,9 +631,12 @@ impl Tween {
         Sequence::with_capacity(2).then(self).then(tween)
     }
 
-    /// Create a new tween animation.
+    /// Create a new tween animation for a [`Component`].
+    ///
+    /// The target component type is implicitly determined by the [`Lens`].
     ///
     /// # Example
+    ///
     /// ```
     /// # use bevy_tweening::{lens::*, *};
     /// # use bevy::math::{Vec3, curve::EaseFunction};
@@ -672,7 +675,25 @@ impl Tween {
         }
     }
 
+    /// Create a new tween animation for an [`Asset`].
     ///
+    /// The target asset type is implicitly determined by the [`Lens`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy_tweening::{lens::*, *};
+    /// # use bevy::{prelude::Color, math::{Vec3, curve::EaseFunction}};
+    /// # use std::time::Duration;
+    /// let tween = Tween::new_asset(
+    ///     EaseFunction::QuadraticInOut,
+    ///     Duration::from_secs(1),
+    ///     ColorMaterialColorLens {
+    ///         start: Color::BLACK,
+    ///         end: Color::WHITE,
+    ///     },
+    /// );
+    /// ```
     #[must_use]
     pub fn new_asset<A, L>(
         ease_function: impl Into<EaseMethod>,
@@ -684,7 +705,8 @@ impl Tween {
         L: Lens<A> + Send + Sync + 'static,
     {
         let action = move |ptr: MutUntyped, ratio: f32| {
-            // SAFETY: ptr was obtained from the same component type.
+            // SAFETY: ptr was obtained from the captured asset type, through the Assets<A>
+            // resource type saved in type_id below.
             #[allow(unsafe_code)]
             let asset = unsafe { ptr.with_type::<A>() };
             lens.lerp(asset, ratio);
@@ -700,13 +722,14 @@ impl Tween {
         }
     }
 
-    /// Enable raising a completed event on looping.
+    /// Enable raising a event on cycle completion.
     ///
     /// If enabled, the tween will raise a [`TweenCompletedEvent`] each time
-    /// the tween's progress reaches `1.`. In case of looping tweens (repeat
-    /// count > 1), the event is raised once per loop. For mirrored repeats, a
-    /// "loop" is one travel from start to end or end to start (so the full
-    /// cycle start -> end -> start counts as 2 loops and raises 2 events).
+    /// the tween completes a cycle (reaches or passes its cycle duration). In
+    /// case of repeating tweens (repeat count > 1), the event is raised once
+    /// per cycle. For mirrored repeats, a cycle is one travel from start to
+    /// end **or** end to start, so the full loop start -> end -> start counts
+    /// as 2 cycles and raises 2 events.
     ///
     /// # Example
     ///
@@ -723,7 +746,7 @@ impl Tween {
     /// #        end: Vec3::new(3.5, 0., 0.),
     /// #    },
     /// )
-    /// // Raise a TweenCompletedEvent each loop
+    /// // Raise a TweenCompletedEvent each cycle
     /// .with_completed_event(true);
     ///
     /// fn my_system(mut reader: EventReader<TweenCompletedEvent>) {

From 56ef60ac5e0179d29be80fd5092eb943f6cbee5d Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 13 Jul 2025 18:56:35 +0200
Subject: [PATCH 31/66] Add retargeting and tweenable swapping

---
 examples/sequence.rs |   4 +-
 src/lib.rs           | 524 +++++++++++++++++++++++++++++++++++--------
 src/test_utils.rs    |   5 +
 3 files changed, 439 insertions(+), 94 deletions(-)

diff --git a/examples/sequence.rs b/examples/sequence.rs
index a527945..185c7b6 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -271,14 +271,14 @@ fn update_text(
 ) {
     let anim_red = q_anim_red.single().unwrap();
     let progress_red = if let Some(anim) = animator.get(anim_red.path_tween_id) {
-        anim.tweenable.cycle_fraction()
+        anim.tweenable().cycle_fraction()
     } else {
         1.
     };
 
     let anim_blue = q_anim_blue.single().unwrap();
     let progress_blue = if let Some(anim) = animator.get(anim_blue.move_and_rotate_tween_id) {
-        anim.tweenable.cycle_fraction()
+        anim.tweenable().cycle_fraction()
     } else {
         1.
     };
diff --git a/src/lib.rs b/src/lib.rs
index e5cb574..c99f0bf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -306,6 +306,17 @@ impl From<Duration> for RepeatCount {
     }
 }
 
+impl RepeatCount {
+    /// Calculate the total duration for this repeat count.
+    pub fn total_duration(&self, cycle_duration: Duration) -> TotalDuration {
+        match self {
+            RepeatCount::Finite(count) => TotalDuration::Finite(cycle_duration * *count),
+            RepeatCount::For(duration) => TotalDuration::Finite(*duration),
+            RepeatCount::Infinite => TotalDuration::Infinite,
+        }
+    }
+}
+
 /// Repeat strategy for animation cycles.
 ///
 /// Only applicable when [`RepeatCount`] is greater than the total duration of
@@ -896,6 +907,18 @@ pub enum TweeningError {
     /// `None`.
     #[error("Expected a typed Tweenable, got {0:?} instead.")]
     UntypedTweenable(BoxedTweenable),
+    /// Invalid [`TweenId`].
+    #[error("Invalid TweenId {0:?}.")]
+    InvalidTweenId(TweenId),
+    /// Cannot change target kind.
+    #[error("Unexpected target kind: was component={0}, now component={1}")]
+    MismatchingTargetKind(bool, bool),
+    /// Cannot change component type.
+    #[error("Cannot change component type: was component_id={0:?}, now component_id={1:?}")]
+    MismatchingComponentId(ComponentId, ComponentId),
+    /// Cannot change asset type.
+    #[error("Cannot change asset type: was component_id={0:?}, now component_id={1:?}")]
+    MismatchingAssetResourceId(ComponentId, ComponentId),
 }
 
 /// Component animation target.
@@ -1143,9 +1166,9 @@ impl WorldTargetExtensions for World {
 /// A [`Tweenable`]-based animation.
 pub struct TweenAnim {
     /// Target [`Entity`] containing the component to animate, or target asset.
-    pub target: AnimTarget,
+    target: AnimTarget,
     /// Animation description.
-    pub tweenable: BoxedTweenable,
+    tweenable: BoxedTweenable,
     /// Control if the animation is played or not.
     pub playback_state: PlaybackState,
     /// Relative playback speed. Defaults to `1.` (normal speed; 100%).
@@ -1208,6 +1231,22 @@ impl TweenAnim {
         self.tween_state = TweenState::Active;
     }
 
+    /// Get the target this animation is mutating.
+    ///
+    /// To change the target, use [`TweenAnimator::set_target()`].
+    #[inline]
+    pub fn target(&self) -> &AnimTarget {
+        &self.target
+    }
+
+    /// Get the tweenable describing this animation.
+    ///
+    /// To change the tweenable, use [`TweenAnimator::set_tweenable()`].
+    #[inline]
+    pub fn tweenable(&self) -> &dyn Tweenable {
+        self.tweenable.as_ref()
+    }
+
     /// Get the tweening completion state.
     ///
     /// In general this is [`TweenState::Active`], unless the animation
@@ -1474,6 +1513,18 @@ impl TweenAnimator {
         Ok(self.anims.insert(TweenAnim::new(target.into(), tweenable)))
     }
 
+    /// Check if the animation with the given ID is queued.
+    ///
+    /// # Returns
+    ///
+    /// Returns `true` if the animation is queued, either because it's playing,
+    /// or because it's completed but [`TweenAnim::destroy_on_completion`] was
+    /// set to `false`.
+    #[inline]
+    pub fn contains(&self, id: TweenId) -> bool {
+        self.anims.contains_key(id)
+    }
+
     /// Get a queued tweenable animation from its ID.
     ///
     /// This fails and returns `None` if the animation has completed and was
@@ -1492,6 +1543,28 @@ impl TweenAnimator {
         self.anims.get_mut(id)
     }
 
+    /// Get a queued tweenable animation from its ID.
+    ///
+    /// This fails and returns [`TweeningError::InvalidTweenId`] if the
+    /// animation has completed and was removed from the animator's internal
+    /// queue.
+    #[inline]
+    pub fn try_get(&self, id: TweenId) -> Result<&TweenAnim, TweeningError> {
+        self.anims.get(id).ok_or(TweeningError::InvalidTweenId(id))
+    }
+
+    /// Get a queued tweenable animation from its ID.
+    ///
+    /// This fails and returns [`TweeningError::InvalidTweenId`] if the
+    /// animation has completed and was removed from the animator's internal
+    /// queue.
+    #[inline]
+    pub fn try_get_mut(&mut self, id: TweenId) -> Result<&mut TweenAnim, TweeningError> {
+        self.anims
+            .get_mut(id)
+            .ok_or(TweeningError::InvalidTweenId(id))
+    }
+
     /// Get an iterator over the queued tweenable animations.
     #[inline]
     pub fn iter(&self) -> impl Iterator<Item = (TweenId, &TweenAnim)> {
@@ -1513,6 +1586,222 @@ impl TweenAnimator {
         self.anims.remove(id)
     }
 
+    /// Retarget a queued animation.
+    ///
+    /// Attempt to change the target of a tweening animation already enqueued,
+    /// and possibly already playing.
+    ///
+    /// This function performs a number of checks on the new target to ensure
+    /// it's compatible with the previous target. In particular, the new target
+    /// needs to have:
+    /// - the same kind (component or asset);
+    /// - the same type (component type or asset resource type).
+    ///
+    /// # Returns
+    ///
+    /// On success, returns the previous target which has been replaced.
+    pub fn set_target(
+        &mut self,
+        id: TweenId,
+        target: AnimTarget,
+    ) -> Result<AnimTarget, TweeningError> {
+        let anim = self
+            .anims
+            .get_mut(id)
+            .ok_or(TweeningError::InvalidTweenId(id))?;
+        match (anim.target, target) {
+            (AnimTarget::Component(old_component), AnimTarget::Component(new_component)) => {
+                if old_component.component_id != new_component.component_id {
+                    return Err(TweeningError::MismatchingComponentId(
+                        old_component.component_id,
+                        new_component.component_id,
+                    ));
+                }
+            }
+            (AnimTarget::Asset(old_asset), AnimTarget::Asset(new_asset)) => {
+                if old_asset.resource_id != new_asset.resource_id {
+                    return Err(TweeningError::MismatchingAssetResourceId(
+                        old_asset.resource_id,
+                        new_asset.resource_id,
+                    ));
+                }
+            }
+            _ => {
+                return Err(TweeningError::MismatchingTargetKind(
+                    anim.target.is_component(),
+                    target.is_component(),
+                ))
+            }
+        }
+        let old_target = anim.target;
+        anim.target = target;
+        Ok(old_target)
+    }
+
+    /// Swap a queued animation.
+    ///
+    /// Attempt to change the tweenable of an animation already enqueued, and
+    /// possibly already playing.
+    ///
+    /// If the tweenable is successfully swapped, this resets the
+    /// [`TweenAnim::tween_state()`] to [`TweenState::Active`], even if the
+    /// tweenable would otherwise be completed _e.g._ because its elapsed time
+    /// is past its total duration. Conversely, this doesn't update the target,
+    /// as this function doesn't have mutable access to it.
+    ///
+    /// To ensure the old and new animations have the same elapsed time (for
+    /// example if they need to be synchronized), call [`set_elapsed()`] first
+    ///   on the input `tweenable`, with the duration value of the old
+    ///   tweenable as returned by [`elapsed()`].
+    ///
+    /// ```
+    /// #fn sys(mut animator: ResMut<TweenAnimator>) {
+    /// #let id = TweenId::null();
+    /// let elapsed = animator.get(id).unwrap().elapsed();
+    /// tweenable.set_elapsed(elapsed);
+    /// animator.set_tweenable(id, tweenable);
+    /// #}
+    /// ```
+    ///
+    /// To recompute the actual tweenable animation state and force a target
+    /// update, use [`step_one()`] with a [`Duration::ZERO`].
+    ///
+    /// # Returns
+    ///
+    /// On success, returns the previous tweenable which has been swapped out.
+    ///
+    /// [`set_elapsed()`]: crate::Tweenable::set_elapsed
+    /// [`elapsed()`]: crate::Tweenable::elapsed
+    /// [`step_one()`]: Self::step_one
+    pub fn set_tweenable<T>(
+        &mut self,
+        id: TweenId,
+        tweenable: T,
+    ) -> Result<BoxedTweenable, TweeningError>
+    where
+        T: Tweenable + 'static,
+    {
+        let anim = self
+            .anims
+            .get_mut(id)
+            .ok_or(TweeningError::InvalidTweenId(id))?;
+        let mut old_tweenable: BoxedTweenable = Box::new(tweenable);
+        std::mem::swap(&mut anim.tweenable, &mut old_tweenable);
+        // Reset tweening state, the new tweenable is at t=0
+        anim.tween_state = TweenState::Active;
+        Ok(old_tweenable)
+    }
+
+    /// Step the given queued animation.
+    ///
+    /// In general all animations are stepped automatically via [`step_all()`],
+    /// which is called from a system added by the [`TweeningPlugin`]. This
+    /// function can be used to step a single animation, either in addition or
+    /// in place of that system or any call to [`step_all()`]. If the `id` is
+    /// invalid, this function does nothing.
+    ///
+    /// # Returns
+    ///
+    /// If the animation completed and was destroyed, returns a copy of that
+    /// animation. Otherwise if the animation is still queued, returns `None`.
+    ///
+    /// [`step_all()`]: Self::step_all
+    #[inline]
+    pub fn step_one(
+        &mut self,
+        id: TweenId,
+        world: &mut World,
+        delta_time: Duration,
+        events: Mut<Events<TweenCompletedEvent>>,
+        anim_events: Mut<Events<AnimCompletedEvent>>,
+    ) -> Option<TweenAnim> {
+        if let Ok(retain) = self.step_impl(id, world, delta_time, events, anim_events) {
+            if !retain {
+                return Some(self.anims.remove(id).unwrap());
+            }
+        }
+        None
+    }
+
+    fn step_impl(
+        &mut self,
+        id: TweenId,
+        world: &mut World,
+        delta_time: Duration,
+        mut events: Mut<Events<TweenCompletedEvent>>,
+        mut anim_events: Mut<Events<AnimCompletedEvent>>,
+    ) -> Result<bool, TweeningError> {
+        let anim = self
+            .anims
+            .get_mut(id)
+            .ok_or(TweeningError::InvalidTweenId(id))?;
+
+        // Retain completed animations only if requested
+        if anim.tween_state == TweenState::Completed {
+            return Ok(!anim.destroy_on_completion);
+        }
+
+        // Skip paused animations (but retain them)
+        if anim.playback_state == PlaybackState::Paused {
+            return Ok(true);
+        }
+
+        // Resolve the (untyped) target as a MutUntyped<T>
+        let Some(mut mut_untyped) = (match &anim.target {
+            AnimTarget::Component(ComponentTarget {
+                entity,
+                component_id,
+            }) => world.get_mut_by_id(*entity, *component_id),
+            AnimTarget::Asset(AssetTarget {
+                resource_id,
+                asset_id,
+            }) => {
+                if let Some(assets) = world.get_resource_mut_by_id(*resource_id) {
+                    if let Some(resolver) = self.asset_resolver.get(resource_id) {
+                        resolver(assets, *asset_id)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            }
+        }) else {
+            return Ok(false);
+        };
+
+        // Scale delta time by this animation's speed. Reject negative speeds; use
+        // backward playback to play in reverse direction.
+        // Note: must use f64 for precision; f32 produces visible roundings.
+        let delta_time = delta_time.mul_f64(anim.speed.max(0.));
+
+        // Step the tweenable animation
+        let mut notify_completed = |fraction: f32| {
+            events.send(TweenCompletedEvent {
+                id,
+                target: anim.target,
+                progress: fraction,
+            });
+        };
+        let state = anim.tweenable.step(
+            id,
+            delta_time,
+            mut_untyped.reborrow(),
+            &mut notify_completed,
+        );
+        anim.tween_state = state;
+
+        // Raise completed event
+        if state == TweenState::Completed {
+            anim_events.send(AnimCompletedEvent {
+                id,
+                target: anim.target,
+            });
+        }
+
+        Ok(state == TweenState::Active || !anim.destroy_on_completion)
+    }
+
     /// Step all queued animations.
     ///
     /// Loop over the internal queue of tweenable animations, apply them to
@@ -1721,8 +2010,29 @@ mod tests {
 
     #[test]
     fn repeat_count() {
-        let count = RepeatCount::default();
-        assert_eq!(count, RepeatCount::Finite(1));
+        let cycle_duration = Duration::from_millis(100);
+
+        let repeat = RepeatCount::default();
+        assert_eq!(repeat, RepeatCount::Finite(1));
+        assert_eq!(
+            repeat.total_duration(cycle_duration),
+            TotalDuration::Finite(cycle_duration)
+        );
+
+        let repeat: RepeatCount = 3u32.into();
+        assert_eq!(repeat, RepeatCount::Finite(3));
+        assert_eq!(
+            repeat.total_duration(cycle_duration),
+            TotalDuration::Finite(cycle_duration * 3)
+        );
+
+        let duration = Duration::from_secs(5);
+        let repeat: RepeatCount = duration.into();
+        assert_eq!(repeat, RepeatCount::For(duration));
+        assert_eq!(
+            repeat.total_duration(cycle_duration),
+            TotalDuration::Finite(duration)
+        );
     }
 
     #[test]
@@ -1732,13 +2042,13 @@ mod tests {
     }
 
     #[test]
-    fn tweening_direction() {
+    fn playback_direction() {
         let tweening_direction = PlaybackDirection::default();
         assert_eq!(tweening_direction, PlaybackDirection::Forward);
     }
 
     #[test]
-    fn animator_state() {
+    fn playback_state() {
         let mut state = PlaybackState::default();
         assert_eq!(state, PlaybackState::Playing);
         state = !state;
@@ -1785,9 +2095,10 @@ mod tests {
         assert!(animator.remove(TweenId::null()).is_none());
     }
 
-    // TweenAnim::playback_state is entirely user-controlled
+    // TweenAnim::playback_state is entirely user-controlled; stepping animations
+    // won't change it.
     #[test]
-    fn animator_with_state() {
+    fn animation_playback_state() {
         for state in [PlaybackState::Playing, PlaybackState::Paused] {
             let tween = Tween::new::<DummyComponent, DummyLens>(
                 EaseFunction::QuadraticInOut,
@@ -1884,101 +2195,130 @@ mod tests {
         );
     }
 
-    // #[test]
-    // fn animator_set_tweenable() {
-    //     let tween = Tween::<DummyComponent>::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(1),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
-    //     let mut animator = Animator::new(tween);
+    #[test]
+    fn animator_set_tweenable() {
+        let tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let tween2 = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::SmoothStep,
+            Duration::from_secs(2),
+            DummyLens { start: 2., end: 3. },
+        );
 
-    //     let tween2 = Tween::<DummyComponent>::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(2),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
-    //     animator.set_tweenable(tween2);
+        let mut env = TestEnv::<DummyComponent>::new(tween);
+        env.anim_scope(|anim| anim.destroy_on_completion = false);
+        let id = env.tween_id;
+        assert!(env.animator().contains(id));
 
-    //     assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
-    // }
+        let dt = Duration::from_millis(1500);
 
-    // #[cfg(feature = "bevy_asset")]
-    // #[test]
-    // fn asset_animator_with_state() {
-    //     for state in [AnimatorState::Playing, AnimatorState::Paused] {
-    //         let tween = Tween::new(
-    //             EaseFunction::QuadraticInOut,
-    //             Duration::from_secs(1),
-    //             DummyLens { start: 0., end: 1. },
-    //         );
-    //         let animator = AssetAnimator::new(tween).with_state(state);
-    //         assert_eq!(animator.state, state);
-
-    //         // impl Debug
-    //         let debug_string = format!("{:?}", animator);
-    //         assert_eq!(
-    //             debug_string,
-    //             format!("AssetAnimator {{ state: {:?} }}", animator.state)
-    //         );
-    //     }
-    // }
+        env.step_all(dt);
+        assert_eq!(env.component().value, 1.);
+        assert_eq!(env.anim().unwrap().tween_state(), TweenState::Completed);
 
-    // #[cfg(feature = "bevy_asset")]
-    // #[test]
-    // fn asset_animator_controls() {
-    //     let tween = Tween::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(1),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
-    //     let mut animator = AssetAnimator::new(tween);
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+        // Swap tweens
+        let old_tweenable = env.animator_mut().set_tweenable(id, tween2).unwrap();
+        let id2 = env.tween_id;
+        assert_eq!(id, id2); // the ID doesn't change, the tweenable is swapped in-place
+        assert!(env.animator().contains(id2));
 
-    //     animator.stop();
-    //     assert_eq!(animator.state, AnimatorState::Paused);
-    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+        assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
+        // The elapsed is stored inside the tweenable
+        assert_eq!(old_tweenable.elapsed(), Duration::from_secs(1)); // capped at total_duration()
+        assert_eq!(env.anim().unwrap().tweenable.elapsed(), Duration::ZERO);
 
-    //     animator.tweenable_mut().set_progress(0.5);
-    //     assert_eq!(animator.state, AnimatorState::Paused);
-    //     assert_approx_eq!(animator.tweenable().progress(), 0.5);
+        env.step_all(dt);
+        assert!(env.component().value >= 2. && env.component().value <= 3.);
+    }
 
-    //     animator.tweenable_mut().rewind();
-    //     assert_eq!(animator.state, AnimatorState::Paused);
-    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+    #[test]
+    fn animator_set_target() {
+        let tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(tween);
 
-    //     animator.tweenable_mut().set_progress(0.5);
-    //     animator.state = AnimatorState::Playing;
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     assert_approx_eq!(animator.tweenable().progress(), 0.5);
+        // Register our custom asset type
+        env.world.init_resource::<Assets<DummyAsset>>();
+
+        // Invalid ID
+        {
+            let entity = env.entity;
+            let target =
+                ComponentTarget::new::<DummyComponent>(env.world.components(), entity).unwrap();
+            let err = env
+                .animator_mut()
+                .set_target(TweenId::null(), target.into())
+                .err()
+                .unwrap();
+            let TweeningError::InvalidTweenId(err_id) = err else {
+                panic!();
+            };
+            assert_eq!(err_id, TweenId::null());
+        }
 
-    //     animator.tweenable_mut().rewind();
-    //     assert_eq!(animator.state, AnimatorState::Playing);
-    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
+        // Spawn a second entity without any animation
+        let entity1 = env.entity;
+        let entity2 = env.world_mut().spawn(DummyComponent { value: 0. }).id();
+        assert_ne!(entity1, entity2);
+        assert_eq!(env.component().value, 0.);
 
-    //     animator.stop();
-    //     assert_eq!(animator.state, AnimatorState::Paused);
-    //     assert_approx_eq!(animator.tweenable().progress(), 0.);
-    // }
+        // Step the current target
+        let dt = Duration::from_millis(100);
+        env.step_all(dt);
+        assert!(env.component().value > 0.);
+        assert_eq!(
+            env.world
+                .entity(entity2)
+                .get_components::<&DummyComponent>()
+                .unwrap()
+                .value,
+            0.
+        );
 
-    // #[cfg(feature = "bevy_asset")]
-    // #[test]
-    // fn asset_animator_set_tweenable() {
-    //     let tween = Tween::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(1),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
-    //     let mut animator = AssetAnimator::new(tween);
+        // Now retarget
+        let id = env.tween_id;
+        let target2 =
+            ComponentTarget::new::<DummyComponent>(env.world.components(), entity2).unwrap();
+        let target1 = env.animator_mut().set_target(id, target2.into()).unwrap();
+        assert!(target1.is_component());
+        let comp1 = target1.as_component().unwrap();
+        assert_eq!(comp1.entity, entity1);
+        assert_eq!(
+            comp1.component_id,
+            env.world.component_id::<DummyComponent>().unwrap()
+        );
 
-    //     let tween2 = Tween::new(
-    //         EaseFunction::QuadraticInOut,
-    //         Duration::from_secs(2),
-    //         DummyLens { start: 0., end: 1. },
-    //     );
-    //     animator.set_tweenable(tween2);
+        // Step the new target
+        env.step_all(dt);
+        assert!(env.component().value > 0.);
+        assert!(
+            env.world
+                .entity(entity1)
+                .get_components::<&DummyComponent>()
+                .unwrap()
+                .value
+                > 0.
+        );
 
-    //     assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
-    // }
+        // Invalid target
+        {
+            let target3 =
+                AssetTarget::new(env.world.components(), Handle::<DummyAsset>::default().id())
+                    .unwrap();
+            let err3 = env.animator_mut().set_target(id, target3.into());
+            assert!(err3.is_err());
+            let err3 = err3.err().unwrap();
+            let TweeningError::MismatchingTargetKind(oc, nc) = err3 else {
+                panic!();
+            };
+            assert_eq!(oc, true);
+            assert_eq!(nc, false);
+        }
+    }
 }
diff --git a/src/test_utils.rs b/src/test_utils.rs
index d3a57cb..687adda 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -216,6 +216,11 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
         }
     }
 
+    /// Get the component.
+    pub fn component(&self) -> &T {
+        self.world.get::<T>(self.entity).unwrap()
+    }
+
     /// Get the component.
     pub fn component_mut(&mut self) -> Mut<T> {
         self.world.get_mut::<T>(self.entity).unwrap()

From 7ac47ad0c3da230e8c7c8f68c9ddf92627a118f1 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 13 Jul 2025 19:03:23 +0200
Subject: [PATCH 32/66] README fixes

---
 README.md | 102 +++++++-----------------------------------------------
 1 file changed, 12 insertions(+), 90 deletions(-)

diff --git a/README.md b/README.md
index cab513b..3121397 100644
--- a/README.md
+++ b/README.md
@@ -125,39 +125,32 @@ the first animation. You're responsible for creating sequences that make
 sense. In general, only use infinite tweenable animations alone or as the
 last element of a sequence.
 
-## Predefined Lenses
+## Built-in Lenses
 
 A small number of predefined lenses are available for the most common use cases, which also serve as examples. **Users are encouraged to write their own lens to tailor the animation to their use case.**
 
 The naming scheme for predefined lenses is `"<TargetName><FieldName>Lens"`, where `<TargetName>` is the name of the target Bevy component or asset type which is queried by the internal animation system to be modified, and `<FieldName>` is the field which is mutated in place by the lens. All predefined lenses modify a single field. Custom lenses can be written which modify multiple fields at once.
 
-### Bevy Components
-
-| Target Component | Animated Field | Lens | Feature |
+| Target | Animated Field | Lens | Feature |
 |---|---|---|---|
-| [`Transform`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html) | [`translation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.translation)     | [`TransformPositionLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformPositionLens.html)     | |
-|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (`Quat`)¹ | [`TransformRotationLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotationLens.html)     | |
-|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateXLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateXLens.html)       | |
-|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateYLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateYLens.html)       | |
-|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateZLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateZLens.html)       | |
-|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateAxisLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateAxisLens.html) | |
-|                                                                                            | [`scale`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.scale)                 | [`TransformScaleLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformScaleLens.html)           | |
+| [`Transform`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html) | [`translation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.translation)     | [`TransformPositionLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformPositionLens.html)     | (builtin) |
+|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (`Quat`)¹ | [`TransformRotationLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotationLens.html)     | (builtin) |
+|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateXLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateXLens.html)       | (builtin) |
+|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateYLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateYLens.html)       | (builtin) |
+|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateZLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateZLens.html)       | (builtin) |
+|                                                                                            | [`rotation`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.rotation) (angle)²  | [`TransformRotateAxisLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformRotateAxisLens.html) | (builtin) |
+|                                                                                            | [`scale`](https://docs.rs/bevy/0.16/bevy/transform/components/struct.Transform.html#structfield.scale)                 | [`TransformScaleLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TransformScaleLens.html)           | (builtin) |
 | [`Sprite`](https://docs.rs/bevy/0.16/bevy/sprite/struct.Sprite.html)                     | [`color`](https://docs.rs/bevy/0.16/bevy/sprite/struct.Sprite.html#structfield.color)                                  | [`SpriteColorLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.SpriteColorLens.html)                 | `bevy_sprite` |
 | [`Node`](https://docs.rs/bevy/0.16/bevy/ui/struct.Node.html)                             | [`position`](https://docs.rs/bevy/0.16/bevy/ui/struct.Node.html)                                                       | [`UiPositionLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.UiPositionLens.html)                   | `bevy_ui`     |
 | [`BackgroundColor`](https://docs.rs/bevy/0.16/bevy/ui/struct.BackgroundColor.html)       |                                                                                                                          | [`UiBackgroundColorLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.UiBackgroundColorLens.html)     | `bevy_ui`     |
 | [`TextColor`](https://docs.rs/bevy/0.16/bevy/text/struct.TextColor.html)                 |                                                                                                                          | [`TextColorLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.TextColorLens.html)                     | `bevy_text`   |
+| [`ColorMaterial`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html) | [`color`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html#structfield.color) | [`ColorMaterialColorLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.ColorMaterialColorLens.html) | `bevy_sprite` |
 
 There are two ways to interpolate rotations. See the [comparison of rotation lenses](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/index.html#rotations) for details:
 
 - ¹ Shortest-path interpolation between two rotations, using `Quat::slerp()`.
 - ² Angle-based interpolation, valid for rotations over ½ turn.
 
-### Bevy Assets
-
-| Target Asset | Animated Field | Lens | Feature |
-|---|---|---|---|
-| [`ColorMaterial`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html) | [`color`](https://docs.rs/bevy/0.16/bevy/sprite/struct.ColorMaterial.html#structfield.color) | [`ColorMaterialColorLens`](https://docs.rs/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/bevy_tweening/lens/struct.ColorMaterialColorLens.html) | `bevy_sprite` |
-
 ## Custom lens
 
 A custom lens allows animating any field or group of fields of a Bevy component or asset. A custom lens is a type implementing the `Lens` trait, which is generic over the type of component or asset.
@@ -169,7 +162,7 @@ struct MyXAxisLens {
 }
 
 impl Lens<Transform> for MyXAxisLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: Mut<Transform>, ratio: f32) {
         let x = self.start * (1. - ratio) + self.end * ratio;
         let y = target.translation.y;
         let z = target.translation.z;
@@ -202,7 +195,7 @@ struct MyCustomLens {
 }
 
 impl Lens<MyCustomComponent> for MyCustomLens {
-    fn lerp(&mut self, target: &mut MyCustomComponent, ratio: f32) {
+    fn lerp(&mut self, target: Mut<MyCustomComponent>, ratio: f32) {
         target.0 = self.start + (self.end - self.start) * ratio;
     }
 }
@@ -270,77 +263,6 @@ cargo run --example sequence --features="bevy/bevy_winit"
 
 ![sequence](https://raw.githubusercontent.com/djeedai/bevy_tweening/8b3cad18a090078d9055d77a632be44e701aecc7/examples/sequence.gif)
 
-## Ease Functions
-
-Many [ease functions](https://docs.rs/bevy/0.16/bevy/math/curve/enum.EaseFunction.html) are available from `bevy_math`:
-
-- Linear
-  > `f(t) = t`
-- QuadraticIn
-  > `f(t) = t²`
-- QuadraticOut
-  > `f(t) = -(t * (t - 2.0))`
-- QuadraticInOut
-  > Behaves as `EaseFunction::QuadraticIn` for t < 0.5 and as `EaseFunction::QuadraticOut` for t >= 0.5
-- CubicIn
-  > `f(t) = t³`
-- CubicOut
-  > `f(t) = (t - 1.0)³ + 1.0`
-- CubicInOut
-  > Behaves as `EaseFunction::CubicIn` for t < 0.5 and as `EaseFunction::CubicOut` for t >= 0.5
-- QuarticIn
-  > `f(t) = t⁴`
-- QuarticOut
-  > `f(t) = (t - 1.0)³ * (1.0 - t) + 1.0`
-- QuarticInOut
-  > Behaves as `EaseFunction::QuarticIn` for t < 0.5 and as `EaseFunction::QuarticOut` for t >= 0.5
-- QuinticIn
-  > `f(t) = t⁵`
-- QuinticOut
-  > `f(t) = (t - 1.0)⁵ + 1.0`
-- QuinticInOut
-  > Behaves as `EaseFunction::QuinticIn` for t < 0.5 and as `EaseFunction::QuinticOut` for t >= 0.5
-- SineIn
-  > `f(t) = 1.0 - cos(t * π / 2.0)`
-- SineOut
-  > `f(t) = sin(t * π / 2.0)`
-- SineInOut
-  > Behaves as `EaseFunction::SineIn` for t < 0.5 and as `EaseFunction::SineOut` for t >= 0.5
-- CircularIn
-  > `f(t) = 1.0 - sqrt(1.0 - t²)`
-- CircularOut
-  > `f(t) = sqrt((2.0 - t) * t)`
-- CircularInOut
-  > Behaves as `EaseFunction::CircularIn` for t < 0.5 and as `EaseFunction::CircularOut` for t >= 0.5
-- ExponentialIn
-  > `f(t) = 2.0^(10.0 * (t - 1.0))`
-- ExponentialOut
-  > `f(t) = 1.0 - 2.0^(-10.0 * t)`
-- ExponentialInOut
-  > Behaves as `EaseFunction::ExponentialIn` for t < 0.5 and as `EaseFunction::ExponentialOut` for t >= 0.5
-- ElasticIn
-  > `f(t) = -2.0^(10.0 * t - 10.0) * sin((t * 10.0 - 10.75) * 2.0 * π / 3.0)`
-- ElasticOut
-  > `f(t) = 2.0^(-10.0 * t) * sin((t * 10.0 - 0.75) * 2.0 * π / 3.0) + 1.0`
-- ElasticInOut
-  > Behaves as `EaseFunction::ElasticIn` for t < 0.5 and as `EaseFunction::ElasticOut` for t >= 0.5
-- BackIn
-  > `f(t) = 2.70158 * t³ - 1.70158 * t²`
-- BackOut
-  > `f(t) = 1.0 + 2.70158 * (t - 1.0)³ - 1.70158 * (t - 1.0)²`
-- BackInOut
-  > Behaves as `EaseFunction::BackIn` for t < 0.5 and as `EaseFunction::BackOut` for t >= 0.5
-- BounceIn
-  > bouncy at the start!
-- BounceOut
-  > bouncy at the end!
-- BounceInOut
-  > Behaves as `EaseFunction::BounceIn` for t < 0.5 and as `EaseFunction::BounceOut` for t >= 0.5
-- Steps(usize)
-  > `n` steps connecting the start and the end
-- Elastic(f32)
-  > `f(omega,t) = 1 - (1 - t)²(2sin(omega * t) / omega + cos(omega * t))`, parametrized by omega
-
 ## Compatible Bevy versions
 
 The `main` branch is compatible with the latest Bevy release.

From f4f9f8bf6e28ea0f85242fb0bb00552c8b7de766 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 16 Jul 2025 08:15:24 +0200
Subject: [PATCH 33/66] Fix event sending

---
 CHANGELOG.md               |  15 +-
 benchmarks/benches/lens.rs |  26 ++--
 src/lib.rs                 | 278 +++++++++++++++++++++++++------------
 src/plugin.rs              |   6 +-
 src/test_utils.rs          |   6 +-
 src/tweenable.rs           |   4 +-
 6 files changed, 224 insertions(+), 111 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 32bd25e..0982161 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,12 +5,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-_This change introduces a major API redesign, which removes the need for generics,
-and unifies all animations of all components and assets._
+_This change introduces a major API redesign compared to v0.13.
+It removes the need for generics,
+and unifies all animations of all components and assets,
+executing them from a single exclusive system._
 
 ### Added
 
+- Added `TweenAnimator`, a resource acting as a container for all active animations.
 - Added `TweenId`, a unique identifier for a currently active animation.
+- Added `TweenAnim`, a representation of the runtime parameters of an active animation.
+- Added `AnimTarget`, an enum describing the target mutated by an animation.
+  Also added two structs `ComponentAnimTarget` and `AssetAnimTarget` as its enum variants.
 - Added `TotalDuration::from_cycles()` to simply creating an animation duration
   from a number of individual cycles and their duration.
 - Added `TotalDuration::is_finite()` helper to check an animation duration is finite.
@@ -36,7 +42,10 @@ and unifies all animations of all components and assets._
   fn lerp(&mut self, target: Mut<T>, ratio: f32)
   ```
 
-- The following types lost their generic parameter:
+  The functioning is the same, but this removes one level of indirection.
+  The use of `Mut<T>` should be familiar to most Bevy users.
+
+- The following types lost their generic parameter `<T>`:
   - `Tweenable`
   - `Tween`
   - `Sequence`
diff --git a/benchmarks/benches/lens.rs b/benchmarks/benches/lens.rs
index 3f764b3..1ce600e 100644
--- a/benchmarks/benches/lens.rs
+++ b/benchmarks/benches/lens.rs
@@ -6,7 +6,7 @@ use bevy::{
     ecs::{change_detection::MaybeLocation, component::Tick},
     prelude::*,
 };
-use bevy_tweening::{lens::*, ComponentTarget};
+use bevy_tweening::lens::*;
 use criterion::{black_box, Criterion};
 
 fn text_color_lens(c: &mut Criterion) {
@@ -18,16 +18,16 @@ fn text_color_lens(c: &mut Criterion) {
     let mut added = Tick::new(0);
     let mut last_changed = Tick::new(0);
     let mut caller = MaybeLocation::caller();
-    let mut target = ComponentTarget::new(Mut::new(
+    let mut target = Mut::new(
         &mut text_color,
         &mut added,
         &mut last_changed,
         Tick::new(0),
         Tick::new(0),
         caller.as_mut(),
-    ));
+    );
     c.bench_function("TextColorLens", |b| {
-        b.iter(|| lens.lerp(&mut target, black_box(0.3)))
+        b.iter(|| lens.lerp(target.reborrow(), black_box(0.3)))
     });
 }
 
@@ -40,16 +40,16 @@ fn transform_position_lens(c: &mut Criterion) {
     let mut added = Tick::new(0);
     let mut last_changed = Tick::new(0);
     let mut caller = MaybeLocation::caller();
-    let mut target = ComponentTarget::new(Mut::new(
+    let mut target = Mut::new(
         &mut transform,
         &mut added,
         &mut last_changed,
         Tick::new(0),
         Tick::new(0),
         caller.as_mut(),
-    ));
+    );
     c.bench_function("TransformPositionLens", |b| {
-        b.iter(|| lens.lerp(&mut target, black_box(0.3)))
+        b.iter(|| lens.lerp(target.reborrow(), black_box(0.3)))
     });
 }
 
@@ -62,16 +62,16 @@ fn transform_rotation_lens(c: &mut Criterion) {
     let mut added = Tick::new(0);
     let mut last_changed = Tick::new(0);
     let mut caller = MaybeLocation::caller();
-    let mut target = ComponentTarget::new(Mut::new(
+    let mut target = Mut::new(
         &mut transform,
         &mut added,
         &mut last_changed,
         Tick::new(0),
         Tick::new(0),
         caller.as_mut(),
-    ));
+    );
     c.bench_function("TransformRotationLens", |b| {
-        b.iter(|| lens.lerp(&mut target, black_box(0.3)))
+        b.iter(|| lens.lerp(target.reborrow(), black_box(0.3)))
     });
 }
 
@@ -84,16 +84,16 @@ fn transform_scale_lens(c: &mut Criterion) {
     let mut added = Tick::new(0);
     let mut last_changed = Tick::new(0);
     let mut caller = MaybeLocation::caller();
-    let mut target = ComponentTarget::new(Mut::new(
+    let mut target = Mut::new(
         &mut transform,
         &mut added,
         &mut last_changed,
         Tick::new(0),
         Tick::new(0),
         caller.as_mut(),
-    ));
+    );
     c.bench_function("TransformScaleLens", |b| {
-        b.iter(|| lens.lerp(&mut target, black_box(0.3)))
+        b.iter(|| lens.lerp(target.reborrow(), black_box(0.3)))
     });
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index c99f0bf..996e0dd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -86,7 +86,7 @@
 //! # }
 //! ```
 //!
-//! See the [`EntityCommandsTweeningExtensions`] extension trait for details.
+//! See the [`EntityWorldMutTweeningExtensions`] extension trait for details.
 //!
 //! # Ready to animate
 //!
@@ -155,12 +155,13 @@
 //! The animator determine the component or asset to animate via an
 //! [`AnimTarget`], and accesses its field(s) using a [`Lens`].
 //!
-//! - Components are animated via the [`ComponentTarget`], which identifies a
-//!   component instance on an entity via the [`Entity`] itself and the
+//! - Components are animated via the [`ComponentAnimTarget`], which identifies
+//!   a component instance on an entity via the [`Entity`] itself and the
 //!   [`ComponentId`] of the registered component type.
-//! - Assets are animated in a similar way to component, via the [`AssetTarget`]
-//!   which identifies an asset via the type of its [`Assets`] collection and
-//!   the [`AssetId`] referencing that asset inside the collection.
+//! - Assets are animated in a similar way to component, via the
+//!   [`AssetAnimTarget`] which identifies an asset via the type of its
+//!   [`Assets`] collection and the [`AssetId`] referencing that asset inside
+//!   the collection.
 //!
 //! Because assets are typically shared, and the animation applies to the asset
 //! itself, all users of the asset see the animation. For example, animating the
@@ -479,11 +480,12 @@ new_key_type! {
     pub struct TweenId;
 }
 
-/// Extensions for [`EntityCommands`] to queue tween-based animations.
+/// Extensions to queue tween-based animations.
 ///
-/// This trait provide extension functions to [`EntityCommands`], allowing
-/// convenient syntaxes like inserting a new component and immediately attaching
-/// a tweenable animation to it in a single call.
+/// This trait provide extension functions to [`EntityWorldMut`] and
+/// [`EntityCommands`], allowing convenient syntaxes like inserting a new
+/// component and immediately attaching a tweenable animation to it in a single
+/// call.
 ///
 /// ```
 /// # use bevy::{prelude::*, ecs::world::CommandQueue};
@@ -527,13 +529,33 @@ new_key_type! {
 /// instead. This is best used for cases where you know those conditions at
 /// build time. To avoid a panic, prefer manually queuing a new tweenable
 /// animation through the [`TweenAnimator`].
-pub trait EntityCommandsTweeningExtensions<'a> {
+pub trait EntityWorldMutTweeningExtensions<'a> {
     /// Queue the given [`Tweenable`].
     ///
     /// This calls [`TweenAnimator::add_component()`] on the current entity,
     /// deriving the proper component to animate based on the type of the
     /// lens stored inside the tweenable (see [`Tweenable::type_id()`]). That
     /// component must exists on the entity.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::{*, lens::TransformPositionLens};
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// let tween = Tween::new(
+    ///     EaseFunction::QuadraticIn,
+    ///     Duration::from_secs(1),
+    ///     TransformPositionLens {
+    ///         start: Vec3::ZERO,
+    ///         end: Vec3::new(3.5, 0., 0.),
+    ///     },
+    /// );
+    /// commands.spawn(Transform::default()).tween(tween);
+    /// ```
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
     where
         T: Tweenable + 'static;
@@ -699,7 +721,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     ) -> &mut Self;
 }
 
-impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
+impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
     fn tween<T>(&mut self, tweenable: T) -> &mut EntityCommands<'a>
     where
         T: Tweenable + 'static,
@@ -758,14 +780,14 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     }
 }
 
-impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
+impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
     where
         T: Tweenable + 'static,
     {
         let type_id = tweenable.type_id().unwrap();
         let component_id = self.world().components().get_id(type_id).unwrap();
-        let target = ComponentTarget {
+        let target = ComponentAnimTarget {
             component_id,
             entity: self.id(),
         };
@@ -858,12 +880,12 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityWorldMut<'a> {
 fn make_component_tween_from_ent_world_mut<'w, C: Component<Mutability = Mutable>, T>(
     ent: &mut EntityWorldMut<'w>,
     read: fn(&C) -> T,
-) -> (T, ComponentTarget) {
+) -> (T, ComponentAnimTarget) {
     let component_id = ent.world().component_id::<C>().unwrap();
     let component = ent.get::<C>().unwrap();
     let value = read(component);
     let e = ent.id();
-    let target = ComponentTarget {
+    let target = ComponentAnimTarget {
         entity: e,
         component_id,
     };
@@ -873,16 +895,21 @@ fn make_component_tween_from_ent_world_mut<'w, C: Component<Mutability = Mutable
 /// Event raised when a [`TweenAnim`] completed.
 #[derive(Copy, Clone, Event)]
 pub struct AnimCompletedEvent {
-    /// The ID of the tween animation which completed. Note that commonly the
-    /// [`TweenAnim`] is pruned out of the [`TweenAnimator`] on completion, so
-    /// can't be queried anymore with this ID. However animation IDs are unique,
-    /// so this can be used to identify the tweenable animation from an ID
-    /// stored by the user.
+    /// The ID of the tween animation which completed.
+    ///
+    /// Note that commonly the [`TweenAnim`] is pruned out of the
+    /// [`TweenAnimator`] on completion, so can't be queried anymore with
+    /// this ID. However animation IDs are unique, so this can be used to
+    /// identify the tweenable animation from an ID stored by the user. You
+    /// can prevent a completed animation from being automatically destroyed by
+    /// setting [`TweenAnim::destroy_on_completion`] to `false`.
     pub id: TweenId,
-    /// The animation target. This is provided both as a convenience for
-    /// [`TweenAnim`]s not pruned from the [`TweenAnimator`] on completion, and
-    /// because for those animations which are pruned the information is not
-    /// available in anymore in another way.
+    /// The animation target.
+    ///
+    /// This is provided both as a convenience for [`TweenAnim`]s not destroyed
+    /// from the [`TweenAnimator`] on completion, and because for those
+    /// animations which are destroyed on completion the information is not
+    /// available anymore when this event is received.
     pub target: AnimTarget,
 }
 
@@ -931,14 +958,14 @@ pub enum TweeningError {
 /// This is a lightweight reference (copyable) implicitly tied to a given
 /// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ComponentTarget {
+pub struct ComponentAnimTarget {
     /// Component ID of the registered component being animated.
     pub component_id: ComponentId,
     /// Entity holding the component instance being animated.
     pub entity: Entity,
 }
 
-impl ComponentTarget {
+impl ComponentAnimTarget {
     /// Create a new component target.
     pub fn new<C: Component<Mutability = Mutable>>(
         components: &Components,
@@ -979,14 +1006,14 @@ impl ComponentTarget {
 /// This is a lightweight reference (copyable) implicitly tied to a given
 /// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct AssetTarget {
+pub struct AssetAnimTarget {
     /// Resource ID of the registered [`Assets`] asset container.
     pub resource_id: ComponentId,
     /// Asset ID of the target asset being animated.
     pub asset_id: UntypedAssetId,
 }
 
-impl AssetTarget {
+impl AssetAnimTarget {
     /// Create a new asset target.
     pub fn new<A: Asset>(
         components: &Components,
@@ -1022,21 +1049,22 @@ impl AssetTarget {
 /// Animation target.
 ///
 /// References either a component or an asset used as the target of a tweenable
-/// animation. See [`ComponentTarget`] and [`AssetTarget`] for details. This is
-/// a lightweight reference (copyable) implicitly tied to a given [`World`].
+/// animation. See [`ComponentAnimTarget`] and [`AssetAnimTarget`] for details.
+/// This is a lightweight reference (copyable) implicitly tied to a given
+/// [`World`].
 ///
 /// To create an animation target from a given component or asset, see the
 /// [`WorldTargetExtensions`] extension trait for [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum AnimTarget {
     /// Component animation target.
-    Component(ComponentTarget),
+    Component(ComponentAnimTarget),
     /// Asset animation target.
-    Asset(AssetTarget),
+    Asset(AssetAnimTarget),
 }
 
 impl AnimTarget {
-    /// Check if the target is a component.
+    /// Check if the target is an [`AnimTarget::Component`].
     #[inline]
     pub fn is_component(&self) -> bool {
         matches!(*self, AnimTarget::Component(..))
@@ -1044,7 +1072,7 @@ impl AnimTarget {
 
     /// Convert this target to a component target if possible.
     #[inline]
-    pub fn as_component(&self) -> Option<&ComponentTarget> {
+    pub fn as_component(&self) -> Option<&ComponentAnimTarget> {
         if let Self::Component(component) = self {
             Some(component)
         } else {
@@ -1054,7 +1082,7 @@ impl AnimTarget {
 
     /// Convert this target to a component target if possible.
     #[inline]
-    pub fn as_component_mut(&mut self) -> Option<&mut ComponentTarget> {
+    pub fn as_component_mut(&mut self) -> Option<&mut ComponentAnimTarget> {
         if let Self::Component(component) = self {
             Some(component)
         } else {
@@ -1062,7 +1090,7 @@ impl AnimTarget {
         }
     }
 
-    /// Check if the target is an asset.
+    /// Check if the target is an [`AnimTarget::Asset`].
     #[inline]
     pub fn is_asset(&self) -> bool {
         matches!(*self, AnimTarget::Asset(..))
@@ -1070,7 +1098,7 @@ impl AnimTarget {
 
     /// Convert this target to an asset target if possible.
     #[inline]
-    pub fn as_asset(&self) -> Option<&AssetTarget> {
+    pub fn as_asset(&self) -> Option<&AssetAnimTarget> {
         if let Self::Asset(asset) = self {
             Some(asset)
         } else {
@@ -1080,7 +1108,7 @@ impl AnimTarget {
 
     /// Convert this target to an asset target if possible.
     #[inline]
-    pub fn as_asset_mut(&mut self) -> Option<&mut AssetTarget> {
+    pub fn as_asset_mut(&mut self) -> Option<&mut AssetAnimTarget> {
         if let Self::Asset(asset) = self {
             Some(asset)
         } else {
@@ -1089,14 +1117,14 @@ impl AnimTarget {
     }
 }
 
-impl From<ComponentTarget> for AnimTarget {
-    fn from(value: ComponentTarget) -> Self {
+impl From<ComponentAnimTarget> for AnimTarget {
+    fn from(value: ComponentAnimTarget) -> Self {
         AnimTarget::Component(value)
     }
 }
 
-impl From<AssetTarget> for AnimTarget {
-    fn from(value: AssetTarget) -> Self {
+impl From<AssetAnimTarget> for AnimTarget {
+    fn from(value: AssetAnimTarget) -> Self {
         AnimTarget::Asset(value)
     }
 }
@@ -1119,7 +1147,7 @@ pub trait WorldTargetExtensions {
     fn get_component_target<C: Component<Mutability = Mutable>>(
         &self,
         entity: Entity,
-    ) -> Option<ComponentTarget>;
+    ) -> Option<ComponentAnimTarget>;
 
     /// Get an [`AnimTarget`] for the given asset type and ID pair.
     ///
@@ -1132,31 +1160,31 @@ pub trait WorldTargetExtensions {
     /// Returns the animation target referencing the asset instance, or
     /// `None` if either the ID doesn't reference an existing asset or the asset
     /// type is not registered.
-    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetTarget>;
+    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetAnimTarget>;
 }
 
 impl WorldTargetExtensions for World {
     fn get_component_target<C: Component<Mutability = Mutable>>(
         &self,
         entity: Entity,
-    ) -> Option<ComponentTarget> {
+    ) -> Option<ComponentAnimTarget> {
         let component_id = self.component_id::<C>()?;
         if !self.entities().contains(entity) {
             return None;
         }
-        Some(ComponentTarget {
+        Some(ComponentAnimTarget {
             component_id,
             entity,
         })
     }
 
-    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetTarget> {
+    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetAnimTarget> {
         let id = id.into();
         if !self.resource::<Assets<A>>().contains(id) {
             return None;
         }
         let resource_id = self.resource_id::<Assets<A>>()?;
-        Some(AssetTarget {
+        Some(AssetAnimTarget {
             resource_id,
             asset_id: id.untyped(),
         })
@@ -1204,10 +1232,10 @@ impl TweenAnim {
     /// that you can't insert a single [`Delay`]. You can however use a
     /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
     /// provided there's at least one other typed tweenable in the sequence.
-    pub fn new(target: AnimTarget, tweenable: impl Tweenable + 'static) -> Self {
+    pub fn new(target: AnimTarget, tweenable: BoxedTweenable) -> Self {
         Self {
             target,
-            tweenable: Box::new(tweenable),
+            tweenable,
             playback_state: PlaybackState::Playing,
             speed: 1.,
             destroy_on_completion: true,
@@ -1285,13 +1313,14 @@ impl TweenAnim {
 /// # let entity = Entity::PLACEHOLDER;
 ///     // Create an AnimTarget::Component() from an Entity and a component type
 ///     // let entity = ...
-///     let target = ComponentTarget::new::<Transform>(components, entity)?.into();
+///     let target = ComponentAnimTarget::new::<Transform>(components, entity)?;
+///     let target: AnimTarget = target.into();
 ///
 ///     // Lookup all active animations and filter by target
 ///     let animations: Vec<&TweenAnim> = animator
 ///         .iter()
 ///         .filter_map(|(_id, anim)| {
-///             if anim.target == target {
+///             if *anim.target() == target {
 ///                 Some(anim)
 ///             } else {
 ///                 None
@@ -1336,7 +1365,7 @@ impl TweenAnimator {
     /// Add a new component animation to the animator queue.
     ///
     /// In general you don't need to call this directly. Instead, use the
-    /// extensions provided by [`EntityCommandsTweeningExtensions`] to directly
+    /// extensions provided by [`EntityWorldMutTweeningExtensions`] to directly
     /// create and queue tweenable animations on a given [`EntityCommands`],
     /// like this:
     ///
@@ -1408,23 +1437,24 @@ impl TweenAnimator {
         let Some(type_id) = tweenable.type_id() else {
             return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
         };
-        let target = ComponentTarget::new_untyped(components, type_id, entity)?.into();
+        let target = ComponentAnimTarget::new_untyped(components, type_id, entity)?.into();
         Ok(self.add_component_target(target, tweenable))
     }
 
-    /// Add a new component animation via an existing component target.
+    /// Add a new component animation via an existing [`ComponentAnimTarget`].
     ///
     /// See [`add_component()`] for details. This variant is useful when you can
-    /// build in advance a [`ComponentTarget`], but at the same time don't have
-    /// readily access to the [`Components`] of the world.
+    /// build in advance a [`ComponentAnimTarget`], but at the same time don't
+    /// have readily access to the [`Components`] of the world.
     ///
     /// [`add_component()`]: Self::add_component
     #[inline]
-    pub fn add_component_target<T>(&mut self, target: ComponentTarget, tweenable: T) -> TweenId
+    pub fn add_component_target<T>(&mut self, target: ComponentAnimTarget, tweenable: T) -> TweenId
     where
         T: Tweenable + 'static,
     {
-        self.anims.insert(TweenAnim::new(target.into(), tweenable))
+        self.anims
+            .insert(TweenAnim::new(target.into(), Box::new(tweenable)))
     }
 
     /// Add a new asset animation to the animator queue.
@@ -1495,7 +1525,7 @@ impl TweenAnimator {
             });
         }
         let asset_id = asset_id.into();
-        let target = AssetTarget::new_untyped(components, type_id, asset_id.untyped())?;
+        let target = AssetAnimTarget::new_untyped(components, type_id, asset_id.untyped())?;
         self.asset_resolver.insert(
             target.resource_id,
             Box::new(
@@ -1510,7 +1540,9 @@ impl TweenAnimator {
                 },
             ),
         );
-        Ok(self.anims.insert(TweenAnim::new(target.into(), tweenable)))
+        Ok(self
+            .anims
+            .insert(TweenAnim::new(target.into(), Box::new(tweenable))))
     }
 
     /// Check if the animation with the given ID is queued.
@@ -1655,12 +1687,17 @@ impl TweenAnimator {
     ///   tweenable as returned by [`elapsed()`].
     ///
     /// ```
-    /// #fn sys(mut animator: ResMut<TweenAnimator>) {
-    /// #let id = TweenId::null();
-    /// let elapsed = animator.get(id).unwrap().elapsed();
+    /// # use std::time::Duration;
+    /// # use slotmap::Key as _;
+    /// # use bevy::prelude::*;
+    /// # use bevy_tweening::*;
+    /// # fn sys(mut animator: ResMut<TweenAnimator>) {
+    /// # let id = TweenId::null();
+    /// # let mut tweenable = Delay::new(Duration::from_secs(1));
+    /// let elapsed = animator.get(id).unwrap().tweenable().elapsed();
     /// tweenable.set_elapsed(elapsed);
     /// animator.set_tweenable(id, tweenable);
-    /// #}
+    /// # }
     /// ```
     ///
     /// To recompute the actual tweenable animation state and force a target
@@ -1748,11 +1785,11 @@ impl TweenAnimator {
 
         // Resolve the (untyped) target as a MutUntyped<T>
         let Some(mut mut_untyped) = (match &anim.target {
-            AnimTarget::Component(ComponentTarget {
+            AnimTarget::Component(ComponentAnimTarget {
                 entity,
                 component_id,
             }) => world.get_mut_by_id(*entity, *component_id),
-            AnimTarget::Asset(AssetTarget {
+            AnimTarget::Asset(AssetAnimTarget {
                 resource_id,
                 asset_id,
             }) => {
@@ -1819,6 +1856,9 @@ impl TweenAnimator {
         mut events: Mut<Events<TweenCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) {
+        let mut delayed_events = Vec::with_capacity(8);
+        let mut sent_commands = false;
+
         // Loop over active animations, tick them, and retain those which are still
         // active after that
         self.anims.retain(|tween_id, anim| {
@@ -1834,11 +1874,11 @@ impl TweenAnimator {
 
             // Resolve the (untyped) target as a MutUntyped<T>
             let Some(mut mut_untyped) = (match &anim.target {
-                AnimTarget::Component(ComponentTarget {
+                AnimTarget::Component(ComponentAnimTarget {
                     entity,
                     component_id,
                 }) => world.get_mut_by_id(*entity, *component_id),
-                AnimTarget::Asset(AssetTarget {
+                AnimTarget::Asset(AssetAnimTarget {
                     resource_id,
                     asset_id,
                 }) => {
@@ -1855,6 +1895,7 @@ impl TweenAnimator {
             }) else {
                 return false;
             };
+            let mut_untyped = mut_untyped.reborrow();
 
             // Scale delta time by this animation's speed. Reject negative speeds; use
             // backward playback to play in reverse direction.
@@ -1862,31 +1903,63 @@ impl TweenAnimator {
             let delta_time = delta_time.mul_f64(anim.speed.max(0.));
 
             // Step the tweenable animation
+            let entity = anim.target.as_component().map(|comp| comp.entity);
             let mut notify_completed = |fraction: f32| {
-                events.send(TweenCompletedEvent {
-                    id: tween_id,
-                    target: anim.target,
-                    progress: fraction,
-                });
+                delayed_events.push((
+                    TweenCompletedEvent {
+                        id: tween_id,
+                        target: anim.target,
+                        progress: fraction,
+                    },
+                    entity,
+                ));
             };
-            let state = anim.tweenable.step(
-                tween_id,
-                delta_time,
-                mut_untyped.reborrow(),
-                &mut notify_completed,
-            );
+            let state =
+                anim.tweenable
+                    .step(tween_id, delta_time, mut_untyped, &mut notify_completed);
             anim.tween_state = state;
 
-            // Raise completed event
+            // Send events once we reclaimed mut access to world
+            if !delayed_events.is_empty() {
+                let mut commands = world.commands();
+                sent_commands = true;
+
+                for (event, entity) in delayed_events.drain(..) {
+                    // Send buffered event
+                    events.send(event);
+
+                    // Trigger all entity-scoped observers
+                    if let Some(entity) = entity {
+                        commands.trigger_targets(event, entity);
+                    }
+                }
+            }
+
+            // Record completed event
             if state == TweenState::Completed {
-                anim_events.send(AnimCompletedEvent {
+                let event = AnimCompletedEvent {
                     id: tween_id,
                     target: anim.target,
-                });
+                };
+
+                // Send buffered event
+                anim_events.send(event);
+
+                // Trigger all entity-scoped observers
+                if let Some(entity) = entity {
+                    let mut commands = world.commands();
+                    sent_commands = true;
+                    commands.trigger_targets(event, entity);
+                }
             }
 
             state == TweenState::Active || !anim.destroy_on_completion
         });
+
+        // Flush commands
+        if sent_commands {
+            world.flush();
+        }
     }
 }
 
@@ -2134,6 +2207,37 @@ mod tests {
         }
     }
 
+    #[test]
+    fn animation_events() {
+        let tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        )
+        .with_repeat_count(2)
+        .with_completed_event(true);
+        let mut env = TestEnv::<DummyComponent>::new(tween);
+
+        // Tick until one cycle is completed, but not the entire animation
+        let dt = Duration::from_millis(1200);
+        env.step_all(dt);
+        assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
+
+        // Check events
+        assert_eq!(env.event_count::<TweenCompletedEvent>(), 1);
+        assert_eq!(env.event_count::<AnimCompletedEvent>(), 0);
+
+        // Tick until completion
+        let dt = Duration::from_millis(1000);
+        env.step_all(dt);
+        assert!(env.anim().is_none());
+
+        // Check events (note that we didn't clear previous events, so that's a
+        // cumulative count).
+        assert_eq!(env.event_count::<TweenCompletedEvent>(), 1);
+        assert_eq!(env.event_count::<AnimCompletedEvent>(), 1);
+    }
+
     // #[test]
     // fn animator_controls() {
     //     let tween = Tween::<DummyComponent>::new(
@@ -2250,7 +2354,7 @@ mod tests {
         {
             let entity = env.entity;
             let target =
-                ComponentTarget::new::<DummyComponent>(env.world.components(), entity).unwrap();
+                ComponentAnimTarget::new::<DummyComponent>(env.world.components(), entity).unwrap();
             let err = env
                 .animator_mut()
                 .set_target(TweenId::null(), target.into())
@@ -2284,7 +2388,7 @@ mod tests {
         // Now retarget
         let id = env.tween_id;
         let target2 =
-            ComponentTarget::new::<DummyComponent>(env.world.components(), entity2).unwrap();
+            ComponentAnimTarget::new::<DummyComponent>(env.world.components(), entity2).unwrap();
         let target1 = env.animator_mut().set_target(id, target2.into()).unwrap();
         assert!(target1.is_component());
         let comp1 = target1.as_component().unwrap();
@@ -2309,7 +2413,7 @@ mod tests {
         // Invalid target
         {
             let target3 =
-                AssetTarget::new(env.world.components(), Handle::<DummyAsset>::default().id())
+                AssetAnimTarget::new(env.world.components(), Handle::<DummyAsset>::default().id())
                     .unwrap();
             let err3 = env.animator_mut().set_target(id, target3.into());
             assert!(err3.is_err());
diff --git a/src/plugin.rs b/src/plugin.rs
index cd2da6b..7541e02 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -109,7 +109,7 @@ mod tests {
 
         env.step_all(Duration::from_millis(500));
 
-        assert_eq!(env.event_count(), 0);
+        assert_eq!(env.event_count::<TweenCompletedEvent>(), 0);
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
@@ -124,7 +124,7 @@ mod tests {
         // The final state was still applied before deleting the animation,
         // so the component is changed.
 
-        assert_eq!(env.event_count(), 1);
+        assert_eq!(env.event_count::<TweenCompletedEvent>(), 1);
         let animator = env.animator();
         assert!(animator.get(env.tween_id).is_none()); // done and deleted
         let transform = env.component_mut();
@@ -134,7 +134,7 @@ mod tests {
         // We can continue to tick as much as we want, this doesn't change anything
         env.step_all(Duration::from_millis(100));
 
-        assert_eq!(env.event_count(), 0);
+        assert_eq!(env.event_count::<TweenCompletedEvent>(), 0);
         let animator = env.animator();
         assert!(animator.get(env.tween_id).is_none()); // done and deleted
         let transform = env.component_mut();
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 687adda..a42ae80 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -5,7 +5,7 @@ use bevy::{
         change_detection::DetectChanges as _,
         component::{Component, Mutable},
         entity::Entity,
-        event::Events,
+        event::{Event, Events},
         system::{IntoSystem, System},
         world::{Mut, World},
     },
@@ -227,8 +227,8 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
     }
 
     /// Get the emitted event count since last tick.
-    pub fn event_count(&self) -> usize {
-        let events = self.world.resource::<Events<TweenCompletedEvent>>();
+    pub fn event_count<E: Event>(&self) -> usize {
+        let events = self.world.resource::<Events<E>>();
         events.get_cursor().len(events)
     }
 }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index fd37301..360d7a1 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1378,7 +1378,7 @@ mod tests {
     use slotmap::Key as _;
 
     use super::*;
-    use crate::{lens::*, test_utils::assert_approx_eq, ComponentTarget};
+    use crate::{lens::*, test_utils::assert_approx_eq, ComponentAnimTarget};
 
     // #[derive(Default, Copy, Clone)]
     // struct CallbackMonitor {
@@ -1531,7 +1531,7 @@ mod tests {
                 let component_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
                 if let Ok(mut target) = entity_mut.get_mut_by_id(component_id) {
-                    let world_target = ComponentTarget {
+                    let world_target = ComponentAnimTarget {
                         entity,
                         component_id,
                     }

From 370af8dc5b7119ee6b51268ba041c6046372567c Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 16 Jul 2025 11:26:22 +0200
Subject: [PATCH 34/66] Fix one-shot systems

---
 src/lib.rs       | 306 ++++++++++++++++++++++++++++-------------------
 src/tweenable.rs |  36 ++++--
 2 files changed, 205 insertions(+), 137 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 996e0dd..57194fd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -247,6 +247,7 @@ use bevy::{
     ecs::{
         change_detection::MutUntyped,
         component::{ComponentId, Components, Mutable},
+        system::SystemId,
     },
     platform::collections::HashMap,
     prelude::*,
@@ -1287,6 +1288,18 @@ impl TweenAnim {
     }
 }
 
+type Resolver = Box<
+    dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
+        + Send
+        + Sync
+        + 'static,
+>;
+
+struct StepResult {
+    pub retain: bool,
+    pub sent_commands: bool,
+}
+
 /// Animator for tween-based animations.
 ///
 /// This resource stores all the active tweening animations for the entire
@@ -1341,15 +1354,7 @@ pub struct TweenAnimator {
     /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
     /// The resolver is allowed to fail (return `None`), for example when the
     /// asset ID doesn't reference a valid asset.
-    asset_resolver: HashMap<
-        ComponentId,
-        Box<
-            dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
-                + Send
-                + Sync
-                + 'static,
-        >,
-    >,
+    asset_resolver: HashMap<ComponentId, Resolver>,
 }
 
 impl Default for TweenAnimator {
@@ -1752,8 +1757,24 @@ impl TweenAnimator {
         events: Mut<Events<TweenCompletedEvent>>,
         anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Option<TweenAnim> {
-        if let Ok(retain) = self.step_impl(id, world, delta_time, events, anim_events) {
-            if !retain {
+        let anim = self.anims.get_mut(id)?;
+
+        let ret = Self::step_impl(
+            id,
+            anim,
+            &self.asset_resolver,
+            world,
+            delta_time,
+            events,
+            anim_events,
+        );
+
+        if let Ok(ret) = ret {
+            if ret.sent_commands {
+                world.flush();
+            }
+
+            if !ret.retain {
                 return Some(self.anims.remove(id).unwrap());
             }
         }
@@ -1761,26 +1782,34 @@ impl TweenAnimator {
     }
 
     fn step_impl(
-        &mut self,
-        id: TweenId,
+        tween_id: TweenId,
+        anim: &mut TweenAnim,
+        asset_resolver: &HashMap<ComponentId, Resolver>,
         world: &mut World,
         delta_time: Duration,
         mut events: Mut<Events<TweenCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
-    ) -> Result<bool, TweeningError> {
-        let anim = self
-            .anims
-            .get_mut(id)
-            .ok_or(TweeningError::InvalidTweenId(id))?;
+    ) -> Result<StepResult, TweeningError> {
+        let mut queued_systems = Vec::with_capacity(8);
+        let mut completed_events = Vec::with_capacity(8);
+        let mut sent_commands = false;
 
         // Retain completed animations only if requested
         if anim.tween_state == TweenState::Completed {
-            return Ok(!anim.destroy_on_completion);
+            let ret = StepResult {
+                retain: !anim.destroy_on_completion,
+                sent_commands: false,
+            };
+            return Ok(ret);
         }
 
         // Skip paused animations (but retain them)
         if anim.playback_state == PlaybackState::Paused {
-            return Ok(true);
+            let ret = StepResult {
+                retain: true,
+                sent_commands: false,
+            };
+            return Ok(ret);
         }
 
         // Resolve the (untyped) target as a MutUntyped<T>
@@ -1794,7 +1823,7 @@ impl TweenAnimator {
                 asset_id,
             }) => {
                 if let Some(assets) = world.get_resource_mut_by_id(*resource_id) {
-                    if let Some(resolver) = self.asset_resolver.get(resource_id) {
+                    if let Some(resolver) = asset_resolver.get(resource_id) {
                         resolver(assets, *asset_id)
                     } else {
                         None
@@ -1804,7 +1833,11 @@ impl TweenAnimator {
                 }
             }
         }) else {
-            return Ok(false);
+            let ret = StepResult {
+                retain: false,
+                sent_commands: false,
+            };
+            return Ok(ret);
         };
 
         // Scale delta time by this animation's speed. Reject negative speeds; use
@@ -1813,30 +1846,74 @@ impl TweenAnimator {
         let delta_time = delta_time.mul_f64(anim.speed.max(0.));
 
         // Step the tweenable animation
+        let entity = anim.target.as_component().map(|comp| comp.entity);
         let mut notify_completed = |fraction: f32| {
-            events.send(TweenCompletedEvent {
-                id,
-                target: anim.target,
-                progress: fraction,
-            });
+            completed_events.push((
+                TweenCompletedEvent {
+                    id: tween_id,
+                    target: anim.target,
+                    progress: fraction,
+                },
+                entity,
+            ));
+        };
+        let mut queue_system = |system_id: SystemId| {
+            queued_systems.push(system_id);
         };
         let state = anim.tweenable.step(
-            id,
+            tween_id,
             delta_time,
             mut_untyped.reborrow(),
             &mut notify_completed,
+            &mut queue_system,
         );
         anim.tween_state = state;
 
-        // Raise completed event
+        // Send tween completed events once we reclaimed mut access to world and can get
+        // a Commands.
+        if !completed_events.is_empty() {
+            let mut commands = world.commands();
+            sent_commands = true;
+
+            for (event, entity) in completed_events.drain(..) {
+                // Send buffered event
+                events.send(event);
+
+                // Trigger all entity-scoped observers
+                if let Some(entity) = entity {
+                    commands.trigger_targets(event, entity);
+                }
+            }
+        }
+
+        // Execute one-shot systems
+        for sys_id in queued_systems.drain(..) {
+            let _ = world.run_system(sys_id);
+        }
+
+        // Raise animation completed event
         if state == TweenState::Completed {
-            anim_events.send(AnimCompletedEvent {
-                id,
+            let event = AnimCompletedEvent {
+                id: tween_id,
                 target: anim.target,
-            });
+            };
+
+            // Send buffered event
+            anim_events.send(event);
+
+            // Trigger all entity-scoped observers
+            if let Some(entity) = entity {
+                let mut commands = world.commands();
+                sent_commands = true;
+                commands.trigger_targets(event, entity);
+            }
         }
 
-        Ok(state == TweenState::Active || !anim.destroy_on_completion)
+        let ret = StepResult {
+            retain: state == TweenState::Active || !anim.destroy_on_completion,
+            sent_commands,
+        };
+        Ok(ret)
     }
 
     /// Step all queued animations.
@@ -1856,104 +1933,25 @@ impl TweenAnimator {
         mut events: Mut<Events<TweenCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) {
-        let mut delayed_events = Vec::with_capacity(8);
         let mut sent_commands = false;
 
         // Loop over active animations, tick them, and retain those which are still
         // active after that
         self.anims.retain(|tween_id, anim| {
-            // Retain completed animations only if requested
-            if anim.tween_state == TweenState::Completed {
-                return !anim.destroy_on_completion;
-            }
-
-            // Skip paused animations (but retain them)
-            if anim.playback_state == PlaybackState::Paused {
-                return true;
-            }
-
-            // Resolve the (untyped) target as a MutUntyped<T>
-            let Some(mut mut_untyped) = (match &anim.target {
-                AnimTarget::Component(ComponentAnimTarget {
-                    entity,
-                    component_id,
-                }) => world.get_mut_by_id(*entity, *component_id),
-                AnimTarget::Asset(AssetAnimTarget {
-                    resource_id,
-                    asset_id,
-                }) => {
-                    if let Some(assets) = world.get_resource_mut_by_id(*resource_id) {
-                        if let Some(resolver) = self.asset_resolver.get(resource_id) {
-                            resolver(assets, *asset_id)
-                        } else {
-                            None
-                        }
-                    } else {
-                        None
-                    }
-                }
-            }) else {
-                return false;
-            };
-            let mut_untyped = mut_untyped.reborrow();
-
-            // Scale delta time by this animation's speed. Reject negative speeds; use
-            // backward playback to play in reverse direction.
-            // Note: must use f64 for precision; f32 produces visible roundings.
-            let delta_time = delta_time.mul_f64(anim.speed.max(0.));
-
-            // Step the tweenable animation
-            let entity = anim.target.as_component().map(|comp| comp.entity);
-            let mut notify_completed = |fraction: f32| {
-                delayed_events.push((
-                    TweenCompletedEvent {
-                        id: tween_id,
-                        target: anim.target,
-                        progress: fraction,
-                    },
-                    entity,
-                ));
-            };
-            let state =
-                anim.tweenable
-                    .step(tween_id, delta_time, mut_untyped, &mut notify_completed);
-            anim.tween_state = state;
-
-            // Send events once we reclaimed mut access to world
-            if !delayed_events.is_empty() {
-                let mut commands = world.commands();
-                sent_commands = true;
-
-                for (event, entity) in delayed_events.drain(..) {
-                    // Send buffered event
-                    events.send(event);
-
-                    // Trigger all entity-scoped observers
-                    if let Some(entity) = entity {
-                        commands.trigger_targets(event, entity);
-                    }
-                }
-            }
-
-            // Record completed event
-            if state == TweenState::Completed {
-                let event = AnimCompletedEvent {
-                    id: tween_id,
-                    target: anim.target,
-                };
-
-                // Send buffered event
-                anim_events.send(event);
-
-                // Trigger all entity-scoped observers
-                if let Some(entity) = entity {
-                    let mut commands = world.commands();
-                    sent_commands = true;
-                    commands.trigger_targets(event, entity);
-                }
+            let ret = Self::step_impl(
+                tween_id,
+                anim,
+                &self.asset_resolver,
+                world,
+                delta_time,
+                events.reborrow(),
+                anim_events.reborrow(),
+            );
+            if let Ok(ret) = ret {
+                sent_commands = sent_commands || ret.sent_commands;
+                return ret.retain;
             }
-
-            state == TweenState::Active || !anim.destroy_on_completion
+            false
         });
 
         // Flush commands
@@ -1995,6 +1993,8 @@ impl ColorLerper for Color {
 
 #[cfg(test)]
 mod tests {
+    use std::marker::PhantomData;
+
     use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
     use slotmap::Key as _;
 
@@ -2238,6 +2238,62 @@ mod tests {
         assert_eq!(env.event_count::<AnimCompletedEvent>(), 1);
     }
 
+    #[derive(Debug, Resource)]
+    struct Count<E: Event> {
+        pub count: i32,
+        pub phantom: PhantomData<E>,
+    }
+
+    impl<E: Event> Default for Count<E> {
+        fn default() -> Self {
+            Self {
+                count: 0,
+                phantom: PhantomData,
+            }
+        }
+    }
+
+    #[test]
+    fn animation_oneshot() {
+        let dummy = Delay::new(Duration::from_secs(1));
+        let mut env = TestEnv::<DummyComponent>::new(dummy);
+        env.world.init_resource::<Count<TweenCompletedEvent>>();
+
+        fn sys_tween(mut count: ResMut<Count<TweenCompletedEvent>>) {
+            count.count += 1;
+        }
+        let sys_id = env.world.register_system(sys_tween);
+
+        assert_eq!(env.world.resource::<Count<TweenCompletedEvent>>().count, 0);
+
+        let tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        )
+        .with_repeat_count(2)
+        .with_completed_system(sys_id);
+        let id = env.tween_id;
+        env.animator_mut().set_tweenable(id, tween).unwrap();
+
+        // Tick until one cycle is completed, but not the entire animation
+        let dt = Duration::from_millis(1200);
+        env.step_all(dt);
+        assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
+
+        // Check one-shot system
+        assert_eq!(env.world.resource::<Count<TweenCompletedEvent>>().count, 1);
+
+        // Tick until completion
+        let dt = Duration::from_millis(1000);
+        env.step_all(dt);
+        assert!(env.anim().is_none());
+
+        // Check one-shot systems (note that we didn't clear previous events, so that's
+        // a cumulative count).
+        assert_eq!(env.world.resource::<Count<TweenCompletedEvent>>().count, 2);
+    }
+
     // #[test]
     // fn animator_controls() {
     //     let tween = Tween::<DummyComponent>::new(
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 360d7a1..e103e9f 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -29,7 +29,7 @@ use crate::{
 ///
 /// ```no_run
 /// # use std::{any::TypeId, time::Duration};
-/// # use bevy::ecs::{system::Commands, change_detection::MutUntyped};
+/// # use bevy::ecs::{system::{Commands, SystemId}, change_detection::MutUntyped};
 /// # use bevy::prelude::*;
 /// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompletedEvent, TweenState, TotalDuration};
 /// #
@@ -40,7 +40,7 @@ use crate::{
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
-/// #     fn step(&mut self, _tween_id: TweenId, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(f32),) -> TweenState  { unimplemented!() }
+/// #     fn step(&mut self, _tween_id: TweenId, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(f32), queue_system: &mut dyn FnMut(SystemId)) -> TweenState  { unimplemented!() }
 /// #     fn rewind(&mut self) { unimplemented!() }
 /// #     fn cycles_completed(&self) -> u32 { unimplemented!() }
 /// #     fn cycle_fraction(&self) -> f32 { unimplemented!() }
@@ -487,6 +487,7 @@ pub trait Tweenable: std::fmt::Debug + Send + Sync {
         delta: Duration,
         target: MutUntyped,
         notify_completed: &mut dyn FnMut(f32),
+        queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState;
 
     /// Rewind the animation to its starting state.
@@ -962,6 +963,7 @@ impl Tweenable for Tween {
         delta: Duration,
         target: MutUntyped,
         notify_completed: &mut dyn FnMut(f32),
+        queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         if self.clock.state(self.playback_direction) == TweenState::Completed {
             return TweenState::Completed;
@@ -993,13 +995,9 @@ impl Tweenable for Tween {
                 notify_completed(fraction);
             }
 
-            // Trigger all entity-scoped observers
-            //commands.trigger_targets(event, entity);
-
-            // Run one-shot completion system
-            // if let Some(system_id) = &self.system_id {
-            //     commands.run_system(*system_id);
-            // }
+            if let Some(system_id) = &self.system_id {
+                queue_system(*system_id);
+            }
         }
 
         state
@@ -1153,6 +1151,7 @@ impl Tweenable for Sequence {
         mut delta: Duration,
         mut target: MutUntyped,
         notify_completed: &mut dyn FnMut(f32),
+        queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         // Calculate the new elapsed time at the end of this tick
         self.elapsed = self.elapsed.saturating_add(delta);
@@ -1167,8 +1166,13 @@ impl Tweenable for Sequence {
 
             let prev_elapsed = tween.elapsed();
 
-            if tween.step(tween_id, delta, target.reborrow(), notify_completed)
-                == TweenState::Active
+            if tween.step(
+                tween_id,
+                delta,
+                target.reborrow(),
+                notify_completed,
+                queue_system,
+            ) == TweenState::Active
             {
                 return TweenState::Active;
             }
@@ -1328,6 +1332,7 @@ impl Tweenable for Delay {
         delta: Duration,
         _target: MutUntyped,
         _notify_completed: &mut dyn FnMut(f32),
+        _queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         self.timer.tick(delta);
 
@@ -1543,7 +1548,14 @@ mod tests {
                             progress: fraction,
                         });
                     };
-                    tween.step(tween_id, duration, target.reborrow(), &mut notify_completed)
+                    let mut queue_system = |_: SystemId| {};
+                    tween.step(
+                        tween_id,
+                        duration,
+                        target.reborrow(),
+                        &mut notify_completed,
+                        &mut queue_system,
+                    )
                 } else {
                     TweenState::Completed
                 }

From ac22e14559b1d0a6fd18b717f23b21930530efc8 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 16 Jul 2025 11:28:57 +0200
Subject: [PATCH 35/66] Fix examples

---
 examples/transform_rotation.rs    | 2 +-
 examples/transform_translation.rs | 2 +-
 examples/ui_position.rs           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/transform_rotation.rs b/examples/transform_rotation.rs
index a2ca3e8..28e6934 100644
--- a/examples/transform_rotation.rs
+++ b/examples/transform_rotation.rs
@@ -34,7 +34,7 @@ fn main() {
 #[reflect(InspectorOptions)]
 struct Options {
     #[inspector(min = 0.01, max = 100.)]
-    speed: f32,
+    speed: f64,
 }
 
 impl Default for Options {
diff --git a/examples/transform_translation.rs b/examples/transform_translation.rs
index 11ac628..8b73c12 100644
--- a/examples/transform_translation.rs
+++ b/examples/transform_translation.rs
@@ -35,7 +35,7 @@ fn main() {
 #[reflect(InspectorOptions)]
 struct Options {
     #[inspector(min = 0.01, max = 100.)]
-    speed: f32,
+    speed: f64,
 }
 
 impl Default for Options {
diff --git a/examples/ui_position.rs b/examples/ui_position.rs
index 16feb95..c175926 100644
--- a/examples/ui_position.rs
+++ b/examples/ui_position.rs
@@ -34,7 +34,7 @@ fn main() {
 #[reflect(InspectorOptions)]
 struct Options {
     #[inspector(min = 0.01, max = 100.)]
-    speed: f32,
+    speed: f64,
 }
 
 impl Default for Options {

From fbb1dc283ab7b762df14672d363e4fc35d40a555 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 16 Jul 2025 15:13:10 +0200
Subject: [PATCH 36/66] Unified `Tween::new()`

---
 examples/colormaterial_color.rs |   2 +-
 examples/menu.rs                |   2 +-
 examples/sequence.rs            |   4 +-
 src/lib.rs                      | 105 ++++++------
 src/plugin.rs                   |  12 +-
 src/test_utils.rs               |   6 +-
 src/tweenable.rs                | 281 ++++++++++----------------------
 7 files changed, 157 insertions(+), 255 deletions(-)

diff --git a/examples/colormaterial_color.rs b/examples/colormaterial_color.rs
index e5b2352..8804076 100644
--- a/examples/colormaterial_color.rs
+++ b/examples/colormaterial_color.rs
@@ -79,7 +79,7 @@ fn setup(
         // asset would change the color of all entities using that material.
         let unique_material = materials.add(Color::BLACK);
 
-        let tween = Tween::new_asset(
+        let tween = Tween::new(
             *ease_function,
             Duration::from_secs(1),
             ColorMaterialColorLens {
diff --git a/examples/menu.rs b/examples/menu.rs
index 0da93a6..19ba0e5 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -135,7 +135,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 fn enable_interaction_after_initial_animation(
     mut commands: Commands,
-    mut reader: EventReader<TweenCompletedEvent>,
+    mut reader: EventReader<CycleCompletedEvent>,
 ) {
     for event in reader.read() {
         if let AnimTarget::Component(comp_target) = &event.target {
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 185c7b6..747a6a8 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -267,7 +267,7 @@ fn update_text(
     mut q_textspans: Query<&mut TextSpan, With<ProgressValue>>,
     q_anim_red: Query<&RedSprite>,
     q_anim_blue: Query<&BlueSprite>,
-    mut q_event_completed: EventReader<TweenCompletedEvent>,
+    mut q_event_completed: EventReader<CycleCompletedEvent>,
 ) {
     let anim_red = q_anim_red.single().unwrap();
     let progress_red = if let Some(anim) = animator.get(anim_red.path_tween_id) {
@@ -291,7 +291,7 @@ fn update_text(
 
     for ev in q_event_completed.read() {
         println!(
-            "Event: TweenCompletedEvent tween_id={:?} target={:?}",
+            "Event: CycleCompletedEvent tween_id={:?} target={:?}",
             ev.id, ev.target
         );
     }
diff --git a/src/lib.rs b/src/lib.rs
index 57194fd..5eeb457 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -45,7 +45,7 @@
 //! let tween = Tween::new(
 //!     // Use a quadratic easing on both endpoints.
 //!     EaseFunction::QuadraticInOut,
-//!     // Animation time.
+//!     // It takes 1 second to go from start to end points.
 //!     Duration::from_secs(1),
 //!     // The lens gives access to the Transform component of the Entity,
 //!     // for the TweenAnimator to animate it. It also contains the start and
@@ -86,15 +86,19 @@
 //! # }
 //! ```
 //!
-//! See the [`EntityWorldMutTweeningExtensions`] extension trait for details.
+//! See the [`EntityWorldMutTweeningExtensions`] extension trait for the various
+//! helpers provided for common animations.
 //!
 //! # Ready to animate
 //!
-//! Unlike previous versions of 🍃 Bevy Tweening, you don't need any particular
-//! setup aside from adding the [`TweeningPlugin`] to your [`App`].
-//! In particular, per-component-type systems are gone. Instead, the
-//! [`TweenAnimator`] updates all tweenable animations for all components and
-//! assets at once, even for custom component and asset types.
+//! Unlike previous versions of 🍃 Bevy Tweening, **you don't need any
+//! particular system setup** aside from adding the [`TweeningPlugin`] to your
+//! [`App`]. In particular, per-component-type and per-asset-type systems are
+//! gone. Instead, the plugin adds a single system executing during the
+//! [`Update`] schedule, which calls [`TweenAnimator::step_all()`]. The
+//! [`TweenAnimator`] acts as a central hub for all queued animations, and
+//! updates them all for all components and assets at once, even for custom
+//! component and asset types.
 //!
 //! # Tweenables
 //!
@@ -107,8 +111,10 @@
 //!   other.
 //! - [`Delay`] - A time delay. This doesn't animate anything.
 //!
-//! To execute multiple animations in parallel, simply enqueue each animation
-//! independently. This require careful selection of timings.
+//! To execute multiple animations in parallel (like the `Tracks` tweenable used
+//! to do in older versions), simply enqueue each animation independently.
+//! This require careful selection of timings if you want to synchronize
+//! animations.
 //!
 //! ## Chaining animations
 //!
@@ -143,16 +149,17 @@
 //!
 //! Note that some tweenable animations can be of infinite duration; this is the
 //! case for example when using [`RepeatCount::Infinite`]. If you add such an
-//! infinite animation in a sequence, and append more tweenable after it, those
-//! tweenable will never play because playback will be stuck forever repeating
+//! infinite animation in a sequence, and append more tweenables after it, those
+//! tweenables will never play because playback will be stuck forever repeating
 //! the first animation. You're responsible for creating sequences that make
 //! sense. In general, only use infinite tweenable animations alone or as the
-//! last element of a sequence.
+//! last element of a sequence (for example, move to position and then rotate
+//! forever on self).
 //!
 //! # `TweenAnimator`
 //!
 //! Bevy components and assets are animated with the [`TweenAnimator`] resource.
-//! The animator determine the component or asset to animate via an
+//! The animator determines the component or asset to animate via an
 //! [`AnimTarget`], and accesses its field(s) using a [`Lens`].
 //!
 //! - Components are animated via the [`ComponentAnimTarget`], which identifies
@@ -160,20 +167,20 @@
 //!   [`ComponentId`] of the registered component type.
 //! - Assets are animated in a similar way to component, via the
 //!   [`AssetAnimTarget`] which identifies an asset via the type of its
-//!   [`Assets`] collection and the [`AssetId`] referencing that asset inside
-//!   the collection.
+//!   [`Assets`] collection (and so indirectly the type of asset itself) and the
+//!   [`AssetId`] referencing that asset inside the collection.
 //!
 //! Because assets are typically shared, and the animation applies to the asset
 //! itself, all users of the asset see the animation. For example, animating the
 //! color of a [`ColorMaterial`] will change the color of all the
 //! 2D meshes using that material. If you want to animate the color of a single
-//! mesh, you have to duplicate the asset and assign a unique copy to that mesh,
+//! mesh, you need to duplicate the asset and assign a unique copy to that mesh,
 //! then animate that copy alone.
 //!
 //! Although you generally should prefer using the various extensions on
-//! commands, like the `.tween()` function on entity commands, under the hood
+//! commands, like the [`.tween()`] function on entity commands, under the hood
 //! the manual process of queuing a new animation involves calling
-//! `TweenAnimator::add_component()` or `TweenAnimator::add_asset()`.
+//! [`TweenAnimator::add_component()`] or [`TweenAnimator::add_asset()`].
 //!
 //! ```no_run
 //! # use bevy::prelude::*;
@@ -195,15 +202,17 @@
 //!
 //! ```no_run
 //! # use bevy_tweening::*;
+//! # fn xxx() -> Option<()> {
 //! # let mut animator = TweenAnimator::default();
 //! # let tween_id = TweenId::default();
-//! animator.get_mut(tween_id).unwrap().speed = 0.8; // 80% playback speed
+//! animator.get_mut(tween_id)?.speed = 0.8; // 80% playback speed
+//! # None }
 //! ```
 //!
 //! ## Lenses
 //!
 //! The [`AnimTarget`] references the container (component or asset) being
-//! animated. However only a part of that component or asset is generally
+//! animated. However, only a part of that component or asset is generally
 //! animated. To that end, the [`TweenAnimator`] accesses the field(s) to
 //! animate via a _lens_, a type that implements the [`Lens`] trait and allows
 //! mapping a container to the actual value(s) animated.
@@ -239,6 +248,7 @@
 //! [`TextColor`]: https://docs.rs/bevy/0.16.0/bevy/text/struct.TextColor.html
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
 //! [`TransformPositionLens`]: crate::lens::TransformPositionLens
+//! [`.tween()`]: crate::EntityWorldMutTweeningExtensions::tween
 
 use std::{any::TypeId, time::Duration};
 
@@ -257,8 +267,8 @@ pub use plugin::{AnimationSystem, TweeningPlugin};
 use slotmap::{new_key_type, SlotMap};
 use thiserror::Error;
 pub use tweenable::{
-    BoxedTweenable, Delay, Sequence, TotalDuration, Tween, TweenAssetExtensions,
-    TweenCompletedEvent, TweenState, Tweenable,
+    BoxedTweenable, CycleCompletedEvent, Delay, Sequence, TotalDuration, Tween, TweenState,
+    Tweenable,
 };
 
 pub mod lens;
@@ -915,7 +925,7 @@ pub struct AnimCompletedEvent {
 }
 
 /// Errors returned by various animation functions.
-#[derive(Debug, Error)]
+#[derive(Debug, Error, Clone, Copy)]
 pub enum TweeningError {
     /// The component of the given type is not registered.
     #[error("Component of type {0:?} is not registered in the World.")]
@@ -933,8 +943,8 @@ pub enum TweeningError {
     },
     /// Expected [`Tweenable::type_id()`] to return a value, but it returned
     /// `None`.
-    #[error("Expected a typed Tweenable, got {0:?} instead.")]
-    UntypedTweenable(BoxedTweenable),
+    #[error("Expected a typed Tweenable.")]
+    UntypedTweenable,
     /// Invalid [`TweenId`].
     #[error("Invalid TweenId {0:?}.")]
     InvalidTweenId(TweenId),
@@ -1032,14 +1042,14 @@ impl AssetAnimTarget {
     /// Create a new asset target from an `Assets<A>` type ID.
     pub fn new_untyped(
         components: &Components,
-        type_id: TypeId,
+        assets_type_id: TypeId,
         asset_id: impl Into<UntypedAssetId>,
     ) -> Result<Self, TweeningError> {
         let asset_id = asset_id.into();
-        // Note: asset_id.type_id() is A, whereas type_id is Assets<A>
+        // Note: asset_id.type_id() is A, whereas assets_type_id is Assets<A>
         let resource_id = components
-            .get_resource_id(type_id)
-            .ok_or(TweeningError::AssetNotRegistered(type_id))?;
+            .get_resource_id(assets_type_id)
+            .ok_or(TweeningError::AssetNotRegistered(assets_type_id))?;
         Ok(Self {
             resource_id,
             asset_id,
@@ -1440,7 +1450,7 @@ impl TweenAnimator {
         T: Tweenable + 'static,
     {
         let Some(type_id) = tweenable.type_id() else {
-            return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
+            return Err(TweeningError::UntypedTweenable);
         };
         let target = ComponentAnimTarget::new_untyped(components, type_id, entity)?.into();
         Ok(self.add_component_target(target, tweenable))
@@ -1521,16 +1531,16 @@ impl TweenAnimator {
         T: Tweenable + 'static,
     {
         let Some(type_id) = tweenable.type_id() else {
-            return Err(TweeningError::UntypedTweenable(Box::new(tweenable)));
+            return Err(TweeningError::UntypedTweenable);
         };
-        if type_id != TypeId::of::<Assets<A>>() {
+        if type_id != TypeId::of::<A>() {
             return Err(TweeningError::InvalidAssetIdType {
-                expected: TypeId::of::<Assets<A>>(),
+                expected: TypeId::of::<A>(),
                 actual: type_id,
             });
         }
         let asset_id = asset_id.into();
-        let target = AssetAnimTarget::new_untyped(components, type_id, asset_id.untyped())?;
+        let target = AssetAnimTarget::new(components, asset_id)?;
         self.asset_resolver.insert(
             target.resource_id,
             Box::new(
@@ -1754,7 +1764,7 @@ impl TweenAnimator {
         id: TweenId,
         world: &mut World,
         delta_time: Duration,
-        events: Mut<Events<TweenCompletedEvent>>,
+        events: Mut<Events<CycleCompletedEvent>>,
         anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Option<TweenAnim> {
         let anim = self.anims.get_mut(id)?;
@@ -1787,7 +1797,7 @@ impl TweenAnimator {
         asset_resolver: &HashMap<ComponentId, Resolver>,
         world: &mut World,
         delta_time: Duration,
-        mut events: Mut<Events<TweenCompletedEvent>>,
+        mut events: Mut<Events<CycleCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Result<StepResult, TweeningError> {
         let mut queued_systems = Vec::with_capacity(8);
@@ -1847,12 +1857,11 @@ impl TweenAnimator {
 
         // Step the tweenable animation
         let entity = anim.target.as_component().map(|comp| comp.entity);
-        let mut notify_completed = |fraction: f32| {
+        let mut notify_completed = || {
             completed_events.push((
-                TweenCompletedEvent {
+                CycleCompletedEvent {
                     id: tween_id,
                     target: anim.target,
-                    progress: fraction,
                 },
                 entity,
             ));
@@ -1921,7 +1930,7 @@ impl TweenAnimator {
     /// Loop over the internal queue of tweenable animations, apply them to
     /// their respective target, and prune all the completed ones (the ones
     /// returning [`TweenState::Completed`]). In the later case, send
-    /// [`TweenCompletedEvent`]s if enabled on each individual tweenable.
+    /// [`CycleCompletedEvent`]s if enabled on each individual tweenable.
     ///
     /// If you use the [`TweeningPlugin`], this is automatically called by the
     /// animation system the plugin registers. See the
@@ -1930,7 +1939,7 @@ impl TweenAnimator {
         &mut self,
         world: &mut World,
         delta_time: Duration,
-        mut events: Mut<Events<TweenCompletedEvent>>,
+        mut events: Mut<Events<CycleCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) {
         let mut sent_commands = false;
@@ -2224,7 +2233,7 @@ mod tests {
         assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
 
         // Check events
-        assert_eq!(env.event_count::<TweenCompletedEvent>(), 1);
+        assert_eq!(env.event_count::<CycleCompletedEvent>(), 1);
         assert_eq!(env.event_count::<AnimCompletedEvent>(), 0);
 
         // Tick until completion
@@ -2234,7 +2243,7 @@ mod tests {
 
         // Check events (note that we didn't clear previous events, so that's a
         // cumulative count).
-        assert_eq!(env.event_count::<TweenCompletedEvent>(), 1);
+        assert_eq!(env.event_count::<CycleCompletedEvent>(), 1);
         assert_eq!(env.event_count::<AnimCompletedEvent>(), 1);
     }
 
@@ -2257,14 +2266,14 @@ mod tests {
     fn animation_oneshot() {
         let dummy = Delay::new(Duration::from_secs(1));
         let mut env = TestEnv::<DummyComponent>::new(dummy);
-        env.world.init_resource::<Count<TweenCompletedEvent>>();
+        env.world.init_resource::<Count<CycleCompletedEvent>>();
 
-        fn sys_tween(mut count: ResMut<Count<TweenCompletedEvent>>) {
+        fn sys_tween(mut count: ResMut<Count<CycleCompletedEvent>>) {
             count.count += 1;
         }
         let sys_id = env.world.register_system(sys_tween);
 
-        assert_eq!(env.world.resource::<Count<TweenCompletedEvent>>().count, 0);
+        assert_eq!(env.world.resource::<Count<CycleCompletedEvent>>().count, 0);
 
         let tween = Tween::new::<DummyComponent, DummyLens>(
             EaseFunction::QuadraticInOut,
@@ -2282,7 +2291,7 @@ mod tests {
         assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
 
         // Check one-shot system
-        assert_eq!(env.world.resource::<Count<TweenCompletedEvent>>().count, 1);
+        assert_eq!(env.world.resource::<Count<CycleCompletedEvent>>().count, 1);
 
         // Tick until completion
         let dt = Duration::from_millis(1000);
@@ -2291,7 +2300,7 @@ mod tests {
 
         // Check one-shot systems (note that we didn't clear previous events, so that's
         // a cumulative count).
-        assert_eq!(env.world.resource::<Count<TweenCompletedEvent>>().count, 2);
+        assert_eq!(env.world.resource::<Count<CycleCompletedEvent>>().count, 2);
     }
 
     // #[test]
diff --git a/src/plugin.rs b/src/plugin.rs
index 7541e02..5d4be5f 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{AnimCompletedEvent, TweenAnimator, TweenCompletedEvent};
+use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnimator};
 
 /// Plugin to register the [`TweenAnimator`] and the systme playing animations.
 ///
@@ -15,7 +15,7 @@ pub struct TweeningPlugin;
 impl Plugin for TweeningPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<TweenAnimator>()
-            .add_event::<TweenCompletedEvent>()
+            .add_event::<CycleCompletedEvent>()
             .add_event::<AnimCompletedEvent>()
             .add_systems(
                 Update,
@@ -36,7 +36,7 @@ pub enum AnimationSystem {
 pub(crate) fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
     // TODO: Use SystemState to cache all of that...
-    world.resource_scope(|world, events: Mut<Events<TweenCompletedEvent>>| {
+    world.resource_scope(|world, events: Mut<Events<CycleCompletedEvent>>| {
         world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
             world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
                 animator.step_all(world, delta_time, events, anim_events);
@@ -109,7 +109,7 @@ mod tests {
 
         env.step_all(Duration::from_millis(500));
 
-        assert_eq!(env.event_count::<TweenCompletedEvent>(), 0);
+        assert_eq!(env.event_count::<CycleCompletedEvent>(), 0);
         let animator = env.animator();
         let anim = animator.get(env.tween_id).unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
@@ -124,7 +124,7 @@ mod tests {
         // The final state was still applied before deleting the animation,
         // so the component is changed.
 
-        assert_eq!(env.event_count::<TweenCompletedEvent>(), 1);
+        assert_eq!(env.event_count::<CycleCompletedEvent>(), 1);
         let animator = env.animator();
         assert!(animator.get(env.tween_id).is_none()); // done and deleted
         let transform = env.component_mut();
@@ -134,7 +134,7 @@ mod tests {
         // We can continue to tick as much as we want, this doesn't change anything
         env.step_all(Duration::from_millis(100));
 
-        assert_eq!(env.event_count::<TweenCompletedEvent>(), 0);
+        assert_eq!(env.event_count::<CycleCompletedEvent>(), 0);
         let animator = env.animator();
         assert!(animator.get(env.tween_id).is_none()); // done and deleted
         let transform = env.component_mut();
diff --git a/src/test_utils.rs b/src/test_utils.rs
index a42ae80..7261bdb 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -118,7 +118,7 @@ macro_rules! assert_approx_eq {
 pub(crate) use assert_approx_eq;
 
 use crate::{
-    AnimCompletedEvent, TweenAnim, TweenAnimator, TweenCompletedEvent, TweenId, Tweenable,
+    AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenAnimator, TweenId, Tweenable,
     WorldTargetExtensions as _,
 };
 
@@ -138,7 +138,7 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
     pub fn new(tweenable: impl Tweenable + 'static) -> Self {
         let mut world = World::new();
         world.init_resource::<Time>();
-        world.init_resource::<Events<TweenCompletedEvent>>();
+        world.init_resource::<Events<CycleCompletedEvent>>();
         world.init_resource::<Events<AnimCompletedEvent>>();
         world.init_resource::<TweenAnimator>();
 
@@ -185,7 +185,7 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
         self.system.run((), &mut self.world);
 
         // Update events after system ticked, in case system emitted some events
-        let mut events = self.world.resource_mut::<Events<TweenCompletedEvent>>();
+        let mut events = self.world.resource_mut::<Events<CycleCompletedEvent>>();
         events.update();
         let mut events = self.world.resource_mut::<Events<AnimCompletedEvent>>();
         events.update();
diff --git a/src/tweenable.rs b/src/tweenable.rs
index e103e9f..2befc6f 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1,7 +1,7 @@
 use std::{any::TypeId, cmp::Ordering, time::Duration};
 
 use bevy::{
-    ecs::{change_detection::MutUntyped, component::Mutable, system::SystemId},
+    ecs::{change_detection::MutUntyped, system::SystemId},
     prelude::*,
 };
 
@@ -31,7 +31,7 @@ use crate::{
 /// # use std::{any::TypeId, time::Duration};
 /// # use bevy::ecs::{system::{Commands, SystemId}, change_detection::MutUntyped};
 /// # use bevy::prelude::*;
-/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, TweenCompletedEvent, TweenState, TotalDuration};
+/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, CycleCompletedEvent, TweenState, TotalDuration};
 /// #
 /// # #[derive(Debug)]
 /// # struct MyTweenable;
@@ -40,7 +40,7 @@ use crate::{
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
-/// #     fn step(&mut self, _tween_id: TweenId, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(f32), queue_system: &mut dyn FnMut(SystemId)) -> TweenState  { unimplemented!() }
+/// #     fn step(&mut self, _tween_id: TweenId, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(), queue_system: &mut dyn FnMut(SystemId)) -> TweenState  { unimplemented!() }
 /// #     fn rewind(&mut self) { unimplemented!() }
 /// #     fn cycles_completed(&self) -> u32 { unimplemented!() }
 /// #     fn cycle_fraction(&self) -> f32 { unimplemented!() }
@@ -77,41 +77,38 @@ pub enum TweenState {
     Completed,
 }
 
-/// Event raised when a [`Tween`] completed.
+/// Event raised when an animation completed a single cycle.
 ///
-/// This event is raised when a [`Tween`] completed. When looping, this is
-/// raised once per iteration. In case the animation direction changes
-/// ([`RepeatStrategy::MirroredRepeat`]), an iteration corresponds to a single
-/// progress from one endpoint to the other, whatever the direction. Therefore a
-/// complete cycle start -> end -> start counts as 2 iterations and raises 2
-/// events (one when reaching the end, one when reaching back the start).
+/// This event is raised when a [`Tweenable`] animation completed a single
+/// cycle. In case the animation direction changes each cycle
+/// ([`RepeatStrategy::MirroredRepeat`]), a cycle corresponds to a single
+/// progress from one endpoint value of the lens to the other, whatever the
+/// direction. Therefore a complete loop start -> end -> start counts as 2
+/// cycles and raises 2 events (one when reaching the end value, one when
+/// reaching back the start value).
 ///
 /// # Note
 ///
-/// The semantic is slightly different from [`TweenState::Completed`], which
-/// indicates that the tweenable has finished ticking and do not need to be
-/// updated anymore, a state which is never reached for looping animation. Here
-/// the [`TweenCompletedEvent`] instead marks the end of a single loop
-/// iteration.
+/// The semantic is different from [`TweenState::Completed`], which indicates
+/// that the tweenable has finished stepping and do not need to be updated
+/// anymore, a state which is never reached for looping animation. Here the
+/// [`CycleCompletedEvent`] instead marks the end of a single cycle.
 #[derive(Copy, Clone, Event)]
-pub struct TweenCompletedEvent {
-    /// The ID of the tween animation which completed.
+pub struct CycleCompletedEvent {
+    /// The ID of the tweenable animation which completed.
     ///
-    /// This is the ID of the top-level [`TweenAnim`] this tween is part of. It
-    /// can be used to retrieve the animation with [`TweenAnimator::get()`].
+    /// This is the ID of the top-level [`TweenAnim`] this tweenable is part of.
+    /// It can be used to retrieve the entire animation with
+    /// [`TweenAnimator::get()`].
     ///
     /// [`TweenAnim`]: crate::TweenAnim
     /// [`TweenAnimator::get()`]: crate::TweenAnimator::get
     pub id: TweenId,
-    /// The [`Entity`] the tween which completed and the [`TweenAnim`] it's part
-    /// of are attached to.
+    /// The target the tweenable which completed and the [`TweenAnim`] it's
+    /// part of are mutating.
     ///
     /// [`TweenAnim`]: crate::TweenAnim
     pub target: AnimTarget,
-    /// Current progress of the owner [`TweenAnim`].
-    ///
-    /// [`TweenAnim`]: crate::TweenAnim
-    pub progress: f32,
 }
 
 #[derive(Debug)]
@@ -412,7 +409,7 @@ impl Ord for TotalDuration {
 }
 
 /// An animatable entity, either a single [`Tween`] or a collection of them.
-pub trait Tweenable: std::fmt::Debug + Send + Sync {
+pub trait Tweenable: Send + Sync {
     /// Get the duration of a single cycle of the animation.
     ///
     /// Note that for [`RepeatStrategy::MirroredRepeat`], this is the duration
@@ -486,7 +483,7 @@ pub trait Tweenable: std::fmt::Debug + Send + Sync {
         tween_id: TweenId,
         delta: Duration,
         target: MutUntyped,
-        notify_completed: &mut dyn FnMut(f32),
+        notify_completed: &mut dyn FnMut(),
         queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState;
 
@@ -563,78 +560,26 @@ impl_boxed!(Delay);
 
 type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 
-/// TODO
-pub trait TweenAssetExtensions {
-    /// TODO
-    fn new<A, L>(ease_function: impl Into<EaseMethod>, duration: Duration, lens: L) -> Self
-    where
-        A: Asset,
-        L: Lens<A> + Send + Sync + 'static;
-}
-
-enum TweenAction {
-    Component(Box<TargetAction>),
-    Asset(Box<TargetAction>),
-}
-
-impl std::fmt::Debug for TweenAction {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            TweenAction::Component(..) => write!(f, "TweenAction::Component"),
-            TweenAction::Asset(..) => write!(f, "TweenAction::Asset"),
-        }
-    }
-}
-
-/// Single tweening animation instance.
-#[derive(Debug)]
+/// Single tweening animation description.
+///
+/// A _tween_ is the basic building block of an animation. It describes a single
+/// tweening animation between two values, accessed through a given [`Lens`].
 pub struct Tween {
     ease_method: EaseMethod,
     clock: AnimClock,
     /// Direction of playback the user asked for.
     playback_direction: PlaybackDirection,
-    action: TweenAction,
+    action: Box<TargetAction>,
     system_id: Option<SystemId>,
     send_completed_event: bool,
-    /// Type ID of the target component or `Assets<A>` resource.
+    /// Type ID of the target.
     type_id: TypeId,
 }
 
 impl Tween {
-    /// Chain another [`Tweenable`] after this tween, making a [`Sequence`] with
-    /// the two.
+    /// Create a new tween animation.
     ///
-    /// # Example
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::math::{*,curve::EaseFunction};
-    /// # use std::time::Duration;
-    /// 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);
-    /// ```
-    #[must_use]
-    pub fn then(self, tween: impl Tweenable + 'static) -> Sequence {
-        Sequence::with_capacity(2).then(self).then(tween)
-    }
-
-    /// Create a new tween animation for a [`Component`].
-    ///
-    /// The target component type is implicitly determined by the [`Lens`].
+    /// The target type is implicitly determined by the [`Lens`].
     ///
     /// # Example
     ///
@@ -653,79 +598,31 @@ impl Tween {
     /// ```
     #[inline]
     #[must_use]
-    pub fn new<C, L>(ease_method: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
+    pub fn new<T, L>(ease_method: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
     where
-        C: Component<Mutability = Mutable>,
-        L: Lens<C> + Send + Sync + 'static,
+        T: 'static,
+        L: Lens<T> + Send + Sync + 'static,
     {
         let action = move |ptr: MutUntyped, ratio: f32| {
-            // SAFETY: ptr was obtained from the same component type, via the type_id saved
-            // below.
+            // SAFETY: ptr was obtained from the same type, via the type_id saved below.
             #[allow(unsafe_code)]
-            let comp = unsafe { ptr.with_type::<C>() };
-            lens.lerp(comp, ratio);
+            let target = unsafe { ptr.with_type::<T>() };
+            lens.lerp(target, ratio);
         };
         Self {
             ease_method: ease_method.into(),
             clock: AnimClock::new(duration),
             playback_direction: PlaybackDirection::Forward,
-            action: TweenAction::Component(Box::new(action)),
-            system_id: None,
-            send_completed_event: false,
-            type_id: TypeId::of::<C>(),
-        }
-    }
-
-    /// Create a new tween animation for an [`Asset`].
-    ///
-    /// The target asset type is implicitly determined by the [`Lens`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{prelude::Color, math::{Vec3, curve::EaseFunction}};
-    /// # use std::time::Duration;
-    /// let tween = Tween::new_asset(
-    ///     EaseFunction::QuadraticInOut,
-    ///     Duration::from_secs(1),
-    ///     ColorMaterialColorLens {
-    ///         start: Color::BLACK,
-    ///         end: Color::WHITE,
-    ///     },
-    /// );
-    /// ```
-    #[must_use]
-    pub fn new_asset<A, L>(
-        ease_function: impl Into<EaseMethod>,
-        duration: Duration,
-        mut lens: L,
-    ) -> Self
-    where
-        A: Asset,
-        L: Lens<A> + Send + Sync + 'static,
-    {
-        let action = move |ptr: MutUntyped, ratio: f32| {
-            // SAFETY: ptr was obtained from the captured asset type, through the Assets<A>
-            // resource type saved in type_id below.
-            #[allow(unsafe_code)]
-            let asset = unsafe { ptr.with_type::<A>() };
-            lens.lerp(asset, ratio);
-        };
-        Self {
-            ease_method: ease_function.into(),
-            clock: AnimClock::new(duration),
-            playback_direction: PlaybackDirection::Forward,
-            action: TweenAction::Asset(Box::new(action)),
+            action: Box::new(action),
             system_id: None,
             send_completed_event: false,
-            type_id: TypeId::of::<Assets<A>>(),
+            type_id: TypeId::of::<T>(),
         }
     }
 
     /// Enable raising a event on cycle completion.
     ///
-    /// If enabled, the tween will raise a [`TweenCompletedEvent`] each time
+    /// If enabled, the tween will raise a [`CycleCompletedEvent`] each time
     /// the tween completes a cycle (reaches or passes its cycle duration). In
     /// case of repeating tweens (repeat count > 1), the event is raised once
     /// per cycle. For mirrored repeats, a cycle is one travel from start to
@@ -747,13 +644,13 @@ impl Tween {
     /// #        end: Vec3::new(3.5, 0., 0.),
     /// #    },
     /// )
-    /// // Raise a TweenCompletedEvent each cycle
+    /// // Raise a CycleCompletedEvent each cycle
     /// .with_completed_event(true);
     ///
-    /// fn my_system(mut reader: EventReader<TweenCompletedEvent>) {
+    /// fn my_system(mut reader: EventReader<CycleCompletedEvent>) {
     ///     for ev in reader.read() {
     ///         println!(
-    ///             "Tween animation {:?} raised TweenCompletedEvent for target entity {:?}!",
+    ///             "Tween animation {:?} raised CycleCompletedEvent for target entity {:?}!",
     ///             ev.id,
     ///             ev.target.as_component().unwrap().entity
     ///         );
@@ -857,6 +754,37 @@ impl Tween {
         self.playback_direction
     }
 
+    /// Chain another [`Tweenable`] after this tween, making a [`Sequence`] with
+    /// the two.
+    ///
+    /// # Example
+    /// ```
+    /// # use bevy_tweening::{lens::*, *};
+    /// # use bevy::math::{*,curve::EaseFunction};
+    /// # use std::time::Duration;
+    /// 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);
+    /// ```
+    #[must_use]
+    pub fn then(self, tween: impl Tweenable + 'static) -> Sequence {
+        Sequence::with_capacity(2).then(self).then(tween)
+    }
+
     /// Get the elapsed cycle index (numbered from 0), accounting for finite
     /// endpoint.
     ///
@@ -915,31 +843,6 @@ impl Tween {
     }
 }
 
-impl TweenAssetExtensions for Tween {
-    #[must_use]
-    fn new<A, L>(ease_function: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
-    where
-        A: Asset,
-        L: Lens<A> + Send + Sync + 'static,
-    {
-        let action = move |ptr: MutUntyped, ratio: f32| {
-            // SAFETY: ptr was obtained from the same asset type.
-            #[allow(unsafe_code)]
-            let asset = unsafe { ptr.with_type::<A>() };
-            lens.lerp(asset, ratio);
-        };
-        Self {
-            ease_method: ease_function.into(),
-            clock: AnimClock::new(duration),
-            playback_direction: PlaybackDirection::Forward,
-            action: TweenAction::Asset(Box::new(action)),
-            system_id: None,
-            send_completed_event: false,
-            type_id: TypeId::of::<Assets<A>>(),
-        }
-    }
-}
-
 impl Tweenable for Tween {
     fn cycle_duration(&self) -> Duration {
         self.clock.cycle_duration
@@ -962,7 +865,7 @@ impl Tweenable for Tween {
         _tween_id: TweenId,
         delta: Duration,
         target: MutUntyped,
-        notify_completed: &mut dyn FnMut(f32),
+        notify_completed: &mut dyn FnMut(),
         queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         if self.clock.state(self.playback_direction) == TweenState::Completed {
@@ -980,19 +883,12 @@ impl Tweenable for Tween {
         // consistent.
         let fraction = self.clock.mirrored_cycle_fraction();
         let fraction = self.ease_method.sample(fraction);
-        match &mut self.action {
-            TweenAction::Component(action) => {
-                action(target, fraction);
-            }
-            TweenAction::Asset(action) => {
-                action(target, fraction);
-            }
-        };
+        (self.action)(target, fraction);
 
         // If completed at least once this frame, notify the user
         if times_completed != 0 {
             if self.send_completed_event {
-                notify_completed(fraction);
+                notify_completed();
             }
 
             if let Some(system_id) = &self.system_id {
@@ -1013,7 +909,6 @@ impl Tweenable for Tween {
 }
 
 /// A sequence of tweens played back in order one after the other.
-#[derive(Debug)]
 pub struct Sequence {
     tweens: Vec<BoxedTweenable>,
     index: usize,
@@ -1150,7 +1045,7 @@ impl Tweenable for Sequence {
         tween_id: TweenId,
         mut delta: Duration,
         mut target: MutUntyped,
-        notify_completed: &mut dyn FnMut(f32),
+        notify_completed: &mut dyn FnMut(),
         queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         // Calculate the new elapsed time at the end of this tick
@@ -1331,18 +1226,17 @@ impl Tweenable for Delay {
         _tween_id: TweenId,
         delta: Duration,
         _target: MutUntyped,
-        _notify_completed: &mut dyn FnMut(f32),
+        _notify_completed: &mut dyn FnMut(),
         _queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         self.timer.tick(delta);
 
-        let _progress = self.elapsed().div_duration_f64(self.cycle_duration());
         let state = self.state();
 
         // // If completed this frame, notify the user
         // if (state == TweenState::Completed) && !was_completed {
         //     if self.send_completed_events {
-        //         let event = TweenCompletedEvent {
+        //         let event = CycleCompletedEvent {
         //             id: tween_id,
         //             entity,
         //             progress,
@@ -1513,7 +1407,7 @@ mod tests {
     /// Utility to create a test environment to tick a tween.
     fn make_test_env() -> (World, Entity, SystemId) {
         let mut world = World::new();
-        world.init_resource::<Events<TweenCompletedEvent>>();
+        world.init_resource::<Events<CycleCompletedEvent>>();
         let entity = world.spawn(Transform::default()).id();
         let system_id = world.register_system(oneshot_test);
         (world, entity, system_id)
@@ -1532,7 +1426,7 @@ mod tests {
     ) -> TweenState {
         // Tick the given tween and apply its state to the given entity target
         let state = world.resource_scope(
-            |world: &mut World, mut events: Mut<Events<TweenCompletedEvent>>| {
+            |world: &mut World, mut events: Mut<Events<CycleCompletedEvent>>| {
                 let component_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
                 if let Ok(mut target) = entity_mut.get_mut_by_id(component_id) {
@@ -1541,11 +1435,10 @@ mod tests {
                         component_id,
                     }
                     .into();
-                    let mut notify_completed = |fraction: f32| {
-                        events.send(TweenCompletedEvent {
+                    let mut notify_completed = || {
+                        events.send(CycleCompletedEvent {
                             id: tween_id,
                             target: world_target,
-                            progress: fraction,
                         });
                     };
                     let mut queue_system = |_: SystemId| {};
@@ -1564,7 +1457,7 @@ mod tests {
 
         // Propagate events
         {
-            let mut events = world.resource_mut::<Events<TweenCompletedEvent>>();
+            let mut events = world.resource_mut::<Events<CycleCompletedEvent>>();
             events.update();
         }
 
@@ -1675,7 +1568,7 @@ mod tests {
                 }
 
                 let (mut world, entity, system_id) = make_test_env();
-                let mut event_reader_system_state: SystemState<EventReader<TweenCompletedEvent>> =
+                let mut event_reader_system_state: SystemState<EventReader<CycleCompletedEvent>> =
                     SystemState::new(&mut world);
 
                 // Activate oneshot system

From 6f064b70350eb7a8f9c07412dddfa279b400e764 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 16 Jul 2025 19:52:13 +0200
Subject: [PATCH 37/66] Improve tween documentation

---
 images/tween_cycles.svg   | 400 ++++++++++++++++++++++++++++++++++++++
 images/tween_mirrored.svg | 326 +++++++++++++++++++++++++++++++
 src/lib.rs                |  29 ++-
 src/tweenable.rs          | 178 ++++++++++++++---
 4 files changed, 900 insertions(+), 33 deletions(-)
 create mode 100644 images/tween_cycles.svg
 create mode 100644 images/tween_mirrored.svg

diff --git a/images/tween_cycles.svg b/images/tween_cycles.svg
new file mode 100644
index 0000000..a563416
--- /dev/null
+++ b/images/tween_cycles.svg
@@ -0,0 +1,400 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="355.27557"
+   height="196.53542"
+   viewBox="0 0 355.27557 196.53541"
+   version="1.1"
+   id="svg1"
+   inkscape:version="1.3.2 (091e20e, 2023-11-25)"
+   sodipodi:docname="tween_cycles.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     showgrid="true"
+     inkscape:zoom="2.1774144"
+     inkscape:cx="144.20773"
+     inkscape:cy="139.3855"
+     inkscape:window-width="1728"
+     inkscape:window-height="962"
+     inkscape:window-x="0"
+     inkscape:window-y="38"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1">
+    <inkscape:grid
+       id="grid1"
+       units="mm"
+       originx="-3.7795274"
+       originy="-37.795285"
+       spacingx="3.7795276"
+       spacingy="3.7795276"
+       empcolor="#0099e5"
+       empopacity="0.30196078"
+       color="#0099e5"
+       opacity="0.14901961"
+       empspacing="5"
+       dotted="false"
+       gridanglex="30"
+       gridanglez="30"
+       visible="true" />
+  </sodipodi:namedview>
+  <defs
+     id="defs1">
+    <marker
+       style="overflow:visible"
+       id="Dot"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Dot"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         transform="scale(0.5)"
+         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
+         d="M 5,0 C 5,2.76 2.76,5 0,5 -2.76,5 -5,2.76 -5,0 c 0,-2.76 2.3,-5 5,-5 2.76,0 5,2.24 5,5 z"
+         sodipodi:nodetypes="sssss"
+         id="path17" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="SemiCircleEmpty"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Empty semicircle"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;fill-rule:evenodd;stroke:context-stroke;stroke-width:1.08"
+         d="m 2.7752958,-3.0274156 c -1.656,0 -2.99999998,1.344 -2.99999998,3 0,1.656 1.34399998,3 2.99999998,3"
+         id="path26" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="ArrowWideRounded"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Wide, rounded arrow"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;stroke:context-stroke;stroke-width:1;stroke-linecap:round"
+         d="M 3,-3 0,0 3,3"
+         transform="rotate(180,0.125,0)"
+         sodipodi:nodetypes="ccc"
+         id="path3" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="ArrowWideRounded-7"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Wide, rounded arrow"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;stroke:context-stroke;stroke-width:1;stroke-linecap:round"
+         d="M 3,-3 0,0 3,3"
+         transform="rotate(180,0.125,0)"
+         sodipodi:nodetypes="ccc"
+         id="path3-6" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="Dot-0"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Dot"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         transform="scale(0.5)"
+         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
+         d="M 5,0 C 5,2.76 2.76,5 0,5 -2.76,5 -5,2.76 -5,0 c 0,-2.76 2.3,-5 5,-5 2.76,0 5,2.24 5,5 z"
+         sodipodi:nodetypes="sssss"
+         id="path17-7" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="ArrowWideRounded-9"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Wide, rounded arrow"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;stroke:context-stroke;stroke-width:1;stroke-linecap:round"
+         d="M 3,-3 0,0 3,3"
+         transform="rotate(180,0.125,0)"
+         sodipodi:nodetypes="ccc"
+         id="path3-8" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="Dot-8"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Dot"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         transform="scale(0.5)"
+         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
+         d="M 5,0 C 5,2.76 2.76,5 0,5 -2.76,5 -5,2.76 -5,0 c 0,-2.76 2.3,-5 5,-5 2.76,0 5,2.24 5,5 z"
+         sodipodi:nodetypes="sssss"
+         id="path17-1" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="SemiCircleEmpty-0"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Empty semicircle"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;fill-rule:evenodd;stroke:context-stroke;stroke-width:1.08"
+         d="m 2.7752958,-3.0274156 c -1.656,0 -2.99999998,1.344 -2.99999998,3 0,1.656 1.34399998,3 2.99999998,3"
+         id="path26-6" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="Dot-4"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Dot"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         transform="scale(0.5)"
+         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
+         d="M 5,0 C 5,2.76 2.76,5 0,5 -2.76,5 -5,2.76 -5,0 c 0,-2.76 2.3,-5 5,-5 2.76,0 5,2.24 5,5 z"
+         sodipodi:nodetypes="sssss"
+         id="path17-5" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="SemiCircleEmpty-06"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Empty semicircle"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;fill-rule:evenodd;stroke:context-stroke;stroke-width:1.08"
+         d="m 2.7752958,-3.0274156 c -1.656,0 -2.99999998,1.344 -2.99999998,3 0,1.656 1.34399998,3 2.99999998,3"
+         id="path26-9" />
+    </marker>
+  </defs>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-3.7795274,-37.795284)">
+    <rect
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.999997;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       id="rect3"
+       width="355.27557"
+       height="196.53542"
+       x="3.7795274"
+       y="37.795284" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 318.35931,94.488185 H 26.779849"
+       id="path5-0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#ArrowWideRounded);marker-end:url(#ArrowWideRounded)"
+       d="M 309.92128,207.87402 H 26.456695"
+       id="path5-0-5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#ArrowWideRounded-9);marker-end:url(#ArrowWideRounded-9)"
+       d="M 253.22836,75.590553 197.03544,75.218198"
+       id="path5-0-5-3"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;opacity:1;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:0.999995;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:0.999995, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 83.149609,188.97638 V 94.988182"
+       id="path5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:1, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 196.53544,188.97639 V 75.590556"
+       id="path5-6" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:1, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 253.22836,188.97638 V 75.590552"
+       id="path5-6-2" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:1, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 310.20247,207.27718 V 94.488193"
+       id="path5-6-2-2" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:0.999995;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:0.999995, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="m 139.84253,188.97638 -1e-5,-93.988198"
+       id="path5-5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:#076d00;fill-opacity:0.789174;stroke-width:3.77953;-inkscape-stroke:none"
+       d="M 26.456694,188.97638 V 37.79528"
+       id="path1" />
+    <path
+       style="fill:none;fill-opacity:0.789174;stroke:#000000;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#ArrowWideRounded)"
+       d="M 26.456694,84.852275 V 188.97638"
+       id="path2"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-opacity:0.789174;stroke:#000000;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#ArrowWideRounded-7)"
+       d="M 321.25985,188.97638 H 26.456694"
+       id="path2-0"
+       sodipodi:nodetypes="cc" />
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="16.821236"
+       y="77.545403"
+       id="text3"><tspan
+         sodipodi:role="line"
+         id="tspan3"
+         x="16.821236"
+         y="77.545403">ratio</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="318.63187"
+       y="179.61218"
+       id="text3-6"><tspan
+         sodipodi:role="line"
+         id="tspan3-1"
+         x="318.63187"
+         y="179.61218">time</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="116.22158"
+       y="227.41917"
+       id="text3-6-7"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-6"
+         x="116.22158"
+         y="227.41917">total duration</tspan></text>
+    <path
+       style="font-variation-settings:normal;opacity:1;fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#Dot);marker-end:url(#SemiCircleEmpty);stop-color:#000000;stop-opacity:1"
+       d="M 83.149617,188.97638 139.84252,94.488194"
+       id="path4-5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#Dot-8);marker-end:url(#SemiCircleEmpty-0);stop-color:#000000"
+       d="m 139.84252,188.97638 56.6929,-94.488185"
+       id="path4-5-4"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#Dot-4);marker-end:url(#SemiCircleEmpty-06);stop-color:#000000"
+       d="m 196.53544,188.97638 56.6929,-94.488185"
+       id="path4-5-8"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#Dot-0);marker-end:url(#Dot-0);stop-color:#000000"
+       d="M 253.22836,188.97638 309.92127,94.488199"
+       id="path4-5-9"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#Dot);marker-end:url(#SemiCircleEmpty)"
+       d="M 26.456694,188.97638 83.149609,94.488194"
+       id="path4"
+       sodipodi:nodetypes="cc" />
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="10.024361"
+       y="194.78888"
+       id="text3-6-9"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-2"
+         x="10.024361"
+         y="194.78888">0</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="9.7977982"
+       y="100.32413"
+       id="text3-6-9-0"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-2-0"
+         x="9.7977982"
+         y="100.32413">1</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="169.59009"
+       y="64.941193"
+       id="text3-6-7-8"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-6-3"
+         x="169.59009"
+         y="64.941193"
+         dx="0 0 0 0 0 2.8861492 0 0 0 0 0 0 0 -0.28861493">cycle duration</tspan></text>
+  </g>
+</svg>
diff --git a/images/tween_mirrored.svg b/images/tween_mirrored.svg
new file mode 100644
index 0000000..52fa7b7
--- /dev/null
+++ b/images/tween_mirrored.svg
@@ -0,0 +1,326 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="355.27557"
+   height="196.53542"
+   viewBox="0 0 355.27557 196.53541"
+   version="1.1"
+   id="svg1"
+   inkscape:version="1.3.2 (091e20e, 2023-11-25)"
+   sodipodi:docname="tween_mirrored.svg"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     showgrid="true"
+     inkscape:zoom="2.1774144"
+     inkscape:cx="144.20773"
+     inkscape:cy="139.3855"
+     inkscape:window-width="1728"
+     inkscape:window-height="962"
+     inkscape:window-x="0"
+     inkscape:window-y="38"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1">
+    <inkscape:grid
+       id="grid1"
+       units="mm"
+       originx="-3.7795274"
+       originy="-37.795285"
+       spacingx="3.7795276"
+       spacingy="3.7795276"
+       empcolor="#0099e5"
+       empopacity="0.30196078"
+       color="#0099e5"
+       opacity="0.14901961"
+       empspacing="5"
+       dotted="false"
+       gridanglex="30"
+       gridanglez="30"
+       visible="true" />
+  </sodipodi:namedview>
+  <defs
+     id="defs1">
+    <marker
+       style="overflow:visible"
+       id="Dot"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Dot"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         transform="scale(0.5)"
+         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
+         d="M 5,0 C 5,2.76 2.76,5 0,5 -2.76,5 -5,2.76 -5,0 c 0,-2.76 2.3,-5 5,-5 2.76,0 5,2.24 5,5 z"
+         sodipodi:nodetypes="sssss"
+         id="path17" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="ArrowWideRounded"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Wide, rounded arrow"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;stroke:context-stroke;stroke-width:1;stroke-linecap:round"
+         d="M 3,-3 0,0 3,3"
+         transform="rotate(180,0.125,0)"
+         sodipodi:nodetypes="ccc"
+         id="path3" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="ArrowWideRounded-7"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Wide, rounded arrow"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;stroke:context-stroke;stroke-width:1;stroke-linecap:round"
+         d="M 3,-3 0,0 3,3"
+         transform="rotate(180,0.125,0)"
+         sodipodi:nodetypes="ccc"
+         id="path3-6" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="Dot-0"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Dot"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         transform="scale(0.5)"
+         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
+         d="M 5,0 C 5,2.76 2.76,5 0,5 -2.76,5 -5,2.76 -5,0 c 0,-2.76 2.3,-5 5,-5 2.76,0 5,2.24 5,5 z"
+         sodipodi:nodetypes="sssss"
+         id="path17-7" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="ArrowWideRounded-9"
+       refX="0"
+       refY="0"
+       orient="auto-start-reverse"
+       inkscape:stockid="Wide, rounded arrow"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         style="fill:none;stroke:context-stroke;stroke-width:1;stroke-linecap:round"
+         d="M 3,-3 0,0 3,3"
+         transform="rotate(180,0.125,0)"
+         sodipodi:nodetypes="ccc"
+         id="path3-8" />
+    </marker>
+    <marker
+       style="overflow:visible"
+       id="Dot-8"
+       refX="0"
+       refY="0"
+       orient="auto"
+       inkscape:stockid="Dot"
+       markerWidth="1"
+       markerHeight="1"
+       viewBox="0 0 1 1"
+       inkscape:isstock="true"
+       inkscape:collect="always"
+       preserveAspectRatio="xMidYMid">
+      <path
+         transform="scale(0.5)"
+         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
+         d="M 5,0 C 5,2.76 2.76,5 0,5 -2.76,5 -5,2.76 -5,0 c 0,-2.76 2.3,-5 5,-5 2.76,0 5,2.24 5,5 z"
+         sodipodi:nodetypes="sssss"
+         id="path17-1" />
+    </marker>
+  </defs>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-3.7795274,-37.795284)">
+    <rect
+       style="fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:0.999997;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       id="rect3"
+       width="355.27557"
+       height="196.53542"
+       x="3.7795274"
+       y="37.795284" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 318.35931,94.488185 H 26.779849"
+       id="path5-0"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#ArrowWideRounded);marker-end:url(#ArrowWideRounded)"
+       d="M 309.92128,207.87402 H 26.456695"
+       id="path5-0-5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#ArrowWideRounded-9);marker-end:url(#ArrowWideRounded-9)"
+       d="M 253.22836,75.590553 197.03544,75.218198"
+       id="path5-0-5-3"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;opacity:1;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:0.999995;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:0.999995, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 83.149609,188.97638 V 94.988182"
+       id="path5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:1, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 196.53544,188.97639 V 75.590556"
+       id="path5-6" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:1, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 253.22836,188.97638 V 75.590552"
+       id="path5-6-2" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:1, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="M 310.20247,207.27718 V 94.488193"
+       id="path5-6-2-2" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:0.999995;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:0.999995, 3;stroke-dashoffset:0;stroke-opacity:1"
+       d="m 139.84253,188.97638 -1e-5,-93.988198"
+       id="path5-5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:#076d00;fill-opacity:0.789174;stroke-width:3.77953;-inkscape-stroke:none"
+       d="M 26.456694,188.97638 V 37.79528"
+       id="path1" />
+    <path
+       style="fill:none;fill-opacity:0.789174;stroke:#000000;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#ArrowWideRounded)"
+       d="M 26.456694,84.852275 V 188.97638"
+       id="path2"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:none;fill-opacity:0.789174;stroke:#000000;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#ArrowWideRounded-7)"
+       d="M 321.25985,188.97638 H 26.456694"
+       id="path2-0"
+       sodipodi:nodetypes="cc" />
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="16.821236"
+       y="77.545403"
+       id="text3"><tspan
+         sodipodi:role="line"
+         id="tspan3"
+         x="16.821236"
+         y="77.545403">ratio</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="318.63187"
+       y="179.61218"
+       id="text3-6"><tspan
+         sodipodi:role="line"
+         id="tspan3-1"
+         x="318.63187"
+         y="179.61218">time</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="116.22158"
+       y="227.41917"
+       id="text3-6-7"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-6"
+         x="116.22158"
+         y="227.41917">total duration</tspan></text>
+    <path
+       style="font-variation-settings:normal;opacity:1;fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#Dot);stop-color:#000000;stop-opacity:1"
+       d="M 83.149608,94.488192 139.84252,188.97638"
+       id="path4-5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#Dot-0);marker-end:url(#Dot-0);stop-color:#000000"
+       d="M 253.22836,188.97638 309.92127,94.488199"
+       id="path4-5-9"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#Dot);marker-end:"
+       d="M 26.456694,188.97638 83.149609,94.488194"
+       id="path4"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="font-variation-settings:normal;fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker-start:url(#Dot-8);stop-color:#000000"
+       d="m 196.53543,94.488192 56.69292,94.488188"
+       id="path4-5-5"
+       sodipodi:nodetypes="cc" />
+    <path
+       style="fill:#000000;fill-opacity:1;stroke:#e70063;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#Dot-8)"
+       d="M 139.84252,188.97638 196.53544,94.488194"
+       id="path4-9"
+       sodipodi:nodetypes="cc" />
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="10.024361"
+       y="194.78888"
+       id="text3-6-9"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-2"
+         x="10.024361"
+         y="194.78888">0</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="9.7977982"
+       y="100.32413"
+       id="text3-6-9-0"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-2-0"
+         x="9.7977982"
+         y="100.32413">1</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:16px;font-family:Sans;-inkscape-font-specification:Sans;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+       x="169.59009"
+       y="64.941193"
+       id="text3-6-7-8"><tspan
+         sodipodi:role="line"
+         id="tspan3-1-6-3"
+         x="169.59009"
+         y="64.941193"
+         dx="0 0 0 0 0 2.8861492 0 0 0 0 0 0 0 -0.28861493">cycle duration</tspan></text>
+  </g>
+</svg>
diff --git a/src/lib.rs b/src/lib.rs
index 5eeb457..952bff2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1202,7 +1202,18 @@ impl WorldTargetExtensions for World {
     }
 }
 
-/// A [`Tweenable`]-based animation.
+/// Animation instance queued into the [`TweenAnimator`].
+///
+/// The [`TweenAnim`] represents a single animation instance for a single
+/// target, component or asset. It cannot be created manually; instead you must
+/// enqueue a new component or asset animation into the [`TweenAnimator`] via
+/// [`add_component()`] or [`add_asset()`], respectively. Once created, use the
+/// [`TweenAnimator`] to access it, and modify the runtime playback of this
+/// instance. Each instance is independent, even if it mutates the same target
+/// as another instance.
+///
+/// [`add_component()`]: crate::TweenAnimator::add_component
+/// [`add_asset()`]: crate::TweenAnimator::add_asset
 pub struct TweenAnim {
     /// Target [`Entity`] containing the component to animate, or target asset.
     target: AnimTarget,
@@ -1321,7 +1332,16 @@ struct StepResult {
 /// # Active animations
 ///
 /// Animations queued into the [`TweenAnimator`] by default are pruned
-/// automatically on completion, and only active animations are retained.
+/// automatically on completion, and only active animations are retained. If you
+/// want the animator to retain completed animation instances, so you can
+/// continue to access them, you can set [`TweenAnim::destroy_on_completion`] to
+/// `false` to prevent this automated destruction. Note however that doing so
+/// will retain the animation instance forever, until set to `true` again. So
+/// you should avoid retaining all animations forever to prevent wasting memory
+/// and degrading performances. In general, the default pruning behavior is best
+/// suited for one-shot animations re-created each time they're needed.
+/// Conversely, disabling auto-destruction on completion is best suited to
+/// reusing the same animation instance again and again.
 ///
 /// # Lookup without `TweenId`
 ///
@@ -1935,6 +1955,11 @@ impl TweenAnimator {
     /// If you use the [`TweeningPlugin`], this is automatically called by the
     /// animation system the plugin registers. See the
     /// [`AnimationSystem::AnimationUpdate`] system set.
+    ///
+    /// Note that the order in which the animations are iterated over and
+    /// played, and therefore also any event is raised or any one-shot system is
+    /// executed, is an unspecfied implementation detail. There is no guarantee
+    /// on that order nor its stability frame to frame.
     pub fn step_all(
         &mut self,
         world: &mut World,
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 2befc6f..e99d126 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -564,6 +564,87 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 ///
 /// A _tween_ is the basic building block of an animation. It describes a single
 /// tweening animation between two values, accessed through a given [`Lens`].
+/// The animation is composed of one or more cycles, and can be played forward
+/// or backward. On completion, you can be notified via events, observers, or
+/// the execution of a one-shot system.
+///
+/// # Cycles
+///
+/// A tween can be configured to repeat multiple, or even an infinity, of times.
+/// Each repeat iteration is called a _cycle_. The duration of a single cycle is
+/// the _cycle duration_, and the duration of the entire tween animation
+/// including all cycles is the _total duration_.
+#[doc = include_str!("../images/tween_cycles.svg")]
+///
+/// _An example tween with 5 cycles._
+///
+/// The number of cycles is configured through the [`RepeatCount`].
+///
+/// - [`RepeatCount::Finite`] directly sets a number of cycles. The total
+///   duration is inferred from the cycle duration and number of cycles.
+/// - [`RepeatCount::For`] selects a total duration for the animation, from
+///   which a number of cycles is derived. In that case, the number of cycles
+///   may be a fractional number; the last cycle is only partial, and may not
+///   reach the endpoint of the lens.
+/// - [`RepeatCount::Infinite`] enables infinitely-repeating cycles. In that
+///   case the total duration of the animation is infinite, and the animation
+///   itself is said to be infinite.
+///
+/// The _repeat strategy_ determines whether cycles are mirrored when they
+/// repeat. By default, all cycles produce a linear _ratio_ monotonically
+/// increasing from `0` to `1`. When mirrored, every other cycle instead
+/// produces a _decreasing_ ratio from `1` to `0`. The repeat strategy is
+/// configured with [`RepeatStrategy`].
+#[doc = include_str!("../images/tween_mirrored.svg")]
+///
+/// _A tween with 5 cycles, using the mirrored repeat strategy._
+///
+/// Once the ratio in `[0:1]` has been calculated, it's passed through the
+/// easing function to obtain the final interpolation factor that
+/// [`Lens::lerp()`] receives.
+///
+/// # Elapsed time and playback direction
+///
+/// The _elapsed time_ of an animation represents the current time since the
+/// start of the animation. This includes all cycles, and is bound by the total
+/// duration of the animation. This is a property of an active animation, and is
+/// available per instance from the [`TweenAnim`] representing the instance. So
+/// a tween itself, which describes an animation without a specific target to
+/// animate, doesn't have an elapsed time.
+///
+/// The tween however has a _playback direction_. By default, the playback
+/// direction is [`PlaybackDirection::Forward`], and the animation plays forward
+/// as described above. By instead using [`PlaybackDirection::Backward`], the
+/// tween plays in reverse from end to start. Practically, this means that the
+/// elapsed time _decreases_ from its current value back to zero, and the
+/// animation completes at `t=0`. Note that as a result, because infinite
+/// animations ([`RepeatCount::Infinite`]) don't have an end time, they cannot
+/// be rewinded when the playback direction is backward.
+///
+/// # Completion events and one-shot systems
+///
+/// Sometimes, you want to be notified of the completion of an animation cycle,
+/// or the completion of the entire animation itself. To that end, the [`Tween`]
+/// supports several mechanisms:
+///
+/// - Each time a _single_ cycle is completed, the tween can emit a
+///   [`CycleCompletedEvent`]. The event is emitted as a buffered event, to be
+///   read by another system through an [`EventReader`]. For component targets,
+///   entity-scoped observers are also triggered. Both of these are enabled
+///   through [`with_completed_event()`] and [`set_completed_event()`].
+///   Alternatively, or in addition, a custom one-shot system can be executed,
+///   enabled through [`with_completed_system()`] and
+///   [`set_completed_system()`]. Per-cycle events are disabled by default, and
+///   no one-shot system is registered by default.
+/// - At the end of all cycles, when the animation itself completes, the tween
+///   emits an [`AnimCompletedEvent`]. This event is always emitted.
+///
+/// [`TweenAnim`]: crate::TweenAnim
+/// [`with_completed_event()`]: Self::with_completed_event
+/// [`set_completed_event()`]: Self::set_completed_event
+/// [`with_completed_system()`]: Self::with_completed_system
+/// [`set_completed_system()`]: Self::set_completed_system
+/// [`AnimCompletedEvent`]: crate::AnimCompletedEvent
 pub struct Tween {
     ease_method: EaseMethod,
     clock: AnimClock,
@@ -579,7 +660,11 @@ pub struct Tween {
 impl Tween {
     /// Create a new tween animation.
     ///
-    /// The target type is implicitly determined by the [`Lens`].
+    /// The new animation is described by a given cycle duration, a repeat count
+    /// which determines its total duration, as well as an easing function and a
+    /// lens describing how the cycles affect the animation target. The target
+    /// type is implicitly determined by the type `T` of the [`Lens<T>`]
+    /// argument.
     ///
     /// # Example
     ///
@@ -598,7 +683,11 @@ impl Tween {
     /// ```
     #[inline]
     #[must_use]
-    pub fn new<T, L>(ease_method: impl Into<EaseMethod>, duration: Duration, mut lens: L) -> Self
+    pub fn new<T, L>(
+        ease_method: impl Into<EaseMethod>,
+        cycle_duration: Duration,
+        mut lens: L,
+    ) -> Self
     where
         T: 'static,
         L: Lens<T> + Send + Sync + 'static,
@@ -611,7 +700,7 @@ impl Tween {
         };
         Self {
             ease_method: ease_method.into(),
-            clock: AnimClock::new(duration),
+            clock: AnimClock::new(cycle_duration),
             playback_direction: PlaybackDirection::Forward,
             action: Box::new(action),
             system_id: None,
@@ -620,6 +709,31 @@ impl Tween {
         }
     }
 
+    /// Set the number of times to repeat the animation.
+    ///
+    /// The repeat count determines the number of cycles of the animation. See
+    /// [the top-level `Tween` documentation] for details.
+    ///
+    /// [the top-level `Tween` documentation]: crate::Tween#cycles
+    #[must_use]
+    pub fn with_repeat_count(mut self, count: impl Into<RepeatCount>) -> Self {
+        self.clock.total_duration =
+            TotalDuration::from_cycles(self.clock.cycle_duration, count.into());
+        self
+    }
+
+    /// Configure how the cycles repeat.
+    ///
+    /// This enables or disables cycle mirroring. See [the top-level `Tween`
+    /// documentation] for details.
+    ///
+    /// [the top-level `Tween` documentation]: crate::Tween#cycles
+    #[must_use]
+    pub fn with_repeat_strategy(mut self, strategy: RepeatStrategy) -> Self {
+        self.clock.strategy = strategy;
+        self
+    }
+
     /// Enable raising a event on cycle completion.
     ///
     /// If enabled, the tween will raise a [`CycleCompletedEvent`] each time
@@ -663,15 +777,19 @@ impl Tween {
         self
     }
 
+    /// Set whether the tween emits [`CycleCompletedEvent`].
+    ///
+    /// See [`with_completed_event()`] for details.
     ///
+    /// [`with_completed_event()`]: Self::with_completed_event
     pub fn set_completed_event(&mut self, send: bool) {
         self.send_completed_event = send;
     }
 
-    /// Enable running a one-shot system upon completion.
+    /// Enable running a one-shot system upon cycle completion.
     ///
     /// If enabled, the tween will run a system via a provided [`SystemId`] when
-    /// the animation completes. This is similar to the
+    /// the animation completes a single cycle. This is similar to the
     /// [`with_completed_event()`], but uses a system registered by
     /// [`register_system()`] instead of a callback.
     ///
@@ -681,8 +799,8 @@ impl Tween {
     /// # use bevy_tweening::{lens::*, *};
     /// # use bevy::{ecs::event::EventReader, math::{Vec3, curve::EaseFunction}, ecs::world::World, ecs::system::Query, ecs::entity::Entity, ecs::query::With};
     /// # use std::time::Duration;
-    /// let mut world = World::new();
-    /// let test_system_system_id = world.register_system(test_system);
+    /// # let mut world = World::new();
+    /// let test_system_id = world.register_system(test_system);
     /// let tween = Tween::new(
     ///     // [...]
     /// #    EaseFunction::QuadraticInOut,
@@ -692,11 +810,12 @@ impl Tween {
     /// #        end: Vec3::new(3.5, 0., 0.),
     /// #    },
     /// )
-    /// .with_completed_system(test_system_system_id);
+    /// .with_completed_system(test_system_id);
     ///
-    /// fn test_system(query: Query<Entity>) {
-    ///    for entity in query.iter() {
-    ///       println!("Found an entity!");
+    /// fn test_system(animator: Res<TweenAnimator>) {
+    ///    println!("Animations still queued after this cycle completion:");
+    ///    for (id, anim) in animator.iter() {
+    ///       println!("Anim #{:?} playback_state={:?}", id, anim.playback_state);
     ///    }
     /// }
     /// ```
@@ -709,12 +828,20 @@ impl Tween {
         self
     }
 
+    /// Set the one-shot system executed when a cycle completes.
+    ///
+    /// See [`with_completed_system()`] for details.
     ///
+    /// [`with_completed_system()`]: Self::with_completed_system
     pub fn set_completed_system(&mut self, system_id: SystemId) {
         self.system_id = Some(system_id);
     }
 
+    /// Clear the one-shot system executed when a cycle completes.
     ///
+    /// See [`with_completed_system()`] for details.
+    ///
+    /// [`with_completed_system()`]: Self::with_completed_system
     pub fn clear_completed_system(&mut self) {
         self.system_id = None;
     }
@@ -722,7 +849,7 @@ impl Tween {
     /// Set the playback direction of the tween.
     ///
     /// The playback direction controls whether the internal animation clock,
-    /// and therefore the elapsed time, move forward or backward.
+    /// and therefore also the elapsed time, both move forward or backward.
     ///
     /// Changing the direction doesn't change any target state, nor the elapsed
     /// time of the tween. Only the direction of playback from this moment
@@ -733,7 +860,9 @@ impl Tween {
 
     /// Set the playback direction of the tween.
     ///
-    /// See [`Tween::set_playback_direction()`].
+    /// See [`set_playback_direction()`] for details.
+    ///
+    /// [`set_playback_direction()`]: Self::set_playback_direction
     #[must_use]
     pub fn with_playback_direction(mut self, direction: PlaybackDirection) -> Self {
         self.playback_direction = direction;
@@ -743,7 +872,8 @@ impl Tween {
     /// The current animation playback direction.
     ///
     /// This is the value set by the user with [`with_playback_direction()`] and
-    /// [`set_playback_direction()`]. This is never changed by the playback.
+    /// [`set_playback_direction()`]. This is never changed by the animation
+    /// playback itself.
     ///
     /// See [`PlaybackDirection`] for details.
     ///
@@ -807,8 +937,9 @@ impl Tween {
     /// fraction is capped at `1.0` (the tween doesn't loop when reaching
     /// the end of its last cycle).
     ///
-    /// The returned value is always in `[0:1]` for finite tweens, and `[0:1)`
-    /// for infinite ones.
+    /// The returned value is always in `[0:1]` for finite tweens, with the
+    /// value `1.0` returned only when the last cycle is completed, and in
+    /// `[0:1)` for infinite tweens as they never complete.
     #[must_use]
     #[inline]
     pub fn cycle_fraction(&self) -> f32 {
@@ -826,21 +957,6 @@ impl Tween {
     pub fn is_cycle_mirrored(&self) -> bool {
         self.clock.is_cycle_mirrored(self.clock.cycle_index())
     }
-
-    /// Set the number of times to repeat the animation.
-    #[must_use]
-    pub fn with_repeat_count(mut self, count: impl Into<RepeatCount>) -> Self {
-        self.clock.total_duration =
-            TotalDuration::from_cycles(self.clock.cycle_duration, count.into());
-        self
-    }
-
-    /// Choose how the animation behaves upon a repetition.
-    #[must_use]
-    pub fn with_repeat_strategy(mut self, strategy: RepeatStrategy) -> Self {
-        self.clock.strategy = strategy;
-        self
-    }
 }
 
 impl Tweenable for Tween {

From d13ab254a9e49a65f07c979890bd0e051116b7e9 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 16 Jul 2025 22:15:57 +0200
Subject: [PATCH 38/66] Clamp negative anim speed

---
 src/lib.rs | 49 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 42 insertions(+), 7 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 952bff2..93ba8d8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1219,10 +1219,22 @@ pub struct TweenAnim {
     target: AnimTarget,
     /// Animation description.
     tweenable: BoxedTweenable,
-    /// Control if the animation is played or not.
+    /// Control if the animation is played or not. Defaults to
+    /// [`PlaybackState::Playing`].
+    ///
+    /// Pausing an animation with [`PlaybackState::Paused`] is functionaly
+    /// equivalent to setting its [`speed`] to zero. The two fields remain
+    /// independent though, for convenience.
+    ///
+    /// [`speed`]: Self::speed
     pub playback_state: PlaybackState,
     /// Relative playback speed. Defaults to `1.` (normal speed; 100%).
     ///
+    /// Setting a negative or zero speed value effectively pauses the animation
+    /// (although the [`playback_state`] remains unchanged). Negative values may
+    /// be clamped to 0. when the animation is stepped, but positive or zero
+    /// values are never modified by the [`TweenAnimator`].
+    ///
     /// # Time precision
     ///
     /// _This note is an implementation detail which can usually be ignored._
@@ -1234,10 +1246,16 @@ pub struct TweenAnim {
     /// bits or more), even compared to `f64` (64 bits), and the fact this speed
     /// factor is a multiplier whereas most other time quantities are added or
     /// subtracted.
+    ///
+    /// [`playback_state`]: Self::playback_state
     pub speed: f64,
     /// Destroy the animation once completed. This defaults to `true`, and makes
-    /// [`TweenAnimator::step_all()`] destroy this [`TweenAnim`] once it
-    /// completed. To keep the animation queued, set this to `false`.
+    /// [`TweenAnimator::step_one()`] and [`TweenAnimator::step_all()`]
+    /// destroy this [`TweenAnim`] once it completed. To keep the animation
+    /// queued, and allow access after it completed, set this to `false`. Note
+    /// however that you should avoid leaving all animations queued if they're
+    /// unused, as this wastes memory and may degrade performances if too many
+    /// completed animations are kept around for no good reason.
     pub destroy_on_completion: bool,
     /// Current tweening completion state.
     tween_state: TweenState,
@@ -1254,7 +1272,7 @@ impl TweenAnim {
     /// that you can't insert a single [`Delay`]. You can however use a
     /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
     /// provided there's at least one other typed tweenable in the sequence.
-    pub fn new(target: AnimTarget, tweenable: BoxedTweenable) -> Self {
+    fn new(target: AnimTarget, tweenable: BoxedTweenable) -> Self {
         Self {
             target,
             tweenable,
@@ -1480,7 +1498,11 @@ impl TweenAnimator {
     ///
     /// See [`add_component()`] for details. This variant is useful when you can
     /// build in advance a [`ComponentAnimTarget`], but at the same time don't
-    /// have readily access to the [`Components`] of the world.
+    /// readily have access to the [`Components`] of the world.
+    ///
+    /// Note that there's no equivalent for assets, because asset animations
+    /// need to register some internal type-dependent resolver due to assets
+    /// being only accessible through the typed [`Assets<A>`] API.
     ///
     /// [`add_component()`]: Self::add_component
     #[inline]
@@ -1824,6 +1846,9 @@ impl TweenAnimator {
         let mut completed_events = Vec::with_capacity(8);
         let mut sent_commands = false;
 
+        // Sanity checks on fields which can be freely modified by the user
+        anim.speed = anim.speed.max(0.);
+
         // Retain completed animations only if requested
         if anim.tween_state == TweenState::Completed {
             let ret = StepResult {
@@ -1834,7 +1859,7 @@ impl TweenAnimator {
         }
 
         // Skip paused animations (but retain them)
-        if anim.playback_state == PlaybackState::Paused {
+        if anim.playback_state == PlaybackState::Paused || anim.speed <= 0. {
             let ret = StepResult {
                 retain: true,
                 sent_commands: false,
@@ -1873,7 +1898,7 @@ impl TweenAnimator {
         // Scale delta time by this animation's speed. Reject negative speeds; use
         // backward playback to play in reverse direction.
         // Note: must use f64 for precision; f32 produces visible roundings.
-        let delta_time = delta_time.mul_f64(anim.speed.max(0.));
+        let delta_time = delta_time.mul_f64(anim.speed);
 
         // Step the tweenable animation
         let entity = anim.target.as_component().map(|comp| comp.entity);
@@ -2387,6 +2412,16 @@ mod tests {
             env.anim().unwrap().tweenable.elapsed(),
             Duration::from_millis(240)
         );
+
+        env.anim_scope(|anim| anim.speed = -1.);
+        env.step_all(Duration::from_millis(100));
+        // Safety: invalid negative speed clamped to 0.
+        assert_eq!(env.anim().unwrap().speed, 0.);
+        // At zero speed, step is a no-op so elapse() didn't change
+        assert_eq!(
+            env.anim().unwrap().tweenable.elapsed(),
+            Duration::from_millis(240)
+        );
     }
 
     #[test]

From 369c67de5f0ae27c82a9423c77840787286c7427 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 16 Jul 2025 22:45:18 +0200
Subject: [PATCH 39/66] Intern resource scoping in step_xxx()

---
 src/lib.rs       | 191 ++++++++++++++++++++++++++++++-----------------
 src/plugin.rs    |   9 +--
 src/tweenable.rs |   2 +-
 3 files changed, 124 insertions(+), 78 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 93ba8d8..38fb441 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1477,6 +1477,17 @@ impl TweenAnimator {
     ///     Some(())
     /// }
     /// ```
+    ///
+    /// Note in the above that at the time when the animation is queued into the
+    /// animator, the component doesn't yet exist in the world, because the
+    /// spawning is deffered via [`Commands`]. This is not an error; the
+    /// [`TweenAnimator`] doesn't perform any check when this function is
+    /// called, on purpose to allow patterns like inserting the returned
+    /// [`TweenId`] into a component or resource from within the same system
+    /// which spawned the target, without having to apply deferred commands
+    /// first. When the animation steps however, the target is validated, and if
+    /// invalid (either because the entity doesn't exist or it doesn't have the
+    /// target component) then the animation instance is destroyed.
     #[inline]
     pub fn add_component<T>(
         &mut self,
@@ -1604,11 +1615,18 @@ impl TweenAnimator {
 
     /// Check if the animation with the given ID is queued.
     ///
+    /// If this returns `false` then any animation which might have existed with
+    /// this ID was destroyed, and this ID will forever be invalid and
+    /// unused.
+    ///
     /// # Returns
     ///
     /// Returns `true` if the animation is queued, either because it's playing,
     /// or because it's completed but [`TweenAnim::destroy_on_completion`] was
-    /// set to `false`.
+    /// set to `false`. In that case the [`TweenAnim`] can be accessed by the
+    /// likes of [`get()`].
+    ///
+    /// [`get()`]: Self::get
     #[inline]
     pub fn contains(&self, id: TweenId) -> bool {
         self.anims.contains_key(id)
@@ -1617,7 +1635,8 @@ impl TweenAnimator {
     /// Get a queued tweenable animation from its ID.
     ///
     /// This fails and returns `None` if the animation has completed and was
-    /// removed from the animator's internal queue.
+    /// removed from the animator's internal queue, or if the ID is invalid
+    /// (notably, `TweenId::null()`).
     #[inline]
     pub fn get(&self, id: TweenId) -> Option<&TweenAnim> {
         self.anims.get(id)
@@ -1626,7 +1645,8 @@ impl TweenAnimator {
     /// Get a queued tweenable animation from its ID.
     ///
     /// This fails and returns `None` if the animation has completed and was
-    /// removed from the animator's internal queue.
+    /// removed from the animator's internal queue, or if the ID is invalid
+    /// (notably, `TweenId::null()`).
     #[inline]
     pub fn get_mut(&mut self, id: TweenId) -> Option<&mut TweenAnim> {
         self.anims.get_mut(id)
@@ -1636,7 +1656,7 @@ impl TweenAnimator {
     ///
     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
     /// animation has completed and was removed from the animator's internal
-    /// queue.
+    /// queue, or if the ID is invalid (notably, `TweenId::null()`).
     #[inline]
     pub fn try_get(&self, id: TweenId) -> Result<&TweenAnim, TweeningError> {
         self.anims.get(id).ok_or(TweeningError::InvalidTweenId(id))
@@ -1646,7 +1666,7 @@ impl TweenAnimator {
     ///
     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
     /// animation has completed and was removed from the animator's internal
-    /// queue.
+    /// queue, or if the ID is invalid (notably, `TweenId::null()`).
     #[inline]
     pub fn try_get_mut(&mut self, id: TweenId) -> Result<&mut TweenAnim, TweeningError> {
         self.anims
@@ -1655,12 +1675,22 @@ impl TweenAnimator {
     }
 
     /// Get an iterator over the queued tweenable animations.
+    ///
+    /// # Returns
+    ///
+    /// An iterator over pairs of (ID, animation) for all animations still in
+    /// the internal queue.
     #[inline]
     pub fn iter(&self) -> impl Iterator<Item = (TweenId, &TweenAnim)> {
         self.anims.iter()
     }
 
     /// Get a mutable iterator over the queued tweenable animations.
+    ///
+    /// # Returns
+    ///
+    /// An iterator over pairs of (ID, animation) for all animations still in
+    /// the internal queue.
     #[inline]
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (TweenId, &mut TweenAnim)> {
         self.anims.iter_mut()
@@ -1668,8 +1698,19 @@ impl TweenAnimator {
 
     /// Remove a queued tweenable animation and return it.
     ///
-    /// After the animation is removed, the `id` is invalid and will never be
-    /// reused.
+    /// This immediately removes the animation, if it exists, without modifying
+    /// further its target. After the animation is removed, the `id` is
+    /// invalid and will never be reused. The animation cannot be re-queued;
+    /// instead, a new animation sould be created with [`add_component()`] or
+    /// [`add_asset()`], which will generate a different ID.
+    ///
+    /// # Returns
+    ///
+    /// If the ID was valid and an animation with this ID was removed, returns
+    /// that animation. Otherwise returns `None`.
+    ///
+    /// [`add_component()`]: Self::add_component
+    /// [`add_asset()`]: Self::add_asset
     #[inline]
     pub fn remove(&mut self, id: TweenId) -> Option<TweenAnim> {
         self.anims.remove(id)
@@ -1678,17 +1719,19 @@ impl TweenAnimator {
     /// Retarget a queued animation.
     ///
     /// Attempt to change the target of a tweening animation already enqueued,
-    /// and possibly already playing.
-    ///
-    /// This function performs a number of checks on the new target to ensure
-    /// it's compatible with the previous target. In particular, the new target
-    /// needs to have:
+    /// and possibly already playing. This function performs a number of checks
+    /// on the new target to ensure it's compatible with the previous
+    /// target. In particular, the new target needs to have:
     /// - the same kind (component or asset);
-    /// - the same type (component type or asset resource type).
+    /// - the same type.
     ///
     /// # Returns
     ///
     /// On success, returns the previous target which has been replaced.
+    ///
+    /// [`add_component()`]: Self::add_component
+    /// [`add_asset()`]: Self::add_asset
+    /// [`set_target()`]: Self::set_target
     pub fn set_target(
         &mut self,
         id: TweenId,
@@ -1794,6 +1837,13 @@ impl TweenAnimator {
     /// in place of that system or any call to [`step_all()`]. If the `id` is
     /// invalid, this function does nothing.
     ///
+    /// One useful use of this function is to force a mutation on the target,
+    /// for example because some specific animation change was made which
+    /// couldn't directly mutate it. By passing [`Duration::ZERO`], this
+    /// function effectively forces the target state to the current animation
+    /// "position" without playing back the animation itself (the elapsed time
+    /// is not modified).
+    ///
     /// # Returns
     ///
     /// If the animation completed and was destroyed, returns a copy of that
@@ -1803,34 +1853,36 @@ impl TweenAnimator {
     #[inline]
     pub fn step_one(
         &mut self,
-        id: TweenId,
         world: &mut World,
+        id: TweenId,
         delta_time: Duration,
-        events: Mut<Events<CycleCompletedEvent>>,
-        anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Option<TweenAnim> {
-        let anim = self.anims.get_mut(id)?;
-
-        let ret = Self::step_impl(
-            id,
-            anim,
-            &self.asset_resolver,
-            world,
-            delta_time,
-            events,
-            anim_events,
-        );
+        world.resource_scope(|world, events: Mut<Events<CycleCompletedEvent>>| {
+            world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
+                let anim = self.anims.get_mut(id)?;
+
+                let ret = Self::step_impl(
+                    id,
+                    anim,
+                    &self.asset_resolver,
+                    world,
+                    delta_time,
+                    events,
+                    anim_events,
+                );
 
-        if let Ok(ret) = ret {
-            if ret.sent_commands {
-                world.flush();
-            }
+                if let Ok(ret) = ret {
+                    if ret.sent_commands {
+                        world.flush();
+                    }
 
-            if !ret.retain {
-                return Some(self.anims.remove(id).unwrap());
-            }
-        }
-        None
+                    if !ret.retain {
+                        return Some(self.anims.remove(id).unwrap());
+                    }
+                }
+                None
+            })
+        })
     }
 
     fn step_impl(
@@ -1975,48 +2027,47 @@ impl TweenAnimator {
     /// Loop over the internal queue of tweenable animations, apply them to
     /// their respective target, and prune all the completed ones (the ones
     /// returning [`TweenState::Completed`]). In the later case, send
-    /// [`CycleCompletedEvent`]s if enabled on each individual tweenable.
+    /// [`AnimCompletedEvent`]s.
     ///
     /// If you use the [`TweeningPlugin`], this is automatically called by the
     /// animation system the plugin registers. See the
     /// [`AnimationSystem::AnimationUpdate`] system set.
     ///
     /// Note that the order in which the animations are iterated over and
-    /// played, and therefore also any event is raised or any one-shot system is
-    /// executed, is an unspecfied implementation detail. There is no guarantee
-    /// on that order nor its stability frame to frame.
-    pub fn step_all(
-        &mut self,
-        world: &mut World,
-        delta_time: Duration,
-        mut events: Mut<Events<CycleCompletedEvent>>,
-        mut anim_events: Mut<Events<AnimCompletedEvent>>,
-    ) {
-        let mut sent_commands = false;
+    /// played, and therefore also the order in which any event is raised or any
+    /// one-shot system is executed, is an unspecified implementation detail.
+    /// There is no guarantee on that order nor its stability frame to
+    /// frame.
+    pub fn step_all(&mut self, world: &mut World, delta_time: Duration) {
+        world.resource_scope(|world, mut events: Mut<Events<CycleCompletedEvent>>| {
+            world.resource_scope(|world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                let mut sent_commands = false;
+
+                // Loop over active animations, tick them, and retain those which are still
+                // active after that
+                self.anims.retain(|tween_id, anim| {
+                    let ret = Self::step_impl(
+                        tween_id,
+                        anim,
+                        &self.asset_resolver,
+                        world,
+                        delta_time,
+                        events.reborrow(),
+                        anim_events.reborrow(),
+                    );
+                    if let Ok(ret) = ret {
+                        sent_commands = sent_commands || ret.sent_commands;
+                        return ret.retain;
+                    }
+                    false
+                });
 
-        // Loop over active animations, tick them, and retain those which are still
-        // active after that
-        self.anims.retain(|tween_id, anim| {
-            let ret = Self::step_impl(
-                tween_id,
-                anim,
-                &self.asset_resolver,
-                world,
-                delta_time,
-                events.reborrow(),
-                anim_events.reborrow(),
-            );
-            if let Ok(ret) = ret {
-                sent_commands = sent_commands || ret.sent_commands;
-                return ret.retain;
-            }
-            false
+                // Flush commands
+                if sent_commands {
+                    world.flush();
+                }
+            });
         });
-
-        // Flush commands
-        if sent_commands {
-            world.flush();
-        }
     }
 }
 
diff --git a/src/plugin.rs b/src/plugin.rs
index 5d4be5f..1872492 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -35,13 +35,8 @@ pub enum AnimationSystem {
 /// Core animation systemt ticking the [`TweenAnimator`].
 pub(crate) fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
-    // TODO: Use SystemState to cache all of that...
-    world.resource_scope(|world, events: Mut<Events<CycleCompletedEvent>>| {
-        world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
-            world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
-                animator.step_all(world, delta_time, events, anim_events);
-            });
-        });
+    world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
+        animator.step_all(world, delta_time);
     });
 }
 
diff --git a/src/tweenable.rs b/src/tweenable.rs
index e99d126..83aab3f 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -797,7 +797,7 @@ impl Tween {
     ///
     /// ```
     /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::{Vec3, curve::EaseFunction}, ecs::world::World, ecs::system::Query, ecs::entity::Entity, ecs::query::With};
+    /// # use bevy::{ecs::event::EventReader, math::{Vec3, curve::EaseFunction}, ecs::world::World, ecs::system::Query, ecs::entity::Entity, ecs::query::With, prelude::Res};
     /// # use std::time::Duration;
     /// # let mut world = World::new();
     /// let test_system_id = world.register_system(test_system);

From 2e7a438309a3bed5a5b661503425ee1bafcf7b64 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 17 Jul 2025 15:09:05 +0200
Subject: [PATCH 40/66] Add some more `#[must_use]`

---
 src/tweenable.rs | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/tweenable.rs b/src/tweenable.rs
index 83aab3f..080e103 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -416,6 +416,7 @@ pub trait Tweenable: Send + Sync {
     /// of a single way, either from start to end or back from end to start.
     /// The total "loop" duration start -> end -> start to reach back the
     /// same state in this case is the double of the cycle duration.
+    #[must_use]
     fn cycle_duration(&self) -> Duration;
 
     /// Get the total duration of the entire animation, including repeating.
@@ -424,6 +425,7 @@ pub trait Tweenable: Send + Sync {
     /// duration of a single cycle ([`cycle_duration()`]).
     ///
     /// [`cycle_duration()`]: Self::cycle_duration
+    #[must_use]
     fn total_duration(&self) -> TotalDuration;
 
     /// Set the current animation playback elapsed time.
@@ -459,6 +461,7 @@ pub trait Tweenable: Send + Sync {
     ///
     /// [`cycle_duration()`]: Tweenable::cycle_duration
     /// [`total_duration()`]: Tweenable::total_duration
+    #[must_use]
     fn elapsed(&self) -> Duration;
 
     /// Step the tweenable.
@@ -507,11 +510,13 @@ pub trait Tweenable: Send + Sync {
     /// [`RepeatStrategy::MirroredRepeat`] this corresponds to a playback in
     /// a single direction, so tweening from start to end and back to start
     /// counts as two completed cycles (one forward, one backward).
+    #[must_use]
     fn cycles_completed(&self) -> u32 {
         self.elapsed().div_duration_f64(self.cycle_duration()) as u32
     }
 
     /// Get the completion fraction in `[0:1]` of the current cycle.
+    #[must_use]
     fn cycle_fraction(&self) -> f32 {
         self.elapsed()
             .div_duration_f64(self.cycle_duration())
@@ -540,6 +545,7 @@ pub trait Tweenable: Send + Sync {
     /// actually have any target associated with it.
     ///
     /// [`TweenAnimator`]: crate::TweenAnimator
+    #[must_use]
     fn type_id(&self) -> Option<TypeId>;
 }
 
@@ -1036,8 +1042,15 @@ pub struct Sequence {
 impl Sequence {
     /// Create a new sequence of tweens.
     ///
-    /// This method panics if the input collection is empty.
+    /// The collection of tweens form a single cycle of the sequence. If any
+    /// constituting item is of infinite duration, the sequence itself becomes
+    /// of infinite duration.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the input collection is empty.
     #[must_use]
+    #[inline]
     pub fn new(items: impl IntoIterator<Item = impl Into<BoxedTweenable>>) -> Self {
         let tweens: Vec<_> = items.into_iter().map(Into::into).collect();
         assert!(!tweens.is_empty());
@@ -1053,11 +1066,12 @@ impl Sequence {
         }
     }
 
-    /// Create a new sequence containing a single tween.
+    /// Create a new sequence containing a single tweenable animation.
     #[must_use]
-    pub fn from_single(tween: impl Tweenable + 'static) -> Self {
-        let total_duration = tween.total_duration();
-        let boxed: BoxedTweenable = Box::new(tween);
+    #[inline]
+    pub fn from_single(tweenable: impl Tweenable + 'static) -> Self {
+        let total_duration = tweenable.total_duration();
+        let boxed: BoxedTweenable = Box::new(tweenable);
         Self {
             tweens: vec![boxed],
             index: 0,

From eaede15ce4c23638a5689b50562d398e3d83186e Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 17 Jul 2025 18:36:30 +0200
Subject: [PATCH 41/66] Misc. doc improvements and minor clean-ups

---
 src/lib.rs        | 183 ++++++++++++++++++++++++++++++----------------
 src/plugin.rs     |   2 +-
 src/test_utils.rs |   2 +-
 src/tweenable.rs  |   4 +
 4 files changed, 125 insertions(+), 66 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 38fb441..7109800 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -733,6 +733,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
 }
 
 impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
+    #[inline]
     fn tween<T>(&mut self, tweenable: T) -> &mut EntityCommands<'a>
     where
         T: Tweenable + 'static,
@@ -742,6 +743,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
         })
     }
 
+    #[inline]
     fn move_to(
         &mut self,
         end: Vec3,
@@ -754,6 +756,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
         })
     }
 
+    #[inline]
     fn move_from(
         &mut self,
         start: Vec3,
@@ -766,6 +769,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
         })
     }
 
+    #[inline]
     fn scale_to(
         &mut self,
         end: Vec3,
@@ -778,6 +782,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
         })
     }
 
+    #[inline]
     fn scale_from(
         &mut self,
         start: Vec3,
@@ -810,99 +815,59 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         self
     }
 
+    #[inline]
     fn move_to(
         &mut self,
         end: Vec3,
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let (start, target) =
-            make_component_tween_from_ent_world_mut(self, |transform: &Transform| {
-                transform.translation
-            });
+        let start = self.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
-        self.world_scope(|world: &mut World| {
-            world
-                .resource_mut::<TweenAnimator>()
-                .add_component_target(target.into(), tween);
-        });
-        self
+        self.tween(tween)
     }
 
+    #[inline]
     fn move_from(
         &mut self,
         start: Vec3,
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let (end, target) =
-            make_component_tween_from_ent_world_mut(self, |transform: &Transform| {
-                transform.translation
-            });
+        let end = self.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
-        self.world_scope(|world: &mut World| {
-            world
-                .resource_mut::<TweenAnimator>()
-                .add_component_target(target.into(), tween);
-        });
-        self
+        self.tween(tween)
     }
 
+    #[inline]
     fn scale_to(
         &mut self,
         end: Vec3,
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let (start, target) =
-            make_component_tween_from_ent_world_mut(self, |transform: &Transform| transform.scale);
+        let start = self.get::<Transform>().unwrap().scale;
         let lens = lens::TransformScaleLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
-        self.world_scope(|world: &mut World| {
-            world
-                .resource_mut::<TweenAnimator>()
-                .add_component_target(target.into(), tween);
-        });
-        self
+        self.tween(tween)
     }
 
+    #[inline]
     fn scale_from(
         &mut self,
         start: Vec3,
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let (end, target) =
-            make_component_tween_from_ent_world_mut(self, |transform: &Transform| transform.scale);
+        let end = self.get::<Transform>().unwrap().scale;
         let lens = lens::TransformScaleLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
-        self.world_scope(|world: &mut World| {
-            world
-                .resource_mut::<TweenAnimator>()
-                .add_component_target(target.into(), tween);
-        });
-        self
+        self.tween(tween)
     }
 }
 
-#[inline]
-fn make_component_tween_from_ent_world_mut<'w, C: Component<Mutability = Mutable>, T>(
-    ent: &mut EntityWorldMut<'w>,
-    read: fn(&C) -> T,
-) -> (T, ComponentAnimTarget) {
-    let component_id = ent.world().component_id::<C>().unwrap();
-    let component = ent.get::<C>().unwrap();
-    let value = read(component);
-    let e = ent.id();
-    let target = ComponentAnimTarget {
-        entity: e,
-        component_id,
-    };
-    (value, target)
-}
-
 /// Event raised when a [`TweenAnim`] completed.
 #[derive(Copy, Clone, Event)]
 pub struct AnimCompletedEvent {
@@ -965,9 +930,6 @@ pub enum TweeningError {
 /// component is identified by the ID of the component type as registered in the
 /// [`World`] where the animation is queued, and the [`Entity`] holding the
 /// component instance of that type.
-///
-/// This is a lightweight reference (copyable) implicitly tied to a given
-/// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ComponentAnimTarget {
     /// Component ID of the registered component being animated.
@@ -978,6 +940,19 @@ pub struct ComponentAnimTarget {
 
 impl ComponentAnimTarget {
     /// Create a new component target.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::any::TypeId;
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// fn my_system(mut commands: Commands, components: &Components) {
+    ///     let entity = commands.spawn(Transform::default()).id();
+    ///     let target = ComponentAnimTarget::new::<Transform>(components, entity);
+    ///     // [...]
+    /// }
+    /// ```
     pub fn new<C: Component<Mutability = Mutable>>(
         components: &Components,
         entity: Entity,
@@ -992,6 +967,25 @@ impl ComponentAnimTarget {
     }
 
     /// Create a new component target from a component type ID.
+    ///
+    /// This is useful when the component type is not known at compile time;
+    /// otherwise you should prefer [`new()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::any::TypeId;
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// fn my_system(mut commands: Commands, components: &Components) {
+    ///     let entity = commands.spawn(Transform::default()).id();
+    ///     let type_id = TypeId::of::<Transform>();
+    ///     let target = ComponentAnimTarget::new_untyped(components, type_id, entity);
+    ///     // [...]
+    /// }
+    /// ```
+    ///
+    /// [`new()`]: Self::new
     pub fn new_untyped(
         components: &Components,
         type_id: TypeId,
@@ -1013,9 +1007,6 @@ impl ComponentAnimTarget {
 /// is identified by the ID of the [`Assets`] resource type registered in the
 /// [`World`] where the animation is queued, and the unique asset ID identifying
 /// the asset instance inside that [`Assets`] resource.
-///
-/// This is a lightweight reference (copyable) implicitly tied to a given
-/// [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct AssetAnimTarget {
     /// Resource ID of the registered [`Assets`] asset container.
@@ -1026,6 +1017,21 @@ pub struct AssetAnimTarget {
 
 impl AssetAnimTarget {
     /// Create a new asset target.
+    ///
+    /// The asset type `A` must be such that [`Assets<A>`] is registered in the
+    /// input [`Components`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// fn my_system(components: &Components, asset_server: Res<AssetServer>) {
+    ///     let handle: Handle<Image> = asset_server.load("image.png");
+    ///     let target = AssetAnimTarget::new::<Image>(components, &handle);
+    ///     // [...]
+    /// }
+    /// ```
     pub fn new<A: Asset>(
         components: &Components,
         asset_id: impl Into<AssetId<A>>,
@@ -1040,6 +1046,27 @@ impl AssetAnimTarget {
     }
 
     /// Create a new asset target from an `Assets<A>` type ID.
+    ///
+    /// The `assets_type_id` must reference an [`Assets<A>`] type registered in
+    /// the input [`Components`]. This is useful when the component type is not
+    /// known at compile time; otherwise you should prefer [`new()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::any::TypeId;
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// fn my_system(components: &Components, asset_server: Res<AssetServer>) {
+    ///     let handle: Handle<Image> = asset_server.load("image.png");
+    ///     let handle = handle.untyped();
+    ///     let assets_type_id = TypeId::of::<Assets<Image>>();
+    ///     let target = AssetAnimTarget::new_untyped(components, assets_type_id, &handle);
+    ///     // [...]
+    /// }
+    /// ```
+    ///
+    /// [`new()`]: Self::new
     pub fn new_untyped(
         components: &Components,
         assets_type_id: TypeId,
@@ -1082,6 +1109,11 @@ impl AnimTarget {
     }
 
     /// Convert this target to a component target if possible.
+    ///
+    /// # Returns
+    ///
+    /// Returns self as a [`ComponentAnimTarget`] if the value matches that enum
+    /// variant, or `None` if it doesn't.
     #[inline]
     pub fn as_component(&self) -> Option<&ComponentAnimTarget> {
         if let Self::Component(component) = self {
@@ -1092,6 +1124,11 @@ impl AnimTarget {
     }
 
     /// Convert this target to a component target if possible.
+    ///
+    /// # Returns
+    ///
+    /// Returns self as a [`ComponentAnimTarget`] if the value matches that enum
+    /// variant, or `None` if it doesn't.
     #[inline]
     pub fn as_component_mut(&mut self) -> Option<&mut ComponentAnimTarget> {
         if let Self::Component(component) = self {
@@ -1108,6 +1145,11 @@ impl AnimTarget {
     }
 
     /// Convert this target to an asset target if possible.
+    ///
+    /// # Returns
+    ///
+    /// Returns self as an [`AssetAnimTarget`] if the value matches that enum
+    /// variant, or `None` if it doesn't.
     #[inline]
     pub fn as_asset(&self) -> Option<&AssetAnimTarget> {
         if let Self::Asset(asset) = self {
@@ -1118,6 +1160,11 @@ impl AnimTarget {
     }
 
     /// Convert this target to an asset target if possible.
+    ///
+    /// # Returns
+    ///
+    /// Returns self as an [`AssetAnimTarget`] if the value matches that enum
+    /// variant, or `None` if it doesn't.
     #[inline]
     pub fn as_asset_mut(&mut self) -> Option<&mut AssetAnimTarget> {
         if let Self::Asset(asset) = self {
@@ -1144,7 +1191,8 @@ impl From<AssetAnimTarget> for AnimTarget {
 ///
 /// This trait extends [`World`] with some helper functions.
 pub trait WorldTargetExtensions {
-    /// Get an [`AnimTarget`] for the given component type and entity pair.
+    /// Get a [`ComponentAnimTarget`] for the given component type and entity
+    /// pair.
     ///
     /// The target references the component instance held by the entity. The
     /// entity must exist in the [`World`], and the component type must be
@@ -1155,12 +1203,12 @@ pub trait WorldTargetExtensions {
     /// Returns the animation target referencing the component instance, or
     /// `None` if either the entity doesn't exist or the component type is not
     /// registered.
-    fn get_component_target<C: Component<Mutability = Mutable>>(
+    fn get_anim_component_target<C: Component<Mutability = Mutable>>(
         &self,
         entity: Entity,
     ) -> Option<ComponentAnimTarget>;
 
-    /// Get an [`AnimTarget`] for the given asset type and ID pair.
+    /// Get an [`AssetAnimTarget`] for the given asset type and ID pair.
     ///
     /// The target references the asset instance with the given ID. The
     /// ID must be valid, that is reference an existing asset in the `Assets<A>`
@@ -1171,11 +1219,12 @@ pub trait WorldTargetExtensions {
     /// Returns the animation target referencing the asset instance, or
     /// `None` if either the ID doesn't reference an existing asset or the asset
     /// type is not registered.
-    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetAnimTarget>;
+    fn get_anim_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>)
+        -> Option<AssetAnimTarget>;
 }
 
 impl WorldTargetExtensions for World {
-    fn get_component_target<C: Component<Mutability = Mutable>>(
+    fn get_anim_component_target<C: Component<Mutability = Mutable>>(
         &self,
         entity: Entity,
     ) -> Option<ComponentAnimTarget> {
@@ -1189,7 +1238,10 @@ impl WorldTargetExtensions for World {
         })
     }
 
-    fn get_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>) -> Option<AssetAnimTarget> {
+    fn get_anim_asset_target<A: Asset>(
+        &self,
+        id: impl Into<AssetId<A>>,
+    ) -> Option<AssetAnimTarget> {
         let id = id.into();
         if !self.resource::<Assets<A>>().contains(id) {
             return None;
@@ -1212,6 +1264,9 @@ impl WorldTargetExtensions for World {
 /// instance. Each instance is independent, even if it mutates the same target
 /// as another instance.
 ///
+/// _If you're looking for the basic tweenable animation description, see
+/// [`Tween`] instead._
+///
 /// [`add_component()`]: crate::TweenAnimator::add_component
 /// [`add_asset()`]: crate::TweenAnimator::add_asset
 pub struct TweenAnim {
diff --git a/src/plugin.rs b/src/plugin.rs
index 1872492..9b102ec 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnimator};
 
-/// Plugin to register the [`TweenAnimator`] and the systme playing animations.
+/// Plugin to register the [`TweenAnimator`] and the system playing animations.
 ///
 /// This plugin registers the common resources and events used by 🍃 Bevy
 /// Tweening as well as the core animation system which executes all pending
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 7261bdb..7bd98a2 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -147,7 +147,7 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
 
         let entity = world.spawn(T::default()).id();
         let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
-            let target = world.get_component_target::<T>(entity).unwrap();
+            let target = world.get_anim_component_target::<T>(entity).unwrap();
             animator.add_component_target(target, tweenable)
         });
 
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 080e103..98f33da 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -574,6 +574,9 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 /// or backward. On completion, you can be notified via events, observers, or
 /// the execution of a one-shot system.
 ///
+/// _If you're looking for the runtime representation of a tweenable animation
+/// queued into the [`TweenAnimator`], see [`TweenAnim`] instead._
+///
 /// # Cycles
 ///
 /// A tween can be configured to repeat multiple, or even an infinity, of times.
@@ -651,6 +654,7 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 /// [`with_completed_system()`]: Self::with_completed_system
 /// [`set_completed_system()`]: Self::set_completed_system
 /// [`AnimCompletedEvent`]: crate::AnimCompletedEvent
+/// [`TweenAnimator`]: crate::TweenAnimator
 pub struct Tween {
     ease_method: EaseMethod,
     clock: AnimClock,

From da152922d6ffde574a4a8e20f90d54444d1fc7b3 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 17 Jul 2025 22:09:04 +0200
Subject: [PATCH 42/66] Top-level doc polish

---
 src/lib.rs | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 7109800..555a7bb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,15 +10,15 @@
     missing_docs
 )]
 
-//! Tweening animation plugin for the Bevy game engine
+//! Tweening animation plugin for the Bevy game engine.
 //!
 //! 🍃 Bevy Tweening provides interpolation-based animation between ("tweening")
-//! two values, for any component and asset, including both built-in Bevy ones
-//! and custom user-defined ones. Each field of a component or asset can be
-//! animated via a collection of predefined easing functions, or providing a
-//! custom animation curve. The library supports any number of animations queued
-//! in parallel, even on the same component or asset type, and allows runtime
-//! control over playback and animation speed.
+//! two values, to animate any field of any component and asset, including both
+//! built-in Bevy ones and custom user-defined ones. Each field of a component
+//! or asset can be animated via a collection of predefined easing functions, or
+//! providing a custom animation curve. The library supports any number of
+//! animations queued in parallel, even on the same component or asset type, and
+//! allows runtime control over playback and animation speed.
 //!
 //! # Example
 //!
@@ -239,6 +239,21 @@
 //! can see above is very simple. This allows animating virtually any field of
 //! any component or asset, whether shipped with Bevy or defined by the user.
 //!
+//! # Tweening vs. keyframed animation
+//!
+//! 🍃 Bevy Tweening is a "tweening" animation library. It focuses on simple
+//! animations often used in applications and games to breathe life into a user
+//! interface or the objects of a game world. The API design favors simplicity,
+//! often for quick one-shot animations created from code. This type of
+//! animation is inherently simpler than a full-blown animation solution, like
+//! `bevy_animation`, which typically works with complex keyframe-based
+//! animation curves authored via Digital Content Creation (DCC) tools like 3D
+//! modellers and exported as assets, and whose most common usage is skeletal
+//! animation of characters. There's a grey area between those two approaches,
+//! and you can use both to achieve most animations, but 🍃 Bevy Tweening will
+//! shine for simpler animations while `bevy_animation` while offer a more
+//! extensive support for larger, more complex ones.
+//!
 //! [`Transform::translation`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html#structfield.translation
 //! [`Entity`]: https://docs.rs/bevy/0.16.0/bevy/ecs/entity/struct.Entity.html
 //! [`Query`]: https://docs.rs/bevy/0.16.0/bevy/ecs/system/struct.Query.html

From 6175ae7da499df284ced17c1a2fc21213263e1b8 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 17 Jul 2025 18:05:49 +0200
Subject: [PATCH 43/66] Try to make TweenAnim a component

---
 CHANGELOG.md         |   1 -
 Cargo.toml           |   3 +-
 examples/sequence.rs |  12 ++--
 src/lib.rs           | 158 +++++++++++++++++++++----------------------
 src/plugin.rs        |  11 +--
 src/test_utils.rs    |   4 +-
 src/tweenable.rs     |  57 ++++++++--------
 7 files changed, 121 insertions(+), 125 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0982161..2c08328 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,7 +13,6 @@ executing them from a single exclusive system._
 ### Added
 
 - Added `TweenAnimator`, a resource acting as a container for all active animations.
-- Added `TweenId`, a unique identifier for a currently active animation.
 - Added `TweenAnim`, a representation of the runtime parameters of an active animation.
 - Added `AnimTarget`, an enum describing the target mutated by an animation.
   Also added two structs `ComponentAnimTarget` and `AssetAnimTarget` as its enum variants.
diff --git a/Cargo.toml b/Cargo.toml
index e0dc9b6..6daaf27 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,8 +27,7 @@ bevy_text = ["bevy/bevy_text", "bevy/bevy_render", "bevy/bevy_sprite"]
 [dependencies]
 # Note: abuse 'bevy_color' to force 'bevy_math/curve' feature, which defines EaseFunction
 bevy = { version = "0.16", default-features = false, features = [ "bevy_color", "bevy_asset" ]}
-slotmap = "1.0"
-thiserror = "2.0.12"
+thiserror = "2"
 
 [dev-dependencies]
 bevy-inspector-egui = { version = "0.31" }
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 747a6a8..191a4be 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -33,19 +33,19 @@ struct BlueProgress;
 struct RedSprite {
     /// ID of the tween making the red sprite move along a path around the
     /// screen.
-    pub path_tween_id: TweenId,
+    pub path_tween_id: Entity,
     /// ID of the tween making the red sprite rotate on itself back and forth.
     #[allow(unused)]
-    pub rotate_tween_id: TweenId,
+    pub rotate_tween_id: Entity,
 }
 
 #[derive(Component)]
 struct BlueSprite {
     /// ID of the tween making the blue sprite move along a path, then rotate.
-    pub move_and_rotate_tween_id: TweenId,
+    pub move_and_rotate_tween_id: Entity,
     /// ID of the tween making the blue sprite scale.
     #[allow(unused)]
-    pub scale_tween_id: TweenId,
+    pub scale_tween_id: Entity,
 }
 
 #[derive(Component)]
@@ -169,7 +169,7 @@ fn setup(
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
         // Because we want to monitor the progress of the animations, we need to fetch
-        // their TweenId. This requires inserting them manually in the TweenAnimator
+        // their Entity. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
         let path_tween_id = animator.add_component(components, entity, anim_move_along_path)?;
         let rotate_tween_id =
@@ -247,7 +247,7 @@ fn setup(
         let seq2 = tween_delay.then(tween_scale);
 
         // Because we want to monitor the progress of the animations, we need to fetch
-        // their TweenId. This requires inserting them manually in the TweenAnimator
+        // their Entity. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
         let move_and_rotate_tween_id = animator.add_component(components, entity, seq1)?;
         let scale_tween_id = animator.add_component(components, entity, seq2)?;
diff --git a/src/lib.rs b/src/lib.rs
index 555a7bb..52b077f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -198,13 +198,13 @@
 //! # None }
 //! ```
 //!
-//! After that, you can use the [`TweenId`] to control the animation playback:
+//! After that, you can use the [`Entity`] to control the animation playback:
 //!
 //! ```no_run
 //! # use bevy_tweening::*;
 //! # fn xxx() -> Option<()> {
 //! # let mut animator = TweenAnimator::default();
-//! # let tween_id = TweenId::default();
+//! # let tween_id = Entity::default();
 //! animator.get_mut(tween_id)?.speed = 0.8; // 80% playback speed
 //! # None }
 //! ```
@@ -279,7 +279,6 @@ use bevy::{
 };
 pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
-use slotmap::{new_key_type, SlotMap};
 use thiserror::Error;
 pub use tweenable::{
     BoxedTweenable, CycleCompletedEvent, Delay, Sequence, TotalDuration, Tween, TweenState,
@@ -501,11 +500,6 @@ impl std::ops::Not for PlaybackDirection {
     }
 }
 
-new_key_type! {
-    /// Unique identifier for a tweenable animation currently registered with the [`TweenAnimator`].
-    pub struct TweenId;
-}
-
 /// Extensions to queue tween-based animations.
 ///
 /// This trait provide extension functions to [`EntityWorldMut`] and
@@ -548,7 +542,7 @@ new_key_type! {
 /// ```
 ///
 /// This convenience comes at the price of reduced control and error checking.
-/// Additional information like the [`TweenId`] of a newly created [`TweenAnim`]
+/// Additional information like the [`Entity`] of a newly created [`TweenAnim`]
 /// cannot be retrieved. And any error (_e.g._ trying to insert an animation
 /// with a tweenable of a component type while the entity doesn't have that
 /// component) cannot be forwarded back to the caller, so will produce a panic
@@ -598,7 +592,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
     /// [`TweenAnimator::add_component()`].
     ///
@@ -638,7 +632,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
     /// [`TweenAnimator::add_component()`].
     ///
@@ -678,7 +672,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
     /// [`TweenAnimator::add_component()`].
     ///
@@ -718,7 +712,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`TweenId`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the ID and control
     /// the animation playback, directly add the tweenable via
     /// [`TweenAnimator::add_component()`].
     ///
@@ -823,9 +817,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
             entity: self.id(),
         };
         self.world_scope(|world: &mut World| {
-            world
-                .resource_mut::<TweenAnimator>()
-                .add_component_target(target.into(), tweenable);
+            world.spawn(TweenAnim::new(target.into(), Box::new(tweenable)));
         });
         self
     }
@@ -837,7 +829,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let start = self.get::<Transform>().unwrap().translation;
+        let start=  self.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -850,7 +842,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let end = self.get::<Transform>().unwrap().translation;
+        let end=  self.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -863,7 +855,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let start = self.get::<Transform>().unwrap().scale;
+        let start=  self.get::<Transform>().unwrap().scale;
         let lens = lens::TransformScaleLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -876,7 +868,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let end = self.get::<Transform>().unwrap().scale;
+        let end=  self.get::<Transform>().unwrap().scale;
         let lens = lens::TransformScaleLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -894,7 +886,7 @@ pub struct AnimCompletedEvent {
     /// identify the tweenable animation from an ID stored by the user. You
     /// can prevent a completed animation from being automatically destroyed by
     /// setting [`TweenAnim::destroy_on_completion`] to `false`.
-    pub id: TweenId,
+    pub id: Entity,
     /// The animation target.
     ///
     /// This is provided both as a convenience for [`TweenAnim`]s not destroyed
@@ -925,9 +917,9 @@ pub enum TweeningError {
     /// `None`.
     #[error("Expected a typed Tweenable.")]
     UntypedTweenable,
-    /// Invalid [`TweenId`].
-    #[error("Invalid TweenId {0:?}.")]
-    InvalidTweenId(TweenId),
+    /// Invalid [`Entity`].
+    #[error("Invalid Entity {0:?}.")]
+    InvalidTweenId(Entity),
     /// Cannot change target kind.
     #[error("Unexpected target kind: was component={0}, now component={1}")]
     MismatchingTargetKind(bool, bool),
@@ -1284,6 +1276,7 @@ impl WorldTargetExtensions for World {
 ///
 /// [`add_component()`]: crate::TweenAnimator::add_component
 /// [`add_asset()`]: crate::TweenAnimator::add_asset
+#[derive(Component)]
 pub struct TweenAnim {
     /// Target [`Entity`] containing the component to animate, or target asset.
     target: AnimTarget,
@@ -1404,6 +1397,32 @@ type Resolver = Box<
         + 'static,
 >;
 
+//pub struct ResolverId(pub u32);
+
+///
+#[derive(Default, Resource)]
+pub struct TweenResolver {
+    /// Asset resolver allowing to convert a pair of { untyped pointer to
+    /// `Assets<A>`, untyped `AssetId` } into an untyped pointer to the asset A
+    /// itself. This is necessary because there's no UntypedAssets interface in
+    /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
+    /// The resolver is allowed to fail (return `None`), for example when the
+    /// asset ID doesn't reference a valid asset.
+    asset_resolver: HashMap<ComponentId, Resolver>,
+}
+
+impl TweenResolver {
+    ///
+    pub fn resolve_asset(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<&(dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>> + Send + Sync + 'static)> {
+        self.asset_resolver
+            .get(&component_id)
+            .map(|resolver| resolver.as_ref())
+    }
+}
+
 struct StepResult {
     pub retain: bool,
     pub sent_commands: bool,
@@ -1412,7 +1431,7 @@ struct StepResult {
 /// Animator for tween-based animations.
 ///
 /// This resource stores all the active tweening animations for the entire
-/// application. It's essentially a hash map from a [`TweenId`] uniquely
+/// application. It's essentially a hash map from a [`Entity`] uniquely
 /// identifying an active animation, to the [`TweenAnim`] runtime data of that
 /// animation. Use this resource to lookup animations by ID and modify their
 /// runtime data, for example their playback speed.
@@ -1431,9 +1450,9 @@ struct StepResult {
 /// Conversely, disabling auto-destruction on completion is best suited to
 /// reusing the same animation instance again and again.
 ///
-/// # Lookup without `TweenId`
+/// # Lookup without `Entity`
 ///
-/// If you don't know the [`TweenId`] of an animation, you can also lookup the
+/// If you don't know the [`Entity`] of an animation, you can also lookup the
 /// set of animations for a given target, either component on an entity or an
 /// asset.
 ///
@@ -1462,27 +1481,7 @@ struct StepResult {
 ///     Ok(())
 /// }
 /// ```
-#[derive(Resource)]
-pub struct TweenAnimator {
-    /// Queue of animations currently playing.
-    anims: SlotMap<TweenId, TweenAnim>,
-    /// Asset resolver allowing to convert a pair of { untyped pointer to
-    /// `Assets<A>`, untyped `AssetId` } into an untyped pointer to the asset A
-    /// itself. This is necessary because there's no UntypedAssets interface in
-    /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
-    /// The resolver is allowed to fail (return `None`), for example when the
-    /// asset ID doesn't reference a valid asset.
-    asset_resolver: HashMap<ComponentId, Resolver>,
-}
 
-impl Default for TweenAnimator {
-    fn default() -> Self {
-        Self {
-            anims: Default::default(),
-            asset_resolver: Default::default(),
-        }
-    }
-}
 
 impl TweenAnimator {
     /// Add a new component animation to the animator queue.
@@ -1512,7 +1511,7 @@ impl TweenAnimator {
     /// world.entity_mut(entity).tween(tween);
     /// ```
     ///
-    /// This function is still useful if you want to store the [`TweenId`] of
+    /// This function is still useful if you want to store the [`Entity`] of
     /// the new animation, to later access it to dynamically modify the playback
     /// (e.g. speed).
     ///
@@ -1521,9 +1520,9 @@ impl TweenAnimator {
     /// # use bevy_tweening::{lens::*, *};
     /// # use std::time::Duration;
     /// # fn make_tween() -> Tween { unimplemented!() }
-    /// // Helper component to store a TweenId
+    /// // Helper component to store a Entity
     /// #[derive(Component)]
-    /// struct MyTweenId(pub TweenId);
+    /// struct MyTweenId(pub Entity);
     ///
     /// // System which spawns the component and its animation
     /// fn my_spawn_system(
@@ -1535,7 +1534,7 @@ impl TweenAnimator {
     ///     let entity = commands.spawn(Transform::default()).id();
     ///     // The component type is deducted from `tween` here
     ///     let tween_id = animator.add_component(components, entity, tween)?;
-    ///     // Save the new TweenId for later use
+    ///     // Save the new Entity for later use
     ///     commands.entity(entity).insert(MyTweenId(tween_id));
     ///     Ok(())
     /// }
@@ -1553,7 +1552,7 @@ impl TweenAnimator {
     /// spawning is deffered via [`Commands`]. This is not an error; the
     /// [`TweenAnimator`] doesn't perform any check when this function is
     /// called, on purpose to allow patterns like inserting the returned
-    /// [`TweenId`] into a component or resource from within the same system
+    /// [`Entity`] into a component or resource from within the same system
     /// which spawned the target, without having to apply deferred commands
     /// first. When the animation steps however, the target is validated, and if
     /// invalid (either because the entity doesn't exist or it doesn't have the
@@ -1564,7 +1563,7 @@ impl TweenAnimator {
         components: &Components,
         entity: Entity,
         tweenable: T,
-    ) -> Result<TweenId, TweeningError>
+    ) -> Result<Entity, TweeningError>
     where
         T: Tweenable + 'static,
     {
@@ -1587,7 +1586,7 @@ impl TweenAnimator {
     ///
     /// [`add_component()`]: Self::add_component
     #[inline]
-    pub fn add_component_target<T>(&mut self, target: ComponentAnimTarget, tweenable: T) -> TweenId
+    pub fn add_component_target<T>(&mut self, target: ComponentAnimTarget, tweenable: T) -> Entity
     where
         T: Tweenable + 'static,
     {
@@ -1605,9 +1604,9 @@ impl TweenAnimator {
     /// #[derive(Asset, TypePath)]
     /// struct MyAsset;
     ///
-    /// // Helper component to store a TweenId
+    /// // Helper component to store a Entity
     /// #[derive(Resource)]
-    /// struct MyTweenId(pub TweenId);
+    /// struct MyTweenId(pub Entity);
     ///
     /// // System which spawns the asset animation
     /// fn my_spawn_system(
@@ -1620,7 +1619,7 @@ impl TweenAnimator {
     ///     let handle = assets.add(MyAsset);
     ///     // The asset type is deducted from `tween` here
     ///     let tween_id = animator.add_asset(components, handle.id(), tween)?;
-    ///     // Save the new TweenId for later use
+    ///     // Save the new Entity for later use
     ///     my_tween_id.0 = tween_id;
     ///     Ok(())
     /// }
@@ -1649,7 +1648,7 @@ impl TweenAnimator {
         components: &Components,
         asset_id: impl Into<AssetId<A>>,
         tweenable: T,
-    ) -> Result<TweenId, TweeningError>
+    ) -> Result<Entity, TweeningError>
     where
         T: Tweenable + 'static,
     {
@@ -1698,7 +1697,7 @@ impl TweenAnimator {
     ///
     /// [`get()`]: Self::get
     #[inline]
-    pub fn contains(&self, id: TweenId) -> bool {
+    pub fn contains(&self, id: Entity) -> bool {
         self.anims.contains_key(id)
     }
 
@@ -1706,9 +1705,9 @@ impl TweenAnimator {
     ///
     /// This fails and returns `None` if the animation has completed and was
     /// removed from the animator's internal queue, or if the ID is invalid
-    /// (notably, `TweenId::null()`).
+    /// (notably, `Entity::PLACEHOLDER`).
     #[inline]
-    pub fn get(&self, id: TweenId) -> Option<&TweenAnim> {
+    pub fn get(&self, id: Entity) -> Option<&TweenAnim> {
         self.anims.get(id)
     }
 
@@ -1716,9 +1715,9 @@ impl TweenAnimator {
     ///
     /// This fails and returns `None` if the animation has completed and was
     /// removed from the animator's internal queue, or if the ID is invalid
-    /// (notably, `TweenId::null()`).
+    /// (notably, `Entity::PLACEHOLDER`).
     #[inline]
-    pub fn get_mut(&mut self, id: TweenId) -> Option<&mut TweenAnim> {
+    pub fn get_mut(&mut self, id: Entity) -> Option<&mut TweenAnim> {
         self.anims.get_mut(id)
     }
 
@@ -1726,9 +1725,9 @@ impl TweenAnimator {
     ///
     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
     /// animation has completed and was removed from the animator's internal
-    /// queue, or if the ID is invalid (notably, `TweenId::null()`).
+    /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
     #[inline]
-    pub fn try_get(&self, id: TweenId) -> Result<&TweenAnim, TweeningError> {
+    pub fn try_get(&self, id: Entity) -> Result<&TweenAnim, TweeningError> {
         self.anims.get(id).ok_or(TweeningError::InvalidTweenId(id))
     }
 
@@ -1736,9 +1735,9 @@ impl TweenAnimator {
     ///
     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
     /// animation has completed and was removed from the animator's internal
-    /// queue, or if the ID is invalid (notably, `TweenId::null()`).
+    /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
     #[inline]
-    pub fn try_get_mut(&mut self, id: TweenId) -> Result<&mut TweenAnim, TweeningError> {
+    pub fn try_get_mut(&mut self, id: Entity) -> Result<&mut TweenAnim, TweeningError> {
         self.anims
             .get_mut(id)
             .ok_or(TweeningError::InvalidTweenId(id))
@@ -1751,7 +1750,7 @@ impl TweenAnimator {
     /// An iterator over pairs of (ID, animation) for all animations still in
     /// the internal queue.
     #[inline]
-    pub fn iter(&self) -> impl Iterator<Item = (TweenId, &TweenAnim)> {
+    pub fn iter(&self) -> impl Iterator<Item = (Entity, &TweenAnim)> {
         self.anims.iter()
     }
 
@@ -1762,7 +1761,7 @@ impl TweenAnimator {
     /// An iterator over pairs of (ID, animation) for all animations still in
     /// the internal queue.
     #[inline]
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (TweenId, &mut TweenAnim)> {
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (Entity, &mut TweenAnim)> {
         self.anims.iter_mut()
     }
 
@@ -1782,7 +1781,7 @@ impl TweenAnimator {
     /// [`add_component()`]: Self::add_component
     /// [`add_asset()`]: Self::add_asset
     #[inline]
-    pub fn remove(&mut self, id: TweenId) -> Option<TweenAnim> {
+    pub fn remove(&mut self, id: Entity) -> Option<TweenAnim> {
         self.anims.remove(id)
     }
 
@@ -1804,7 +1803,7 @@ impl TweenAnimator {
     /// [`set_target()`]: Self::set_target
     pub fn set_target(
         &mut self,
-        id: TweenId,
+        id: Entity,
         target: AnimTarget,
     ) -> Result<AnimTarget, TweeningError> {
         let anim = self
@@ -1862,7 +1861,7 @@ impl TweenAnimator {
     /// # use bevy::prelude::*;
     /// # use bevy_tweening::*;
     /// # fn sys(mut animator: ResMut<TweenAnimator>) {
-    /// # let id = TweenId::null();
+    /// # let id = Entity::PLACEHOLDER;
     /// # let mut tweenable = Delay::new(Duration::from_secs(1));
     /// let elapsed = animator.get(id).unwrap().tweenable().elapsed();
     /// tweenable.set_elapsed(elapsed);
@@ -1882,7 +1881,7 @@ impl TweenAnimator {
     /// [`step_one()`]: Self::step_one
     pub fn set_tweenable<T>(
         &mut self,
-        id: TweenId,
+        id: Entity,
         tweenable: T,
     ) -> Result<BoxedTweenable, TweeningError>
     where
@@ -1924,7 +1923,7 @@ impl TweenAnimator {
     pub fn step_one(
         &mut self,
         world: &mut World,
-        id: TweenId,
+        id: Entity,
         delta_time: Duration,
     ) -> Option<TweenAnim> {
         world.resource_scope(|world, events: Mut<Events<CycleCompletedEvent>>| {
@@ -1956,7 +1955,7 @@ impl TweenAnimator {
     }
 
     fn step_impl(
-        tween_id: TweenId,
+        tween_id: Entity,
         anim: &mut TweenAnim,
         asset_resolver: &HashMap<ComponentId, Resolver>,
         world: &mut World,
@@ -2176,7 +2175,6 @@ mod tests {
     use std::marker::PhantomData;
 
     use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
-    use slotmap::Key as _;
 
     use super::*;
     use crate::test_utils::*;
@@ -2342,10 +2340,10 @@ mod tests {
     #[test]
     fn animator_default() {
         let mut animator = TweenAnimator::default();
-        assert!(animator.get(TweenId::null()).is_none());
+        assert!(animator.get(Entity::PLACEHOLDER).is_none());
         assert!(animator.iter().next().is_none());
         assert!(animator.iter_mut().next().is_none());
-        assert!(animator.remove(TweenId::null()).is_none());
+        assert!(animator.remove(Entity::PLACEHOLDER).is_none());
     }
 
     // TweenAnim::playback_state is entirely user-controlled; stepping animations
@@ -2603,13 +2601,13 @@ mod tests {
                 ComponentAnimTarget::new::<DummyComponent>(env.world.components(), entity).unwrap();
             let err = env
                 .animator_mut()
-                .set_target(TweenId::null(), target.into())
+                .set_target(Entity::PLACEHOLDER, target.into())
                 .err()
                 .unwrap();
             let TweeningError::InvalidTweenId(err_id) = err else {
                 panic!();
             };
-            assert_eq!(err_id, TweenId::null());
+            assert_eq!(err_id, Entity::PLACEHOLDER);
         }
 
         // Spawn a second entity without any animation
diff --git a/src/plugin.rs b/src/plugin.rs
index 9b102ec..34caaa0 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnimator};
+use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenResolver};
 
 /// Plugin to register the [`TweenAnimator`] and the system playing animations.
 ///
@@ -14,7 +14,7 @@ pub struct TweeningPlugin;
 
 impl Plugin for TweeningPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<TweenAnimator>()
+        app.init_resource::<TweenResolver>()
             .add_event::<CycleCompletedEvent>()
             .add_event::<AnimCompletedEvent>()
             .add_systems(
@@ -35,8 +35,11 @@ pub enum AnimationSystem {
 /// Core animation systemt ticking the [`TweenAnimator`].
 pub(crate) fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
-    world.resource_scope(|world, mut animator: Mut<TweenAnimator>| {
-        animator.step_all(world, delta_time);
+    let anims = world.query::<&mut TweenAnim>();
+    world.resource_scope(|world, mut resolver: Mut<TweenResolver>| {
+        for anim in anims.iter_mut(world) {
+            anim.step(world, delta_time);
+        }
     });
 }
 
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 7bd98a2..50a2364 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -118,7 +118,7 @@ macro_rules! assert_approx_eq {
 pub(crate) use assert_approx_eq;
 
 use crate::{
-    AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenAnimator, TweenId, Tweenable,
+    AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenAnimator, Tweenable,
     WorldTargetExtensions as _,
 };
 
@@ -127,7 +127,7 @@ use crate::{
 pub(crate) struct TestEnv<T: Component> {
     pub world: World,
     pub entity: Entity,
-    pub tween_id: TweenId,
+    pub tween_id: Entity,
     system: Box<dyn System<In = (), Out = ()>>,
     _phantom: PhantomData<T>,
 }
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 98f33da..02a29cd 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -5,9 +5,7 @@ use bevy::{
     prelude::*,
 };
 
-use crate::{
-    AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy, TweenId,
-};
+use crate::{AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy};
 
 /// The dynamic tweenable type.
 ///
@@ -31,7 +29,7 @@ use crate::{
 /// # use std::{any::TypeId, time::Duration};
 /// # use bevy::ecs::{system::{Commands, SystemId}, change_detection::MutUntyped};
 /// # use bevy::prelude::*;
-/// # use bevy_tweening::{BoxedTweenable, Sequence, TweenId, Tweenable, CycleCompletedEvent, TweenState, TotalDuration};
+/// # use bevy_tweening::{BoxedTweenable, Sequence, Entity, Tweenable, CycleCompletedEvent, TweenState, TotalDuration};
 /// #
 /// # #[derive(Debug)]
 /// # struct MyTweenable;
@@ -40,7 +38,7 @@ use crate::{
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
-/// #     fn step(&mut self, _tween_id: TweenId, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(), queue_system: &mut dyn FnMut(SystemId)) -> TweenState  { unimplemented!() }
+/// #     fn step(&mut self, _tween_id: Entity, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(), queue_system: &mut dyn FnMut(SystemId)) -> TweenState  { unimplemented!() }
 /// #     fn rewind(&mut self) { unimplemented!() }
 /// #     fn cycles_completed(&self) -> u32 { unimplemented!() }
 /// #     fn cycle_fraction(&self) -> f32 { unimplemented!() }
@@ -103,7 +101,7 @@ pub struct CycleCompletedEvent {
     ///
     /// [`TweenAnim`]: crate::TweenAnim
     /// [`TweenAnimator::get()`]: crate::TweenAnimator::get
-    pub id: TweenId,
+    pub id: Entity,
     /// The target the tweenable which completed and the [`TweenAnim`] it's
     /// part of are mutating.
     ///
@@ -483,7 +481,7 @@ pub trait Tweenable: Send + Sync {
     /// [`elapsed()`]: Tweenable::elapsed
     fn step(
         &mut self,
-        tween_id: TweenId,
+        tween_id: Entity,
         delta: Duration,
         target: MutUntyped,
         notify_completed: &mut dyn FnMut(),
@@ -988,7 +986,7 @@ impl Tweenable for Tween {
 
     fn step(
         &mut self,
-        _tween_id: TweenId,
+        _tween_id: Entity,
         delta: Duration,
         target: MutUntyped,
         notify_completed: &mut dyn FnMut(),
@@ -1176,7 +1174,7 @@ impl Tweenable for Sequence {
 
     fn step(
         &mut self,
-        tween_id: TweenId,
+        tween_id: Entity,
         mut delta: Duration,
         mut target: MutUntyped,
         notify_completed: &mut dyn FnMut(),
@@ -1357,7 +1355,7 @@ impl Tweenable for Delay {
 
     fn step(
         &mut self,
-        _tween_id: TweenId,
+        _tween_id: Entity,
         delta: Duration,
         _target: MutUntyped,
         _notify_completed: &mut dyn FnMut(),
@@ -1408,7 +1406,6 @@ mod tests {
     use bevy::ecs::{
         change_detection::MaybeLocation, component::Tick, event::Events, system::SystemState,
     };
-    use slotmap::Key as _;
 
     use super::*;
     use crate::{lens::*, test_utils::assert_approx_eq, ComponentAnimTarget};
@@ -1552,7 +1549,7 @@ mod tests {
 
     /// Manually tick a test tweenable targeting a component.
     fn manual_tick_component(
-        tween_id: TweenId,
+        tween_id: Entity,
         duration: Duration,
         tween: &mut dyn Tweenable,
         world: &mut World,
@@ -1920,7 +1917,7 @@ mod tests {
 
                     // Tick the tween
                     let actual_state = manual_tick_component(
-                        TweenId::null(), // unused in this test
+                        Entity::PLACEHOLDER, // unused in this test
                         tick_duration,
                         &mut tween,
                         &mut world,
@@ -1984,7 +1981,7 @@ mod tests {
 
                     // Dummy tick to update target
                     let actual_state = manual_tick_component(
-                        TweenId::null(), // unused in this test
+                        Entity::PLACEHOLDER, // unused in this test
                         Duration::ZERO,
                         &mut tween,
                         &mut world,
@@ -2046,7 +2043,7 @@ mod tests {
         tween.set_playback_direction(PlaybackDirection::Backward);
         assert_eq!(tween.elapsed(), d300);
         manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             Duration::from_millis(100),
             &mut tween,
             &mut world,
@@ -2102,7 +2099,7 @@ mod tests {
 
         for i in 1..=16 {
             let state = manual_tick_component(
-                TweenId::null(), // unused in this test
+                Entity::PLACEHOLDER, // unused in this test
                 Duration::from_millis(200),
                 &mut seq,
                 &mut world,
@@ -2155,7 +2152,7 @@ mod tests {
         // - Start the third tween
         for delta_ms in [500, 2000] {
             manual_tick_component(
-                TweenId::null(), // unused in this test
+                Entity::PLACEHOLDER, // unused in this test
                 Duration::from_millis(delta_ms),
                 &mut seq,
                 &mut world,
@@ -2268,7 +2265,7 @@ mod tests {
 
     //     for i in 1..=6 {
     //         let state = manual_tick_component(
-    //             TweenId::null(), // unused in this test
+    //             Entity::PLACEHOLDER, // unused in this test
     //             Duration::from_millis(200),
     //             &mut tracks,
     //             &mut world,
@@ -2305,7 +2302,7 @@ mod tests {
     //     assert_approx_eq!(tracks.progress(), 0.9);
     //     // tick to udpate state (set_progress() does not update state)
     //     let state = manual_tick_component(
-    //         TweenId::null(), // unused in this test
+    //         Entity::PLACEHOLDER, // unused in this test
     //         Duration::ZERO,
     //         &mut tracks,
     //         &mut world,
@@ -2318,7 +2315,7 @@ mod tests {
     //     assert_approx_eq!(tracks.progress(), 1.);
     //     // tick to udpate state (set_progress() does not update state)
     //     let state = manual_tick_component(
-    //         TweenId::null(), // unused in this test
+    //         Entity::PLACEHOLDER, // unused in this test
     //         Duration::ZERO,
     //         &mut tracks,
     //         &mut world,
@@ -2331,7 +2328,7 @@ mod tests {
     //     assert_approx_eq!(tracks.progress(), 0.);
     //     // tick to udpate state (set_progress() does not update state)
     //     let state = manual_tick_component(
-    //         TweenId::null(), // unused in this test
+    //         Entity::PLACEHOLDER, // unused in this test
     //         Duration::ZERO,
     //         &mut tracks,
     //         &mut world,
@@ -2378,7 +2375,7 @@ mod tests {
             let dt = Duration::from_millis(200);
             time += dt;
             let state = manual_tick_component(
-                TweenId::null(), // unused in this test
+                Entity::PLACEHOLDER, // unused in this test
                 dt,
                 &mut delay,
                 &mut world,
@@ -2409,7 +2406,7 @@ mod tests {
         assert_eq!(0, delay.cycles_completed());
         assert_eq!(Duration::ZERO, delay.elapsed());
         let state: TweenState = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             Duration::ZERO,
             &mut delay,
             &mut world,
@@ -2475,7 +2472,7 @@ mod tests {
         let dt = Duration::from_millis(100);
         time += dt;
         let state = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             dt,
             &mut tween,
             &mut world,
@@ -2491,7 +2488,7 @@ mod tests {
         let dt = Duration::from_millis(1200);
         time += dt;
         let state = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             dt,
             &mut tween,
             &mut world,
@@ -2507,7 +2504,7 @@ mod tests {
         let dt = Duration::from_millis(3500);
         time += dt;
         let state = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             dt,
             &mut tween,
             &mut world,
@@ -2523,7 +2520,7 @@ mod tests {
         let dt = Duration::from_millis(200);
         time += dt;
         let state = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             dt,
             &mut tween,
             &mut world,
@@ -2549,7 +2546,7 @@ mod tests {
         // 10%
         let dt = Duration::from_millis(100);
         let state = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             dt,
             &mut tween,
             &mut world,
@@ -2573,7 +2570,7 @@ mod tests {
         // 120% - mirror
         let dt = Duration::from_millis(1200);
         let state = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             dt,
             &mut tween,
             &mut world,
@@ -2598,7 +2595,7 @@ mod tests {
         // 400% - done mirror (because Completed freezes the state)
         let dt = Duration::from_millis(4000);
         let state = manual_tick_component(
-            TweenId::null(), // unused in this test
+            Entity::PLACEHOLDER, // unused in this test
             dt,
             &mut tween,
             &mut world,

From 113794ed919213e11d55f35957cc263529cb6e10 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 19 Jul 2025 16:02:08 +0200
Subject: [PATCH 44/66] Remove one-shot suppoer in favor of observers

---
 src/lib.rs        | 1960 ++++++++++++++++++++++++++-------------------
 src/plugin.rs     |  130 ++-
 src/test_utils.rs |   39 +-
 src/tweenable.rs  |  125 +--
 4 files changed, 1259 insertions(+), 995 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 52b077f..8c15dc8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -272,7 +272,6 @@ use bevy::{
     ecs::{
         change_detection::MutUntyped,
         component::{ComponentId, Components, Mutable},
-        system::SystemId,
     },
     platform::collections::HashMap,
     prelude::*,
@@ -805,6 +804,19 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
     }
 }
 
+///
+pub trait EntityWorldMutTargetExtensions<'a> {
+    ///
+    fn anim_target<C: Component<Mutability = Mutable>>(self) -> ComponentAnimTarget;
+}
+
+impl<'a> EntityWorldMutTargetExtensions<'a> for EntityWorldMut<'a> {
+    #[inline]
+    fn anim_target<C: Component<Mutability = Mutable>>(self) -> ComponentAnimTarget {
+        ComponentAnimTarget::new::<C>(self.world().components(), self.id()).unwrap()
+    }
+}
+
 impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
     where
@@ -829,7 +841,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let start=  self.get::<Transform>().unwrap().translation;
+        let start = self.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -842,7 +854,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let end=  self.get::<Transform>().unwrap().translation;
+        let end = self.get::<Transform>().unwrap().translation;
         let lens = lens::TransformPositionLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -855,7 +867,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let start=  self.get::<Transform>().unwrap().scale;
+        let start = self.get::<Transform>().unwrap().scale;
         let lens = lens::TransformScaleLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -868,7 +880,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> &mut Self {
-        let end=  self.get::<Transform>().unwrap().scale;
+        let end = self.get::<Transform>().unwrap().scale;
         let lens = lens::TransformScaleLens { start, end };
         let tween = Tween::new(ease_method, duration, lens);
         self.tween(tween)
@@ -899,12 +911,24 @@ pub struct AnimCompletedEvent {
 /// Errors returned by various animation functions.
 #[derive(Debug, Error, Clone, Copy)]
 pub enum TweeningError {
+    /// The asset resolver for the given asset is not registered.
+    #[error("Asset resolver for asset with resource ID {0:?} is not registered.")]
+    AssetResolverNotRegistered(ComponentId),
+    /// The entity was not found in the World.
+    #[error("Entity {0:?} not found in the World.")]
+    EntityNotFound(Entity),
+    /// The entity should have had a TweenAnim but it was not found.
+    #[error("Entity {0:?} doesn't have a TweenAnim.")]
+    MissingTweenAnim(Entity),
     /// The component of the given type is not registered.
     #[error("Component of type {0:?} is not registered in the World.")]
     ComponentNotRegistered(TypeId),
     /// The asset container for the given asset type is not registered.
     #[error("Asset container Assets<A> for asset type A = {0:?} is not registered in the World.")]
     AssetNotRegistered(TypeId),
+    /// The asset cannot be found.
+    #[error("Asset ID {0:?} is invalid.")]
+    InvalidAssetId(UntypedAssetId),
     /// The asset ID references a different type than expected.
     #[error("Expected type of asset ID to be {expected:?} but got {actual:?} instead.")]
     InvalidAssetIdType {
@@ -1346,6 +1370,111 @@ impl TweenAnim {
         }
     }
 
+    pub(crate) fn step(
+        &mut self,
+        mut commands: Commands,
+        tween_id: Entity,
+        delta_time: Duration,
+        mut mut_untyped: MutUntyped,
+        mut events: Mut<Events<CycleCompletedEvent>>,
+        mut anim_events: Mut<Events<AnimCompletedEvent>>,
+    ) -> Result<StepResult, TweeningError> {
+        let mut completed_events = Vec::with_capacity(8);
+        let mut sent_commands = false;
+
+        // Sanity checks on fields which can be freely modified by the user
+        self.speed = self.speed.max(0.);
+
+        // Retain completed animations only if requested
+        if self.tween_state == TweenState::Completed {
+            let ret = StepResult {
+                retain: !self.destroy_on_completion,
+                sent_commands: false,
+            };
+            return Ok(ret);
+        }
+
+        // Skip paused animations (but retain them)
+        if self.playback_state == PlaybackState::Paused || self.speed <= 0. {
+            let ret = StepResult {
+                retain: true,
+                sent_commands: false,
+            };
+            return Ok(ret);
+        }
+
+        // Scale delta time by this animation's speed. Reject negative speeds; use
+        // backward playback to play in reverse direction.
+        // Note: must use f64 for precision; f32 produces visible roundings.
+        let delta_time = delta_time.mul_f64(self.speed);
+
+        // Step the tweenable animation
+        let entity = self.target.as_component().map(|comp| comp.entity);
+        let mut notify_completed = || {
+            completed_events.push((
+                CycleCompletedEvent {
+                    id: tween_id,
+                    target: self.target,
+                },
+                entity,
+            ));
+        };
+        let state = self.tweenable.step(
+            tween_id,
+            delta_time,
+            mut_untyped.reborrow(),
+            &mut notify_completed,
+        );
+        self.tween_state = state;
+
+        // Send tween completed events once we reclaimed mut access to world and can get
+        // a Commands.
+        if !completed_events.is_empty() {
+            sent_commands = true;
+
+            for (event, entity) in completed_events.drain(..) {
+                // Send buffered event
+                events.send(event);
+
+                // Trigger all entity-scoped observers
+                if let Some(entity) = entity {
+                    commands.trigger_targets(event, entity);
+                }
+            }
+        }
+
+        // // Execute one-shot systems
+        // for sys_id in queued_systems.drain(..) {
+        //     let _ = world.run_system(sys_id);
+        // }
+
+        // Raise animation completed event
+        if state == TweenState::Completed {
+            let event = AnimCompletedEvent {
+                id: tween_id,
+                target: self.target,
+            };
+
+            // Send buffered event
+            anim_events.send(event);
+
+            // Trigger all global observers
+            commands.trigger(event);
+
+            // Trigger all entity-scoped observers
+            if let Some(entity) = entity {
+                sent_commands = true;
+                commands.trigger_targets(event, entity);
+            }
+        }
+
+        let ret = StepResult {
+            retain: state == TweenState::Active || !self.destroy_on_completion,
+            sent_commands,
+        };
+        Ok(ret)
+    }
+
     /// Stop animation playback and rewind the animation.
     ///
     /// This changes the animator state to [`PlaybackState::Paused`] and rewinds
@@ -1378,467 +1507,6 @@ impl TweenAnim {
         self.tweenable.as_ref()
     }
 
-    /// Get the tweening completion state.
-    ///
-    /// In general this is [`TweenState::Active`], unless the animation
-    /// completed and [`destroy_on_completion`] is `false`.
-    ///
-    /// [`destroy_on_completion`]: Self::destroy_on_completion
-    #[inline]
-    pub fn tween_state(&self) -> TweenState {
-        self.tween_state
-    }
-}
-
-type Resolver = Box<
-    dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
-        + Send
-        + Sync
-        + 'static,
->;
-
-//pub struct ResolverId(pub u32);
-
-///
-#[derive(Default, Resource)]
-pub struct TweenResolver {
-    /// Asset resolver allowing to convert a pair of { untyped pointer to
-    /// `Assets<A>`, untyped `AssetId` } into an untyped pointer to the asset A
-    /// itself. This is necessary because there's no UntypedAssets interface in
-    /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
-    /// The resolver is allowed to fail (return `None`), for example when the
-    /// asset ID doesn't reference a valid asset.
-    asset_resolver: HashMap<ComponentId, Resolver>,
-}
-
-impl TweenResolver {
-    ///
-    pub fn resolve_asset(
-        &self,
-        component_id: ComponentId,
-    ) -> Option<&(dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>> + Send + Sync + 'static)> {
-        self.asset_resolver
-            .get(&component_id)
-            .map(|resolver| resolver.as_ref())
-    }
-}
-
-struct StepResult {
-    pub retain: bool,
-    pub sent_commands: bool,
-}
-
-/// Animator for tween-based animations.
-///
-/// This resource stores all the active tweening animations for the entire
-/// application. It's essentially a hash map from a [`Entity`] uniquely
-/// identifying an active animation, to the [`TweenAnim`] runtime data of that
-/// animation. Use this resource to lookup animations by ID and modify their
-/// runtime data, for example their playback speed.
-///
-/// # Active animations
-///
-/// Animations queued into the [`TweenAnimator`] by default are pruned
-/// automatically on completion, and only active animations are retained. If you
-/// want the animator to retain completed animation instances, so you can
-/// continue to access them, you can set [`TweenAnim::destroy_on_completion`] to
-/// `false` to prevent this automated destruction. Note however that doing so
-/// will retain the animation instance forever, until set to `true` again. So
-/// you should avoid retaining all animations forever to prevent wasting memory
-/// and degrading performances. In general, the default pruning behavior is best
-/// suited for one-shot animations re-created each time they're needed.
-/// Conversely, disabling auto-destruction on completion is best suited to
-/// reusing the same animation instance again and again.
-///
-/// # Lookup without `Entity`
-///
-/// If you don't know the [`Entity`] of an animation, you can also lookup the
-/// set of animations for a given target, either component on an entity or an
-/// asset.
-///
-/// ```
-/// # use bevy::{prelude::*, ecs::component::Components};
-/// # use bevy_tweening::*;
-/// fn my_system(components: &Components, animator: Res<TweenAnimator>) -> Result<()> {
-/// # let entity = Entity::PLACEHOLDER;
-///     // Create an AnimTarget::Component() from an Entity and a component type
-///     // let entity = ...
-///     let target = ComponentAnimTarget::new::<Transform>(components, entity)?;
-///     let target: AnimTarget = target.into();
-///
-///     // Lookup all active animations and filter by target
-///     let animations: Vec<&TweenAnim> = animator
-///         .iter()
-///         .filter_map(|(_id, anim)| {
-///             if *anim.target() == target {
-///                 Some(anim)
-///             } else {
-///                 None
-///             }
-///         })
-///         .collect::<_>();
-///
-///     Ok(())
-/// }
-/// ```
-
-
-impl TweenAnimator {
-    /// Add a new component animation to the animator queue.
-    ///
-    /// In general you don't need to call this directly. Instead, use the
-    /// extensions provided by [`EntityWorldMutTweeningExtensions`] to directly
-    /// create and queue tweenable animations on a given [`EntityCommands`],
-    /// like this:
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use std::time::Duration;
-    /// # let mut world = World::default();
-    /// # world.register_component::<Transform>();
-    /// # world.register_resource::<TweenAnimator>();
-    /// # world.init_resource::<TweenAnimator>();
-    /// # let entity = world.spawn_empty().id();
-    /// let tween = Tween::new(
-    ///     EaseFunction::QuadraticInOut,
-    ///     Duration::from_secs(1),
-    ///     TransformPositionLens {
-    ///         start: Vec3::ZERO,
-    ///         end: Vec3::new(3.5, 0., 0.),
-    ///     },
-    /// );
-    /// world.entity_mut(entity).tween(tween);
-    /// ```
-    ///
-    /// This function is still useful if you want to store the [`Entity`] of
-    /// the new animation, to later access it to dynamically modify the playback
-    /// (e.g. speed).
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use std::time::Duration;
-    /// # fn make_tween() -> Tween { unimplemented!() }
-    /// // Helper component to store a Entity
-    /// #[derive(Component)]
-    /// struct MyTweenId(pub Entity);
-    ///
-    /// // System which spawns the component and its animation
-    /// fn my_spawn_system(
-    ///     mut commands: Commands,
-    ///     components: &Components,
-    ///     mut animator: ResMut<TweenAnimator>,
-    /// ) -> Result<()> {
-    ///     # let tween = make_tween();
-    ///     let entity = commands.spawn(Transform::default()).id();
-    ///     // The component type is deducted from `tween` here
-    ///     let tween_id = animator.add_component(components, entity, tween)?;
-    ///     // Save the new Entity for later use
-    ///     commands.entity(entity).insert(MyTweenId(tween_id));
-    ///     Ok(())
-    /// }
-    ///
-    /// // System which modifies the animation playback
-    /// fn my_use_system(mut animator: ResMut<TweenAnimator>, query: Query<&MyTweenId>) -> Option<()> {
-    ///     let tween_id = query.single().ok()?.0;
-    ///     animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
-    ///     Some(())
-    /// }
-    /// ```
-    ///
-    /// Note in the above that at the time when the animation is queued into the
-    /// animator, the component doesn't yet exist in the world, because the
-    /// spawning is deffered via [`Commands`]. This is not an error; the
-    /// [`TweenAnimator`] doesn't perform any check when this function is
-    /// called, on purpose to allow patterns like inserting the returned
-    /// [`Entity`] into a component or resource from within the same system
-    /// which spawned the target, without having to apply deferred commands
-    /// first. When the animation steps however, the target is validated, and if
-    /// invalid (either because the entity doesn't exist or it doesn't have the
-    /// target component) then the animation instance is destroyed.
-    #[inline]
-    pub fn add_component<T>(
-        &mut self,
-        components: &Components,
-        entity: Entity,
-        tweenable: T,
-    ) -> Result<Entity, TweeningError>
-    where
-        T: Tweenable + 'static,
-    {
-        let Some(type_id) = tweenable.type_id() else {
-            return Err(TweeningError::UntypedTweenable);
-        };
-        let target = ComponentAnimTarget::new_untyped(components, type_id, entity)?.into();
-        Ok(self.add_component_target(target, tweenable))
-    }
-
-    /// Add a new component animation via an existing [`ComponentAnimTarget`].
-    ///
-    /// See [`add_component()`] for details. This variant is useful when you can
-    /// build in advance a [`ComponentAnimTarget`], but at the same time don't
-    /// readily have access to the [`Components`] of the world.
-    ///
-    /// Note that there's no equivalent for assets, because asset animations
-    /// need to register some internal type-dependent resolver due to assets
-    /// being only accessible through the typed [`Assets<A>`] API.
-    ///
-    /// [`add_component()`]: Self::add_component
-    #[inline]
-    pub fn add_component_target<T>(&mut self, target: ComponentAnimTarget, tweenable: T) -> Entity
-    where
-        T: Tweenable + 'static,
-    {
-        self.anims
-            .insert(TweenAnim::new(target.into(), Box::new(tweenable)))
-    }
-
-    /// Add a new asset animation to the animator queue.
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use std::time::Duration;
-    /// # fn make_tween() -> Tween { unimplemented!() }
-    /// #[derive(Asset, TypePath)]
-    /// struct MyAsset;
-    ///
-    /// // Helper component to store a Entity
-    /// #[derive(Resource)]
-    /// struct MyTweenId(pub Entity);
-    ///
-    /// // System which spawns the asset animation
-    /// fn my_spawn_system(
-    ///     mut assets: ResMut<Assets<MyAsset>>,
-    ///     components: &Components,
-    ///     mut animator: ResMut<TweenAnimator>,
-    ///     mut my_tween_id: ResMut<MyTweenId>,
-    /// ) -> Result<()> {
-    ///     # let tween = make_tween();
-    ///     let handle = assets.add(MyAsset);
-    ///     // The asset type is deducted from `tween` here
-    ///     let tween_id = animator.add_asset(components, handle.id(), tween)?;
-    ///     // Save the new Entity for later use
-    ///     my_tween_id.0 = tween_id;
-    ///     Ok(())
-    /// }
-    ///
-    /// // System which modifies the animation playback
-    /// fn my_use_system(
-    ///     mut animator: ResMut<TweenAnimator>,
-    ///     my_tween_id: Res<MyTweenId>,
-    /// ) -> Option<()> {
-    ///     let tween_id = my_tween_id.0;
-    ///     animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
-    ///     Some(())
-    /// }
-    /// ```
-    ///
-    /// Note that unlike [`add_component()`], this function depends on the asset
-    /// type. This is required to allow registering some internal resolver to
-    /// extract the typed animation from its typed `Assets<A>`, as this can't be
-    /// done via untyped references (unlike for components).
-    ///
-    /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
-    /// [`add_component()`]: Self::add_component
-    #[inline]
-    pub fn add_asset<T, A: Asset>(
-        &mut self,
-        components: &Components,
-        asset_id: impl Into<AssetId<A>>,
-        tweenable: T,
-    ) -> Result<Entity, TweeningError>
-    where
-        T: Tweenable + 'static,
-    {
-        let Some(type_id) = tweenable.type_id() else {
-            return Err(TweeningError::UntypedTweenable);
-        };
-        if type_id != TypeId::of::<A>() {
-            return Err(TweeningError::InvalidAssetIdType {
-                expected: TypeId::of::<A>(),
-                actual: type_id,
-            });
-        }
-        let asset_id = asset_id.into();
-        let target = AssetAnimTarget::new(components, asset_id)?;
-        self.asset_resolver.insert(
-            target.resource_id,
-            Box::new(
-                |assets: MutUntyped, asset_id: UntypedAssetId| -> Option<MutUntyped> {
-                    // SAFETY: The correct type is captured from the outer function
-                    #[allow(unsafe_code)]
-                    let assets = unsafe { assets.with_type::<Assets<A>>() };
-                    let asset_id = asset_id.try_typed::<A>().ok()?;
-                    assets
-                        .filter_map_unchanged(|assets| assets.get_mut(asset_id))
-                        .map(Into::into)
-                },
-            ),
-        );
-        Ok(self
-            .anims
-            .insert(TweenAnim::new(target.into(), Box::new(tweenable))))
-    }
-
-    /// Check if the animation with the given ID is queued.
-    ///
-    /// If this returns `false` then any animation which might have existed with
-    /// this ID was destroyed, and this ID will forever be invalid and
-    /// unused.
-    ///
-    /// # Returns
-    ///
-    /// Returns `true` if the animation is queued, either because it's playing,
-    /// or because it's completed but [`TweenAnim::destroy_on_completion`] was
-    /// set to `false`. In that case the [`TweenAnim`] can be accessed by the
-    /// likes of [`get()`].
-    ///
-    /// [`get()`]: Self::get
-    #[inline]
-    pub fn contains(&self, id: Entity) -> bool {
-        self.anims.contains_key(id)
-    }
-
-    /// Get a queued tweenable animation from its ID.
-    ///
-    /// This fails and returns `None` if the animation has completed and was
-    /// removed from the animator's internal queue, or if the ID is invalid
-    /// (notably, `Entity::PLACEHOLDER`).
-    #[inline]
-    pub fn get(&self, id: Entity) -> Option<&TweenAnim> {
-        self.anims.get(id)
-    }
-
-    /// Get a queued tweenable animation from its ID.
-    ///
-    /// This fails and returns `None` if the animation has completed and was
-    /// removed from the animator's internal queue, or if the ID is invalid
-    /// (notably, `Entity::PLACEHOLDER`).
-    #[inline]
-    pub fn get_mut(&mut self, id: Entity) -> Option<&mut TweenAnim> {
-        self.anims.get_mut(id)
-    }
-
-    /// Get a queued tweenable animation from its ID.
-    ///
-    /// This fails and returns [`TweeningError::InvalidTweenId`] if the
-    /// animation has completed and was removed from the animator's internal
-    /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
-    #[inline]
-    pub fn try_get(&self, id: Entity) -> Result<&TweenAnim, TweeningError> {
-        self.anims.get(id).ok_or(TweeningError::InvalidTweenId(id))
-    }
-
-    /// Get a queued tweenable animation from its ID.
-    ///
-    /// This fails and returns [`TweeningError::InvalidTweenId`] if the
-    /// animation has completed and was removed from the animator's internal
-    /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
-    #[inline]
-    pub fn try_get_mut(&mut self, id: Entity) -> Result<&mut TweenAnim, TweeningError> {
-        self.anims
-            .get_mut(id)
-            .ok_or(TweeningError::InvalidTweenId(id))
-    }
-
-    /// Get an iterator over the queued tweenable animations.
-    ///
-    /// # Returns
-    ///
-    /// An iterator over pairs of (ID, animation) for all animations still in
-    /// the internal queue.
-    #[inline]
-    pub fn iter(&self) -> impl Iterator<Item = (Entity, &TweenAnim)> {
-        self.anims.iter()
-    }
-
-    /// Get a mutable iterator over the queued tweenable animations.
-    ///
-    /// # Returns
-    ///
-    /// An iterator over pairs of (ID, animation) for all animations still in
-    /// the internal queue.
-    #[inline]
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (Entity, &mut TweenAnim)> {
-        self.anims.iter_mut()
-    }
-
-    /// Remove a queued tweenable animation and return it.
-    ///
-    /// This immediately removes the animation, if it exists, without modifying
-    /// further its target. After the animation is removed, the `id` is
-    /// invalid and will never be reused. The animation cannot be re-queued;
-    /// instead, a new animation sould be created with [`add_component()`] or
-    /// [`add_asset()`], which will generate a different ID.
-    ///
-    /// # Returns
-    ///
-    /// If the ID was valid and an animation with this ID was removed, returns
-    /// that animation. Otherwise returns `None`.
-    ///
-    /// [`add_component()`]: Self::add_component
-    /// [`add_asset()`]: Self::add_asset
-    #[inline]
-    pub fn remove(&mut self, id: Entity) -> Option<TweenAnim> {
-        self.anims.remove(id)
-    }
-
-    /// Retarget a queued animation.
-    ///
-    /// Attempt to change the target of a tweening animation already enqueued,
-    /// and possibly already playing. This function performs a number of checks
-    /// on the new target to ensure it's compatible with the previous
-    /// target. In particular, the new target needs to have:
-    /// - the same kind (component or asset);
-    /// - the same type.
-    ///
-    /// # Returns
-    ///
-    /// On success, returns the previous target which has been replaced.
-    ///
-    /// [`add_component()`]: Self::add_component
-    /// [`add_asset()`]: Self::add_asset
-    /// [`set_target()`]: Self::set_target
-    pub fn set_target(
-        &mut self,
-        id: Entity,
-        target: AnimTarget,
-    ) -> Result<AnimTarget, TweeningError> {
-        let anim = self
-            .anims
-            .get_mut(id)
-            .ok_or(TweeningError::InvalidTweenId(id))?;
-        match (anim.target, target) {
-            (AnimTarget::Component(old_component), AnimTarget::Component(new_component)) => {
-                if old_component.component_id != new_component.component_id {
-                    return Err(TweeningError::MismatchingComponentId(
-                        old_component.component_id,
-                        new_component.component_id,
-                    ));
-                }
-            }
-            (AnimTarget::Asset(old_asset), AnimTarget::Asset(new_asset)) => {
-                if old_asset.resource_id != new_asset.resource_id {
-                    return Err(TweeningError::MismatchingAssetResourceId(
-                        old_asset.resource_id,
-                        new_asset.resource_id,
-                    ));
-                }
-            }
-            _ => {
-                return Err(TweeningError::MismatchingTargetKind(
-                    anim.target.is_component(),
-                    target.is_component(),
-                ))
-            }
-        }
-        let old_target = anim.target;
-        anim.target = target;
-        Ok(old_target)
-    }
-
     /// Swap a queued animation.
     ///
     /// Attempt to change the tweenable of an animation already enqueued, and
@@ -1847,13 +1515,13 @@ impl TweenAnimator {
     /// If the tweenable is successfully swapped, this resets the
     /// [`TweenAnim::tween_state()`] to [`TweenState::Active`], even if the
     /// tweenable would otherwise be completed _e.g._ because its elapsed time
-    /// is past its total duration. Conversely, this doesn't update the target,
-    /// as this function doesn't have mutable access to it.
+    /// is past its total duration. Conversely, this doesn't update the
+    /// target, as this function doesn't have mutable access to it.
     ///
     /// To ensure the old and new animations have the same elapsed time (for
     /// example if they need to be synchronized), call [`set_elapsed()`] first
-    ///   on the input `tweenable`, with the duration value of the old
-    ///   tweenable as returned by [`elapsed()`].
+    /// on the input `tweenable`, with the duration value of the old tweenable
+    /// as returned by [`elapsed()`].
     ///
     /// ```
     /// # use std::time::Duration;
@@ -1879,267 +1547,870 @@ impl TweenAnimator {
     /// [`set_elapsed()`]: crate::Tweenable::set_elapsed
     /// [`elapsed()`]: crate::Tweenable::elapsed
     /// [`step_one()`]: Self::step_one
-    pub fn set_tweenable<T>(
-        &mut self,
-        id: Entity,
-        tweenable: T,
-    ) -> Result<BoxedTweenable, TweeningError>
+    pub fn set_tweenable<T>(&mut self, tweenable: T) -> Result<BoxedTweenable, TweeningError>
     where
         T: Tweenable + 'static,
     {
-        let anim = self
-            .anims
-            .get_mut(id)
-            .ok_or(TweeningError::InvalidTweenId(id))?;
         let mut old_tweenable: BoxedTweenable = Box::new(tweenable);
-        std::mem::swap(&mut anim.tweenable, &mut old_tweenable);
+        std::mem::swap(&mut self.tweenable, &mut old_tweenable);
         // Reset tweening state, the new tweenable is at t=0
-        anim.tween_state = TweenState::Active;
+        self.tween_state = TweenState::Active;
         Ok(old_tweenable)
     }
 
-    /// Step the given queued animation.
-    ///
-    /// In general all animations are stepped automatically via [`step_all()`],
-    /// which is called from a system added by the [`TweeningPlugin`]. This
-    /// function can be used to step a single animation, either in addition or
-    /// in place of that system or any call to [`step_all()`]. If the `id` is
-    /// invalid, this function does nothing.
-    ///
-    /// One useful use of this function is to force a mutation on the target,
-    /// for example because some specific animation change was made which
-    /// couldn't directly mutate it. By passing [`Duration::ZERO`], this
-    /// function effectively forces the target state to the current animation
-    /// "position" without playing back the animation itself (the elapsed time
-    /// is not modified).
-    ///
-    /// # Returns
+    /// Get the tweening completion state.
     ///
-    /// If the animation completed and was destroyed, returns a copy of that
-    /// animation. Otherwise if the animation is still queued, returns `None`.
+    /// In general this is [`TweenState::Active`], unless the animation
+    /// completed and [`destroy_on_completion`] is `false`.
     ///
-    /// [`step_all()`]: Self::step_all
+    /// [`destroy_on_completion`]: Self::destroy_on_completion
     #[inline]
-    pub fn step_one(
-        &mut self,
-        world: &mut World,
-        id: Entity,
-        delta_time: Duration,
-    ) -> Option<TweenAnim> {
-        world.resource_scope(|world, events: Mut<Events<CycleCompletedEvent>>| {
-            world.resource_scope(|world, anim_events: Mut<Events<AnimCompletedEvent>>| {
-                let anim = self.anims.get_mut(id)?;
-
-                let ret = Self::step_impl(
-                    id,
-                    anim,
-                    &self.asset_resolver,
-                    world,
-                    delta_time,
-                    events,
-                    anim_events,
-                );
-
-                if let Ok(ret) = ret {
-                    if ret.sent_commands {
-                        world.flush();
-                    }
-
-                    if !ret.retain {
-                        return Some(self.anims.remove(id).unwrap());
-                    }
-                }
-                None
-            })
-        })
+    pub fn tween_state(&self) -> TweenState {
+        self.tween_state
     }
+}
 
-    fn step_impl(
-        tween_id: Entity,
-        anim: &mut TweenAnim,
-        asset_resolver: &HashMap<ComponentId, Resolver>,
-        world: &mut World,
-        delta_time: Duration,
-        mut events: Mut<Events<CycleCompletedEvent>>,
-        mut anim_events: Mut<Events<AnimCompletedEvent>>,
-    ) -> Result<StepResult, TweeningError> {
-        let mut queued_systems = Vec::with_capacity(8);
-        let mut completed_events = Vec::with_capacity(8);
-        let mut sent_commands = false;
+type Resolver = Box<
+    dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
+        + Send
+        + Sync
+        + 'static,
+>;
 
-        // Sanity checks on fields which can be freely modified by the user
-        anim.speed = anim.speed.max(0.);
+type ScopedResolver = Box<
+    dyn for<'w> Fn(
+            &mut World,
+            UntypedAssetId,
+            Entity,
+            Duration,
+            Mut<Events<CycleCompletedEvent>>,
+            Mut<Events<AnimCompletedEvent>>,
+        ) -> Result<StepResult, TweeningError>
+        + Send
+        + Sync
+        + 'static,
+>;
 
-        // Retain completed animations only if requested
-        if anim.tween_state == TweenState::Completed {
-            let ret = StepResult {
-                retain: !anim.destroy_on_completion,
-                sent_commands: false,
-            };
-            return Ok(ret);
-        }
+///
+#[derive(Default, Resource)]
+pub struct TweenResolver {
+    /// Asset resolver allowing to convert a pair of { untyped pointer to
+    /// `Assets<A>`, untyped `AssetId` } into an untyped pointer to the asset A
+    /// itself. This is necessary because there's no UntypedAssets interface in
+    /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
+    /// The resolver is allowed to fail (return `None`), for example when the
+    /// asset ID doesn't reference a valid asset.
+    asset_resolver: HashMap<ComponentId, Resolver>,
+    scoped_resolver: HashMap<ComponentId, ScopedResolver>,
+}
 
-        // Skip paused animations (but retain them)
-        if anim.playback_state == PlaybackState::Paused || anim.speed <= 0. {
-            let ret = StepResult {
-                retain: true,
-                sent_commands: false,
-            };
-            return Ok(ret);
-        }
+impl TweenResolver {
+    ///
+    pub fn resolve_asset(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<
+        &(dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
+              + Send
+              + Sync
+              + 'static),
+    > {
+        self.asset_resolver
+            .get(&component_id)
+            .map(|resolver| resolver.as_ref())
+    }
 
-        // Resolve the (untyped) target as a MutUntyped<T>
-        let Some(mut mut_untyped) = (match &anim.target {
-            AnimTarget::Component(ComponentAnimTarget {
-                entity,
-                component_id,
-            }) => world.get_mut_by_id(*entity, *component_id),
-            AnimTarget::Asset(AssetAnimTarget {
-                resource_id,
-                asset_id,
-            }) => {
-                if let Some(assets) = world.get_resource_mut_by_id(*resource_id) {
-                    if let Some(resolver) = asset_resolver.get(resource_id) {
-                        resolver(assets, *asset_id)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            }
-        }) else {
-            let ret = StepResult {
-                retain: false,
-                sent_commands: false,
-            };
-            return Ok(ret);
+    ///
+    pub fn register_scoped_for<A: Asset>(&mut self, components: &Components) {
+        let resource_id = components.resource_id::<Assets<A>>().unwrap();
+        let resolver = |world: &mut World,
+                        asset_id: UntypedAssetId,
+                        entity: Entity,
+                        delta_time: Duration,
+                        mut cycle_events: Mut<Events<CycleCompletedEvent>>,
+                        mut anim_events: Mut<Events<AnimCompletedEvent>>|
+         -> Result<StepResult, TweeningError> {
+            let asset_id = asset_id.typed::<A>();
+            // First, remove the Assets<A> from the world so we can access it mutably in
+            // parallel of the TweenAnim
+            world.resource_scope(|world, assets: Mut<Assets<A>>| {
+                // Next, fetch the asset A itself from its Assets<A> based on its asset ID
+                let Some(asset) = assets.filter_map_unchanged(|assets| assets.get_mut(asset_id))
+                else {
+                    return Err(TweeningError::InvalidAssetId(asset_id.into()));
+                };
+
+                let (mut entities, commands) = world.entities_and_commands();
+
+                // Resolve the TweenAnim component
+                let Ok([mut ent]) = entities.get_mut([entity]) else {
+                    return Err(TweeningError::EntityNotFound(entity));
+                };
+                let Some(mut anim) = ent.get_mut::<TweenAnim>() else {
+                    return Err(TweeningError::MissingTweenAnim(ent.id()));
+                };
+
+                // Finally, step the TweenAnim and mutate the target
+                anim.step(
+                    commands,
+                    entity,
+                    delta_time,
+                    asset.into(),
+                    cycle_events.reborrow(),
+                    anim_events.reborrow(),
+                )
+            })
         };
+        self.scoped_resolver
+            .entry(resource_id)
+            .or_insert(Box::new(resolver));
+    }
 
-        // Scale delta time by this animation's speed. Reject negative speeds; use
-        // backward playback to play in reverse direction.
-        // Note: must use f64 for precision; f32 produces visible roundings.
-        let delta_time = delta_time.mul_f64(anim.speed);
-
-        // Step the tweenable animation
-        let entity = anim.target.as_component().map(|comp| comp.entity);
-        let mut notify_completed = || {
-            completed_events.push((
-                CycleCompletedEvent {
-                    id: tween_id,
-                    target: anim.target,
-                },
-                entity,
+    #[inline]
+    pub(crate) fn resolve_scope(
+        &self,
+        world: &mut World,
+        target: &AssetAnimTarget,
+        entity: Entity,
+        delta_time: Duration,
+        cycle_events: Mut<Events<CycleCompletedEvent>>,
+        anim_events: Mut<Events<AnimCompletedEvent>>,
+    ) -> Result<StepResult, TweeningError> {
+        let Some(resolver) = self.scoped_resolver.get(&target.resource_id) else {
+            return Err(TweeningError::AssetResolverNotRegistered(
+                target.resource_id,
             ));
         };
-        let mut queue_system = |system_id: SystemId| {
-            queued_systems.push(system_id);
-        };
-        let state = anim.tweenable.step(
-            tween_id,
+        resolver(
+            world,
+            target.asset_id,
+            entity,
             delta_time,
-            mut_untyped.reborrow(),
-            &mut notify_completed,
-            &mut queue_system,
-        );
-        anim.tween_state = state;
-
-        // Send tween completed events once we reclaimed mut access to world and can get
-        // a Commands.
-        if !completed_events.is_empty() {
-            let mut commands = world.commands();
-            sent_commands = true;
-
-            for (event, entity) in completed_events.drain(..) {
-                // Send buffered event
-                events.send(event);
-
-                // Trigger all entity-scoped observers
-                if let Some(entity) = entity {
-                    commands.trigger_targets(event, entity);
-                }
-            }
-        }
-
-        // Execute one-shot systems
-        for sys_id in queued_systems.drain(..) {
-            let _ = world.run_system(sys_id);
-        }
-
-        // Raise animation completed event
-        if state == TweenState::Completed {
-            let event = AnimCompletedEvent {
-                id: tween_id,
-                target: anim.target,
-            };
-
-            // Send buffered event
-            anim_events.send(event);
-
-            // Trigger all entity-scoped observers
-            if let Some(entity) = entity {
-                let mut commands = world.commands();
-                sent_commands = true;
-                commands.trigger_targets(event, entity);
-            }
-        }
-
-        let ret = StepResult {
-            retain: state == TweenState::Active || !anim.destroy_on_completion,
-            sent_commands,
-        };
-        Ok(ret)
+            cycle_events,
+            anim_events,
+        )
     }
+}
 
-    /// Step all queued animations.
-    ///
-    /// Loop over the internal queue of tweenable animations, apply them to
-    /// their respective target, and prune all the completed ones (the ones
-    /// returning [`TweenState::Completed`]). In the later case, send
-    /// [`AnimCompletedEvent`]s.
-    ///
-    /// If you use the [`TweeningPlugin`], this is automatically called by the
-    /// animation system the plugin registers. See the
-    /// [`AnimationSystem::AnimationUpdate`] system set.
-    ///
-    /// Note that the order in which the animations are iterated over and
-    /// played, and therefore also the order in which any event is raised or any
-    /// one-shot system is executed, is an unspecified implementation detail.
-    /// There is no guarantee on that order nor its stability frame to
-    /// frame.
-    pub fn step_all(&mut self, world: &mut World, delta_time: Duration) {
-        world.resource_scope(|world, mut events: Mut<Events<CycleCompletedEvent>>| {
-            world.resource_scope(|world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
-                let mut sent_commands = false;
-
-                // Loop over active animations, tick them, and retain those which are still
-                // active after that
-                self.anims.retain(|tween_id, anim| {
-                    let ret = Self::step_impl(
-                        tween_id,
-                        anim,
-                        &self.asset_resolver,
-                        world,
-                        delta_time,
-                        events.reborrow(),
-                        anim_events.reborrow(),
-                    );
-                    if let Ok(ret) = ret {
-                        sent_commands = sent_commands || ret.sent_commands;
-                        return ret.retain;
-                    }
-                    false
-                });
-
-                // Flush commands
-                if sent_commands {
-                    world.flush();
-                }
-            });
-        });
-    }
+pub(crate) struct StepResult {
+    pub retain: bool,
+    #[allow(unused)]
+    pub sent_commands: bool,
 }
 
+// /// Animator for tween-based animations.
+// ///
+// /// This resource stores all the active tweening animations for the entire
+// /// application. It's essentially a hash map from a [`Entity`] uniquely
+// /// identifying an active animation, to the [`TweenAnim`] runtime data of
+// that /// animation. Use this resource to lookup animations by ID and modify
+// their /// runtime data, for example their playback speed.
+// ///
+// /// # Active animations
+// ///
+// /// Animations queued into the [`TweenAnimator`] by default are pruned
+// /// automatically on completion, and only active animations are retained. If
+// you /// want the animator to retain completed animation instances, so you can
+// /// continue to access them, you can set [`TweenAnim::destroy_on_completion`]
+// to /// `false` to prevent this automated destruction. Note however that doing
+// so /// will retain the animation instance forever, until set to `true` again.
+// So /// you should avoid retaining all animations forever to prevent wasting
+// memory /// and degrading performances. In general, the default pruning
+// behavior is best /// suited for one-shot animations re-created each time
+// they're needed. /// Conversely, disabling auto-destruction on completion is
+// best suited to /// reusing the same animation instance again and again.
+// ///
+// /// # Lookup without `Entity`
+// ///
+// /// If you don't know the [`Entity`] of an animation, you can also lookup the
+// /// set of animations for a given target, either component on an entity or an
+// /// asset.
+// ///
+// /// ```
+// /// # use bevy::{prelude::*, ecs::component::Components};
+// /// # use bevy_tweening::*;
+// /// fn my_system(components: &Components, animator: Res<TweenAnimator>) ->
+// Result<()> { /// # let entity = Entity::PLACEHOLDER;
+// ///     // Create an AnimTarget::Component() from an Entity and a component
+// type ///     // let entity = ...
+// ///     let target = ComponentAnimTarget::new::<Transform>(components,
+// entity)?; ///     let target: AnimTarget = target.into();
+// ///
+// ///     // Lookup all active animations and filter by target
+// ///     let animations: Vec<&TweenAnim> = animator
+// ///         .iter()
+// ///         .filter_map(|(_id, anim)| {
+// ///             if *anim.target() == target {
+// ///                 Some(anim)
+// ///             } else {
+// ///                 None
+// ///             }
+// ///         })
+// ///         .collect::<_>();
+// ///
+// ///     Ok(())
+// /// }
+// /// ```
+
+// impl TweenAnimator {
+//     /// Add a new component animation to the animator queue.
+//     ///
+//     /// In general you don't need to call this directly. Instead, use the
+//     /// extensions provided by [`EntityWorldMutTweeningExtensions`] to
+// directly     /// create and queue tweenable animations on a given
+// [`EntityCommands`],     /// like this:
+//     ///
+//     /// ```
+//     /// # use bevy::prelude::*;
+//     /// # use bevy_tweening::{lens::*, *};
+//     /// # use std::time::Duration;
+//     /// # let mut world = World::default();
+//     /// # world.register_component::<Transform>();
+//     /// # world.register_resource::<TweenAnimator>();
+//     /// # world.init_resource::<TweenAnimator>();
+//     /// # let entity = world.spawn_empty().id();
+//     /// let tween = Tween::new(
+//     ///     EaseFunction::QuadraticInOut,
+//     ///     Duration::from_secs(1),
+//     ///     TransformPositionLens {
+//     ///         start: Vec3::ZERO,
+//     ///         end: Vec3::new(3.5, 0., 0.),
+//     ///     },
+//     /// );
+//     /// world.entity_mut(entity).tween(tween);
+//     /// ```
+//     ///
+//     /// This function is still useful if you want to store the [`Entity`] of
+//     /// the new animation, to later access it to dynamically modify the
+// playback     /// (e.g. speed).
+//     ///
+//     /// ```
+//     /// # use bevy::{prelude::*, ecs::component::Components};
+//     /// # use bevy_tweening::{lens::*, *};
+//     /// # use std::time::Duration;
+//     /// # fn make_tween() -> Tween { unimplemented!() }
+//     /// // Helper component to store a Entity
+//     /// #[derive(Component)]
+//     /// struct MyTweenId(pub Entity);
+//     ///
+//     /// // System which spawns the component and its animation
+//     /// fn my_spawn_system(
+//     ///     mut commands: Commands,
+//     ///     components: &Components,
+//     ///     mut animator: ResMut<TweenAnimator>,
+//     /// ) -> Result<()> {
+//     ///     # let tween = make_tween();
+//     ///     let entity = commands.spawn(Transform::default()).id();
+//     ///     // The component type is deducted from `tween` here
+//     ///     let tween_id = animator.add_component(components, entity,
+// tween)?;     ///     // Save the new Entity for later use
+//     ///     commands.entity(entity).insert(MyTweenId(tween_id));
+//     ///     Ok(())
+//     /// }
+//     ///
+//     /// // System which modifies the animation playback
+//     /// fn my_use_system(mut animator: ResMut<TweenAnimator>, query:
+// Query<&MyTweenId>) -> Option<()> {     ///     let tween_id =
+// query.single().ok()?.0;     ///     animator.get_mut(tween_id)?.speed = 1.2;
+// // 120% playback speed     ///     Some(())
+//     /// }
+//     /// ```
+//     ///
+//     /// Note in the above that at the time when the animation is queued into
+// the     /// animator, the component doesn't yet exist in the world, because
+// the     /// spawning is deffered via [`Commands`]. This is not an error; the
+//     /// [`TweenAnimator`] doesn't perform any check when this function is
+//     /// called, on purpose to allow patterns like inserting the returned
+//     /// [`Entity`] into a component or resource from within the same system
+//     /// which spawned the target, without having to apply deferred commands
+//     /// first. When the animation steps however, the target is validated, and
+// if     /// invalid (either because the entity doesn't exist or it doesn't
+// have the     /// target component) then the animation instance is destroyed.
+//     #[inline]
+//     pub fn add_component<T>(
+//         &mut self,
+//         components: &Components,
+//         entity: Entity,
+//         tweenable: T,
+//     ) -> Result<Entity, TweeningError>
+//     where
+//         T: Tweenable + 'static,
+//     {
+//         let Some(type_id) = tweenable.type_id() else {
+//             return Err(TweeningError::UntypedTweenable);
+//         };
+//         let target = ComponentAnimTarget::new_untyped(components, type_id,
+// entity)?.into();         Ok(self.add_component_target(target, tweenable))
+//     }
+
+//     /// Add a new component animation via an existing
+// [`ComponentAnimTarget`].     ///
+//     /// See [`add_component()`] for details. This variant is useful when you
+// can     /// build in advance a [`ComponentAnimTarget`], but at the same time
+// don't     /// readily have access to the [`Components`] of the world.
+//     ///
+//     /// Note that there's no equivalent for assets, because asset animations
+//     /// need to register some internal type-dependent resolver due to assets
+//     /// being only accessible through the typed [`Assets<A>`] API.
+//     ///
+//     /// [`add_component()`]: Self::add_component
+//     #[inline]
+//     pub fn add_component_target<T>(&mut self, target: ComponentAnimTarget,
+// tweenable: T) -> Entity     where
+//         T: Tweenable + 'static,
+//     {
+//         self.anims
+//             .insert(TweenAnim::new(target.into(), Box::new(tweenable)))
+//     }
+
+//     /// Add a new asset animation to the animator queue.
+//     ///
+//     /// ```
+//     /// # use bevy::{prelude::*, ecs::component::Components};
+//     /// # use bevy_tweening::{lens::*, *};
+//     /// # use std::time::Duration;
+//     /// # fn make_tween() -> Tween { unimplemented!() }
+//     /// #[derive(Asset, TypePath)]
+//     /// struct MyAsset;
+//     ///
+//     /// // Helper component to store a Entity
+//     /// #[derive(Resource)]
+//     /// struct MyTweenId(pub Entity);
+//     ///
+//     /// // System which spawns the asset animation
+//     /// fn my_spawn_system(
+//     ///     mut assets: ResMut<Assets<MyAsset>>,
+//     ///     components: &Components,
+//     ///     mut animator: ResMut<TweenAnimator>,
+//     ///     mut my_tween_id: ResMut<MyTweenId>,
+//     /// ) -> Result<()> {
+//     ///     # let tween = make_tween();
+//     ///     let handle = assets.add(MyAsset);
+//     ///     // The asset type is deducted from `tween` here
+//     ///     let tween_id = animator.add_asset(components, handle.id(),
+// tween)?;     ///     // Save the new Entity for later use
+//     ///     my_tween_id.0 = tween_id;
+//     ///     Ok(())
+//     /// }
+//     ///
+//     /// // System which modifies the animation playback
+//     /// fn my_use_system(
+//     ///     mut animator: ResMut<TweenAnimator>,
+//     ///     my_tween_id: Res<MyTweenId>,
+//     /// ) -> Option<()> {
+//     ///     let tween_id = my_tween_id.0;
+//     ///     animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
+//     ///     Some(())
+//     /// }
+//     /// ```
+//     ///
+//     /// Note that unlike [`add_component()`], this function depends on the
+// asset     /// type. This is required to allow registering some internal
+// resolver to     /// extract the typed animation from its typed `Assets<A>`,
+// as this can't be     /// done via untyped references (unlike for components).
+//     ///
+//     /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
+//     /// [`add_component()`]: Self::add_component
+//     #[inline]
+//     pub fn add_asset<T, A: Asset>(
+//         &mut self,
+//         components: &Components,
+//         asset_id: impl Into<AssetId<A>>,
+//         tweenable: T,
+//     ) -> Result<Entity, TweeningError>
+//     where
+//         T: Tweenable + 'static,
+//     {
+//         let Some(type_id) = tweenable.type_id() else {
+//             return Err(TweeningError::UntypedTweenable);
+//         };
+//         if type_id != TypeId::of::<A>() {
+//             return Err(TweeningError::InvalidAssetIdType {
+//                 expected: TypeId::of::<A>(),
+//                 actual: type_id,
+//             });
+//         }
+//         let asset_id = asset_id.into();
+//         let target = AssetAnimTarget::new(components, asset_id)?;
+//         self.asset_resolver.insert(
+//             target.resource_id,
+//             Box::new(
+//                 |assets: MutUntyped, asset_id: UntypedAssetId| -> Option<MutUntyped> {
+//                     // SAFETY: The correct type is captured from the outer
+// function                     #[allow(unsafe_code)]
+//                     let assets = unsafe { assets.with_type::<Assets<A>>() };
+//                     let asset_id = asset_id.try_typed::<A>().ok()?;
+//                     assets
+//                         .filter_map_unchanged(|assets|
+// assets.get_mut(asset_id))                         .map(Into::into)
+//                 },
+//             ),
+//         );
+//         Ok(self
+//             .anims
+//             .insert(TweenAnim::new(target.into(), Box::new(tweenable))))
+//     }
+
+//     /// Check if the animation with the given ID is queued.
+//     ///
+//     /// If this returns `false` then any animation which might have existed
+// with     /// this ID was destroyed, and this ID will forever be invalid and
+//     /// unused.
+//     ///
+//     /// # Returns
+//     ///
+//     /// Returns `true` if the animation is queued, either because it's
+// playing,     /// or because it's completed but
+// [`TweenAnim::destroy_on_completion`] was     /// set to `false`. In that case
+// the [`TweenAnim`] can be accessed by the     /// likes of [`get()`].
+//     ///
+//     /// [`get()`]: Self::get
+//     #[inline]
+//     pub fn contains(&self, id: Entity) -> bool {
+//         self.anims.contains_key(id)
+//     }
+
+//     /// Get a queued tweenable animation from its ID.
+//     ///
+//     /// This fails and returns `None` if the animation has completed and was
+//     /// removed from the animator's internal queue, or if the ID is invalid
+//     /// (notably, `Entity::PLACEHOLDER`).
+//     #[inline]
+//     pub fn get(&self, id: Entity) -> Option<&TweenAnim> {
+//         self.anims.get(id)
+//     }
+
+//     /// Get a queued tweenable animation from its ID.
+//     ///
+//     /// This fails and returns `None` if the animation has completed and was
+//     /// removed from the animator's internal queue, or if the ID is invalid
+//     /// (notably, `Entity::PLACEHOLDER`).
+//     #[inline]
+//     pub fn get_mut(&mut self, id: Entity) -> Option<&mut TweenAnim> {
+//         self.anims.get_mut(id)
+//     }
+
+//     /// Get a queued tweenable animation from its ID.
+//     ///
+//     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
+//     /// animation has completed and was removed from the animator's internal
+//     /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
+//     #[inline]
+//     pub fn try_get(&self, id: Entity) -> Result<&TweenAnim, TweeningError> {
+//         self.anims.get(id).ok_or(TweeningError::InvalidTweenId(id))
+//     }
+
+//     /// Get a queued tweenable animation from its ID.
+//     ///
+//     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
+//     /// animation has completed and was removed from the animator's internal
+//     /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
+//     #[inline]
+//     pub fn try_get_mut(&mut self, id: Entity) -> Result<&mut TweenAnim,
+// TweeningError> {         self.anims
+//             .get_mut(id)
+//             .ok_or(TweeningError::InvalidTweenId(id))
+//     }
+
+//     /// Get an iterator over the queued tweenable animations.
+//     ///
+//     /// # Returns
+//     ///
+//     /// An iterator over pairs of (ID, animation) for all animations still in
+//     /// the internal queue.
+//     #[inline]
+//     pub fn iter(&self) -> impl Iterator<Item = (Entity, &TweenAnim)> {
+//         self.anims.iter()
+//     }
+
+//     /// Get a mutable iterator over the queued tweenable animations.
+//     ///
+//     /// # Returns
+//     ///
+//     /// An iterator over pairs of (ID, animation) for all animations still in
+//     /// the internal queue.
+//     #[inline]
+//     pub fn iter_mut(&mut self) -> impl Iterator<Item = (Entity, &mut
+// TweenAnim)> {         self.anims.iter_mut()
+//     }
+
+//     /// Remove a queued tweenable animation and return it.
+//     ///
+//     /// This immediately removes the animation, if it exists, without
+// modifying     /// further its target. After the animation is removed, the
+// `id` is     /// invalid and will never be reused. The animation cannot be
+// re-queued;     /// instead, a new animation sould be created with
+// [`add_component()`] or     /// [`add_asset()`], which will generate a
+// different ID.     ///
+//     /// # Returns
+//     ///
+//     /// If the ID was valid and an animation with this ID was removed,
+// returns     /// that animation. Otherwise returns `None`.
+//     ///
+//     /// [`add_component()`]: Self::add_component
+//     /// [`add_asset()`]: Self::add_asset
+//     #[inline]
+//     pub fn remove(&mut self, id: Entity) -> Option<TweenAnim> {
+//         self.anims.remove(id)
+//     }
+
+//     /// Retarget a queued animation.
+//     ///
+//     /// Attempt to change the target of a tweening animation already
+// enqueued,     /// and possibly already playing. This function performs a
+// number of checks     /// on the new target to ensure it's compatible with the
+// previous     /// target. In particular, the new target needs to have:
+//     /// - the same kind (component or asset);
+//     /// - the same type.
+//     ///
+//     /// # Returns
+//     ///
+//     /// On success, returns the previous target which has been replaced.
+//     ///
+//     /// [`add_component()`]: Self::add_component
+//     /// [`add_asset()`]: Self::add_asset
+//     /// [`set_target()`]: Self::set_target
+//     pub fn set_target(
+//         &mut self,
+//         id: Entity,
+//         target: AnimTarget,
+//     ) -> Result<AnimTarget, TweeningError> {
+//         let anim = self
+//             .anims
+//             .get_mut(id)
+//             .ok_or(TweeningError::InvalidTweenId(id))?;
+//         match (anim.target, target) {
+//             (AnimTarget::Component(old_component),
+// AnimTarget::Component(new_component)) => {                 if
+// old_component.component_id != new_component.component_id {
+// return Err(TweeningError::MismatchingComponentId(
+// old_component.component_id,
+// new_component.component_id,                     ));
+//                 }
+//             }
+//             (AnimTarget::Asset(old_asset), AnimTarget::Asset(new_asset)) => {
+//                 if old_asset.resource_id != new_asset.resource_id {
+//                     return Err(TweeningError::MismatchingAssetResourceId(
+//                         old_asset.resource_id,
+//                         new_asset.resource_id,
+//                     ));
+//                 }
+//             }
+//             _ => {
+//                 return Err(TweeningError::MismatchingTargetKind(
+//                     anim.target.is_component(),
+//                     target.is_component(),
+//                 ))
+//             }
+//         }
+//         let old_target = anim.target;
+//         anim.target = target;
+//         Ok(old_target)
+//     }
+
+//     /// Swap a queued animation.
+//     ///
+//     /// Attempt to change the tweenable of an animation already enqueued, and
+//     /// possibly already playing.
+//     ///
+//     /// If the tweenable is successfully swapped, this resets the
+//     /// [`TweenAnim::tween_state()`] to [`TweenState::Active`], even if the
+//     /// tweenable would otherwise be completed _e.g._ because its elapsed
+// time     /// is past its total duration. Conversely, this doesn't update the
+// target,     /// as this function doesn't have mutable access to it.
+//     ///
+//     /// To ensure the old and new animations have the same elapsed time (for
+//     /// example if they need to be synchronized), call [`set_elapsed()`]
+// first     ///   on the input `tweenable`, with the duration value of the old
+//     ///   tweenable as returned by [`elapsed()`].
+//     ///
+//     /// ```
+//     /// # use std::time::Duration;
+//     /// # use slotmap::Key as _;
+//     /// # use bevy::prelude::*;
+//     /// # use bevy_tweening::*;
+//     /// # fn sys(mut animator: ResMut<TweenAnimator>) {
+//     /// # let id = Entity::PLACEHOLDER;
+//     /// # let mut tweenable = Delay::new(Duration::from_secs(1));
+//     /// let elapsed = animator.get(id).unwrap().tweenable().elapsed();
+//     /// tweenable.set_elapsed(elapsed);
+//     /// animator.set_tweenable(id, tweenable);
+//     /// # }
+//     /// ```
+//     ///
+//     /// To recompute the actual tweenable animation state and force a target
+//     /// update, use [`step_one()`] with a [`Duration::ZERO`].
+//     ///
+//     /// # Returns
+//     ///
+//     /// On success, returns the previous tweenable which has been swapped
+// out.     ///
+//     /// [`set_elapsed()`]: crate::Tweenable::set_elapsed
+//     /// [`elapsed()`]: crate::Tweenable::elapsed
+//     /// [`step_one()`]: Self::step_one
+//     pub fn set_tweenable<T>(
+//         &mut self,
+//         id: Entity,
+//         tweenable: T,
+//     ) -> Result<BoxedTweenable, TweeningError>
+//     where
+//         T: Tweenable + 'static,
+//     {
+//         let anim = self
+//             .anims
+//             .get_mut(id)
+//             .ok_or(TweeningError::InvalidTweenId(id))?;
+//         let mut old_tweenable: BoxedTweenable = Box::new(tweenable);
+//         std::mem::swap(&mut anim.tweenable, &mut old_tweenable);
+//         // Reset tweening state, the new tweenable is at t=0
+//         anim.tween_state = TweenState::Active;
+//         Ok(old_tweenable)
+//     }
+
+//     /// Step the given queued animation.
+//     ///
+//     /// In general all animations are stepped automatically via
+// [`step_all()`],     /// which is called from a system added by the
+// [`TweeningPlugin`]. This     /// function can be used to step a single
+// animation, either in addition or     /// in place of that system or any call
+// to [`step_all()`]. If the `id` is     /// invalid, this function does
+// nothing.     ///
+//     /// One useful use of this function is to force a mutation on the target,
+//     /// for example because some specific animation change was made which
+//     /// couldn't directly mutate it. By passing [`Duration::ZERO`], this
+//     /// function effectively forces the target state to the current animation
+//     /// "position" without playing back the animation itself (the elapsed
+// time     /// is not modified).
+//     ///
+//     /// # Returns
+//     ///
+//     /// If the animation completed and was destroyed, returns a copy of that
+//     /// animation. Otherwise if the animation is still queued, returns
+// `None`.     ///
+//     /// [`step_all()`]: Self::step_all
+//     #[inline]
+//     pub fn step_one(
+//         &mut self,
+//         world: &mut World,
+//         id: Entity,
+//         delta_time: Duration,
+//     ) -> Option<TweenAnim> {
+//         world.resource_scope(|world, events:
+// Mut<Events<CycleCompletedEvent>>| {             world.resource_scope(|world,
+// anim_events: Mut<Events<AnimCompletedEvent>>| {                 let anim =
+// self.anims.get_mut(id)?;
+
+//                 let ret = Self::step_impl(
+//                     id,
+//                     anim,
+//                     &self.asset_resolver,
+//                     world,
+//                     delta_time,
+//                     events,
+//                     anim_events,
+//                 );
+
+//                 if let Ok(ret) = ret {
+//                     if ret.sent_commands {
+//                         world.flush();
+//                     }
+
+//                     if !ret.retain {
+//                         return Some(self.anims.remove(id).unwrap());
+//                     }
+//                 }
+//                 None
+//             })
+//         })
+//     }
+
+//     fn step_impl(
+//         tween_id: Entity,
+//         anim: &mut TweenAnim,
+//         asset_resolver: &HashMap<ComponentId, Resolver>,
+//         world: &mut World,
+//         delta_time: Duration,
+//         mut events: Mut<Events<CycleCompletedEvent>>,
+//         mut anim_events: Mut<Events<AnimCompletedEvent>>,
+//     ) -> Result<StepResult, TweeningError> {
+//         let mut queued_systems = Vec::with_capacity(8);
+//         let mut completed_events = Vec::with_capacity(8);
+//         let mut sent_commands = false;
+
+//         // Sanity checks on fields which can be freely modified by the user
+//         anim.speed = anim.speed.max(0.);
+
+//         // Retain completed animations only if requested
+//         if anim.tween_state == TweenState::Completed {
+//             let ret = StepResult {
+//                 retain: !anim.destroy_on_completion,
+//                 sent_commands: false,
+//             };
+//             return Ok(ret);
+//         }
+
+//         // Skip paused animations (but retain them)
+//         if anim.playback_state == PlaybackState::Paused || anim.speed <= 0. {
+//             let ret = StepResult {
+//                 retain: true,
+//                 sent_commands: false,
+//             };
+//             return Ok(ret);
+//         }
+
+//         // Resolve the (untyped) target as a MutUntyped<T>
+//         let Some(mut mut_untyped) = (match &anim.target {
+//             AnimTarget::Component(ComponentAnimTarget {
+//                 entity,
+//                 component_id,
+//             }) => world.get_mut_by_id(*entity, *component_id),
+//             AnimTarget::Asset(AssetAnimTarget {
+//                 resource_id,
+//                 asset_id,
+//             }) => {
+//                 if let Some(assets) =
+// world.get_resource_mut_by_id(*resource_id) {                     if let
+// Some(resolver) = asset_resolver.get(resource_id) {
+// resolver(assets, *asset_id)                     } else {
+//                         None
+//                     }
+//                 } else {
+//                     None
+//                 }
+//             }
+//         }) else {
+//             let ret = StepResult {
+//                 retain: false,
+//                 sent_commands: false,
+//             };
+//             return Ok(ret);
+//         };
+
+//         // Scale delta time by this animation's speed. Reject negative
+// speeds; use         // backward playback to play in reverse direction.
+//         // Note: must use f64 for precision; f32 produces visible roundings.
+//         let delta_time = delta_time.mul_f64(anim.speed);
+
+//         // Step the tweenable animation
+//         let entity = anim.target.as_component().map(|comp| comp.entity);
+//         let mut notify_completed = || {
+//             completed_events.push((
+//                 CycleCompletedEvent {
+//                     id: tween_id,
+//                     target: anim.target,
+//                 },
+//                 entity,
+//             ));
+//         };
+//         let mut queue_system = |system_id: SystemId| {
+//             queued_systems.push(system_id);
+//         };
+//         let state = anim.tweenable.step(
+//             tween_id,
+//             delta_time,
+//             mut_untyped.reborrow(),
+//             &mut notify_completed,
+//             &mut queue_system,
+//         );
+//         anim.tween_state = state;
+
+//         // Send tween completed events once we reclaimed mut access to world
+// and can get         // a Commands.
+//         if !completed_events.is_empty() {
+//             let mut commands = world.commands();
+//             sent_commands = true;
+
+//             for (event, entity) in completed_events.drain(..) {
+//                 // Send buffered event
+//                 events.send(event);
+
+//                 // Trigger all entity-scoped observers
+//                 if let Some(entity) = entity {
+//                     commands.trigger_targets(event, entity);
+//                 }
+//             }
+//         }
+
+//         // Execute one-shot systems
+//         for sys_id in queued_systems.drain(..) {
+//             let _ = world.run_system(sys_id);
+//         }
+
+//         // Raise animation completed event
+//         if state == TweenState::Completed {
+//             let event = AnimCompletedEvent {
+//                 id: tween_id,
+//                 target: anim.target,
+//             };
+
+//             // Send buffered event
+//             anim_events.send(event);
+
+//             // Trigger all entity-scoped observers
+//             if let Some(entity) = entity {
+//                 let mut commands = world.commands();
+//                 sent_commands = true;
+//                 commands.trigger_targets(event, entity);
+//             }
+//         }
+
+//         let ret = StepResult {
+//             retain: state == TweenState::Active ||
+// !anim.destroy_on_completion,             sent_commands,
+//         };
+//         Ok(ret)
+//     }
+
+//     /// Step all queued animations.
+//     ///
+//     /// Loop over the internal queue of tweenable animations, apply them to
+//     /// their respective target, and prune all the completed ones (the ones
+//     /// returning [`TweenState::Completed`]). In the later case, send
+//     /// [`AnimCompletedEvent`]s.
+//     ///
+//     /// If you use the [`TweeningPlugin`], this is automatically called by
+// the     /// animation system the plugin registers. See the
+//     /// [`AnimationSystem::AnimationUpdate`] system set.
+//     ///
+//     /// Note that the order in which the animations are iterated over and
+//     /// played, and therefore also the order in which any event is raised or
+// any     /// one-shot system is executed, is an unspecified implementation
+// detail.     /// There is no guarantee on that order nor its stability frame
+// to     /// frame.
+//     pub fn step_all(&mut self, world: &mut World, delta_time: Duration) {
+//         world.resource_scope(|world, mut events:
+// Mut<Events<CycleCompletedEvent>>| {             world.resource_scope(|world,
+// mut anim_events: Mut<Events<AnimCompletedEvent>>| {                 let mut
+// sent_commands = false;
+
+//                 // Loop over active animations, tick them, and retain those
+// which are still                 // active after that
+//                 self.anims.retain(|tween_id, anim| {
+//                     let ret = Self::step_impl(
+//                         tween_id,
+//                         anim,
+//                         &self.asset_resolver,
+//                         world,
+//                         delta_time,
+//                         events.reborrow(),
+//                         anim_events.reborrow(),
+//                     );
+//                     if let Ok(ret) = ret {
+//                         sent_commands = sent_commands || ret.sent_commands;
+//                         return ret.retain;
+//                     }
+//                     false
+//                 });
+
+//                 // Flush commands
+//                 if sent_commands {
+//                     world.flush();
+//                 }
+//             });
+//         });
+//     }
+// }
+
 /// Extension trait to interpolate between two colors.
 ///
 /// This adds a [`Color::lerp()`] function which linearly interpolates the
@@ -2337,14 +2608,14 @@ mod tests {
         assert_eq!(1., ease.sample(0.));
     }
 
-    #[test]
-    fn animator_default() {
-        let mut animator = TweenAnimator::default();
-        assert!(animator.get(Entity::PLACEHOLDER).is_none());
-        assert!(animator.iter().next().is_none());
-        assert!(animator.iter_mut().next().is_none());
-        assert!(animator.remove(Entity::PLACEHOLDER).is_none());
-    }
+    // #[test]
+    // fn animator_default() {
+    //     let mut animator = TweenAnimator::default();
+    //     assert!(animator.get(Entity::PLACEHOLDER).is_none());
+    //     assert!(animator.iter().next().is_none());
+    //     assert!(animator.iter_mut().next().is_none());
+    //     assert!(animator.remove(Entity::PLACEHOLDER).is_none());
+    // }
 
     // TweenAnim::playback_state is entirely user-controlled; stepping animations
     // won't change it.
@@ -2357,10 +2628,9 @@ mod tests {
                 DummyLens { start: 0., end: 1. },
             );
             let mut env = TestEnv::<DummyComponent>::new(tween);
-            env.anim_scope(|anim| {
-                anim.playback_state = state;
-                anim.destroy_on_completion = false;
-            });
+            let mut anim = env.anim_mut().unwrap();
+            anim.playback_state = state;
+            anim.destroy_on_completion = false;
 
             // Tick once
             let dt = Duration::from_millis(100);
@@ -2376,7 +2646,7 @@ mod tests {
             assert_eq!(env.anim().unwrap().tweenable.elapsed(), elapsed);
 
             // Force playback, otherwise we can't complete
-            env.anim_scope(|anim| anim.playback_state = PlaybackState::Playing);
+            env.anim_mut().unwrap().playback_state = PlaybackState::Playing;
 
             // Even after completion, the playback state is untouched
             env.step_all(Duration::from_secs(10) - elapsed);
@@ -2417,59 +2687,90 @@ mod tests {
     }
 
     #[derive(Debug, Resource)]
-    struct Count<E: Event> {
+    struct Count<E: Event, T = ()> {
         pub count: i32,
         pub phantom: PhantomData<E>,
+        pub phantom2: PhantomData<T>,
     }
 
-    impl<E: Event> Default for Count<E> {
+    impl<E: Event, T> Default for Count<E, T> {
         fn default() -> Self {
             Self {
                 count: 0,
                 phantom: PhantomData,
+                phantom2: PhantomData,
             }
         }
     }
 
-    #[test]
-    fn animation_oneshot() {
-        let dummy = Delay::new(Duration::from_secs(1));
-        let mut env = TestEnv::<DummyComponent>::new(dummy);
-        env.world.init_resource::<Count<CycleCompletedEvent>>();
-
-        fn sys_tween(mut count: ResMut<Count<CycleCompletedEvent>>) {
-            count.count += 1;
-        }
-        let sys_id = env.world.register_system(sys_tween);
-
-        assert_eq!(env.world.resource::<Count<CycleCompletedEvent>>().count, 0);
+    struct GlobalMarker;
 
+    #[test]
+    fn animation_observe() {
         let tween = Tween::new::<DummyComponent, DummyLens>(
             EaseFunction::QuadraticInOut,
             Duration::from_secs(1),
             DummyLens { start: 0., end: 1. },
         )
         .with_repeat_count(2)
-        .with_completed_system(sys_id);
-        let id = env.tween_id;
-        env.animator_mut().set_tweenable(id, tween).unwrap();
+        .with_completed_event(true);
+        let mut env = TestEnv::<DummyComponent>::new(tween);
+
+        env.world.init_resource::<Count<CycleCompletedEvent>>();
+        assert_eq!(env.world.resource::<Count<CycleCompletedEvent>>().count, 0);
+        env.world
+            .init_resource::<Count<CycleCompletedEvent, GlobalMarker>>();
+        assert_eq!(
+            env.world
+                .resource::<Count<CycleCompletedEvent, GlobalMarker>>()
+                .count,
+            0
+        );
+
+        fn observe_global(
+            _trigger: Trigger<CycleCompletedEvent>,
+            mut count: ResMut<Count<CycleCompletedEvent, GlobalMarker>>,
+        ) {
+            count.count += 1;
+        }
+        env.world.add_observer(observe_global);
+
+        fn observe_entity(
+            _trigger: Trigger<CycleCompletedEvent>,
+            mut count: ResMut<Count<CycleCompletedEvent>>,
+        ) {
+            count.count += 1;
+        }
+        env.world.entity_mut(env.entity).observe(observe_entity);
 
         // Tick until one cycle is completed, but not the entire animation
         let dt = Duration::from_millis(1200);
         env.step_all(dt);
         assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
 
-        // Check one-shot system
+        // Check observer system ran
         assert_eq!(env.world.resource::<Count<CycleCompletedEvent>>().count, 1);
+        assert_eq!(
+            env.world
+                .resource::<Count<CycleCompletedEvent, GlobalMarker>>()
+                .count,
+            1
+        );
 
         // Tick until completion
         let dt = Duration::from_millis(1000);
         env.step_all(dt);
         assert!(env.anim().is_none());
 
-        // Check one-shot systems (note that we didn't clear previous events, so that's
-        // a cumulative count).
+        // Check observer system ran (note that we didn't clear previous events, so
+        // that's a cumulative count).
         assert_eq!(env.world.resource::<Count<CycleCompletedEvent>>().count, 2);
+        assert_eq!(
+            env.world
+                .resource::<Count<CycleCompletedEvent, GlobalMarker>>()
+                .count,
+            2
+        );
     }
 
     // #[test]
@@ -2521,7 +2822,7 @@ mod tests {
 
         assert_approx_eq!(env.anim().unwrap().speed, 1.); // default speed
 
-        env.anim_scope(|anim| anim.speed = 2.4);
+        env.anim_mut().unwrap().speed = 2.4;
         assert_approx_eq!(env.anim().unwrap().speed, 2.4);
 
         env.step_all(Duration::from_millis(100));
@@ -2532,7 +2833,7 @@ mod tests {
             Duration::from_millis(240)
         );
 
-        env.anim_scope(|anim| anim.speed = -1.);
+        env.anim_mut().unwrap().speed = -1.;
         env.step_all(Duration::from_millis(100));
         // Safety: invalid negative speed clamped to 0.
         assert_eq!(env.anim().unwrap().speed, 0.);
@@ -2557,9 +2858,7 @@ mod tests {
         );
 
         let mut env = TestEnv::<DummyComponent>::new(tween);
-        env.anim_scope(|anim| anim.destroy_on_completion = false);
-        let id = env.tween_id;
-        assert!(env.animator().contains(id));
+        env.anim_mut().unwrap().destroy_on_completion = false;
 
         let dt = Duration::from_millis(1500);
 
@@ -2568,10 +2867,7 @@ mod tests {
         assert_eq!(env.anim().unwrap().tween_state(), TweenState::Completed);
 
         // Swap tweens
-        let old_tweenable = env.animator_mut().set_tweenable(id, tween2).unwrap();
-        let id2 = env.tween_id;
-        assert_eq!(id, id2); // the ID doesn't change, the tweenable is swapped in-place
-        assert!(env.animator().contains(id2));
+        let old_tweenable = env.anim_mut().unwrap().set_tweenable(tween2).unwrap();
 
         assert_eq!(env.anim().unwrap().tween_state(), TweenState::Active);
         // The elapsed is stored inside the tweenable
@@ -2582,91 +2878,93 @@ mod tests {
         assert!(env.component().value >= 2. && env.component().value <= 3.);
     }
 
-    #[test]
-    fn animator_set_target() {
-        let tween = Tween::new::<DummyComponent, DummyLens>(
-            EaseFunction::QuadraticInOut,
-            Duration::from_secs(1),
-            DummyLens { start: 0., end: 1. },
-        );
-        let mut env = TestEnv::<DummyComponent>::new(tween);
-
-        // Register our custom asset type
-        env.world.init_resource::<Assets<DummyAsset>>();
-
-        // Invalid ID
-        {
-            let entity = env.entity;
-            let target =
-                ComponentAnimTarget::new::<DummyComponent>(env.world.components(), entity).unwrap();
-            let err = env
-                .animator_mut()
-                .set_target(Entity::PLACEHOLDER, target.into())
-                .err()
-                .unwrap();
-            let TweeningError::InvalidTweenId(err_id) = err else {
-                panic!();
-            };
-            assert_eq!(err_id, Entity::PLACEHOLDER);
-        }
-
-        // Spawn a second entity without any animation
-        let entity1 = env.entity;
-        let entity2 = env.world_mut().spawn(DummyComponent { value: 0. }).id();
-        assert_ne!(entity1, entity2);
-        assert_eq!(env.component().value, 0.);
-
-        // Step the current target
-        let dt = Duration::from_millis(100);
-        env.step_all(dt);
-        assert!(env.component().value > 0.);
-        assert_eq!(
-            env.world
-                .entity(entity2)
-                .get_components::<&DummyComponent>()
-                .unwrap()
-                .value,
-            0.
-        );
+    // #[test]
+    // fn animator_set_target() {
+    //     let tween = Tween::new::<DummyComponent, DummyLens>(
+    //         EaseFunction::QuadraticInOut,
+    //         Duration::from_secs(1),
+    //         DummyLens { start: 0., end: 1. },
+    //     );
+    //     let mut env = TestEnv::<DummyComponent>::new(tween);
+
+    //     // Register our custom asset type
+    //     env.world.init_resource::<Assets<DummyAsset>>();
+
+    //     // Invalid ID
+    //     {
+    //         let entity = env.entity;
+    //         let target =
+    //
+    // ComponentAnimTarget::new::<DummyComponent>(env.world.components(),
+    // entity).unwrap();         let err = env
+    //             .animator_mut()
+    //             .set_target(Entity::PLACEHOLDER, target.into())
+    //             .err()
+    //             .unwrap();
+    //         let TweeningError::InvalidTweenId(err_id) = err else {
+    //             panic!();
+    //         };
+    //         assert_eq!(err_id, Entity::PLACEHOLDER);
+    //     }
+
+    //     // Spawn a second entity without any animation
+    //     let entity1 = env.entity;
+    //     let entity2 = env.world_mut().spawn(DummyComponent { value: 0.
+    // }).id();     assert_ne!(entity1, entity2);
+    //     assert_eq!(env.component().value, 0.);
+
+    //     // Step the current target
+    //     let dt = Duration::from_millis(100);
+    //     env.step_all(dt);
+    //     assert!(env.component().value > 0.);
+    //     assert_eq!(
+    //         env.world
+    //             .entity(entity2)
+    //             .get_components::<&DummyComponent>()
+    //             .unwrap()
+    //             .value,
+    //         0.
+    //     );
 
-        // Now retarget
-        let id = env.tween_id;
-        let target2 =
-            ComponentAnimTarget::new::<DummyComponent>(env.world.components(), entity2).unwrap();
-        let target1 = env.animator_mut().set_target(id, target2.into()).unwrap();
-        assert!(target1.is_component());
-        let comp1 = target1.as_component().unwrap();
-        assert_eq!(comp1.entity, entity1);
-        assert_eq!(
-            comp1.component_id,
-            env.world.component_id::<DummyComponent>().unwrap()
-        );
+    //     // Now retarget
+    //     let id = env.entity;
+    //     let target2 =
+    //         ComponentAnimTarget::new::<DummyComponent>(env.world.
+    // components(), entity2).unwrap();     let target1 =
+    // env.animator_mut().set_target(id, target2.into()).unwrap();
+    //     assert!(target1.is_component());
+    //     let comp1 = target1.as_component().unwrap();
+    //     assert_eq!(comp1.entity, entity1);
+    //     assert_eq!(
+    //         comp1.component_id,
+    //         env.world.component_id::<DummyComponent>().unwrap()
+    //     );
 
-        // Step the new target
-        env.step_all(dt);
-        assert!(env.component().value > 0.);
-        assert!(
-            env.world
-                .entity(entity1)
-                .get_components::<&DummyComponent>()
-                .unwrap()
-                .value
-                > 0.
-        );
+    //     // Step the new target
+    //     env.step_all(dt);
+    //     assert!(env.component().value > 0.);
+    //     assert!(
+    //         env.world
+    //             .entity(entity1)
+    //             .get_components::<&DummyComponent>()
+    //             .unwrap()
+    //             .value
+    //             > 0.
+    //     );
 
-        // Invalid target
-        {
-            let target3 =
-                AssetAnimTarget::new(env.world.components(), Handle::<DummyAsset>::default().id())
-                    .unwrap();
-            let err3 = env.animator_mut().set_target(id, target3.into());
-            assert!(err3.is_err());
-            let err3 = err3.err().unwrap();
-            let TweeningError::MismatchingTargetKind(oc, nc) = err3 else {
-                panic!();
-            };
-            assert_eq!(oc, true);
-            assert_eq!(nc, false);
-        }
-    }
+    //     // Invalid target
+    //     {
+    //         let target3 =
+    //             AssetAnimTarget::new(env.world.components(),
+    // Handle::<DummyAsset>::default().id())                 .unwrap();
+    //         let err3 = env.animator_mut().set_target(id, target3.into());
+    //         assert!(err3.is_err());
+    //         let err3 = err3.err().unwrap();
+    //         let TweeningError::MismatchingTargetKind(oc, nc) = err3 else {
+    //             panic!();
+    //         };
+    //         assert_eq!(oc, true);
+    //         assert_eq!(nc, false);
+    //     }
+    // }
 }
diff --git a/src/plugin.rs b/src/plugin.rs
index 34caaa0..320540f 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenResolver};
+use crate::{AnimCompletedEvent, AnimTarget, CycleCompletedEvent, TweenAnim, TweenResolver};
 
 /// Plugin to register the [`TweenAnimator`] and the system playing animations.
 ///
@@ -32,15 +32,102 @@ pub enum AnimationSystem {
     AnimationUpdate,
 }
 
-/// Core animation systemt ticking the [`TweenAnimator`].
+/// Core animation systemt ticking all queued animations.
 pub(crate) fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
-    let anims = world.query::<&mut TweenAnim>();
-    world.resource_scope(|world, mut resolver: Mut<TweenResolver>| {
-        for anim in anims.iter_mut(world) {
-            anim.step(world, delta_time);
-        }
+
+    // Gather all entities with a TweenAnim. We can't iterate over them while at the
+    // same time retaining a mutable access to the World (in order to resolve the
+    // MutUntyped of the target), so we first make a copy of the entities and
+    // targets.
+    let mut q_anims = world.query::<(Entity, &TweenAnim)>();
+    let mut anims = q_anims
+        .iter(world)
+        .map(|(entity, anim)| (entity, anim.target))
+        .collect::<Vec<_>>();
+
+    // Update animations
+    let mut to_remove = Vec::with_capacity(anims.len());
+    world.resource_scope(|world, asset_resolver: Mut<TweenResolver>| {
+        world.resource_scope(
+            |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                world.resource_scope(|world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                    let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
+                    for (entity, target) in anims.drain(..) {
+                        let ret = match target {
+                            AnimTarget::Component(comp_target) => {
+                                let (mut entities, commands) = world.entities_and_commands();
+                                if entity == comp_target.entity {
+                                    // The TweenAnim animates another component on the same entity
+                                    let Ok([mut ent]) = entities.get_mut([entity]) else {
+                                        continue;
+                                    };
+                                    let Ok([anim, target]) =
+                                        ent.get_mut_by_id([anim_comp_id, comp_target.component_id])
+                                    else {
+                                        continue;
+                                    };
+                                    // SAFETY: We fetched the EntityMut from the component ID of
+                                    // TweenAnim
+                                    #[allow(unsafe_code)]
+                                    let mut anim = unsafe { anim.with_type::<TweenAnim>() };
+                                    anim.step(
+                                        commands,
+                                        entity,
+                                        delta_time,
+                                        target,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    )
+                                } else {
+                                    // The TweenAnim animates a component on a different entity
+                                    let Ok([mut anim, mut target]) =
+                                        entities.get_mut([entity, comp_target.entity])
+                                    else {
+                                        continue;
+                                    };
+                                    let Some(mut anim) = anim.get_mut::<TweenAnim>() else {
+                                        continue;
+                                    };
+                                    let Ok(target) = target.get_mut_by_id(comp_target.component_id)
+                                    else {
+                                        continue;
+                                    };
+                                    anim.step(
+                                        commands,
+                                        entity,
+                                        delta_time,
+                                        target,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    )
+                                }
+                            }
+                            AnimTarget::Asset(asset_target) => asset_resolver.resolve_scope(
+                                world,
+                                &asset_target,
+                                entity,
+                                delta_time,
+                                cycle_events.reborrow(),
+                                anim_events.reborrow(),
+                            ),
+                        };
+
+                        let retain = ret.map(|ret| ret.retain).unwrap_or(false);
+                        if !retain {
+                            to_remove.push(entity);
+                        }
+                    }
+                });
+            },
+        );
     });
+
+    for entity in to_remove.drain(..) {
+        world.entity_mut(entity).remove::<TweenAnim>();
+    }
+
+    world.flush();
 }
 
 #[cfg(test)]
@@ -97,8 +184,7 @@ mod tests {
 
         env.step_all(Duration::ZERO);
 
-        let animator = env.animator();
-        let anim = animator.get(env.tween_id).unwrap();
+        let anim = env.anim().unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let transform = env.component_mut();
@@ -108,8 +194,7 @@ mod tests {
         env.step_all(Duration::from_millis(500));
 
         assert_eq!(env.event_count::<CycleCompletedEvent>(), 0);
-        let animator = env.animator();
-        let anim = animator.get(env.tween_id).unwrap();
+        let anim = env.anim().unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let transform = env.component_mut();
@@ -123,8 +208,8 @@ mod tests {
         // so the component is changed.
 
         assert_eq!(env.event_count::<CycleCompletedEvent>(), 1);
-        let animator = env.animator();
-        assert!(animator.get(env.tween_id).is_none()); // done and deleted
+        let anim = env.anim();
+        assert!(anim.is_none()); // done and deleted
         let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
@@ -133,8 +218,8 @@ mod tests {
         env.step_all(Duration::from_millis(100));
 
         assert_eq!(env.event_count::<CycleCompletedEvent>(), 0);
-        let animator = env.animator();
-        assert!(animator.get(env.tween_id).is_none()); // done and deleted
+        let anim = env.anim();
+        assert!(anim.is_none()); // done and deleted
         let transform = env.component_mut();
         assert!(!transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
@@ -182,8 +267,7 @@ mod tests {
         // Mutation disabled
         env.step_all(Duration::ZERO);
 
-        let animator = env.animator();
-        let anim = animator.get(env.tween_id).unwrap();
+        let anim = env.anim().unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
@@ -193,8 +277,7 @@ mod tests {
         // Zero-length tick should not change the component
         env.step_all(Duration::ZERO);
 
-        let animator = env.animator();
-        let anim = animator.get(env.tween_id).unwrap();
+        let anim = env.anim().unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
@@ -204,8 +287,7 @@ mod tests {
         // New tick, but lens mutation still disabled
         env.step_all(Duration::from_millis(200));
 
-        let animator = env.animator();
-        let anim = animator.get(env.tween_id).unwrap();
+        let anim = env.anim().unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
@@ -220,8 +302,7 @@ mod tests {
         // increment the component's value.
         env.step_all(Duration::ZERO);
 
-        let animator = env.animator();
-        let anim = animator.get(env.tween_id).unwrap();
+        let anim = env.anim().unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
@@ -234,8 +315,7 @@ mod tests {
         // value == 0.7
         env.step_all(Duration::from_millis(300));
 
-        let animator = env.animator();
-        let anim = animator.get(env.tween_id).unwrap();
+        let anim = env.anim().unwrap();
         assert_eq!(anim.playback_state, PlaybackState::Playing);
         assert_eq!(anim.tweenable.cycles_completed(), 0);
         let component = env.component_mut();
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 50a2364..35dc1c4 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -118,8 +118,8 @@ macro_rules! assert_approx_eq {
 pub(crate) use assert_approx_eq;
 
 use crate::{
-    AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenAnimator, Tweenable,
-    WorldTargetExtensions as _,
+    AnimCompletedEvent, ComponentAnimTarget, CycleCompletedEvent, TweenAnim, TweenResolver,
+    Tweenable,
 };
 
 /// A simple isolated test environment with a [`World`] and a single
@@ -127,7 +127,6 @@ use crate::{
 pub(crate) struct TestEnv<T: Component> {
     pub world: World,
     pub entity: Entity,
-    pub tween_id: Entity,
     system: Box<dyn System<In = (), Out = ()>>,
     _phantom: PhantomData<T>,
 }
@@ -140,21 +139,20 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
         world.init_resource::<Time>();
         world.init_resource::<Events<CycleCompletedEvent>>();
         world.init_resource::<Events<AnimCompletedEvent>>();
-        world.init_resource::<TweenAnimator>();
+        world.init_resource::<TweenResolver>();
 
         let mut system = IntoSystem::into_system(crate::plugin::animator_system);
         system.initialize(&mut world);
 
         let entity = world.spawn(T::default()).id();
-        let tween_id = world.resource_scope(|world, mut animator: Mut<'_, TweenAnimator>| {
-            let target = world.get_anim_component_target::<T>(entity).unwrap();
-            animator.add_component_target(target, tweenable)
-        });
+        let target = ComponentAnimTarget::new::<T>(world.components(), entity).unwrap();
+        world
+            .entity_mut(entity)
+            .insert(TweenAnim::new(target.into(), Box::new(tweenable)));
 
         Self {
             world,
             entity,
-            tween_id,
             system: Box::new(system),
             _phantom: PhantomData,
         }
@@ -191,29 +189,14 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
         events.update();
     }
 
-    /// Get the animator for the component.
-    pub fn animator(&self) -> &TweenAnimator {
-        self.world.resource::<TweenAnimator>()
-    }
-
-    /// Get the animator for the component.
-    #[allow(dead_code)]
-    pub fn animator_mut(&mut self) -> Mut<TweenAnimator> {
-        self.world.resource_mut::<TweenAnimator>()
-    }
-
     /// Get the animation.
     pub fn anim(&self) -> Option<&TweenAnim> {
-        self.world.resource::<TweenAnimator>().get(self.tween_id)
+        self.world.get::<TweenAnim>(self.entity)
     }
 
-    /// Apply a mutating closure to the animation.
-    pub fn anim_scope(&mut self, func: impl FnOnce(&mut TweenAnim)) {
-        let tween_id = self.tween_id;
-        let mut animator = self.world.resource_mut::<TweenAnimator>();
-        if let Some(anim) = animator.get_mut(tween_id) {
-            func(anim);
-        }
+    /// Get the animation.
+    pub fn anim_mut(&mut self) -> Option<Mut<TweenAnim>> {
+        self.world.get_mut::<TweenAnim>(self.entity)
     }
 
     /// Get the component.
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 02a29cd..88820ec 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -485,7 +485,6 @@ pub trait Tweenable: Send + Sync {
         delta: Duration,
         target: MutUntyped,
         notify_completed: &mut dyn FnMut(),
-        queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState;
 
     /// Rewind the animation to its starting state.
@@ -659,7 +658,6 @@ pub struct Tween {
     /// Direction of playback the user asked for.
     playback_direction: PlaybackDirection,
     action: Box<TargetAction>,
-    system_id: Option<SystemId>,
     send_completed_event: bool,
     /// Type ID of the target.
     type_id: TypeId,
@@ -711,7 +709,6 @@ impl Tween {
             clock: AnimClock::new(cycle_duration),
             playback_direction: PlaybackDirection::Forward,
             action: Box::new(action),
-            system_id: None,
             send_completed_event: false,
             type_id: TypeId::of::<T>(),
         }
@@ -794,66 +791,6 @@ impl Tween {
         self.send_completed_event = send;
     }
 
-    /// Enable running a one-shot system upon cycle completion.
-    ///
-    /// If enabled, the tween will run a system via a provided [`SystemId`] when
-    /// the animation completes a single cycle. This is similar to the
-    /// [`with_completed_event()`], but uses a system registered by
-    /// [`register_system()`] instead of a callback.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::{Vec3, curve::EaseFunction}, ecs::world::World, ecs::system::Query, ecs::entity::Entity, ecs::query::With, prelude::Res};
-    /// # use std::time::Duration;
-    /// # let mut world = World::new();
-    /// let test_system_id = world.register_system(test_system);
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed_system(test_system_id);
-    ///
-    /// fn test_system(animator: Res<TweenAnimator>) {
-    ///    println!("Animations still queued after this cycle completion:");
-    ///    for (id, anim) in animator.iter() {
-    ///       println!("Anim #{:?} playback_state={:?}", id, anim.playback_state);
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// [`with_completed_event()`]: crate::Tween::with_completed_event
-    /// [`register_system()`]: bevy::ecs::world::World::register_system
-    #[must_use]
-    pub fn with_completed_system(mut self, system_id: SystemId) -> Self {
-        self.system_id = Some(system_id);
-        self
-    }
-
-    /// Set the one-shot system executed when a cycle completes.
-    ///
-    /// See [`with_completed_system()`] for details.
-    ///
-    /// [`with_completed_system()`]: Self::with_completed_system
-    pub fn set_completed_system(&mut self, system_id: SystemId) {
-        self.system_id = Some(system_id);
-    }
-
-    /// Clear the one-shot system executed when a cycle completes.
-    ///
-    /// See [`with_completed_system()`] for details.
-    ///
-    /// [`with_completed_system()`]: Self::with_completed_system
-    pub fn clear_completed_system(&mut self) {
-        self.system_id = None;
-    }
-
     /// Set the playback direction of the tween.
     ///
     /// The playback direction controls whether the internal animation clock,
@@ -990,7 +927,6 @@ impl Tweenable for Tween {
         delta: Duration,
         target: MutUntyped,
         notify_completed: &mut dyn FnMut(),
-        queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         if self.clock.state(self.playback_direction) == TweenState::Completed {
             return TweenState::Completed;
@@ -1010,14 +946,8 @@ impl Tweenable for Tween {
         (self.action)(target, fraction);
 
         // If completed at least once this frame, notify the user
-        if times_completed != 0 {
-            if self.send_completed_event {
-                notify_completed();
-            }
-
-            if let Some(system_id) = &self.system_id {
-                queue_system(*system_id);
-            }
+        if times_completed != 0 && self.send_completed_event {
+            notify_completed();
         }
 
         state
@@ -1178,7 +1108,6 @@ impl Tweenable for Sequence {
         mut delta: Duration,
         mut target: MutUntyped,
         notify_completed: &mut dyn FnMut(),
-        queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         // Calculate the new elapsed time at the end of this tick
         self.elapsed = self.elapsed.saturating_add(delta);
@@ -1193,13 +1122,8 @@ impl Tweenable for Sequence {
 
             let prev_elapsed = tween.elapsed();
 
-            if tween.step(
-                tween_id,
-                delta,
-                target.reborrow(),
-                notify_completed,
-                queue_system,
-            ) == TweenState::Active
+            if tween.step(tween_id, delta, target.reborrow(), notify_completed)
+                == TweenState::Active
             {
                 return TweenState::Active;
             }
@@ -1359,7 +1283,6 @@ impl Tweenable for Delay {
         delta: Duration,
         _target: MutUntyped,
         _notify_completed: &mut dyn FnMut(),
-        _queue_system: &mut dyn FnMut(SystemId),
     ) -> TweenState {
         self.timer.tick(delta);
 
@@ -1536,17 +1459,13 @@ mod tests {
     }
 
     /// Utility to create a test environment to tick a tween.
-    fn make_test_env() -> (World, Entity, SystemId) {
+    fn make_test_env() -> (World, Entity) {
         let mut world = World::new();
         world.init_resource::<Events<CycleCompletedEvent>>();
         let entity = world.spawn(Transform::default()).id();
-        let system_id = world.register_system(oneshot_test);
-        (world, entity, system_id)
+        (world, entity)
     }
 
-    /// one-shot system to be used for testing
-    fn oneshot_test() {}
-
     /// Manually tick a test tweenable targeting a component.
     fn manual_tick_component(
         tween_id: Entity,
@@ -1572,14 +1491,7 @@ mod tests {
                             target: world_target,
                         });
                     };
-                    let mut queue_system = |_: SystemId| {};
-                    tween.step(
-                        tween_id,
-                        duration,
-                        target.reborrow(),
-                        &mut notify_completed,
-                        &mut queue_system,
-                    )
+                    tween.step(tween_id, duration, target.reborrow(), &mut notify_completed)
                 } else {
                     TweenState::Completed
                 }
@@ -1698,15 +1610,10 @@ mod tests {
                     tween.set_elapsed(backward_start_time);
                 }
 
-                let (mut world, entity, system_id) = make_test_env();
+                let (mut world, entity) = make_test_env();
                 let mut event_reader_system_state: SystemState<EventReader<CycleCompletedEvent>> =
                     SystemState::new(&mut world);
 
-                // Activate oneshot system
-                tween.set_completed_system(system_id);
-                assert!(tween.system_id.is_some());
-                assert_eq!(tween.system_id.unwrap(), system_id);
-
                 // Loop over 2.2 seconds, so greater than one ping-pong loop (2 cycles in
                 // MirroredRepeat)
                 let tick_duration = Duration::from_millis(200);
@@ -2003,10 +1910,6 @@ mod tests {
                 // Clear event sending
                 tween.set_completed_event(false);
                 assert!(!tween.send_completed_event);
-
-                // Clear oneshot system
-                tween.clear_completed_system();
-                assert!(tween.system_id.is_none());
             }
         }
     }
@@ -2037,7 +1940,7 @@ mod tests {
         tween.set_playback_direction(PlaybackDirection::Backward);
         assert_eq!(tween.elapsed(), d300);
 
-        let (mut world, entity, _system_id) = make_test_env();
+        let (mut world, entity) = make_test_env();
 
         // Progress always increases alongside the current direction
         tween.set_playback_direction(PlaybackDirection::Backward);
@@ -2095,7 +1998,7 @@ mod tests {
         );
         let mut seq = tween1.then(tween2);
 
-        let (mut world, entity, _system_id) = make_test_env();
+        let (mut world, entity) = make_test_env();
 
         for i in 1..=16 {
             let state = manual_tick_component(
@@ -2144,7 +2047,7 @@ mod tests {
             .with_repeat_count(RepeatCount::Finite(1))
         }));
 
-        let (mut world, entity, _system_id) = make_test_env();
+        let (mut world, entity) = make_test_env();
 
         // Tick halfway through the first tween, then in one tick:
         // - Finish the first tween
@@ -2368,7 +2271,7 @@ mod tests {
         }
 
         // Dummy world and event writer
-        let (mut world, entity, _system_id) = make_test_env();
+        let (mut world, entity) = make_test_env();
 
         let mut time = Duration::ZERO;
         for i in 1..=6 {
@@ -2464,7 +2367,7 @@ mod tests {
 
         assert_eq!(Duration::ZERO, tween.elapsed());
 
-        let (mut world, entity, _system_id) = make_test_env();
+        let (mut world, entity) = make_test_env();
 
         let mut time = Duration::ZERO;
 
@@ -2541,7 +2444,7 @@ mod tests {
 
         assert_eq!(Duration::ZERO, tween.elapsed());
 
-        let (mut world, entity, _system_id) = make_test_env();
+        let (mut world, entity) = make_test_env();
 
         // 10%
         let dt = Duration::from_millis(100);

From 8ebb665dfe67daaa9a5e3c9362dd39244820648e Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 19 Jul 2025 16:31:02 +0200
Subject: [PATCH 45/66] Fix doctest

---
 src/lib.rs       | 98 +++++++++++++++++++++++++++---------------------
 src/tweenable.rs | 52 ++-----------------------
 2 files changed, 58 insertions(+), 92 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 8c15dc8..db0dca5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -183,30 +183,35 @@
 //! [`TweenAnimator::add_component()`] or [`TweenAnimator::add_asset()`].
 //!
 //! ```no_run
-//! # use bevy::prelude::*;
+//! # use bevy::{prelude::*, ecs::component::Components};
 //! # use bevy_tweening::*;
-//! # fn xxx() -> Option<()> {
-//! # let mut animator = TweenAnimator::default();
-//! # let entity = Entity::PLACEHOLDER;
-//! # let world = World::default();
-//! # let components = world.components();
 //! # fn make_tween() -> Tween { unimplemented!() }
-//! // Create a tween animation description
-//! let tween: Tween = make_tween();
-//! // Enqueue a new component animation instance
-//! let tween_id = animator.add_component(components, entity, tween);
-//! # None }
+//! fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
+//! # let entity = Entity::PLACEHOLDER;
+//!     let entity = commands.spawn(Transform::default()).id();
+//!     let target = ComponentAnimTarget::new::<Transform>(components, entity)?;
+//!     // Place the TweenAnim on the same entity as the target component:
+//!     let tween: Tween = make_tween();
+//!     commands
+//!         .entity(entity)
+//!         .insert(TweenAnim::new(target, tween));
+//!     // ---OR---
+//!     // Place it on its own entity
+//!     let tween: Tween = make_tween();
+//!     commands.spawn(TweenAnim::new(target, tween));
+//!     Ok(())
+//! }
 //! ```
 //!
-//! After that, you can use the [`Entity`] to control the animation playback:
+//! After that, you can use the [`TweenAnim`] component to control the animation
+//! playback:
 //!
 //! ```no_run
+//! # use bevy::prelude::Single;
 //! # use bevy_tweening::*;
-//! # fn xxx() -> Option<()> {
-//! # let mut animator = TweenAnimator::default();
-//! # let tween_id = Entity::default();
-//! animator.get_mut(tween_id)?.speed = 0.8; // 80% playback speed
-//! # None }
+//! fn my_system(mut anim: Single<&mut TweenAnim>) {
+//!     anim.speed = 0.8; // 80% playback speed
+//! }
 //! ```
 //!
 //! ## Lenses
@@ -829,7 +834,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
             entity: self.id(),
         };
         self.world_scope(|world: &mut World| {
-            world.spawn(TweenAnim::new(target.into(), Box::new(tweenable)));
+            world.spawn(TweenAnim::new(target, tweenable));
         });
         self
     }
@@ -1351,18 +1356,26 @@ pub struct TweenAnim {
 impl TweenAnim {
     /// Create a new tween animation.
     ///
+    /// This components represents the runtime animation being played to mutate
+    /// a specific target.
+    ///
     /// # Panics
     ///
     /// Panics if the tweenable is "typeless", that is [`Tweenable::type_id()`]
-    /// returns `None`. Root animations enqueued in the [`TweenAnimator`] must
-    /// target a concrete component or asset type. This means in particular
-    /// that you can't insert a single [`Delay`]. You can however use a
-    /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
-    /// provided there's at least one other typed tweenable in the sequence.
-    fn new(target: AnimTarget, tweenable: BoxedTweenable) -> Self {
+    /// returns `None`. Animations must target a concrete component or asset
+    /// type. This means in particular that you can't insert a single
+    /// [`Delay`]. You can however use a [`Delay`] or other typeless
+    /// tweenables as part of a [`Sequence`], provided there's at least one
+    /// other typed tweenable in the sequence.
+    #[inline]
+    pub fn new(target: impl Into<AnimTarget>, tweenable: impl Tweenable + 'static) -> Self {
+        assert!(
+            tweenable.type_id().is_some(),
+            "The top-level Tweenable of a TweenAnim must be typed (type_id() returns Some)."
+        );
         Self {
-            target,
-            tweenable,
+            target: target.into(),
+            tweenable: Box::new(tweenable),
             playback_state: PlaybackState::Playing,
             speed: 1.,
             destroy_on_completion: true,
@@ -1507,34 +1520,33 @@ impl TweenAnim {
         self.tweenable.as_ref()
     }
 
-    /// Swap a queued animation.
+    /// Set a new animation description.
     ///
     /// Attempt to change the tweenable of an animation already enqueued, and
     /// possibly already playing.
     ///
     /// If the tweenable is successfully swapped, this resets the
-    /// [`TweenAnim::tween_state()`] to [`TweenState::Active`], even if the
-    /// tweenable would otherwise be completed _e.g._ because its elapsed time
-    /// is past its total duration. Conversely, this doesn't update the
-    /// target, as this function doesn't have mutable access to it.
+    /// [`tween_state()`] to [`TweenState::Active`], even if the tweenable would
+    /// otherwise be completed _e.g._ because its elapsed time is past its
+    /// total duration. Conversely, this doesn't update the target component or
+    /// asset, as this function doesn't have mutable access to it.
     ///
     /// To ensure the old and new animations have the same elapsed time (for
-    /// example if they need to be synchronized), call [`set_elapsed()`] first
-    /// on the input `tweenable`, with the duration value of the old tweenable
-    /// as returned by [`elapsed()`].
+    /// example if they need to be synchronized, if they're variants of each
+    /// other), call [`set_elapsed()`] first on the input `tweenable`, with
+    /// the duration value of the old tweenable returned by [`elapsed()`].
     ///
     /// ```
     /// # use std::time::Duration;
-    /// # use slotmap::Key as _;
     /// # use bevy::prelude::*;
     /// # use bevy_tweening::*;
-    /// # fn sys(mut animator: ResMut<TweenAnimator>) {
-    /// # let id = Entity::PLACEHOLDER;
-    /// # let mut tweenable = Delay::new(Duration::from_secs(1));
-    /// let elapsed = animator.get(id).unwrap().tweenable().elapsed();
-    /// tweenable.set_elapsed(elapsed);
-    /// animator.set_tweenable(id, tweenable);
-    /// # }
+    /// # fn make_tweenable() -> Tween { unimplemented!() }
+    /// fn my_system(mut anim: Single<&mut TweenAnim>) {
+    ///     let mut tweenable = make_tweenable();
+    ///     let elapsed = anim.tweenable().elapsed();
+    ///     tweenable.set_elapsed(elapsed);
+    ///     anim.set_tweenable(tweenable);
+    /// }
     /// ```
     ///
     /// To recompute the actual tweenable animation state and force a target
@@ -1544,6 +1556,7 @@ impl TweenAnim {
     ///
     /// On success, returns the previous tweenable which has been swapped out.
     ///
+    /// [`tween_state()`]: Self::tween_state
     /// [`set_elapsed()`]: crate::Tweenable::set_elapsed
     /// [`elapsed()`]: crate::Tweenable::elapsed
     /// [`step_one()`]: Self::step_one
@@ -2126,7 +2139,6 @@ pub(crate) struct StepResult {
 //     ///
 //     /// ```
 //     /// # use std::time::Duration;
-//     /// # use slotmap::Key as _;
 //     /// # use bevy::prelude::*;
 //     /// # use bevy_tweening::*;
 //     /// # fn sys(mut animator: ResMut<TweenAnimator>) {
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 88820ec..3cc6f9d 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1,9 +1,6 @@
 use std::{any::TypeId, cmp::Ordering, time::Duration};
 
-use bevy::{
-    ecs::{change_detection::MutUntyped, system::SystemId},
-    prelude::*,
-};
+use bevy::{ecs::change_detection::MutUntyped, prelude::*};
 
 use crate::{AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy};
 
@@ -29,7 +26,7 @@ use crate::{AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, Repeat
 /// # use std::{any::TypeId, time::Duration};
 /// # use bevy::ecs::{system::{Commands, SystemId}, change_detection::MutUntyped};
 /// # use bevy::prelude::*;
-/// # use bevy_tweening::{BoxedTweenable, Sequence, Entity, Tweenable, CycleCompletedEvent, TweenState, TotalDuration};
+/// # use bevy_tweening::{BoxedTweenable, Sequence, Tweenable, CycleCompletedEvent, TweenState, TotalDuration};
 /// #
 /// # #[derive(Debug)]
 /// # struct MyTweenable;
@@ -38,7 +35,7 @@ use crate::{AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, Repeat
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
-/// #     fn step(&mut self, _tween_id: Entity, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut(), queue_system: &mut dyn FnMut(SystemId)) -> TweenState  { unimplemented!() }
+/// #     fn step(&mut self, _tween_id: Entity, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut()) -> TweenState  { unimplemented!() }
 /// #     fn rewind(&mut self) { unimplemented!() }
 /// #     fn cycles_completed(&self) -> u32 { unimplemented!() }
 /// #     fn cycle_fraction(&self) -> f32 { unimplemented!() }
@@ -1175,7 +1172,6 @@ impl Tweenable for Sequence {
 #[derive(Debug)]
 pub struct Delay {
     timer: Timer,
-    system_id: Option<SystemId>,
 }
 
 impl Delay {
@@ -1196,51 +1192,9 @@ impl Delay {
         assert!(!duration.is_zero());
         Self {
             timer: Timer::new(duration, TimerMode::Once),
-            system_id: None,
         }
     }
 
-    /// Enable running a one-shot system upon completion.
-    ///
-    /// If enabled, the tween will run a system via a provided [`SystemId`] when
-    /// the animation completes. This is similar to the
-    /// [`with_completed_event()`], but uses a system registered by
-    /// [`register_system()`] instead.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy_tweening::{lens::*, *};
-    /// # use bevy::{ecs::event::EventReader, math::{Vec3, curve::EaseFunction}, ecs::world::World, ecs::system::Query, ecs::entity::Entity};
-    /// # use std::time::Duration;
-    /// let mut world = World::new();
-    /// let test_system_system_id = world.register_system(test_system);
-    /// let tween = Tween::new(
-    ///     // [...]
-    /// #    EaseFunction::QuadraticInOut,
-    /// #    Duration::from_secs(1),
-    /// #    TransformPositionLens {
-    /// #        start: Vec3::ZERO,
-    /// #        end: Vec3::new(3.5, 0., 0.),
-    /// #    },
-    /// )
-    /// .with_completed_system(test_system_system_id);
-    ///
-    /// fn test_system(query: Query<Entity>) {
-    ///    for entity in query.iter() {
-    ///       println!("Found an Entity!");
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// [`with_completed_event()`]: crate::Tween::with_completed_event
-    /// [`register_system()`]: bevy::ecs::world::World::register_system
-    #[must_use]
-    pub fn with_completed_system(mut self, system_id: SystemId) -> Self {
-        self.system_id = Some(system_id);
-        self
-    }
-
     /// Check if the delay completed.
     pub fn is_completed(&self) -> bool {
         self.timer.finished()

From 9cbb28be0932d82afb870490c85983593f1b3187 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 20 Jul 2025 08:41:12 +0200
Subject: [PATCH 46/66] Add `tween_target()`

---
 examples/sequence.rs |  59 ++++++++++++---------
 src/lib.rs           | 120 +++++++++++++++++++++++++++++++++++++++----
 src/test_utils.rs    |   2 +-
 3 files changed, 147 insertions(+), 34 deletions(-)

diff --git a/examples/sequence.rs b/examples/sequence.rs
index 191a4be..95aa515 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -33,21 +33,25 @@ struct BlueProgress;
 struct RedSprite {
     /// ID of the tween making the red sprite move along a path around the
     /// screen.
-    pub path_tween_id: Entity,
+    #[allow(unused)]
+    pub path_id: Entity,
     /// ID of the tween making the red sprite rotate on itself back and forth.
     #[allow(unused)]
-    pub rotate_tween_id: Entity,
+    pub rotate_id: Entity,
 }
 
 #[derive(Component)]
 struct BlueSprite {
     /// ID of the tween making the blue sprite move along a path, then rotate.
-    pub move_and_rotate_tween_id: Entity,
+    pub move_and_rotate_id: Entity,
     /// ID of the tween making the blue sprite scale.
     #[allow(unused)]
-    pub scale_tween_id: Entity,
+    pub scale_id: Entity,
 }
 
+#[derive(Component)]
+struct RedAnimMarker;
+
 #[derive(Component)]
 struct ProgressValue;
 
@@ -55,7 +59,6 @@ fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
     components: &Components,
-    mut animator: ResMut<TweenAnimator>,
 ) -> Result<()> {
     commands.spawn(Camera2d::default());
 
@@ -151,8 +154,6 @@ fn setup(
                     end: pair[1] - center,
                 },
             )
-            // Get an event after each segment
-            //.with_completed_event(index as u64),
         }));
 
         // Rotate over self, forever. This will continue even after the move along path
@@ -169,14 +170,24 @@ fn setup(
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
         // Because we want to monitor the progress of the animations, we need to fetch
-        // their Entity. This requires inserting them manually in the TweenAnimator
-        // resource, instead of using the extensions of EntityCommands.
-        let path_tween_id = animator.add_component(components, entity, anim_move_along_path)?;
-        let rotate_tween_id =
-            animator.add_component(components, entity, anim_rotate_back_and_forth)?;
+        // their Entity. There's essentially two possibilities for this.
+        // 1) Spawn a new entity, which here we augment with a marker component to
+        //    identify it later, and call tween_target() to spawn the TweenAnim an
+        //    automatically make it target the given entity.
+        let path_tween_id = commands
+            // Spawns (RedAnimMarker, TweenAnim) on same entity
+            .spawn(RedAnimMarker)
+            .tween_target(entity, anim_move_along_path)
+            .id();
+        // 2) Alternatively, we can manually create the TweenAnim with for_component(),
+        //    and insert it like any other component.
+        let anim = TweenAnim::for_component(components, entity, anim_rotate_back_and_forth)?;
+        let rotate_tween_id = commands.spawn(anim).id();
+        // Then we save both entities into RedSprite. We don't really need the first one
+        // since we have the RedAnimMarker component too.
         commands.entity(entity).insert(RedSprite {
-            path_tween_id,
-            rotate_tween_id,
+            path_id: path_tween_id,
+            rotate_id: rotate_tween_id,
         });
     }
 
@@ -218,7 +229,7 @@ fn setup(
                 start: Vec3::new(-200., 100., 0.),
                 end: Vec3::new(200., 100., 0.),
             },
-        ); //.with_completed_event(99); // Get an event once move completed
+        );
 
         let tween_delay = Delay::new(move_duration);
 
@@ -249,11 +260,11 @@ fn setup(
         // Because we want to monitor the progress of the animations, we need to fetch
         // their Entity. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
-        let move_and_rotate_tween_id = animator.add_component(components, entity, seq1)?;
-        let scale_tween_id = animator.add_component(components, entity, seq2)?;
+        let move_and_rotate_id = commands.spawn_empty().tween_target(entity, seq1).id();
+        let scale_id = commands.spawn_empty().tween_target(entity, seq2).id();
         commands.entity(entity).insert(BlueSprite {
-            move_and_rotate_tween_id,
-            scale_tween_id,
+            move_and_rotate_id,
+            scale_id,
         });
     }
 
@@ -261,23 +272,23 @@ fn setup(
 }
 
 fn update_text(
-    animator: Res<TweenAnimator>,
     red_text_children: Single<&Children, With<RedProgress>>,
     blue_text_children: Single<&Children, With<BlueProgress>>,
     mut q_textspans: Query<&mut TextSpan, With<ProgressValue>>,
-    q_anim_red: Query<&RedSprite>,
+    q_tween_anims: Query<&TweenAnim>,
+    q_anim_red: Single<Option<&TweenAnim>, With<RedAnimMarker>>,
     q_anim_blue: Query<&BlueSprite>,
     mut q_event_completed: EventReader<CycleCompletedEvent>,
 ) {
-    let anim_red = q_anim_red.single().unwrap();
-    let progress_red = if let Some(anim) = animator.get(anim_red.path_tween_id) {
+    let anim_red = *q_anim_red;
+    let progress_red = if let Some(anim) = anim_red {
         anim.tweenable().cycle_fraction()
     } else {
         1.
     };
 
     let anim_blue = q_anim_blue.single().unwrap();
-    let progress_blue = if let Some(anim) = animator.get(anim_blue.move_and_rotate_tween_id) {
+    let progress_blue = if let Ok(anim) = q_tween_anims.get(anim_blue.move_and_rotate_id) {
         anim.tweenable().cycle_fraction()
     } else {
         1.
diff --git a/src/lib.rs b/src/lib.rs
index db0dca5..a1598c9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -554,12 +554,13 @@ impl std::ops::Not for PlaybackDirection {
 /// build time. To avoid a panic, prefer manually queuing a new tweenable
 /// animation through the [`TweenAnimator`].
 pub trait EntityWorldMutTweeningExtensions<'a> {
-    /// Queue the given [`Tweenable`].
+    /// Queue the given [`Tweenable`] to animate the current entity.
     ///
-    /// This calls [`TweenAnimator::add_component()`] on the current entity,
-    /// deriving the proper component to animate based on the type of the
-    /// lens stored inside the tweenable (see [`Tweenable::type_id()`]). That
-    /// component must exists on the entity.
+    /// This inserts a new [`TweenAnim`] on a newly spawned entity, which
+    /// animates the current entity. The proper component to animate on the
+    /// current entity is based on the type of the lens stored inside the
+    /// tweenable (see [`Tweenable::type_id()`]). That component must exists
+    /// on the current entity.
     ///
     /// # Example
     ///
@@ -578,12 +579,50 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///         end: Vec3::new(3.5, 0., 0.),
     ///     },
     /// );
+    /// // Spawn Transform on a first entity, and TweenAnim on a second one,
+    /// // animating the Transform one.
     /// commands.spawn(Transform::default()).tween(tween);
     /// ```
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
     where
         T: Tweenable + 'static;
 
+    /// Queue the given [`Tweenable`] to animate a target entity.
+    ///
+    /// This inserts a new [`TweenAnim`] on the current entity, which
+    /// animates a given target entity. The proper component to animate on the
+    /// target entity is based on the type of the lens stored inside the
+    /// tweenable (see [`Tweenable::type_id()`]). That component must exists
+    /// on the target entity.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::{*, lens::TransformPositionLens};
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// #[derive(Component)]
+    /// struct AnimMarker;
+    ///
+    /// let tween = Tween::new(
+    ///     EaseFunction::QuadraticIn,
+    ///     Duration::from_secs(1),
+    ///     TransformPositionLens {
+    ///         start: Vec3::ZERO,
+    ///         end: Vec3::new(3.5, 0., 0.),
+    ///     },
+    /// );
+    /// let target = commands.spawn(Transform::default()).id();
+    /// // Spawn (AnimMarker, TweenAnim) on a new entity
+    /// commands.spawn(AnimMarker).tween_target(target, tween);
+    /// ```
+    fn tween_target<T>(&mut self, entity: Entity, tweenable: T) -> &mut Self
+    where
+        T: Tweenable + 'static;
+
     /// Queue a new tween animation to move the current entity.
     ///
     /// The entity must have a [`Transform`] component. The tween animation will
@@ -756,6 +795,16 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
         })
     }
 
+    #[inline]
+    fn tween_target<T>(&mut self, entity: Entity, tweenable: T) -> &mut EntityCommands<'a>
+    where
+        T: Tweenable + 'static,
+    {
+        self.queue(move |mut this: EntityWorldMut| {
+            this.tween_target(entity, tweenable);
+        })
+    }
+
     #[inline]
     fn move_to(
         &mut self,
@@ -823,7 +872,16 @@ impl<'a> EntityWorldMutTargetExtensions<'a> for EntityWorldMut<'a> {
 }
 
 impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
+    #[inline]
     fn tween<T>(&mut self, tweenable: T) -> &mut Self
+    where
+        T: Tweenable + 'static,
+    {
+        let entity = self.id();
+        self.tween_target(entity, tweenable)
+    }
+
+    fn tween_target<T>(&mut self, entity: Entity, tweenable: T) -> &mut Self
     where
         T: Tweenable + 'static,
     {
@@ -831,11 +889,9 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         let component_id = self.world().components().get_id(type_id).unwrap();
         let target = ComponentAnimTarget {
             component_id,
-            entity: self.id(),
+            entity,
         };
-        self.world_scope(|world: &mut World| {
-            world.spawn(TweenAnim::new(target, tweenable));
-        });
+        self.insert(TweenAnim::new(target, tweenable));
         self
     }
 
@@ -1383,6 +1439,52 @@ impl TweenAnim {
         }
     }
 
+    /// Create a new tweenable animation for a specific component target.
+    ///
+    /// This is a convenience helper which builds a [`ComponentAnimTarget`] then
+    /// calls [`new()`] with it. It's often useful in cases where you want to
+    /// manually insert the [`TweenAnim`] component to save its [`Entity`] so
+    /// you can reference it later, typically to control playback. Otherwise,
+    /// prefer using [`.tween()`] or similar to automatically create the
+    /// component and insert it.
+    ///
+    /// Note that the target component type is automically derived from the
+    /// input `tweenable`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::any::TypeId;
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// # fn make_tween() -> Tween { unimplemented!() }
+    /// fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
+    ///     // Get the entity holding the target component to animate. It doesn't need
+    ///     // to be spawned here, it only needs to exist.
+    ///     let target_entity = commands.spawn(Transform::default()).id();
+    ///     // Create the animation
+    ///     let tween = make_tween();
+    ///     let anim = TweenAnim::for_component(components, target_entity, tween)?;
+    ///     // Spawn the TweenAnim component on a new, separate Entity, and record that
+    ///     // Entity for later reference.
+    ///     let anim_entity = commands.spawn(anim).id();
+    ///     // [...]
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// [`new()`]: Self::new
+    /// [`.tween()`]: crate::EntityWorldMutTweeningExtensions::tween
+    pub fn for_component(
+        components: &Components,
+        target: Entity,
+        tweenable: impl Tweenable + 'static,
+    ) -> Result<Self, TweeningError> {
+        let type_id = tweenable.type_id().ok_or(TweeningError::UntypedTweenable)?;
+        let target = ComponentAnimTarget::new_untyped(components, type_id, target)?;
+        Ok(Self::new(target, tweenable))
+    }
+
     pub(crate) fn step(
         &mut self,
         mut commands: Commands,
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 35dc1c4..ea739ad 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -148,7 +148,7 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
         let target = ComponentAnimTarget::new::<T>(world.components(), entity).unwrap();
         world
             .entity_mut(entity)
-            .insert(TweenAnim::new(target.into(), Box::new(tweenable)));
+            .insert(TweenAnim::new(target, tweenable));
 
         Self {
             world,

From 6b60b626860474abf6d712bd8f0e2e54b1b1b22b Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 20 Jul 2025 09:12:38 +0200
Subject: [PATCH 47/66] Add `tween_asset()` and fix examples

---
 examples/colormaterial_color.rs   | 24 +++++------
 examples/transform_rotation.rs    |  4 +-
 examples/transform_translation.rs |  4 +-
 examples/ui_position.rs           |  4 +-
 src/lib.rs                        | 72 +++++++++++++++++++++++++++++++
 5 files changed, 89 insertions(+), 19 deletions(-)

diff --git a/examples/colormaterial_color.rs b/examples/colormaterial_color.rs
index 8804076..e688bab 100644
--- a/examples/colormaterial_color.rs
+++ b/examples/colormaterial_color.rs
@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use bevy::{color::palettes::css::*, ecs::component::Components, prelude::*};
+use bevy::{color::palettes::css::*, prelude::*};
 use bevy_tweening::{lens::*, *};
 
 mod utils;
@@ -23,12 +23,10 @@ fn main() {
 }
 
 fn setup(
-    components: &Components,
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
-    mut animator: ResMut<TweenAnimator>,
-) {
+) -> Result<(), BevyError> {
     commands.spawn(Camera2d::default());
 
     let size = 80.;
@@ -90,15 +88,13 @@ fn setup(
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        if let Err(err) = animator.add_asset(components, unique_material.id(), tween) {
-            println!("Failed to add asset animation: {err:?}");
-        }
-
-        commands.spawn((
-            Mesh2d(quad_mesh.clone()),
-            MeshMaterial2d(unique_material),
-            Transform::from_translation(Vec3::new(x, y, 0.)).with_scale(Vec3::splat(size)),
-        ));
+        commands
+            .spawn((
+                Mesh2d(quad_mesh.clone()),
+                MeshMaterial2d(unique_material.clone()),
+                Transform::from_translation(Vec3::new(x, y, 0.)).with_scale(Vec3::splat(size)),
+            ))
+            .tween_asset(&unique_material, tween);
 
         y -= size * spacing;
         if y < -screen_y {
@@ -106,4 +102,6 @@ fn setup(
             y = screen_y;
         }
     }
+
+    Ok(())
 }
diff --git a/examples/transform_rotation.rs b/examples/transform_rotation.rs
index 28e6934..cf1375b 100644
--- a/examples/transform_rotation.rs
+++ b/examples/transform_rotation.rs
@@ -121,12 +121,12 @@ fn setup(mut commands: Commands) {
     }
 }
 
-fn update_animation_speed(options: Res<Options>, mut animators: ResMut<TweenAnimator>) {
+fn update_animation_speed(options: Res<Options>, mut q_anims: Query<&mut TweenAnim>) {
     if !options.is_changed() {
         return;
     }
 
-    for (_id, anim) in animators.iter_mut() {
+    for mut anim in &mut q_anims {
         anim.speed = options.speed;
     }
 }
diff --git a/examples/transform_translation.rs b/examples/transform_translation.rs
index 8b73c12..33204d2 100644
--- a/examples/transform_translation.rs
+++ b/examples/transform_translation.rs
@@ -110,12 +110,12 @@ fn setup(mut commands: Commands) {
     }
 }
 
-fn update_animation_speed(options: Res<Options>, mut animators: ResMut<TweenAnimator>) {
+fn update_animation_speed(options: Res<Options>, mut q_anims: Query<&mut TweenAnim>) {
     if !options.is_changed() {
         return;
     }
 
-    for (_id, anim) in animators.iter_mut() {
+    for mut anim in &mut q_anims {
         anim.speed = options.speed;
     }
 }
diff --git a/examples/ui_position.rs b/examples/ui_position.rs
index c175926..f98829b 100644
--- a/examples/ui_position.rs
+++ b/examples/ui_position.rs
@@ -131,12 +131,12 @@ fn setup(mut commands: Commands) {
     }
 }
 
-fn update_animation_speed(options: Res<Options>, mut animators: ResMut<TweenAnimator>) {
+fn update_animation_speed(options: Res<Options>, mut q_anims: Query<&mut TweenAnim>) {
     if !options.is_changed() {
         return;
     }
 
-    for (_id, anim) in animators.iter_mut() {
+    for mut anim in &mut q_anims {
         anim.speed = options.speed;
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index a1598c9..d43e40f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -623,6 +623,45 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     where
         T: Tweenable + 'static;
 
+    /// Queue the given [`Tweenable`] to animate a target asset.
+    ///
+    /// This inserts a new [`TweenAnim`] on the current entity, which
+    /// animates a given target asset. The asset type to animate  is validated
+    /// against the one on the type of the lens stored inside the
+    /// tweenable (see [`Tweenable::type_id()`]).
+    ///
+    /// # Panics
+    ///
+    /// This call panics, or queue a command which later panics, if the type of
+    /// the asset `A` is different from the type the `tweenable` is referencing
+    /// through its [`Lens`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::{*, lens::TransformPositionLens};
+    /// # use std::time::Duration;
+    /// # fn make_tween() -> Tween { unimplemented!() }
+    /// #[derive(Asset)]
+    /// struct MyAsset;
+    ///
+    /// #[derive(Component)]
+    /// struct MyAssetRef(pub Handle<MyAsset>);
+    ///
+    /// fn my_system(mut commands: Commands, asset_server: Res<AssetServer>) {
+    ///     let handle: Handle<MyAsset> = asset_server.load("my_asset");
+    ///     let tween = make_tween();
+    ///     // Spawn (MyAssetRef, TweenAnim) on a new entity
+    ///     commands
+    ///         .spawn(MyAssetRef(handle.clone()))
+    ///         .tween_asset(&handle, tween);
+    /// }
+    /// ```
+    fn tween_asset<A: Asset, T>(&mut self, id: impl Into<AssetId<A>>, tweenable: T) -> &mut Self
+    where
+        T: Tweenable + 'static;
+
     /// Queue a new tween animation to move the current entity.
     ///
     /// The entity must have a [`Transform`] component. The tween animation will
@@ -805,6 +844,16 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
         })
     }
 
+    fn tween_asset<A: Asset, T>(&mut self, id: impl Into<AssetId<A>>, tweenable: T) -> &mut Self
+    where
+        T: Tweenable + 'static,
+    {
+        let id = id.into();
+        self.queue(move |mut entity: EntityWorldMut| {
+            entity.tween_asset(id, tweenable);
+        })
+    }
+
     #[inline]
     fn move_to(
         &mut self,
@@ -895,6 +944,29 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         self
     }
 
+    fn tween_asset<A: Asset, T>(&mut self, id: impl Into<AssetId<A>>, tweenable: T) -> &mut Self
+    where
+        T: Tweenable + 'static,
+    {
+        let asset_id = id.into().untyped();
+        let type_id = tweenable.type_id().unwrap();
+        assert_eq!(type_id, TypeId::of::<A>());
+
+        self.world_scope(|world| {
+            world.resource_scope(|world: &mut World, mut resolver: Mut<TweenResolver>| {
+                resolver.register_scoped_for::<A>(world.components());
+            });
+        });
+
+        let resource_id = self.world().resource_id::<Assets<A>>().unwrap();
+        let target = AssetAnimTarget {
+            resource_id,
+            asset_id,
+        };
+        self.insert(TweenAnim::new(target, tweenable));
+        self
+    }
+
     #[inline]
     fn move_to(
         &mut self,

From dc86388b844cca588acc90ab09fd2fd6a63c55bf Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 20 Jul 2025 09:46:01 +0200
Subject: [PATCH 48/66] Fix observer triggering on TweenAnim entity

---
 examples/menu.rs | 116 ++++++++++++++++++++++++------------------
 src/lib.rs       | 130 ++++++++++++++++++++---------------------------
 src/plugin.rs    |  18 +++----
 src/tweenable.rs |  18 +++++++
 4 files changed, 149 insertions(+), 133 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index 19ba0e5..d967257 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -10,19 +10,25 @@ const NORMAL_COLOR: Color = Color::srgba(162. / 255., 226. / 255., 95. / 255., 1
 const HOVER_COLOR: Color = Color::Srgba(AZURE);
 const CLICK_COLOR: Color = Color::Srgba(ALICE_BLUE);
 const TEXT_COLOR: Color = Color::srgba(83. / 255., 163. / 255., 130. / 255., 1.);
-const INIT_TRANSITION_DONE: u64 = 1;
 
-/// The menu in this example has two set of animations:
-/// one for appearance, one for interaction. Interaction animations
-/// are only enabled after appearance animations finished.
+#[derive(Component)]
+struct InitialAnimMarker;
+
+/// The menu in this example has two set of animations: one for appearance, one
+/// for interaction. Interaction animations are only enabled after appearance
+/// animations finished.
 ///
 /// The logic is handled as:
-/// 1. Appearance animations send a `TweenComplete` event with
-/// `INIT_TRANSITION_DONE` 2. The `enable_interaction_after_initial_animation`
-/// system adds a label component `InitTransitionDone` to any button component
-/// which completed its appearance animation, to mark it as active.
-/// 3. The `interaction` system only queries buttons with a `InitTransitionDone`
-/// marker.
+/// 1. Appearance animations send an `AnimCompletedEvent`
+/// 2. The `enable_interaction_after_initial_animation()` system adds a marker
+///    component `InitTransitionDone` to any button component which completed
+///    its appearance animation, to mark it as active.
+/// 3. The `interaction()` system only queries buttons with a
+///    `InitTransitionDone` marker.
+///
+/// For simplicity step 2. is handled via an observer. Note that the observer is
+/// on the Entity which owns the TweenAnim, and not on the one owning the
+/// animated component.
 fn main() {
     App::default()
         .add_plugins((
@@ -43,7 +49,6 @@ fn main() {
         ))
         .add_systems(Update, utils::close_on_esc)
         .add_systems(Update, interaction)
-        .add_systems(Update, enable_interaction_after_initial_animation)
         .add_systems(Startup, setup)
         .run();
 }
@@ -92,41 +97,47 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 )
                 .with_completed_event(true);
 
-                let mut ec = container.spawn((
-                    Name::new(format!("button:{}", text)),
-                    Button,
-                    Node {
-                        min_width: Val::Px(300.),
-                        min_height: Val::Px(80.),
-                        margin: UiRect::all(Val::Px(8.)),
-                        padding: UiRect::all(Val::Px(8.)),
-                        align_content: AlignContent::Center,
-                        align_items: AlignItems::Center,
-                        align_self: AlignSelf::Center,
-                        justify_content: JustifyContent::Center,
-                        ..default()
-                    },
-                    BackgroundColor(NORMAL_COLOR),
-                    Transform::from_scale(Vec3::splat(0.01)),
-                    label,
-                    children![(
-                        Text::new(text.to_string()),
-                        TextFont {
-                            font: font.clone(),
-                            font_size: 48.0,
+                let target = container
+                    .spawn((
+                        Name::new(format!("button:{}", text)),
+                        Button,
+                        Node {
+                            min_width: Val::Px(300.),
+                            min_height: Val::Px(80.),
+                            margin: UiRect::all(Val::Px(8.)),
+                            padding: UiRect::all(Val::Px(8.)),
+                            align_content: AlignContent::Center,
+                            align_items: AlignItems::Center,
+                            align_self: AlignSelf::Center,
+                            justify_content: JustifyContent::Center,
                             ..default()
                         },
-                        TextColor(TEXT_COLOR),
-                        TextLayout::new_with_justify(JustifyText::Center),
-                    )],
-                ));
-
-                if start_time_ms > 0 {
+                        BackgroundColor(NORMAL_COLOR),
+                        Transform::from_scale(Vec3::splat(0.01)),
+                        label,
+                        children![(
+                            Text::new(text.to_string()),
+                            TextFont {
+                                font: font.clone(),
+                                font_size: 48.0,
+                                ..default()
+                            },
+                            TextColor(TEXT_COLOR),
+                            TextLayout::new_with_justify(JustifyText::Center),
+                        )],
+                    ))
+                    .id();
+
+                let tweenable = if start_time_ms > 0 {
                     let delay = Delay::new(Duration::from_millis(start_time_ms));
-                    ec.tween(delay.then(tween_scale));
+                    delay.then(tween_scale).into_boxed()
                 } else {
-                    ec.tween(tween_scale);
-                }
+                    tween_scale.into_boxed()
+                };
+                container
+                    .spawn(InitialAnimMarker)
+                    .observe(enable_interaction_after_initial_animation)
+                    .tween_target(target, tweenable);
 
                 start_time_ms += 500;
             }
@@ -134,15 +145,22 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 }
 
 fn enable_interaction_after_initial_animation(
+    trigger: Trigger<AnimCompletedEvent>,
     mut commands: Commands,
-    mut reader: EventReader<CycleCompletedEvent>,
+    q_names: Query<&Name>,
 ) {
-    for event in reader.read() {
-        if let AnimTarget::Component(comp_target) = &event.target {
-            commands
-                .entity(comp_target.entity)
-                .insert(InitTransitionDone);
-        }
+    if let AnimTarget::Component(comp_target) = &trigger.target {
+        // Resolve the Entity to a friendly name through the Name component. This is
+        // optional, just to make the message nicer.
+        let name = q_names
+            .get(comp_target.entity)
+            .ok()
+            .map(Into::into)
+            .unwrap_or(format!("{:?}", comp_target.entity));
+        println!("Button on entity {name} completed initial animation, activating...",);
+        commands
+            .entity(comp_target.entity)
+            .insert(InitTransitionDone);
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index d43e40f..ef9b931 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -285,8 +285,8 @@ pub use lens::Lens;
 pub use plugin::{AnimationSystem, TweeningPlugin};
 use thiserror::Error;
 pub use tweenable::{
-    BoxedTweenable, CycleCompletedEvent, Delay, Sequence, TotalDuration, Tween, TweenState,
-    Tweenable,
+    BoxedTweenable, CycleCompletedEvent, Delay, IntoBoxedTweenable, Sequence, TotalDuration, Tween,
+    TweenState, Tweenable,
 };
 
 pub mod lens;
@@ -583,9 +583,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// // animating the Transform one.
     /// commands.spawn(Transform::default()).tween(tween);
     /// ```
-    fn tween<T>(&mut self, tweenable: T) -> &mut Self
-    where
-        T: Tweenable + 'static;
+    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self;
 
     /// Queue the given [`Tweenable`] to animate a target entity.
     ///
@@ -619,9 +617,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// // Spawn (AnimMarker, TweenAnim) on a new entity
     /// commands.spawn(AnimMarker).tween_target(target, tween);
     /// ```
-    fn tween_target<T>(&mut self, entity: Entity, tweenable: T) -> &mut Self
-    where
-        T: Tweenable + 'static;
+    fn tween_target(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self;
 
     /// Queue the given [`Tweenable`] to animate a target asset.
     ///
@@ -658,9 +654,11 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///         .tween_asset(&handle, tween);
     /// }
     /// ```
-    fn tween_asset<A: Asset, T>(&mut self, id: impl Into<AssetId<A>>, tweenable: T) -> &mut Self
-    where
-        T: Tweenable + 'static;
+    fn tween_asset<A: Asset>(
+        &mut self,
+        id: impl Into<AssetId<A>>,
+        tweenable: impl IntoBoxedTweenable,
+    ) -> &mut Self;
 
     /// Queue a new tween animation to move the current entity.
     ///
@@ -825,30 +823,32 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
 
 impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
     #[inline]
-    fn tween<T>(&mut self, tweenable: T) -> &mut EntityCommands<'a>
-    where
-        T: Tweenable + 'static,
-    {
+    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut EntityCommands<'a> {
+        let tweenable = tweenable.into_boxed();
         self.queue(move |mut entity: EntityWorldMut| {
             entity.tween(tweenable);
         })
     }
 
     #[inline]
-    fn tween_target<T>(&mut self, entity: Entity, tweenable: T) -> &mut EntityCommands<'a>
-    where
-        T: Tweenable + 'static,
-    {
+    fn tween_target(
+        &mut self,
+        entity: Entity,
+        tweenable: impl IntoBoxedTweenable,
+    ) -> &mut EntityCommands<'a> {
+        let tweenable = tweenable.into_boxed();
         self.queue(move |mut this: EntityWorldMut| {
             this.tween_target(entity, tweenable);
         })
     }
 
-    fn tween_asset<A: Asset, T>(&mut self, id: impl Into<AssetId<A>>, tweenable: T) -> &mut Self
-    where
-        T: Tweenable + 'static,
-    {
+    fn tween_asset<A: Asset>(
+        &mut self,
+        id: impl Into<AssetId<A>>,
+        tweenable: impl IntoBoxedTweenable,
+    ) -> &mut Self {
         let id = id.into();
+        let tweenable = tweenable.into_boxed();
         self.queue(move |mut entity: EntityWorldMut| {
             entity.tween_asset(id, tweenable);
         })
@@ -922,18 +922,13 @@ impl<'a> EntityWorldMutTargetExtensions<'a> for EntityWorldMut<'a> {
 
 impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
     #[inline]
-    fn tween<T>(&mut self, tweenable: T) -> &mut Self
-    where
-        T: Tweenable + 'static,
-    {
+    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
         let entity = self.id();
         self.tween_target(entity, tweenable)
     }
 
-    fn tween_target<T>(&mut self, entity: Entity, tweenable: T) -> &mut Self
-    where
-        T: Tweenable + 'static,
-    {
+    fn tween_target(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self {
+        let tweenable = tweenable.into_boxed();
         let type_id = tweenable.type_id().unwrap();
         let component_id = self.world().components().get_id(type_id).unwrap();
         let target = ComponentAnimTarget {
@@ -944,10 +939,12 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         self
     }
 
-    fn tween_asset<A: Asset, T>(&mut self, id: impl Into<AssetId<A>>, tweenable: T) -> &mut Self
-    where
-        T: Tweenable + 'static,
-    {
+    fn tween_asset<A: Asset>(
+        &mut self,
+        id: impl Into<AssetId<A>>,
+        tweenable: impl IntoBoxedTweenable,
+    ) -> &mut Self {
+        let tweenable = tweenable.into_boxed();
         let asset_id = id.into().untyped();
         let type_id = tweenable.type_id().unwrap();
         assert_eq!(type_id, TypeId::of::<A>());
@@ -1023,21 +1020,19 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
 /// Event raised when a [`TweenAnim`] completed.
 #[derive(Copy, Clone, Event)]
 pub struct AnimCompletedEvent {
-    /// The ID of the tween animation which completed.
+    /// The entity owning the [`TweenAnim`] which completed.
     ///
-    /// Note that commonly the [`TweenAnim`] is pruned out of the
-    /// [`TweenAnimator`] on completion, so can't be queried anymore with
-    /// this ID. However animation IDs are unique, so this can be used to
-    /// identify the tweenable animation from an ID stored by the user. You
-    /// can prevent a completed animation from being automatically destroyed by
+    /// Note that commonly the [`TweenAnim`] is despawned on completion, so
+    /// can't be queried anymore with this entity. You can prevent a completed
+    /// animation from being automatically destroyed by
     /// setting [`TweenAnim::destroy_on_completion`] to `false`.
-    pub id: Entity,
+    pub anim_entity: Entity,
     /// The animation target.
     ///
     /// This is provided both as a convenience for [`TweenAnim`]s not destroyed
-    /// from the [`TweenAnimator`] on completion, and because for those
-    /// animations which are destroyed on completion the information is not
-    /// available anymore when this event is received.
+    /// on completion, and because for those animations which are destroyed
+    /// on completion the information is not available anymore when this
+    /// event is received.
     pub target: AnimTarget,
 }
 
@@ -1496,14 +1491,15 @@ impl TweenAnim {
     /// tweenables as part of a [`Sequence`], provided there's at least one
     /// other typed tweenable in the sequence.
     #[inline]
-    pub fn new(target: impl Into<AnimTarget>, tweenable: impl Tweenable + 'static) -> Self {
+    pub fn new(target: impl Into<AnimTarget>, tweenable: impl IntoBoxedTweenable) -> Self {
+        let tweenable = tweenable.into_boxed();
         assert!(
             tweenable.type_id().is_some(),
             "The top-level Tweenable of a TweenAnim must be typed (type_id() returns Some)."
         );
         Self {
             target: target.into(),
-            tweenable: Box::new(tweenable),
+            tweenable,
             playback_state: PlaybackState::Playing,
             speed: 1.,
             destroy_on_completion: true,
@@ -1560,7 +1556,7 @@ impl TweenAnim {
     pub(crate) fn step(
         &mut self,
         mut commands: Commands,
-        tween_id: Entity,
+        anim_entity: Entity,
         delta_time: Duration,
         mut mut_untyped: MutUntyped,
         mut events: Mut<Events<CycleCompletedEvent>>,
@@ -1596,18 +1592,14 @@ impl TweenAnim {
         let delta_time = delta_time.mul_f64(self.speed);
 
         // Step the tweenable animation
-        let entity = self.target.as_component().map(|comp| comp.entity);
         let mut notify_completed = || {
-            completed_events.push((
-                CycleCompletedEvent {
-                    id: tween_id,
-                    target: self.target,
-                },
-                entity,
-            ));
+            completed_events.push(CycleCompletedEvent {
+                id: anim_entity,
+                target: self.target,
+            });
         };
         let state = self.tweenable.step(
-            tween_id,
+            anim_entity,
             delta_time,
             mut_untyped.reborrow(),
             &mut notify_completed,
@@ -1619,40 +1611,28 @@ impl TweenAnim {
         if !completed_events.is_empty() {
             sent_commands = true;
 
-            for (event, entity) in completed_events.drain(..) {
+            for event in completed_events.drain(..) {
                 // Send buffered event
                 events.send(event);
 
                 // Trigger all entity-scoped observers
-                if let Some(entity) = entity {
-                    commands.trigger_targets(event, entity);
-                }
+                commands.trigger_targets(event, anim_entity);
             }
         }
 
-        // // Execute one-shot systems
-        // for sys_id in queued_systems.drain(..) {
-        //     let _ = world.run_system(sys_id);
-        // }
-
         // Raise animation completed event
         if state == TweenState::Completed {
-            let event = AnimCompletedEvent {
-                id: tween_id,
+            let event: AnimCompletedEvent = AnimCompletedEvent {
+                anim_entity,
                 target: self.target,
             };
 
             // Send buffered event
             anim_events.send(event);
 
-            // Trigger all global observers
-            commands.trigger(event);
-
             // Trigger all entity-scoped observers
-            if let Some(entity) = entity {
-                sent_commands = true;
-                commands.trigger_targets(event, entity);
-            }
+            sent_commands = true;
+            commands.trigger_targets(event, anim_entity);
         }
 
         let ret = StepResult {
diff --git a/src/plugin.rs b/src/plugin.rs
index 320540f..0a18b95 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -53,13 +53,13 @@ pub(crate) fn animator_system(world: &mut World) {
             |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
                 world.resource_scope(|world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
                     let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
-                    for (entity, target) in anims.drain(..) {
-                        let ret = match target {
+                    for (anim_entity, anim_target) in anims.drain(..) {
+                        let ret = match anim_target {
                             AnimTarget::Component(comp_target) => {
                                 let (mut entities, commands) = world.entities_and_commands();
-                                if entity == comp_target.entity {
+                                if anim_entity == comp_target.entity {
                                     // The TweenAnim animates another component on the same entity
-                                    let Ok([mut ent]) = entities.get_mut([entity]) else {
+                                    let Ok([mut ent]) = entities.get_mut([anim_entity]) else {
                                         continue;
                                     };
                                     let Ok([anim, target]) =
@@ -73,7 +73,7 @@ pub(crate) fn animator_system(world: &mut World) {
                                     let mut anim = unsafe { anim.with_type::<TweenAnim>() };
                                     anim.step(
                                         commands,
-                                        entity,
+                                        anim_entity,
                                         delta_time,
                                         target,
                                         cycle_events.reborrow(),
@@ -82,7 +82,7 @@ pub(crate) fn animator_system(world: &mut World) {
                                 } else {
                                     // The TweenAnim animates a component on a different entity
                                     let Ok([mut anim, mut target]) =
-                                        entities.get_mut([entity, comp_target.entity])
+                                        entities.get_mut([anim_entity, comp_target.entity])
                                     else {
                                         continue;
                                     };
@@ -95,7 +95,7 @@ pub(crate) fn animator_system(world: &mut World) {
                                     };
                                     anim.step(
                                         commands,
-                                        entity,
+                                        anim_entity,
                                         delta_time,
                                         target,
                                         cycle_events.reborrow(),
@@ -106,7 +106,7 @@ pub(crate) fn animator_system(world: &mut World) {
                             AnimTarget::Asset(asset_target) => asset_resolver.resolve_scope(
                                 world,
                                 &asset_target,
-                                entity,
+                                anim_entity,
                                 delta_time,
                                 cycle_events.reborrow(),
                                 anim_events.reborrow(),
@@ -115,7 +115,7 @@ pub(crate) fn animator_system(world: &mut World) {
 
                         let retain = ret.map(|ret| ret.retain).unwrap_or(false);
                         if !retain {
-                            to_remove.push(entity);
+                            to_remove.push(anim_entity);
                         }
                     }
                 });
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 3cc6f9d..9153f6b 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -56,6 +56,24 @@ use crate::{AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, Repeat
 /// ```
 pub type BoxedTweenable = Box<dyn Tweenable + 'static>;
 
+/// Helper trait to accept boxed and non-boxed tweenables in various functions.
+pub trait IntoBoxedTweenable {
+    /// Convert to a [`BoxedTweenable`].
+    fn into_boxed(self) -> BoxedTweenable;
+}
+
+impl IntoBoxedTweenable for BoxedTweenable {
+    fn into_boxed(self) -> BoxedTweenable {
+        self
+    }
+}
+
+impl<T: Tweenable + 'static> IntoBoxedTweenable for T {
+    fn into_boxed(self) -> BoxedTweenable {
+        Box::new(self)
+    }
+}
+
 /// Playback state of a [`Tweenable`].
 ///
 /// This is returned by [`Tweenable::step()`] to allow the caller to execute

From 61ff5ef3ad07417b06e20871e9d78bee07a94ecb Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 24 Jul 2025 10:23:56 +0200
Subject: [PATCH 49/66] Rename `tween_target()` to `tween_component()` for
 consistency

---
 examples/menu.rs     |   2 +-
 examples/sequence.rs |   6 +-
 src/lib.rs           | 166 ++++++++++++++++++++++++++++++++-----------
 3 files changed, 128 insertions(+), 46 deletions(-)

diff --git a/examples/menu.rs b/examples/menu.rs
index d967257..887ee71 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -137,7 +137,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 container
                     .spawn(InitialAnimMarker)
                     .observe(enable_interaction_after_initial_animation)
-                    .tween_target(target, tweenable);
+                    .tween_component(target, tweenable);
 
                 start_time_ms += 500;
             }
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 95aa515..3d687e7 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -177,7 +177,7 @@ fn setup(
         let path_tween_id = commands
             // Spawns (RedAnimMarker, TweenAnim) on same entity
             .spawn(RedAnimMarker)
-            .tween_target(entity, anim_move_along_path)
+            .tween_component(entity, anim_move_along_path)
             .id();
         // 2) Alternatively, we can manually create the TweenAnim with for_component(),
         //    and insert it like any other component.
@@ -260,8 +260,8 @@ fn setup(
         // Because we want to monitor the progress of the animations, we need to fetch
         // their Entity. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
-        let move_and_rotate_id = commands.spawn_empty().tween_target(entity, seq1).id();
-        let scale_id = commands.spawn_empty().tween_target(entity, seq2).id();
+        let move_and_rotate_id = commands.spawn_empty().tween_component(entity, seq1).id();
+        let scale_id = commands.spawn_empty().tween_component(entity, seq2).id();
         commands.entity(entity).insert(BlueSprite {
             move_and_rotate_id,
             scale_id,
diff --git a/src/lib.rs b/src/lib.rs
index ef9b931..5a04b5d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -59,14 +59,15 @@
 //! commands
 //!     // Spawn an entity to animate the position of.
 //!     .spawn(Transform::default())
-//!     // Queue the tweenable animation
+//!     // Create a tweenable animation targetting the current entity.
+//!     // This spawns a TweenAnim component.
 //!     .tween(tween);
 //! # }
 //! ```
 //!
 //! This example shows the general pattern to add animations for any component
-//! or asset. Since moving the position of an object is a very common
-//! task, 🍃 Bevy Tweening provides a shortcut for it. The above example can be
+//! or asset. Since moving the position of an object is a very common task,
+//! 🍃 Bevy Tweening provides a shortcut for it. The above example can be
 //! rewritten more concicely as:
 //!
 //! ```
@@ -77,7 +78,7 @@
 //! commands
 //!     // Spawn an entity to animate the position of.
 //!     .spawn((Transform::default(),))
-//!     // Create-and-queue a new Transform::translation animation
+//!     // Create a new Transform::translation animation
 //!     .move_to(
 //!         Vec3::new(1., 2., -4.),
 //!         Duration::from_secs(1),
@@ -86,19 +87,62 @@
 //! # }
 //! ```
 //!
+//! The [`tween()`] extension is convenient for fire-and-forget animations,
+//! because it implicitly targets the current entity. However, sometimes you
+//! want to remember the [`Entity`] owning the [`TweenAnim`], or insert a marker
+//! component on it, so that you can retrieve it later to control the animation
+//! at runtime. In that case, you can use instead the [`tween_component()`]
+//! extension instead:
+//!
+//! ```
+//! # use bevy::prelude::*;
+//! # use bevy_tweening::{lens::*, *};
+//! # use std::time::Duration;
+//! # fn system(mut commands: Commands) {
+//! // Marker component to identify the TweenAnim controller.
+//! #[derive(Component)]
+//! struct AnimController;
+//!
+//! // Create a single animation (tween) to move an entity.
+//! let tween = Tween::new(
+//!     // Use a quadratic easing on both endpoints.
+//!     EaseFunction::QuadraticInOut,
+//!     // It takes 1 second to go from start to end points.
+//!     Duration::from_secs(1),
+//!     // The lens gives access to the Transform component of the Entity,
+//!     // for the TweenAnimator to animate it. It also contains the start and
+//!     // end values respectively associated with the progress ratios 0. and 1.
+//!     TransformPositionLens {
+//!         start: Vec3::ZERO,
+//!         end: Vec3::new(1., 2., -4.),
+//!     },
+//! );
+//!
+//! // The Entity with the Transform being animated.
+//! // That entity contains a single Transform component.
+//! let target_entity = commands.spawn(Transform::default()).id();
+//!
+//! // The Entity with the TweenAnim controlling the animation.
+//! // That entity contains the (AnimController, TweenAnim) components.
+//! let anim_entity = commands
+//!     .spawn(AnimController)
+//!     .tween_target(target_entity, tween)
+//!     .id();
+//! # }
+//! ```
+//!
 //! See the [`EntityWorldMutTweeningExtensions`] extension trait for the various
-//! helpers provided for common animations.
+//! helpers provided for common animations like [`move_to()`].
 //!
 //! # Ready to animate
 //!
 //! Unlike previous versions of 🍃 Bevy Tweening, **you don't need any
 //! particular system setup** aside from adding the [`TweeningPlugin`] to your
 //! [`App`]. In particular, per-component-type and per-asset-type systems are
-//! gone. Instead, the plugin adds a single system executing during the
-//! [`Update`] schedule, which calls [`TweenAnimator::step_all()`]. The
-//! [`TweenAnimator`] acts as a central hub for all queued animations, and
-//! updates them all for all components and assets at once, even for custom
-//! component and asset types.
+//! gone. Instead, the plugin adds a _single_ system executing during the
+//! [`Update`] schedule. Each [`TweenAnim`] acts as a controller for one
+//! animation, and mutates its target which can be any component or asset, even
+//! a custom one.
 //!
 //! # Tweenables
 //!
@@ -156,11 +200,12 @@
 //! last element of a sequence (for example, move to position and then rotate
 //! forever on self).
 //!
-//! # `TweenAnimator`
+//! # `TweenAnim`
 //!
-//! Bevy components and assets are animated with the [`TweenAnimator`] resource.
-//! The animator determines the component or asset to animate via an
-//! [`AnimTarget`], and accesses its field(s) using a [`Lens`].
+//! Bevy components and assets are animated with the [`TweenAnim`] component.
+//! This component acts as a controller for the animation. It determines the
+//! target component or asset to animate via an [`AnimTarget`], and accesses the
+//! field(s) of that target using a [`Lens`].
 //!
 //! - Components are animated via the [`ComponentAnimTarget`], which identifies
 //!   a component instance on an entity via the [`Entity`] itself and the
@@ -178,9 +223,34 @@
 //! then animate that copy alone.
 //!
 //! Although you generally should prefer using the various extensions on
-//! commands, like the [`.tween()`] function on entity commands, under the hood
-//! the manual process of queuing a new animation involves calling
-//! [`TweenAnimator::add_component()`] or [`TweenAnimator::add_asset()`].
+//! commands, like the [`tween()`] function on entity commands, under the hood
+//! the manual process of queuing a new animation involves spawning a
+//! [`TweenAnim`] component.
+//!
+//! ```no_run
+//! # use bevy::{prelude::*, ecs::component::Components};
+//! # use bevy_tweening::*;
+//! # fn make_tween() -> Tween { unimplemented!() }
+//! fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
+//! # let entity = Entity::PLACEHOLDER;
+//!     let entity = commands.spawn(Transform::default()).id();
+//!     let target = ComponentAnimTarget::new::<Transform>(components, entity)?;
+//!     // Place the TweenAnim on the same entity as the target component:
+//!     let tween: Tween = make_tween();
+//!     commands
+//!         .entity(entity)
+//!         .insert(TweenAnim::new(target, tween));
+//!     // ---OR---
+//!     // Place it on its own entity
+//!     let tween: Tween = make_tween();
+//!     commands.spawn(TweenAnim::new(target, tween));
+//!     Ok(())
+//! }
+//! ```
+//!
+//! For assets, you also must ensure a resolver is registered for that asset
+//! type, through [`TweenResolver::register_scoped_for()`]. Note that the
+//! [`.tween_asset()`] extension takes care of this for you.
 //!
 //! ```no_run
 //! # use bevy::{prelude::*, ecs::component::Components};
@@ -216,11 +286,11 @@
 //!
 //! ## Lenses
 //!
-//! The [`AnimTarget`] references the container (component or asset) being
+//! The [`AnimTarget`] references the target (component or asset) being
 //! animated. However, only a part of that component or asset is generally
-//! animated. To that end, the [`TweenAnimator`] accesses the field(s) to
-//! animate via a _lens_, a type that implements the [`Lens`] trait and allows
-//! mapping a container to the actual value(s) animated.
+//! animated. To that end, the [`TweenAnim`] accesses the field(s) to animate
+//! via a _lens_, a type that implements the [`Lens`] trait and allows mapping a
+//! target component or asset to the actual value(s) animated.
 //!
 //! For example, the [`TransformPositionLens`] uses a [`Transform`] component as
 //! input, and animates its [`Transform::translation`] field only, leaving the
@@ -239,10 +309,10 @@
 //!
 //! Several built-in lenses are provided in the [`lens`] module for the most
 //! commonly animated fields, like the components of a [`Transform`]. Those are
-//! provided for convenience and mainly as examples. In general 🍃 Bevy Tweening
-//! expects you to write your own lenses by implementing the trait, which as you
-//! can see above is very simple. This allows animating virtually any field of
-//! any component or asset, whether shipped with Bevy or defined by the user.
+//! provided for convenience and mainly as examples. 🍃 Bevy Tweening expects
+//! you to write your own lenses by implementing the [`Lens`] trait, which as
+//! you can see above is very simple. This allows animating virtually any field
+//! of any component or asset, whether shipped with Bevy or defined by the user.
 //!
 //! # Tweening vs. keyframed animation
 //!
@@ -261,14 +331,13 @@
 //!
 //! [`Transform::translation`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html#structfield.translation
 //! [`Entity`]: https://docs.rs/bevy/0.16.0/bevy/ecs/entity/struct.Entity.html
-//! [`Query`]: https://docs.rs/bevy/0.16.0/bevy/ecs/system/struct.Query.html
 //! [`ColorMaterial`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.ColorMaterial.html
-//! [`Sprite`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.Sprite.html
-//! [`Node`]: https://docs.rs/bevy/0.16.0/bevy/ui/struct.Node.html#structfield.position
-//! [`TextColor`]: https://docs.rs/bevy/0.16.0/bevy/text/struct.TextColor.html
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
 //! [`TransformPositionLens`]: crate::lens::TransformPositionLens
-//! [`.tween()`]: crate::EntityWorldMutTweeningExtensions::tween
+//! [`tween()`]: crate::EntityWorldMutTweeningExtensions::tween
+//! [`tween_component()`]: crate::EntityWorldMutTweeningExtensions::tween_component
+//! [`tween_asset()`]: crate::EntityWorldMutTweeningExtensions::tween_asset
+//! [`move_to()`]: crate::EntityWorldMutTweeningExtensions::move_to
 
 use std::{any::TypeId, time::Duration};
 
@@ -529,6 +598,15 @@ impl std::ops::Not for PlaybackDirection {
 /// commands.spawn(Transform::default()).tween(tween);
 /// ```
 ///
+/// The extension offers 3 main functions, grouped into 2 core use cases:
+/// - If you want to animate a component on the _current_ entity, use
+///   [`tween()`]. This spawns a new separate empty entity with a new
+///   [`TweenAnim`], which targets a component on the current entity. There's no
+///   equivalent for assets, since an asset cannot be owned by an entity.
+/// - If you want the _current entity to own the [`TweenAnim`]_:
+///   - [`tween_component()`] animates a given target component.
+///   - [`tween_asset()`] animates a given target asset.
+///
 /// or even more concisely:
 ///
 /// ```
@@ -553,13 +631,17 @@ impl std::ops::Not for PlaybackDirection {
 /// instead. This is best used for cases where you know those conditions at
 /// build time. To avoid a panic, prefer manually queuing a new tweenable
 /// animation through the [`TweenAnimator`].
+///
+/// [`tween()`]: Self::tween
+/// [`tween_component()`]: Self::tween_component
+/// [`tween_asset()`]: Self::tween_asset
 pub trait EntityWorldMutTweeningExtensions<'a> {
     /// Queue the given [`Tweenable`] to animate the current entity.
     ///
     /// This inserts a new [`TweenAnim`] on a newly spawned entity, which
     /// animates the current entity. The proper component to animate on the
     /// current entity is based on the type of the lens stored inside the
-    /// tweenable (see [`Tweenable::type_id()`]). That component must exists
+    /// tweenable (see [`Tweenable::type_id()`]). That component must exist
     /// on the current entity.
     ///
     /// # Example
@@ -585,13 +667,13 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// ```
     fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self;
 
-    /// Queue the given [`Tweenable`] to animate a target entity.
+    /// Queue the given [`Tweenable`] to animate a target component.
     ///
     /// This inserts a new [`TweenAnim`] on the current entity, which
-    /// animates a given target entity. The proper component to animate on the
-    /// target entity is based on the type of the lens stored inside the
-    /// tweenable (see [`Tweenable::type_id()`]). That component must exists
-    /// on the target entity.
+    /// animates a given target component identified by the entity which owns
+    /// it. The type of the component to animate on that target entity is based
+    /// on the type of the lens stored inside the tweenable (see
+    /// [`Tweenable::type_id()`]).
     ///
     /// # Example
     ///
@@ -617,12 +699,12 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// // Spawn (AnimMarker, TweenAnim) on a new entity
     /// commands.spawn(AnimMarker).tween_target(target, tween);
     /// ```
-    fn tween_target(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self;
+    fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self;
 
     /// Queue the given [`Tweenable`] to animate a target asset.
     ///
     /// This inserts a new [`TweenAnim`] on the current entity, which
-    /// animates a given target asset. The asset type to animate  is validated
+    /// animates a given target asset. The asset type to animate is validated
     /// against the one on the type of the lens stored inside the
     /// tweenable (see [`Tweenable::type_id()`]).
     ///
@@ -831,14 +913,14 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
     }
 
     #[inline]
-    fn tween_target(
+    fn tween_component(
         &mut self,
         entity: Entity,
         tweenable: impl IntoBoxedTweenable,
     ) -> &mut EntityCommands<'a> {
         let tweenable = tweenable.into_boxed();
         self.queue(move |mut this: EntityWorldMut| {
-            this.tween_target(entity, tweenable);
+            this.tween_component(entity, tweenable);
         })
     }
 
@@ -924,10 +1006,10 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
     #[inline]
     fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
         let entity = self.id();
-        self.tween_target(entity, tweenable)
+        self.tween_component(entity, tweenable)
     }
 
-    fn tween_target(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self {
+    fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self {
         let tweenable = tweenable.into_boxed();
         let type_id = tweenable.type_id().unwrap();
         let component_id = self.world().components().get_id(type_id).unwrap();

From ff6bb7d3e920c3f20b5dd084f9d98d26bc39fe24 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 24 Jul 2025 09:28:59 +0100
Subject: [PATCH 50/66] Fix a few doc tests

---
 examples/sequence.rs | 2 +-
 src/lib.rs           | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/sequence.rs b/examples/sequence.rs
index 3d687e7..fc5a340 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -172,7 +172,7 @@ fn setup(
         // Because we want to monitor the progress of the animations, we need to fetch
         // their Entity. There's essentially two possibilities for this.
         // 1) Spawn a new entity, which here we augment with a marker component to
-        //    identify it later, and call tween_target() to spawn the TweenAnim an
+        //    identify it later, and call tween_component() to spawn the TweenAnim an
         //    automatically make it target the given entity.
         let path_tween_id = commands
             // Spawns (RedAnimMarker, TweenAnim) on same entity
diff --git a/src/lib.rs b/src/lib.rs
index 5a04b5d..119bd1f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -126,7 +126,7 @@
 //! // That entity contains the (AnimController, TweenAnim) components.
 //! let anim_entity = commands
 //!     .spawn(AnimController)
-//!     .tween_target(target_entity, tween)
+//!     .tween_component(target_entity, tween)
 //!     .id();
 //! # }
 //! ```
@@ -697,7 +697,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// );
     /// let target = commands.spawn(Transform::default()).id();
     /// // Spawn (AnimMarker, TweenAnim) on a new entity
-    /// commands.spawn(AnimMarker).tween_target(target, tween);
+    /// commands.spawn(AnimMarker).tween_component(target, tween);
     /// ```
     fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self;
 
@@ -721,7 +721,7 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// # use bevy_tweening::{*, lens::TransformPositionLens};
     /// # use std::time::Duration;
     /// # fn make_tween() -> Tween { unimplemented!() }
-    /// #[derive(Asset)]
+    /// #[derive(Asset, TypePath)]
     /// struct MyAsset;
     ///
     /// #[derive(Component)]

From c05f8d62d670a63059c5e74dd06fa2382a0d9e60 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 24 Jul 2025 21:11:34 +0100
Subject: [PATCH 51/66] Add step functions to `TweenAnim`.

---
 src/lib.rs    | 205 +++++++++++++++++++++++++++++++++++++++++++++++---
 src/plugin.rs | 101 ++-----------------------
 2 files changed, 201 insertions(+), 105 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 119bd1f..d65bd25 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1547,12 +1547,12 @@ pub struct TweenAnim {
     /// [`playback_state`]: Self::playback_state
     pub speed: f64,
     /// Destroy the animation once completed. This defaults to `true`, and makes
-    /// [`TweenAnimator::step_one()`] and [`TweenAnimator::step_all()`]
-    /// destroy this [`TweenAnim`] once it completed. To keep the animation
-    /// queued, and allow access after it completed, set this to `false`. Note
-    /// however that you should avoid leaving all animations queued if they're
-    /// unused, as this wastes memory and may degrade performances if too many
-    /// completed animations are kept around for no good reason.
+    /// [`TweenAnim::step()`] destroy itself once it completed. To keep the
+    /// animation queued, and allow access after it completed, set this to
+    /// `false`. Note however that you should avoid leaving all animations
+    /// queued if they're unused, as this wastes memory and may degrade
+    /// performances if too many completed animations are kept around for no
+    /// good reason.
     pub destroy_on_completion: bool,
     /// Current tweening completion state.
     tween_state: TweenState,
@@ -1635,13 +1635,198 @@ impl TweenAnim {
         Ok(Self::new(target, tweenable))
     }
 
-    pub(crate) fn step(
+    /// Step a single animation.
+    ///
+    /// _The [`step_all()`] function is called automatically by the animation
+    /// system registered by the [`TweeningPlugin`], you generally don't
+    /// need to call this one._
+    ///
+    /// This is a shortcut for `step_many(world, delta_time, [entity])`, with
+    /// the added benefit that it returns some error if the entity is not valid.
+    /// See [`step_many()`] for details.
+    ///
+    /// # Returns
+    ///
+    /// This returns an error if the entity is not found or doesn't own a
+    /// [`TweenAnim`] component.
+    ///
+    /// [`step_all()`]: Self::step_all
+    /// [`step_many()`]: Self::step_many
+    #[inline]
+    pub fn step_one(
+        world: &mut World,
+        delta_time: Duration,
+        entity: Entity,
+    ) -> Result<(), TweeningError> {
+        let num = Self::step_many(world, delta_time, &[entity]);
+        if num > 0 {
+            Ok(())
+        } else {
+            Err(TweeningError::EntityNotFound(entity))
+        }
+    }
+
+    /// Step some animation(s).
+    ///
+    /// _The [`step_all()`] function is called automatically by the animation
+    /// system registered by the [`TweeningPlugin`], you generally don't
+    /// need to call this one._
+    ///
+    /// Step the given animation(s) by a given `delta_time`, which may be
+    /// [`Duration::ZERO`]. Passing a zero delta time may be useful to force the
+    /// current animation state to be applied to a target, in case you made
+    /// change which do not automatically do so (for example, retargeting an
+    /// animation). The `anims` are the entities which own a [`TweenAnim`]
+    /// component to step; any entity without a [`TweenAnim`] component is
+    /// silently ignored.
+    ///
+    /// The function doesn't check that all input entities are unique. If an
+    /// entity is duplicated in `anims`, the behavior is undefined, including
+    /// (but not guaranteed) stepping the animation multiple times. You're
+    /// responsible for ensuring the input entity slice contains distinct
+    /// entities.
+    ///
+    /// # Returns
+    ///
+    /// Returns the number of [`TweenAnim`] component found and stepped, which
+    /// is always less than or equal to the input `anims` slice length.
+    ///
+    /// [`step_all()`]: Self::step_all
+    pub fn step_many(world: &mut World, delta_time: Duration, anims: &[Entity]) -> usize {
+        let mut q_anims = world.query::<&TweenAnim>();
+        let mut targets = Vec::with_capacity(anims.len());
+        for entity in anims {
+            if let Ok(target) = q_anims.get(world, *entity).map(|anim| anim.target) {
+                targets.push((*entity, target));
+            }
+        }
+        Self::step_impl(world, delta_time, &targets[..]);
+        targets.len()
+    }
+
+    /// Step all animations on the given world.
+    ///
+    /// _This function is called automatically by the animation system
+    /// registered by the [`TweeningPlugin`], you generally don't need to call
+    /// it._
+    ///
+    /// Step the animation by the given `delta_time`, which can be
+    /// `Duration::ZERO`. The `anim_entity` is the [`Entity`] which owns this
+    /// [`TweenAnim`], and is copied into any event sent. The animation target
+    /// is represented by `mut_untyped`, which must point to a valid target
+    /// instance compatible with the [`Tweenable`] associated with this
+    /// animation. It's passed down to [`Tweenable::step()`]
+    pub fn step_all(world: &mut World, delta_time: Duration) -> Result<(), TweeningError> {
+        let mut q_anims = world.query::<(Entity, &TweenAnim)>();
+        let targets = q_anims
+            .iter(world)
+            .map(|(entity, anim)| (entity, anim.target))
+            .collect::<Vec<_>>();
+        Self::step_impl(world, delta_time, &targets[..]);
+        Ok(())
+    }
+
+    fn step_impl(world: &mut World, delta_time: Duration, anims: &[(Entity, AnimTarget)]) {
+        let mut to_remove = Vec::with_capacity(anims.len());
+        world.resource_scope(|world, asset_resolver: Mut<TweenResolver>| {
+            world.resource_scope(
+                |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                    world.resource_scope(
+                        |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                            let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
+                            for (anim_entity, anim_target) in anims {
+                                let ret = match anim_target {
+                                    AnimTarget::Component(comp_target) => {
+                                        let (mut entities, commands) =
+                                            world.entities_and_commands();
+                                        if *anim_entity == comp_target.entity {
+                                            // The TweenAnim animates another component on the same
+                                            // entity
+                                            let Ok([mut ent]) = entities.get_mut([*anim_entity])
+                                            else {
+                                                continue;
+                                            };
+                                            let Ok([anim, target]) = ent.get_mut_by_id([
+                                                anim_comp_id,
+                                                comp_target.component_id,
+                                            ]) else {
+                                                continue;
+                                            };
+                                            // SAFETY: We fetched the EntityMut from the component
+                                            // ID of
+                                            // TweenAnim
+                                            #[allow(unsafe_code)]
+                                            let mut anim = unsafe { anim.with_type::<TweenAnim>() };
+                                            anim.step_self(
+                                                commands,
+                                                *anim_entity,
+                                                delta_time,
+                                                target,
+                                                cycle_events.reborrow(),
+                                                anim_events.reborrow(),
+                                            )
+                                        } else {
+                                            // The TweenAnim animates a component on a different
+                                            // entity
+                                            let Ok([mut anim, mut target]) = entities
+                                                .get_mut([*anim_entity, comp_target.entity])
+                                            else {
+                                                continue;
+                                            };
+                                            let Some(mut anim) = anim.get_mut::<TweenAnim>() else {
+                                                continue;
+                                            };
+                                            let Ok(target) =
+                                                target.get_mut_by_id(comp_target.component_id)
+                                            else {
+                                                continue;
+                                            };
+                                            anim.step_self(
+                                                commands,
+                                                *anim_entity,
+                                                delta_time,
+                                                target,
+                                                cycle_events.reborrow(),
+                                                anim_events.reborrow(),
+                                            )
+                                        }
+                                    }
+                                    AnimTarget::Asset(asset_target) => asset_resolver
+                                        .resolve_scope(
+                                            world,
+                                            &asset_target,
+                                            *anim_entity,
+                                            delta_time,
+                                            cycle_events.reborrow(),
+                                            anim_events.reborrow(),
+                                        ),
+                                };
+
+                                let retain = ret.map(|ret| ret.retain).unwrap_or(false);
+                                if !retain {
+                                    to_remove.push(*anim_entity);
+                                }
+                            }
+                        },
+                    );
+                },
+            );
+        });
+
+        for entity in to_remove.drain(..) {
+            world.entity_mut(entity).remove::<TweenAnim>();
+        }
+
+        world.flush();
+    }
+
+    pub(crate) fn step_self(
         &mut self,
         mut commands: Commands,
         anim_entity: Entity,
         delta_time: Duration,
         mut mut_untyped: MutUntyped,
-        mut events: Mut<Events<CycleCompletedEvent>>,
+        mut cycle_events: Mut<Events<CycleCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Result<StepResult, TweeningError> {
         let mut completed_events = Vec::with_capacity(8);
@@ -1695,7 +1880,7 @@ impl TweenAnim {
 
             for event in completed_events.drain(..) {
                 // Send buffered event
-                events.send(event);
+                cycle_events.send(event);
 
                 // Trigger all entity-scoped observers
                 commands.trigger_targets(event, anim_entity);
@@ -1900,7 +2085,7 @@ impl TweenResolver {
                 };
 
                 // Finally, step the TweenAnim and mutate the target
-                anim.step(
+                anim.step_self(
                     commands,
                     entity,
                     delta_time,
diff --git a/src/plugin.rs b/src/plugin.rs
index 0a18b95..14c5eaa 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{AnimCompletedEvent, AnimTarget, CycleCompletedEvent, TweenAnim, TweenResolver};
+use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenResolver};
 
 /// Plugin to register the [`TweenAnimator`] and the system playing animations.
 ///
@@ -32,102 +32,13 @@ pub enum AnimationSystem {
     AnimationUpdate,
 }
 
-/// Core animation systemt ticking all queued animations.
+/// Core animation system ticking all queued animations.
+///
+/// This calls [`TweenAnim::step_all()`] using a value of the animation timestep
+/// `delta_time` equal to [`Time::delta()`].
 pub(crate) fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
-
-    // Gather all entities with a TweenAnim. We can't iterate over them while at the
-    // same time retaining a mutable access to the World (in order to resolve the
-    // MutUntyped of the target), so we first make a copy of the entities and
-    // targets.
-    let mut q_anims = world.query::<(Entity, &TweenAnim)>();
-    let mut anims = q_anims
-        .iter(world)
-        .map(|(entity, anim)| (entity, anim.target))
-        .collect::<Vec<_>>();
-
-    // Update animations
-    let mut to_remove = Vec::with_capacity(anims.len());
-    world.resource_scope(|world, asset_resolver: Mut<TweenResolver>| {
-        world.resource_scope(
-            |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
-                world.resource_scope(|world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
-                    let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
-                    for (anim_entity, anim_target) in anims.drain(..) {
-                        let ret = match anim_target {
-                            AnimTarget::Component(comp_target) => {
-                                let (mut entities, commands) = world.entities_and_commands();
-                                if anim_entity == comp_target.entity {
-                                    // The TweenAnim animates another component on the same entity
-                                    let Ok([mut ent]) = entities.get_mut([anim_entity]) else {
-                                        continue;
-                                    };
-                                    let Ok([anim, target]) =
-                                        ent.get_mut_by_id([anim_comp_id, comp_target.component_id])
-                                    else {
-                                        continue;
-                                    };
-                                    // SAFETY: We fetched the EntityMut from the component ID of
-                                    // TweenAnim
-                                    #[allow(unsafe_code)]
-                                    let mut anim = unsafe { anim.with_type::<TweenAnim>() };
-                                    anim.step(
-                                        commands,
-                                        anim_entity,
-                                        delta_time,
-                                        target,
-                                        cycle_events.reborrow(),
-                                        anim_events.reborrow(),
-                                    )
-                                } else {
-                                    // The TweenAnim animates a component on a different entity
-                                    let Ok([mut anim, mut target]) =
-                                        entities.get_mut([anim_entity, comp_target.entity])
-                                    else {
-                                        continue;
-                                    };
-                                    let Some(mut anim) = anim.get_mut::<TweenAnim>() else {
-                                        continue;
-                                    };
-                                    let Ok(target) = target.get_mut_by_id(comp_target.component_id)
-                                    else {
-                                        continue;
-                                    };
-                                    anim.step(
-                                        commands,
-                                        anim_entity,
-                                        delta_time,
-                                        target,
-                                        cycle_events.reborrow(),
-                                        anim_events.reborrow(),
-                                    )
-                                }
-                            }
-                            AnimTarget::Asset(asset_target) => asset_resolver.resolve_scope(
-                                world,
-                                &asset_target,
-                                anim_entity,
-                                delta_time,
-                                cycle_events.reborrow(),
-                                anim_events.reborrow(),
-                            ),
-                        };
-
-                        let retain = ret.map(|ret| ret.retain).unwrap_or(false);
-                        if !retain {
-                            to_remove.push(anim_entity);
-                        }
-                    }
-                });
-            },
-        );
-    });
-
-    for entity in to_remove.drain(..) {
-        world.entity_mut(entity).remove::<TweenAnim>();
-    }
-
-    world.flush();
+    let _ = TweenAnim::step_all(world, delta_time);
 }
 
 #[cfg(test)]

From e08643ab4cf1ab315f81ca6d1a65154661f48ea7 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 24 Jul 2025 21:52:47 +0100
Subject: [PATCH 52/66] Fix docs

---
 src/lib.rs       | 228 +++++++++++++++++++++++++++++++++++------------
 src/plugin.rs    |   6 +-
 src/tweenable.rs |  41 +++------
 3 files changed, 185 insertions(+), 90 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index d65bd25..f11a983 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -527,8 +527,8 @@ impl From<EaseFunction> for EaseMethod {
 /// Direction a tweening animation is playing.
 ///
 /// The playback direction determines if the delta animation time passed to
-/// [`Tweenable::step()`], generally by the [`TweenAnimator`], is added or
-/// subtracted to the current time position on the animation's timeline.
+/// [`Tweenable::step()`] is added or subtracted to the current time position on
+/// the animation's timeline.
 /// - In `Forward` direction, time passes forward from `t=0` to the total
 ///   duration of the animation.
 /// - Conversely, in `Backward` direction, time passes backward from the total
@@ -598,15 +598,6 @@ impl std::ops::Not for PlaybackDirection {
 /// commands.spawn(Transform::default()).tween(tween);
 /// ```
 ///
-/// The extension offers 3 main functions, grouped into 2 core use cases:
-/// - If you want to animate a component on the _current_ entity, use
-///   [`tween()`]. This spawns a new separate empty entity with a new
-///   [`TweenAnim`], which targets a component on the current entity. There's no
-///   equivalent for assets, since an asset cannot be owned by an entity.
-/// - If you want the _current entity to own the [`TweenAnim`]_:
-///   - [`tween_component()`] animates a given target component.
-///   - [`tween_asset()`] animates a given target asset.
-///
 /// or even more concisely:
 ///
 /// ```
@@ -623,6 +614,15 @@ impl std::ops::Not for PlaybackDirection {
 /// );
 /// ```
 ///
+/// The extension offers 3 main functions, grouped into 2 core use cases:
+/// - If you want to animate a component on the _current_ entity, use
+///   [`tween()`]. This spawns a new separate empty entity with a new
+///   [`TweenAnim`], which targets a component on the current entity. There's no
+///   equivalent for assets, since an asset cannot be owned by an entity.
+/// - If you want the _current entity to own the [`TweenAnim`]_:
+///   - [`tween_component()`] animates a given target component.
+///   - [`tween_asset()`] animates a given target asset.
+///
 /// This convenience comes at the price of reduced control and error checking.
 /// Additional information like the [`Entity`] of a newly created [`TweenAnim`]
 /// cannot be retrieved. And any error (_e.g._ trying to insert an animation
@@ -630,7 +630,7 @@ impl std::ops::Not for PlaybackDirection {
 /// component) cannot be forwarded back to the caller, so will produce a panic
 /// instead. This is best used for cases where you know those conditions at
 /// build time. To avoid a panic, prefer manually queuing a new tweenable
-/// animation through the [`TweenAnimator`].
+/// animation by spawning a [`TweenAnim`] component yourself.
 ///
 /// [`tween()`]: Self::tween
 /// [`tween_component()`]: Self::tween_component
@@ -644,6 +644,10 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// tweenable (see [`Tweenable::type_id()`]). That component must exist
     /// on the current entity.
     ///
+    /// Because this function spawns a new entity for each animation, you can
+    /// use it multiple times on the same source entity, including with the same
+    /// component.
+    ///
     /// # Example
     ///
     /// ```
@@ -675,6 +679,9 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// on the type of the lens stored inside the tweenable (see
     /// [`Tweenable::type_id()`]).
     ///
+    /// Because this function spawns a new [`TweenAnim`] on the current entity,
+    /// it cannot be called more than once.
+    ///
     /// # Example
     ///
     /// ```
@@ -699,6 +706,16 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     /// // Spawn (AnimMarker, TweenAnim) on a new entity
     /// commands.spawn(AnimMarker).tween_component(target, tween);
     /// ```
+    ///
+    /// # Panics
+    ///
+    /// This call panics, or queue a command which later panics, if a
+    /// [`TweenAnim`] component already exists on the current entity, whether
+    /// from another prior call to [`tween_component()`] or [`tween_asset()`],
+    /// or from manually inserting the component.
+    ///
+    /// [`tween_component()`]: Self::tween_component
+    /// [`tween_asset()`]: Self::tween_asset
     fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self;
 
     /// Queue the given [`Tweenable`] to animate a target asset.
@@ -736,6 +753,16 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///         .tween_asset(&handle, tween);
     /// }
     /// ```
+    ///
+    /// # Panics
+    ///
+    /// This call panics, or queue a command which later panics, if a
+    /// [`TweenAnim`] component already exists on the current entity, whether
+    /// from another prior call to [`tween_component()`] or [`tween_asset()`],
+    /// or from manually inserting the component.
+    ///
+    /// [`tween_component()`]: Self::tween_component
+    /// [`tween_asset()`]: Self::tween_asset
     fn tween_asset<A: Asset>(
         &mut self,
         id: impl Into<AssetId<A>>,
@@ -755,8 +782,8 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`Entity`] created. To retrieve the ID and control
-    /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add_component()`].
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
     ///
     /// # Example
     ///
@@ -795,8 +822,8 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`Entity`] created. To retrieve the ID and control
-    /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add_component()`].
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
     ///
     /// # Example
     ///
@@ -835,8 +862,8 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`Entity`] created. To retrieve the ID and control
-    /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add_component()`].
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
     ///
     /// # Example
     ///
@@ -875,8 +902,8 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
     /// access to the [`Entity`] created. To retrieve the ID and control
-    /// the animation playback, directly add the tweenable via
-    /// [`TweenAnimator::add_component()`].
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
     ///
     /// # Example
     ///
@@ -1495,21 +1522,26 @@ impl WorldTargetExtensions for World {
     }
 }
 
-/// Animation instance queued into the [`TweenAnimator`].
+/// Animation instance.
 ///
 /// The [`TweenAnim`] represents a single animation instance for a single
-/// target, component or asset. It cannot be created manually; instead you must
-/// enqueue a new component or asset animation into the [`TweenAnimator`] via
-/// [`add_component()`] or [`add_asset()`], respectively. Once created, use the
-/// [`TweenAnimator`] to access it, and modify the runtime playback of this
-/// instance. Each instance is independent, even if it mutates the same target
-/// as another instance.
+/// target, component or asset. Each instance is independent, even if it mutates
+/// the same target as another instance. Spawning this component adds an active
+/// animation, and destroying it stops that animation. The component can also be
+/// used to control the animation playback at runtime, like the playback speed.
+///
+/// You can create this component yourself via [`new()`] and spawn it as a
+/// regular component, but doing so involves creating an [`AnimTarget`], which
+/// is now always convenient. Instead, it's often easier to use one of the
+/// extension functions provided by the [`EntityWorldMutTweeningExtensions`]
+/// trait, like [`tween()`]. Those extensions automatically create an approriate
+/// [`AnimTarget`] for you.
 ///
 /// _If you're looking for the basic tweenable animation description, see
 /// [`Tween`] instead._
 ///
-/// [`add_component()`]: crate::TweenAnimator::add_component
-/// [`add_asset()`]: crate::TweenAnimator::add_asset
+/// [`new()`]: Self::new
+/// [`tween()`]: EntityWorldMutTweeningExtensions::tween
 #[derive(Component)]
 pub struct TweenAnim {
     /// Target [`Entity`] containing the component to animate, or target asset.
@@ -1530,7 +1562,7 @@ pub struct TweenAnim {
     /// Setting a negative or zero speed value effectively pauses the animation
     /// (although the [`playback_state`] remains unchanged). Negative values may
     /// be clamped to 0. when the animation is stepped, but positive or zero
-    /// values are never modified by the [`TweenAnimator`].
+    /// values are never modified by the library.
     ///
     /// # Time precision
     ///
@@ -1547,12 +1579,12 @@ pub struct TweenAnim {
     /// [`playback_state`]: Self::playback_state
     pub speed: f64,
     /// Destroy the animation once completed. This defaults to `true`, and makes
-    /// [`TweenAnim::step()`] destroy itself once it completed. To keep the
-    /// animation queued, and allow access after it completed, set this to
-    /// `false`. Note however that you should avoid leaving all animations
-    /// queued if they're unused, as this wastes memory and may degrade
-    /// performances if too many completed animations are kept around for no
-    /// good reason.
+    /// the stepping functions like [`TweenAnim::step_all()`] destroy this
+    /// animation once it completed. To keep the animation queued, and allow
+    /// access after it completed, set this to `false`. Note however that
+    /// you should avoid leaving all animations queued if they're unused, as
+    /// this wastes memory and may degrade performances if too many
+    /// completed animations are kept around for no good reason.
     pub destroy_on_completion: bool,
     /// Current tweening completion state.
     tween_state: TweenState,
@@ -1561,17 +1593,17 @@ pub struct TweenAnim {
 impl TweenAnim {
     /// Create a new tween animation.
     ///
-    /// This components represents the runtime animation being played to mutate
-    /// a specific target.
+    /// This component represents the runtime animation being played to mutate a
+    /// specific target.
     ///
     /// # Panics
     ///
     /// Panics if the tweenable is "typeless", that is [`Tweenable::type_id()`]
     /// returns `None`. Animations must target a concrete component or asset
-    /// type. This means in particular that you can't insert a single
-    /// [`Delay`]. You can however use a [`Delay`] or other typeless
-    /// tweenables as part of a [`Sequence`], provided there's at least one
-    /// other typed tweenable in the sequence.
+    /// type. This means in particular that you can't use a single [`Delay`]
+    /// alone. You can however use a [`Delay`] or other typeless tweenables
+    /// as part of a [`Sequence`], provided there's at least one other typed
+    /// tweenable in the sequence to make it typed too.
     #[inline]
     pub fn new(target: impl Into<AnimTarget>, tweenable: impl IntoBoxedTweenable) -> Self {
         let tweenable = tweenable.into_boxed();
@@ -1645,6 +1677,25 @@ impl TweenAnim {
     /// the added benefit that it returns some error if the entity is not valid.
     /// See [`step_many()`] for details.
     ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::time::Duration;
+    /// # use bevy::prelude::*;
+    /// # use bevy_tweening::*;
+    /// # fn make_tweenable() -> Tween { unimplemented!() }
+    /// #[derive(Component)]
+    /// struct MyMarker;
+    ///
+    /// fn my_system(world: &mut World) -> Result<()> {
+    ///     let mut q_anims = world.query_filtered::<Entity, (With<TweenAnim>, With<MyMarker>)>();
+    ///     let entity = q_anims.single(world)?;
+    ///     let delta_time = Duration::from_millis(200);
+    ///     TweenAnim::step_one(world, delta_time, entity);
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
     /// # Returns
     ///
     /// This returns an error if the entity is not found or doesn't own a
@@ -1686,6 +1737,25 @@ impl TweenAnim {
     /// responsible for ensuring the input entity slice contains distinct
     /// entities.
     ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::time::Duration;
+    /// # use bevy::prelude::*;
+    /// # use bevy_tweening::*;
+    /// # fn make_tweenable() -> Tween { unimplemented!() }
+    /// #[derive(Component)]
+    /// struct MyMarker;
+    ///
+    /// fn my_system(world: &mut World) -> Result<()> {
+    ///     let mut q_anims = world.query_filtered::<Entity, (With<TweenAnim>, With<MyMarker>)>();
+    ///     let entities = q_anims.iter(world).collect::<Vec<Entity>>();
+    ///     let delta_time = Duration::from_millis(200);
+    ///     TweenAnim::step_many(world, delta_time, &entities[..]);
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
     /// # Returns
     ///
     /// Returns the number of [`TweenAnim`] component found and stepped, which
@@ -1710,12 +1780,11 @@ impl TweenAnim {
     /// registered by the [`TweeningPlugin`], you generally don't need to call
     /// it._
     ///
-    /// Step the animation by the given `delta_time`, which can be
-    /// `Duration::ZERO`. The `anim_entity` is the [`Entity`] which owns this
-    /// [`TweenAnim`], and is copied into any event sent. The animation target
-    /// is represented by `mut_untyped`, which must point to a valid target
-    /// instance compatible with the [`Tweenable`] associated with this
-    /// animation. It's passed down to [`Tweenable::step()`]
+    /// Step all the [`TweenAnim`] components of the input world by a given
+    /// `delta_time`, which may be [`Duration::ZERO`]. Passing a zero delta
+    /// time may be useful to force the current animation state to be
+    /// applied to a target, in case you made change which do not
+    /// automatically do so (for example, retargeting an animation).
     pub fn step_all(world: &mut World, delta_time: Duration) -> Result<(), TweeningError> {
         let mut q_anims = world.query::<(Entity, &TweenAnim)>();
         let targets = q_anims
@@ -1820,7 +1889,7 @@ impl TweenAnim {
         world.flush();
     }
 
-    pub(crate) fn step_self(
+    fn step_self(
         &mut self,
         mut commands: Commands,
         anim_entity: Entity,
@@ -1927,7 +1996,7 @@ impl TweenAnim {
 
     /// Get the target this animation is mutating.
     ///
-    /// To change the target, use [`TweenAnimator::set_target()`].
+    /// To change the target, use [`TweenAnim::set_target()`].
     #[inline]
     pub fn target(&self) -> &AnimTarget {
         &self.target
@@ -1935,7 +2004,7 @@ impl TweenAnim {
 
     /// Get the tweenable describing this animation.
     ///
-    /// To change the tweenable, use [`TweenAnimator::set_tweenable()`].
+    /// To change the tweenable, use [`TweenAnim::set_tweenable()`].
     #[inline]
     pub fn tweenable(&self) -> &dyn Tweenable {
         self.tweenable.as_ref()
@@ -1943,14 +2012,16 @@ impl TweenAnim {
 
     /// Set a new animation description.
     ///
-    /// Attempt to change the tweenable of an animation already enqueued, and
-    /// possibly already playing.
+    /// Attempt to change the tweenable of an animation already spawned.
     ///
     /// If the tweenable is successfully swapped, this resets the
     /// [`tween_state()`] to [`TweenState::Active`], even if the tweenable would
-    /// otherwise be completed _e.g._ because its elapsed time is past its
-    /// total duration. Conversely, this doesn't update the target component or
-    /// asset, as this function doesn't have mutable access to it.
+    /// otherwise be completed _e.g._ because its current elapsed time is past
+    /// its total duration. Conversely, this doesn't update the target
+    /// component or asset, as this function doesn't have mutable access to
+    /// it. To force applying the new state to the target without stepping the
+    /// animation forward or backward, call one of the stepping functions like
+    /// [`TweenAnim::step_one()`] passing a delta time of [`Duration::ZERO`].
     ///
     /// To ensure the old and new animations have the same elapsed time (for
     /// example if they need to be synchronized, if they're variants of each
@@ -1970,9 +2041,6 @@ impl TweenAnim {
     /// }
     /// ```
     ///
-    /// To recompute the actual tweenable animation state and force a target
-    /// update, use [`step_one()`] with a [`Duration::ZERO`].
-    ///
     /// # Returns
     ///
     /// On success, returns the previous tweenable which has been swapped out.
@@ -1992,6 +2060,48 @@ impl TweenAnim {
         Ok(old_tweenable)
     }
 
+    /// Retarget this animation.
+    ///
+    /// Attempt to change the target of this animation, even if it's already
+    /// playing. This function performs a number of checks on the new target
+    /// to ensure it's compatible with the previous target currently set. In
+    /// particular, the new target needs to have:
+    /// - the same kind (component or asset);
+    /// - the same type.
+    ///
+    /// # Returns
+    ///
+    /// On success, returns the previous target which has been replaced.
+    pub fn set_target(&mut self, target: AnimTarget) -> Result<AnimTarget, TweeningError> {
+        match (self.target, target) {
+            (AnimTarget::Component(old_component), AnimTarget::Component(new_component)) => {
+                if old_component.component_id != new_component.component_id {
+                    return Err(TweeningError::MismatchingComponentId(
+                        old_component.component_id,
+                        new_component.component_id,
+                    ));
+                }
+            }
+            (AnimTarget::Asset(old_asset), AnimTarget::Asset(new_asset)) => {
+                if old_asset.resource_id != new_asset.resource_id {
+                    return Err(TweeningError::MismatchingAssetResourceId(
+                        old_asset.resource_id,
+                        new_asset.resource_id,
+                    ));
+                }
+            }
+            _ => {
+                return Err(TweeningError::MismatchingTargetKind(
+                    self.target.is_component(),
+                    target.is_component(),
+                ))
+            }
+        }
+        let old_target = self.target;
+        self.target = target;
+        Ok(old_target)
+    }
+
     /// Get the tweening completion state.
     ///
     /// In general this is [`TweenState::Active`], unless the animation
diff --git a/src/plugin.rs b/src/plugin.rs
index 14c5eaa..c1b4bcd 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -2,10 +2,10 @@ use bevy::prelude::*;
 
 use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenResolver};
 
-/// Plugin to register the [`TweenAnimator`] and the system playing animations.
+/// Plugin to register tweening animation framework.
 ///
 /// This plugin registers the common resources and events used by 🍃 Bevy
-/// Tweening as well as the core animation system which executes all pending
+/// Tweening as well as the core animation system which steps all pending
 /// tweenable animations. That system runs in the
 /// [`AnimationSystem::AnimationUpdate`] system set, during the [`Update`]
 /// schedule.
@@ -28,7 +28,7 @@ impl Plugin for TweeningPlugin {
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, SystemSet)]
 #[non_exhaustive]
 pub enum AnimationSystem {
-    /// Ticks all animations. This executes during the [`Update`] schedule.
+    /// Steps all animations. This executes during the [`Update`] schedule.
     AnimationUpdate,
 }
 
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 9153f6b..7022cbd 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -110,12 +110,10 @@ pub enum TweenState {
 pub struct CycleCompletedEvent {
     /// The ID of the tweenable animation which completed.
     ///
-    /// This is the ID of the top-level [`TweenAnim`] this tweenable is part of.
-    /// It can be used to retrieve the entire animation with
-    /// [`TweenAnimator::get()`].
+    /// This is the entity owning the top-level [`TweenAnim`] this tweenable is
+    /// part of.
     ///
     /// [`TweenAnim`]: crate::TweenAnim
-    /// [`TweenAnimator::get()`]: crate::TweenAnimator::get
     pub id: Entity,
     /// The target the tweenable which completed and the [`TweenAnim`] it's
     /// part of are mutating.
@@ -537,26 +535,18 @@ pub trait Tweenable: Send + Sync {
 
     /// Get the [`TypeId`] this tweenable targets.
     ///
-    /// This returns the type of the component or resource that the
-    /// [`TweenAnimator`] needs to fetch from the ECS `World` in order to
-    /// resolve the animation target.
-    ///
-    /// - For components, this is the type of the component itself, _e.g._
-    ///   `TypeId::of::<C>()`.
-    /// - For assets, this is **NOT** the type of the asset `A`, but rather the
-    ///   type of the asset container `Assets<A>`. This is because the asset
-    ///   itself is not stored in the ECS `World`, but in the `Assets<A>`
-    ///   container. So we need to retrieve that container from the world, then
-    ///   find the asset by ID inside it.
+    /// This returns the type of the component or asset that the [`TweenAnim`]
+    /// needs to fetch from the ECS `World` in order to resolve the animation
+    /// target.
     ///
     /// # Returns
     ///
     /// Returns the type of the target, if any, or `None` if this tweenable is
-    /// untyped. Typically only `Delay` is untyped, as this is the only
+    /// untyped. Typically only [`Delay`] is untyped, as this is the only
     /// tweenable which doesn't actually mutate the target, so it doesn't
-    /// actually have any target associated with it.
+    /// actually have any target type associated with it.
     ///
-    /// [`TweenAnimator`]: crate::TweenAnimator
+    /// [`TweenAnim`]: crate::TweenAnim
     #[must_use]
     fn type_id(&self) -> Option<TypeId>;
 }
@@ -586,8 +576,8 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 /// or backward. On completion, you can be notified via events, observers, or
 /// the execution of a one-shot system.
 ///
-/// _If you're looking for the runtime representation of a tweenable animation
-/// queued into the [`TweenAnimator`], see [`TweenAnim`] instead._
+/// _If you're looking for the runtime representation of a tweenable animation,
+/// see [`TweenAnim`] instead._
 ///
 /// # Cycles
 ///
@@ -651,20 +641,15 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 /// - Each time a _single_ cycle is completed, the tween can emit a
 ///   [`CycleCompletedEvent`]. The event is emitted as a buffered event, to be
 ///   read by another system through an [`EventReader`]. For component targets,
-///   entity-scoped observers are also triggered. Both of these are enabled
-///   through [`with_completed_event()`] and [`set_completed_event()`].
-///   Alternatively, or in addition, a custom one-shot system can be executed,
-///   enabled through [`with_completed_system()`] and
-///   [`set_completed_system()`]. Per-cycle events are disabled by default, and
-///   no one-shot system is registered by default.
+///   observers are also triggered. Both of these are enabled through
+///   [`with_completed_event()`] and [`set_completed_event()`]. Per-cycle events
+///   are disabled by default.
 /// - At the end of all cycles, when the animation itself completes, the tween
 ///   emits an [`AnimCompletedEvent`]. This event is always emitted.
 ///
 /// [`TweenAnim`]: crate::TweenAnim
 /// [`with_completed_event()`]: Self::with_completed_event
 /// [`set_completed_event()`]: Self::set_completed_event
-/// [`with_completed_system()`]: Self::with_completed_system
-/// [`set_completed_system()`]: Self::set_completed_system
 /// [`AnimCompletedEvent`]: crate::AnimCompletedEvent
 /// [`TweenAnimator`]: crate::TweenAnimator
 pub struct Tween {

From f037b9e61ac7d932a31790a10872d39602c6e3dc Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Fri, 1 Aug 2025 19:04:49 +0100
Subject: [PATCH 53/66] Resource support and animated commands

---
 Cargo.toml                |    4 +
 examples/ambient_light.rs |  126 +++
 examples/menu.rs          |    2 +-
 src/lib.rs                | 2055 ++++++++++++++++++++-----------------
 src/plugin.rs             |   16 +-
 src/tweenable.rs          |  150 ++-
 6 files changed, 1404 insertions(+), 949 deletions(-)
 create mode 100644 examples/ambient_light.rs

diff --git a/Cargo.toml b/Cargo.toml
index 6daaf27..c75c5e9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,6 +32,10 @@ thiserror = "2"
 [dev-dependencies]
 bevy-inspector-egui = { version = "0.31" }
 
+[[example]]
+name = "ambient_light"
+required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking", "bevy/bevy_pbr"]
+
 [[example]]
 name = "menu"
 required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking"]
diff --git a/examples/ambient_light.rs b/examples/ambient_light.rs
new file mode 100644
index 0000000..ba34b40
--- /dev/null
+++ b/examples/ambient_light.rs
@@ -0,0 +1,126 @@
+//! Example demonstrating resource animation and various transform shortcuts.
+//!
+//! The example animates the `AmbientLight` resource of Bevy's PBR renderer.
+//! This is mostly for example purpose; you probably want to animate some other
+//! (custom) resource.
+
+use std::{f32::consts::FRAC_PI_2, time::Duration};
+
+use bevy::{color::palettes::css::*, core_pipeline::bloom::Bloom, prelude::*};
+use bevy_tweening::{lens::*, *};
+
+mod utils;
+
+// Define our own `Lens` to animate the `AmbientLight` resource.
+struct AmbientLightBrightnessLens {
+    pub start: f32,
+    pub end: f32,
+}
+
+// Implement the `Lens` trait.
+impl Lens<AmbientLight> for AmbientLightBrightnessLens {
+    fn lerp(&mut self, mut target: Mut<AmbientLight>, ratio: f32) {
+        target.brightness = self.start.lerp(self.end, ratio);
+    }
+}
+
+fn main() {
+    App::default()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "AmbientLightLens".to_string(),
+                resolution: (1200., 600.).into(),
+                present_mode: bevy::window::PresentMode::Fifo, // vsync
+                ..default()
+            }),
+            ..default()
+        }))
+        .add_systems(Update, utils::close_on_esc)
+        .add_plugins(TweeningPlugin)
+        .add_systems(Startup, setup)
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut ambient_light: ResMut<AmbientLight>,
+) -> Result<(), BevyError> {
+    // Some fancy 3D camera with HDR and bloom, to emphasize the change of ambient
+    // brightness.
+    commands.spawn((
+        Camera {
+            hdr: true,
+            clear_color: Color::BLACK.into(),
+            ..default()
+        },
+        Bloom {
+            intensity: 0.2,
+            ..default()
+        },
+        Camera3d::default(),
+        Transform::from_xyz(0., -7., 2.).looking_at(Vec3::ZERO, Vec3::Z),
+    ));
+
+    // Set some default ambient color, and zero out brightness for now
+    ambient_light.color = Color::linear_rgb(1., 1., 1.);
+    ambient_light.brightness = 0.0;
+
+    // Some sample "ground" circle, not animated.
+    commands.spawn((
+        Mesh3d(meshes.add(Circle::new(4.))),
+        MeshMaterial3d(materials.add(StandardMaterial {
+            base_color: LIGHT_GREEN.into(),
+            ..default()
+        })),
+        Transform::default(),
+    ));
+
+    // Animate the ambient light's brightness between fairly extreme values, for
+    // example purpose only (please don't do that).
+    let tween = Tween::new(
+        EaseFunction::CubicIn,
+        Duration::from_secs(2),
+        AmbientLightBrightnessLens {
+            start: 0.0,   // pitch black
+            end: 100000., // ahhhh, my eyes!
+        },
+    )
+    .with_repeat(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat);
+    commands.spawn_empty().tween_resource::<AmbientLight>(tween);
+
+    // Spawn some animated character-like capsule...
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Capsule3d::new(0.5, 1.))),
+            MeshMaterial3d(materials.add(StandardMaterial {
+                base_color: PURPLE.into(),
+                ..default()
+            })),
+            Transform::from_rotation(Quat::from_rotation_x(FRAC_PI_2))
+                .with_translation(Vec3::new(-1., 0., 1.)),
+        ))
+        // ...moving left and right (the start position is the Transform::translation)...
+        .move_to(
+            Vec3::new(1., 0., 1.),
+            Duration::from_secs(1),
+            EaseFunction::CircularInOut,
+        )
+        .with_repeat(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat)
+        // This demonstrates that we can continue using the regular EntityCommands to insert more
+        // components on the current entity for example.
+        .insert(Name::new("haha"))
+        // However, after doing so reborrow() is required because insert() returns &mut
+        // EntityCommands, but the animation extensions need it by value.
+        .reborrow()
+        // ...slightly scaling up and back to normal size (the start scale is the Transform::scale).
+        .scale_to(
+            Vec3::splat(1.1),
+            Duration::from_secs(1),
+            EaseFunction::BounceInOut,
+        )
+        .with_repeat(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat);
+
+    Ok(())
+}
diff --git a/examples/menu.rs b/examples/menu.rs
index 887ee71..1068252 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -95,7 +95,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                         end: Vec3::ONE,
                     },
                 )
-                .with_completed_event(true);
+                .with_cycle_completed_event(true);
 
                 let target = container
                     .spawn((
diff --git a/src/lib.rs b/src/lib.rs
index f11a983..c32edae 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,12 +13,22 @@
 //! Tweening animation plugin for the Bevy game engine.
 //!
 //! 🍃 Bevy Tweening provides interpolation-based animation between ("tweening")
-//! two values, to animate any field of any component and asset, including both
-//! built-in Bevy ones and custom user-defined ones. Each field of a component
-//! or asset can be animated via a collection of predefined easing functions, or
-//! providing a custom animation curve. The library supports any number of
-//! animations queued in parallel, even on the same component or asset type, and
-//! allows runtime control over playback and animation speed.
+//! two values, to animate any field of any component, resource, or asset,
+//! including both built-in Bevy ones and custom user-defined ones. Each field
+//! of a component, resource, or asset, can be animated via a collection of
+//! predefined easing functions, or providing a custom animation curve. The
+//! library supports any number of animations queued in parallel, even on the
+//! same component, resource, or asset type, and allows runtime control over
+//! playback and animation speed.
+//!
+//! # Quick start
+//!
+//! Look at the documentation for:
+//! - [`Tween`] -- the description of a tweening animation and the explanation
+//!   of some core concepts
+//! - [`TweeningPlugin`] -- the plugin to add to your app
+//! - [`EntityCommandsTweeningExtensions`] -- the simplest way to spawn
+//!   animations
 //!
 //! # Example
 //!
@@ -65,9 +75,9 @@
 //! # }
 //! ```
 //!
-//! This example shows the general pattern to add animations for any component
-//! or asset. Since moving the position of an object is a very common task,
-//! 🍃 Bevy Tweening provides a shortcut for it. The above example can be
+//! This example shows the general pattern to add animations for any component,
+//! resource, or asset. Since moving the position of an object is a very common
+//! task, 🍃 Bevy Tweening provides a shortcut for it. The above example can be
 //! rewritten more concicely as:
 //!
 //! ```
@@ -91,8 +101,8 @@
 //! because it implicitly targets the current entity. However, sometimes you
 //! want to remember the [`Entity`] owning the [`TweenAnim`], or insert a marker
 //! component on it, so that you can retrieve it later to control the animation
-//! at runtime. In that case, you can use instead the [`tween_component()`]
-//! extension instead:
+//! at runtime. In that case, you can instead use the [`tween_component()`]
+//! extension:
 //!
 //! ```
 //! # use bevy::prelude::*;
@@ -131,8 +141,10 @@
 //! # }
 //! ```
 //!
-//! See the [`EntityWorldMutTweeningExtensions`] extension trait for the various
-//! helpers provided for common animations like [`move_to()`].
+//! See the [`TweeningExtensions`] extension trait for the various
+//! helpers provided for command-based animation, and the
+//! [`EntityCommandsTweeningExtensions`] for an extra layer of convenience for
+//! common animations like [`move_to()`].
 //!
 //! # Ready to animate
 //!
@@ -144,6 +156,11 @@
 //! animation, and mutates its target which can be any component or asset, even
 //! a custom one.
 //!
+//! If you animate resources or assets, please do read the documentation of the
+//! [`TweenResolver`] to ensure the resource or asset type is properly handled.
+//! Depending on your workflow, you may need to register those types with the
+//! resolver. With other workflows this is done automatically for you.
+//!
 //! # Tweenables
 //!
 //! 🍃 Bevy Tweening supports several types of _tweenables_, building blocks
@@ -156,9 +173,9 @@
 //! - [`Delay`] - A time delay. This doesn't animate anything.
 //!
 //! To execute multiple animations in parallel (like the `Tracks` tweenable used
-//! to do in older versions), simply enqueue each animation independently.
-//! This require careful selection of timings if you want to synchronize
-//! animations.
+//! to do in older versions of 🍃 Bevy Tweening; it's now removed), simply
+//! enqueue each animation independently. This require careful selection of
+//! individual timings though if you want to synchronize those animations.
 //!
 //! ## Chaining animations
 //!
@@ -193,33 +210,35 @@
 //!
 //! Note that some tweenable animations can be of infinite duration; this is the
 //! case for example when using [`RepeatCount::Infinite`]. If you add such an
-//! infinite animation in a sequence, and append more tweenables after it, those
-//! tweenables will never play because playback will be stuck forever repeating
-//! the first animation. You're responsible for creating sequences that make
-//! sense. In general, only use infinite tweenable animations alone or as the
-//! last element of a sequence (for example, move to position and then rotate
-//! forever on self).
+//! infinite animation in a sequence, and append more tweenables after it,
+//! **those tweenables will never play** because playback will be stuck forever
+//! repeating the first animation. You're responsible for creating sequences
+//! that make sense. In general, only use infinite tweenable animations alone or
+//! as the last element of a sequence (for example, move to position and then
+//! rotate forever on self).
 //!
 //! # `TweenAnim`
 //!
-//! Bevy components and assets are animated with the [`TweenAnim`] component.
-//! This component acts as a controller for the animation. It determines the
-//! target component or asset to animate via an [`AnimTarget`], and accesses the
-//! field(s) of that target using a [`Lens`].
+//! Bevy components, resources, and assets, are animated with the [`TweenAnim`]
+//! component. This component acts as a controller for a single animation. It
+//! determines the target component, resource, or asset, to animate, via an
+//! [`AnimTarget`], and accesses the field(s) of that target using a [`Lens`].
 //!
 //! - Components are animated via the [`ComponentAnimTarget`], which identifies
 //!   a component instance on an entity via the [`Entity`] itself and the
 //!   [`ComponentId`] of the registered component type.
-//! - Assets are animated in a similar way to component, via the
-//!   [`AssetAnimTarget`] which identifies an asset via the type of its
-//!   [`Assets`] collection (and so indirectly the type of asset itself) and the
-//!   [`AssetId`] referencing that asset inside the collection.
+//! - Resources are animated via the [`ResourceAnimTarget`], which identifies a
+//!   resource instance via the [`ComponentId`] of the registered resource type.
+//! - Assets are animated via the [`AssetAnimTarget`] which identifies an asset
+//!   via the type of its [`Assets`] collection (and so indirectly the type of
+//!   asset itself) and the [`AssetId`] referencing that asset inside that
+//!   collection.
 //!
 //! Because assets are typically shared, and the animation applies to the asset
 //! itself, all users of the asset see the animation. For example, animating the
-//! color of a [`ColorMaterial`] will change the color of all the
-//! 2D meshes using that material. If you want to animate the color of a single
-//! mesh, you need to duplicate the asset and assign a unique copy to that mesh,
+//! color of a [`ColorMaterial`] will change the color of all the 2D meshes
+//! using that material. If you want to animate the color of a single mesh, you
+//! need to duplicate the asset and assign a unique copy to that mesh,
 //! then animate that copy alone.
 //!
 //! Although you generally should prefer using the various extensions on
@@ -248,30 +267,13 @@
 //! }
 //! ```
 //!
-//! For assets, you also must ensure a resolver is registered for that asset
-//! type, through [`TweenResolver::register_scoped_for()`]. Note that the
-//! [`.tween_asset()`] extension takes care of this for you.
-//!
-//! ```no_run
-//! # use bevy::{prelude::*, ecs::component::Components};
-//! # use bevy_tweening::*;
-//! # fn make_tween() -> Tween { unimplemented!() }
-//! fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
-//! # let entity = Entity::PLACEHOLDER;
-//!     let entity = commands.spawn(Transform::default()).id();
-//!     let target = ComponentAnimTarget::new::<Transform>(components, entity)?;
-//!     // Place the TweenAnim on the same entity as the target component:
-//!     let tween: Tween = make_tween();
-//!     commands
-//!         .entity(entity)
-//!         .insert(TweenAnim::new(target, tween));
-//!     // ---OR---
-//!     // Place it on its own entity
-//!     let tween: Tween = make_tween();
-//!     commands.spawn(TweenAnim::new(target, tween));
-//!     Ok(())
-//! }
-//! ```
+//! For resources and assets, you also must ensure a resolver is registered for
+//! that resource or asset type, through
+//! [`TweenResolver::register_resource_resolver_for()`] and
+//! [`TweenResolver::register_asset_resolver_for()`], respectively. Note that
+//! the [`tween_resource()`] and [`tween_asset()`] extensions take care of
+//! this for you, which is another reason to prefer using those rather than
+//! manually spawning a [`TweenAnim`] component.
 //!
 //! After that, you can use the [`TweenAnim`] component to control the animation
 //! playback:
@@ -286,11 +288,11 @@
 //!
 //! ## Lenses
 //!
-//! The [`AnimTarget`] references the target (component or asset) being
-//! animated. However, only a part of that component or asset is generally
-//! animated. To that end, the [`TweenAnim`] accesses the field(s) to animate
-//! via a _lens_, a type that implements the [`Lens`] trait and allows mapping a
-//! target component or asset to the actual value(s) animated.
+//! The [`AnimTarget`] references the target (component, resource, or asset)
+//! being animated. However, only a part of that target is generally animated.
+//! To that end, the [`TweenAnim`] accesses the field(s) to animate via a
+//! _lens_, a type that implements the [`Lens`] trait and allows mapping a
+//! target to the actual value(s) animated.
 //!
 //! For example, the [`TransformPositionLens`] uses a [`Transform`] component as
 //! input, and animates its [`Transform::translation`] field only, leaving the
@@ -334,12 +336,17 @@
 //! [`ColorMaterial`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.ColorMaterial.html
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
 //! [`TransformPositionLens`]: crate::lens::TransformPositionLens
-//! [`tween()`]: crate::EntityWorldMutTweeningExtensions::tween
-//! [`tween_component()`]: crate::EntityWorldMutTweeningExtensions::tween_component
-//! [`tween_asset()`]: crate::EntityWorldMutTweeningExtensions::tween_asset
-//! [`move_to()`]: crate::EntityWorldMutTweeningExtensions::move_to
-
-use std::{any::TypeId, time::Duration};
+//! [`tween()`]: crate::TweeningExtensions::tween
+//! [`tween_component()`]: crate::TweeningExtensions::tween_component
+//! [`tween_resource()`]: crate::TweeningExtensions::tween_resource
+//! [`tween_asset()`]: crate::TweeningExtensions::tween_asset
+//! [`move_to()`]: crate::EntityCommandsTweeningExtensions::move_to
+
+use std::{
+    any::TypeId,
+    ops::{Deref, DerefMut},
+    time::Duration,
+};
 
 use bevy::{
     asset::UntypedAssetId,
@@ -358,6 +365,11 @@ pub use tweenable::{
     TweenState, Tweenable,
 };
 
+use crate::{
+    lens::{TransformPositionLens, TransformScaleLens},
+    tweenable::TweenConfig,
+};
+
 pub mod lens;
 mod plugin;
 mod tweenable;
@@ -598,29 +610,14 @@ impl std::ops::Not for PlaybackDirection {
 /// commands.spawn(Transform::default()).tween(tween);
 /// ```
 ///
-/// or even more concisely:
-///
-/// ```
-/// # use bevy::{prelude::*, ecs::world::CommandQueue};
-/// # use bevy_tweening::*;
-/// # use std::time::Duration;
-/// # let mut queue = CommandQueue::default();
-/// # let mut world = World::default();
-/// # let mut commands = Commands::new(&mut queue, &mut world);
-/// commands.spawn(Transform::default()).move_to(
-///     Vec3::new(3.5, 0., 0.),
-///     Duration::from_secs(1),
-///     EaseFunction::QuadraticIn,
-/// );
-/// ```
-///
-/// The extension offers 3 main functions, grouped into 2 core use cases:
+/// The extension offers 4 main functions, grouped into 2 core use cases:
 /// - If you want to animate a component on the _current_ entity, use
 ///   [`tween()`]. This spawns a new separate empty entity with a new
 ///   [`TweenAnim`], which targets a component on the current entity. There's no
 ///   equivalent for assets, since an asset cannot be owned by an entity.
 /// - If you want the _current entity to own the [`TweenAnim`]_:
 ///   - [`tween_component()`] animates a given target component.
+///   - [`tween_resource()`] animates a given target resource.
 ///   - [`tween_asset()`] animates a given target asset.
 ///
 /// This convenience comes at the price of reduced control and error checking.
@@ -634,8 +631,9 @@ impl std::ops::Not for PlaybackDirection {
 ///
 /// [`tween()`]: Self::tween
 /// [`tween_component()`]: Self::tween_component
+/// [`tween_resource()`]: Self::tween_resource
 /// [`tween_asset()`]: Self::tween_asset
-pub trait EntityWorldMutTweeningExtensions<'a> {
+pub trait TweeningExtensions<'a> {
     /// Queue the given [`Tweenable`] to animate the current entity.
     ///
     /// This inserts a new [`TweenAnim`] on a newly spawned entity, which
@@ -711,13 +709,60 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// This call panics, or queue a command which later panics, if a
     /// [`TweenAnim`] component already exists on the current entity, whether
-    /// from another prior call to [`tween_component()`] or [`tween_asset()`],
-    /// or from manually inserting the component.
+    /// from another prior call to [`tween_component()`] or [`tween_resource()`]
+    /// or [`tween_asset()`], or from manually inserting the component.
     ///
     /// [`tween_component()`]: Self::tween_component
+    /// [`tween_resource()`]: Self::tween_resource
     /// [`tween_asset()`]: Self::tween_asset
     fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self;
 
+    /// Queue the given [`Tweenable`] to animate a target resource.
+    ///
+    /// This inserts a new [`TweenAnim`] on the current entity, which
+    /// animates a given target resource. The type of the resource `R` to
+    /// animate is validated against the type of the lens stored inside the
+    /// tweenable (see [`Tweenable::type_id()`]).
+    ///
+    /// Because this function spawns a new [`TweenAnim`] on the current entity,
+    /// it cannot be called more than once.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::{*, lens::TransformPositionLens};
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// #[derive(Component)]
+    /// struct AnimMarker;
+    ///
+    /// let tween = Tween::new(
+    ///     EaseFunction::QuadraticIn,
+    ///     Duration::from_secs(1),
+    ///     TimeLens { start: 0., end: 1. },
+    /// );
+    /// // Spawn (AnimMarker, TweenAnim) on a new entity
+    /// commands.spawn(AnimMarker).tween_resource(target, tween);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This call panics, or queue a command which later panics, if a
+    /// [`TweenAnim`] component already exists on the current entity, whether
+    /// from another prior call to [`tween_component()`] or [`tween_resource()`]
+    /// or [`tween_asset()`], or from manually inserting the component.
+    ///
+    /// This calls panics if the tweenable type ([`Tweenable::type_id()`]) is
+    /// not `R`.
+    ///
+    /// [`tween_component()`]: Self::tween_component
+    /// [`tween_resource()`]: Self::tween_resource
+    /// [`tween_asset()`]: Self::tween_asset
+    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self;
+
     /// Queue the given [`Tweenable`] to animate a target asset.
     ///
     /// This inserts a new [`TweenAnim`] on the current entity, which
@@ -758,17 +803,39 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// This call panics, or queue a command which later panics, if a
     /// [`TweenAnim`] component already exists on the current entity, whether
-    /// from another prior call to [`tween_component()`] or [`tween_asset()`],
-    /// or from manually inserting the component.
+    /// from another prior call to [`tween_component()`] or [`tween_resource()`]
+    /// or [`tween_asset()`], or from manually inserting the component.
     ///
     /// [`tween_component()`]: Self::tween_component
+    /// [`tween_resource()`]: Self::tween_resource
     /// [`tween_asset()`]: Self::tween_asset
     fn tween_asset<A: Asset>(
         &mut self,
         id: impl Into<AssetId<A>>,
         tweenable: impl IntoBoxedTweenable,
     ) -> &mut Self;
+}
 
+/// Extension trait for [`EntityCommands`], adding animation functionalities for
+/// commonly used tweening animations.
+///
+/// This trait extends [`EntityCommands`] to provide convenience helpers to
+/// common tweening animations like moving the position of an entity. Those
+/// helpers come as an additional layer on top of the [`TweeningExtensions`]
+/// already available for [`EntityCommands`], and further reduce the boilerplate
+/// to creating some common animations.
+///
+/// One of the major source of convenience provided by these helpers is the fact
+/// that some of the data necessary to create the tween animation is
+/// automatically derived from the current value of the component at the time
+/// when the command is processed. For example, the [`move_to()`] helper only
+/// requires specifying the end position, and will automatically read the start
+/// position from the current [`Transform::translation`] value. This avoids
+/// having to explicitly access that component to read that value and manually
+/// store it into a [`Lens`].
+///
+/// [`move_to()`]: Self::move_to
+pub trait EntityCommandsTweeningExtensions<'a> {
     /// Queue a new tween animation to move the current entity.
     ///
     /// The entity must have a [`Transform`] component. The tween animation will
@@ -803,11 +870,11 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
     fn move_to(
-        &mut self,
+        self,
         end: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self;
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 
     /// Queue a new tween animation to move the current entity.
     ///
@@ -843,11 +910,11 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
     fn move_from(
-        &mut self,
+        self,
         start: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self;
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 
     /// Queue a new tween animation to scale the current entity.
     ///
@@ -883,11 +950,11 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
     fn scale_to(
-        &mut self,
+        self,
         end: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self;
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 
     /// Queue a new tween animation to scale the current entity.
     ///
@@ -923,19 +990,358 @@ pub trait EntityWorldMutTweeningExtensions<'a> {
     ///
     /// [`apply_deferred()`]: bevy::ecs::system::System::apply_deferred
     fn scale_from(
-        &mut self,
+        self,
         start: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self;
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
+}
+
+/// Helper trait to abstract a tweening animation command.
+///
+/// This is mostly used internally by the [`AnimatedEntityCommands`] to tweak
+/// the current animation, while also abstracting the various commands used to
+/// implement the [`EntityCommandsTweeningExtensions`]. In general, you probably
+/// don't have any use for that trait.
+pub trait TweenCommand: EntityCommand {
+    /// Get read-only access to the tween configuration of the command.
+    #[allow(unused)]
+    fn config(&self) -> &TweenConfig;
+
+    /// Get mutable access to the tween configuration of the command.
+    fn config_mut(&mut self) -> &mut TweenConfig;
+}
+
+/// Animation command to move an entity to a target position.
+#[derive(Clone, Copy)]
+pub(crate) struct MoveToCommand {
+    end: Vec3,
+    config: TweenConfig,
+}
+
+impl EntityCommand for MoveToCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(start) = entity.get::<Transform>().map(|tr| tr.translation) {
+            let lens = TransformPositionLens {
+                start,
+                end: self.end,
+            };
+            let tween = Tween::from_config(self.config, lens);
+            entity.tween(tween);
+        }
+    }
+}
+
+impl TweenCommand for MoveToCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to move an entity from a source position.
+#[derive(Clone, Copy)]
+pub(crate) struct MoveFromCommand {
+    start: Vec3,
+    config: TweenConfig,
+}
+
+impl EntityCommand for MoveFromCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(end) = entity.get::<Transform>().map(|tr| tr.translation) {
+            let lens = TransformPositionLens {
+                start: self.start,
+                end,
+            };
+            let tween = Tween::from_config(self.config, lens);
+            entity.tween(tween);
+        }
+    }
+}
+
+impl TweenCommand for MoveFromCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to scale an entity to a target size.
+#[derive(Clone, Copy)]
+pub(crate) struct ScaleToCommand {
+    end: Vec3,
+    config: TweenConfig,
+}
+
+impl EntityCommand for ScaleToCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(start) = entity.get::<Transform>().map(|tr| tr.scale) {
+            let lens = TransformScaleLens {
+                start,
+                end: self.end,
+            };
+            let tween = Tween::from_config(self.config, lens);
+            entity.tween(tween);
+        }
+    }
+}
+
+impl TweenCommand for ScaleToCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to scale an entity from a source size.
+#[derive(Clone, Copy)]
+pub(crate) struct ScaleFromCommand {
+    start: Vec3,
+    config: TweenConfig,
+}
+
+impl EntityCommand for ScaleFromCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(end) = entity.get::<Transform>().map(|tr| tr.scale) {
+            let lens = TransformScaleLens {
+                start: self.start,
+                end,
+            };
+            let tween = Tween::from_config(self.config, lens);
+            entity.tween(tween);
+        }
+    }
+}
+
+impl TweenCommand for ScaleFromCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Wrapper over an [`EntityCommands`] which stores an animation command.
+///
+/// The wrapper acts as, and dereferences to, a regular [`EntityCommands`] as
+/// _e.g._ returned by [`Commands::spawn()`]. In addition, it stores a pending
+/// animation command, which can be further tweaked before being queued into the
+/// entity commands queue. This deferred queuing allows fluent patterns like:
+///
+/// ```
+/// # use bevy::prelude::*;
+/// # use bevy_tweening::*;
+/// # fn my_system(mut commands: Commands) {
+/// commands.spawn(Transform::default())
+///     // Consume the EntityCommands, and wrap it into an AnimatedEntityCommands,
+///     // which stores a MoveToCommand animation command.
+///     .move_to(
+///         Vec3::ONE,
+///         Duration::from_millis(400)
+///         EaseFunction::QuadraticIn,
+///     )
+///     // Tweak the MoveToCommand to configure the repeat count of the Tween
+///     .repeat_count(2);
+/// # }
+/// ```
+///
+/// The animation commands always stores the last animation inserted. When the
+/// commands is mutably dereferenced, it first flushes any pending (single)
+/// animation command by inserting it into the underlying [`EntityCommands`]
+/// queue.
+///
+/// To move from an [`AnimatedEntityCommands`] to its underlying
+/// [`EntityCommands`], the former automatically dereferences to the latter.
+/// Note however that once you're back on the base [`EntityCommands`], you can
+/// only get a new [`AnimatedEntityCommands`] via functions consuming the
+/// [`EntityCommands`] by value. In that case, you need to call [`reborrow()`]:
+///
+/// ```
+/// # use bevy::prelude::*;
+/// # use bevy_tweening::*;
+/// # fn my_system(mut commands: Commands) {
+/// commands.spawn(Transform::default())
+///     .move_to(
+///         Vec3::ONE,
+///         Duration::from_millis(400)
+///         EaseFunction::QuadraticIn,
+///     )
+///     // This call invokes std::ops::DerefMut, and returns a mutable ref
+///     // to the underlying EntityCommands
+///     .insert(Name::new("my_object"))
+///     // Here we need to reborrow() to convert from `&mut EntityCommands`
+///     // (by mutable ref) to `EntityCommands` (by value)
+///     .reborrow()
+///     // This call requires an `EntityCommands` (by value)
+///     .scale_to(
+///         Vec3::splat(1.1),
+///         Duration::from_millis(400)
+///         EaseFunction::Linear,
+///     );
+/// # }
+/// ```
+///
+/// [`reborrow()`]: bevy::prelude::EntityCommands::reborrow
+pub struct AnimatedEntityCommands<'a, C: TweenCommand> {
+    commands: Option<EntityCommands<'a>>,
+    cmd: Option<C>,
+}
+
+impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
+    /// Wrap an [`EntityCommands`] into an animated one.
+    pub fn new(commands: EntityCommands<'a>, cmd: C) -> Self {
+        Self {
+            commands: Some(commands),
+            cmd: Some(cmd),
+        }
+    }
+
+    /// Set the repeat count of this animation.
+    #[inline]
+    pub fn with_repeat_count(mut self, repeat_count: impl Into<RepeatCount>) -> Self {
+        if let Some(cmd) = self.cmd.as_mut() {
+            cmd.config_mut().repeat_count = repeat_count.into();
+        }
+        self
+    }
+
+    /// Set the repeat strategy of this animation.
+    #[inline]
+    pub fn with_repeat_strategy(mut self, repeat_strategy: RepeatStrategy) -> Self {
+        if let Some(cmd) = self.cmd.as_mut() {
+            cmd.config_mut().repeat_strategy = repeat_strategy.into();
+        }
+        self
+    }
+
+    /// Configure the repeat parameters of this animation.
+    #[inline]
+    pub fn with_repeat(
+        self,
+        repeat_count: impl Into<RepeatCount>,
+        repeat_strategy: RepeatStrategy,
+    ) -> Self {
+        self.with_repeat_count(repeat_count)
+            .with_repeat_strategy(repeat_strategy)
+    }
+
+    /// Consume self and return the inner [`EntityCommands`].
+    ///
+    /// The current animation is inserted into the commands queue before that
+    /// commands queue is returned.
+    pub fn into_inner(mut self) -> EntityCommands<'a> {
+        self.flush();
+        self.commands.take().unwrap()
+    }
+
+    /// Flush the current animation, inserting it into the commands queue.
+    ///
+    /// This makes it impossible to further tweak the animation. This is
+    /// automatically called when a new animation is created and when the
+    /// commands queue is dropped with the last animation pending.
+    fn flush(&mut self) {
+        if let Some(cmd) = self.cmd.take() {
+            self.queue(cmd);
+        }
+    }
+}
+
+impl<'a, C: TweenCommand> EntityCommandsTweeningExtensions<'a> for AnimatedEntityCommands<'a, C> {
+    #[inline]
+    fn move_to(
+        mut self,
+        end: Vec3,
+        cycle_duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.flush();
+        let commands = self.commands.take().unwrap();
+        commands.move_to(end, cycle_duration, ease_method)
+    }
+
+    #[inline]
+    fn move_from(
+        mut self,
+        start: Vec3,
+        cycle_duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.flush();
+        let commands = self.commands.take().unwrap();
+        commands.move_from(start, cycle_duration, ease_method)
+    }
+
+    #[inline]
+    fn scale_to(
+        mut self,
+        end: Vec3,
+        cycle_duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.flush();
+        let commands = self.commands.take().unwrap();
+        commands.scale_to(end, cycle_duration, ease_method)
+    }
+
+    #[inline]
+    fn scale_from(
+        mut self,
+        start: Vec3,
+        cycle_duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.flush();
+        let commands = self.commands.take().unwrap();
+        commands.scale_from(start, cycle_duration, ease_method)
+    }
+}
+
+impl<'a, C: TweenCommand> Deref for AnimatedEntityCommands<'a, C> {
+    type Target = EntityCommands<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        self.commands.as_ref().unwrap()
+    }
 }
 
-impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
+impl<'a, C: TweenCommand> DerefMut for AnimatedEntityCommands<'a, C> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.flush();
+        self.commands.as_mut().unwrap()
+    }
+}
+
+impl<'a, C: TweenCommand> Drop for AnimatedEntityCommands<'a, C> {
+    fn drop(&mut self) {
+        self.flush();
+    }
+}
+
+impl<'a> TweeningExtensions<'a> for EntityCommands<'a> {
     #[inline]
     fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut EntityCommands<'a> {
         let tweenable = tweenable.into_boxed();
-        self.queue(move |mut entity: EntityWorldMut| {
-            entity.tween(tweenable);
+        self.queue(move |mut this: EntityWorldMut| {
+            this.tween(tweenable);
         })
     }
 
@@ -951,6 +1357,14 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
         })
     }
 
+    #[inline]
+    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
+        let tweenable = tweenable.into_boxed();
+        self.queue(move |mut entity: EntityWorldMut| {
+            entity.tween_resource::<R>(tweenable);
+        })
+    }
+
     fn tween_asset<A: Asset>(
         &mut self,
         id: impl Into<AssetId<A>>,
@@ -962,78 +1376,147 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityCommands<'a> {
             entity.tween_asset(id, tweenable);
         })
     }
+}
 
+impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     #[inline]
     fn move_to(
-        &mut self,
+        self,
         end: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut EntityCommands<'a> {
-        let ease_method = ease_method.into();
-        self.queue(move |mut entity: EntityWorldMut| {
-            entity.move_to(end, duration, ease_method);
-        })
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            MoveToCommand {
+                end,
+                config: TweenConfig {
+                    ease_method: ease_method.into(),
+                    cycle_duration,
+                    ..default()
+                },
+            },
+        )
     }
 
     #[inline]
     fn move_from(
-        &mut self,
+        self,
         start: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut EntityCommands<'a> {
-        let ease_method = ease_method.into();
-        self.queue(move |mut entity: EntityWorldMut| {
-            entity.move_from(start, duration, ease_method);
-        })
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            MoveFromCommand {
+                start,
+                config: TweenConfig {
+                    ease_method: ease_method.into(),
+                    cycle_duration,
+                    ..default()
+                },
+            },
+        )
     }
 
     #[inline]
     fn scale_to(
-        &mut self,
+        self,
         end: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut EntityCommands<'a> {
-        let ease_method = ease_method.into();
-        self.queue(move |mut entity: EntityWorldMut| {
-            entity.scale_to(end, duration, ease_method);
-        })
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            ScaleToCommand {
+                end,
+                config: TweenConfig {
+                    ease_method: ease_method.into(),
+                    cycle_duration,
+                    ..default()
+                },
+            },
+        )
     }
 
     #[inline]
     fn scale_from(
-        &mut self,
+        self,
         start: Vec3,
-        duration: Duration,
+        cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
-    ) -> &mut EntityCommands<'a> {
-        let ease_method = ease_method.into();
-        self.queue(move |mut entity: EntityWorldMut| {
-            entity.scale_from(start, duration, ease_method);
-        })
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            ScaleFromCommand {
+                start,
+                config: TweenConfig {
+                    ease_method: ease_method.into(),
+                    cycle_duration,
+                    ..default()
+                },
+            },
+        )
     }
 }
 
-///
-pub trait EntityWorldMutTargetExtensions<'a> {
-    ///
-    fn anim_target<C: Component<Mutability = Mutable>>(self) -> ComponentAnimTarget;
-}
+impl<'a, C: TweenCommand> TweeningExtensions<'a> for AnimatedEntityCommands<'a, C> {
+    #[inline]
+    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut AnimatedEntityCommands<'a, C> {
+        self.commands.as_mut().unwrap().tween(tweenable);
+        self
+    }
+
+    #[inline]
+    fn tween_component(
+        &mut self,
+        entity: Entity,
+        tweenable: impl IntoBoxedTweenable,
+    ) -> &mut AnimatedEntityCommands<'a, C> {
+        self.commands
+            .as_mut()
+            .unwrap()
+            .tween_component(entity, tweenable);
+        self
+    }
 
-impl<'a> EntityWorldMutTargetExtensions<'a> for EntityWorldMut<'a> {
     #[inline]
-    fn anim_target<C: Component<Mutability = Mutable>>(self) -> ComponentAnimTarget {
-        ComponentAnimTarget::new::<C>(self.world().components(), self.id()).unwrap()
+    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
+        self.commands
+            .as_mut()
+            .unwrap()
+            .tween_resource::<R>(tweenable);
+        self
+    }
+
+    fn tween_asset<A: Asset>(
+        &mut self,
+        id: impl Into<AssetId<A>>,
+        tweenable: impl IntoBoxedTweenable,
+    ) -> &mut Self {
+        self.commands
+            .as_mut()
+            .unwrap()
+            .tween_asset::<A>(id, tweenable);
+        self
     }
 }
 
-impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
+impl<'a> TweeningExtensions<'a> for EntityWorldMut<'a> {
     #[inline]
     fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
         let entity = self.id();
-        self.tween_component(entity, tweenable)
+        let tweenable = tweenable.into_boxed();
+        let type_id = tweenable.type_id().unwrap();
+        let component_id = self.world().components().get_id(type_id).unwrap();
+        let target = ComponentAnimTarget {
+            component_id,
+            entity,
+        };
+        self.world_scope(|world| {
+            world.spawn(TweenAnim::new(target, tweenable));
+        });
+        self
     }
 
     fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self {
@@ -1048,6 +1531,23 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         self
     }
 
+    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
+        let tweenable = tweenable.into_boxed();
+        let type_id = tweenable.type_id().unwrap();
+        assert_eq!(type_id, TypeId::of::<R>());
+
+        self.world_scope(|world| {
+            world.resource_scope(|world: &mut World, mut resolver: Mut<TweenResolver>| {
+                resolver.register_resource_resolver_for::<R>(world.components());
+            });
+        });
+
+        let resource_id = self.world().resource_id::<R>().unwrap();
+        let target = ResourceAnimTarget { resource_id };
+        self.insert(TweenAnim::new(target, tweenable));
+        self
+    }
+
     fn tween_asset<A: Asset>(
         &mut self,
         id: impl Into<AssetId<A>>,
@@ -1060,7 +1560,7 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
 
         self.world_scope(|world| {
             world.resource_scope(|world: &mut World, mut resolver: Mut<TweenResolver>| {
-                resolver.register_scoped_for::<A>(world.components());
+                resolver.register_asset_resolver_for::<A>(world.components());
             });
         });
 
@@ -1072,59 +1572,53 @@ impl<'a> EntityWorldMutTweeningExtensions<'a> for EntityWorldMut<'a> {
         self.insert(TweenAnim::new(target, tweenable));
         self
     }
+}
 
-    #[inline]
-    fn move_to(
-        &mut self,
-        end: Vec3,
-        duration: Duration,
-        ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self {
-        let start = self.get::<Transform>().unwrap().translation;
-        let lens = lens::TransformPositionLens { start, end };
-        let tween = Tween::new(ease_method, duration, lens);
-        self.tween(tween)
-    }
+// impl<'a> TweeningExtensions<'a> for EntityWorldMut<'a> {
+//     type Output = Self;
 
-    #[inline]
-    fn move_from(
-        &mut self,
-        start: Vec3,
-        duration: Duration,
-        ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self {
-        let end = self.get::<Transform>().unwrap().translation;
-        let lens = lens::TransformPositionLens { start, end };
-        let tween = Tween::new(ease_method, duration, lens);
-        self.tween(tween)
-    }
+//     #[inline]
+//     fn move_to(self, end: Vec3, duration: Duration, ease_method: impl
+// Into<EaseMethod>) -> Self {         let start =
+// self.get::<Transform>().unwrap().translation;         let lens =
+// TransformPositionLens { start, end };         let tween =
+// Tween::new(ease_method, duration, lens);         self.tween(tween)
+//     }
 
-    #[inline]
-    fn scale_to(
-        &mut self,
-        end: Vec3,
-        duration: Duration,
-        ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self {
-        let start = self.get::<Transform>().unwrap().scale;
-        let lens = lens::TransformScaleLens { start, end };
-        let tween = Tween::new(ease_method, duration, lens);
-        self.tween(tween)
-    }
+//     #[inline]
+//     fn move_from(
+//         self,
+//         start: Vec3,
+//         duration: Duration,
+//         ease_method: impl Into<EaseMethod>,
+//     ) -> Self {
+//         let end = self.get::<Transform>().unwrap().translation;
+//         let lens = TransformPositionLens { start, end };
+//         let tween = Tween::new(ease_method, duration, lens);
+//         self.tween(tween)
+//     }
 
-    #[inline]
-    fn scale_from(
-        &mut self,
-        start: Vec3,
-        duration: Duration,
-        ease_method: impl Into<EaseMethod>,
-    ) -> &mut Self {
-        let end = self.get::<Transform>().unwrap().scale;
-        let lens = lens::TransformScaleLens { start, end };
-        let tween = Tween::new(ease_method, duration, lens);
-        self.tween(tween)
-    }
-}
+//     #[inline]
+//     fn scale_to(self, end: Vec3, duration: Duration, ease_method: impl
+// Into<EaseMethod>) -> Self {         let start =
+// self.get::<Transform>().unwrap().scale;         let lens = TransformScaleLens
+// { start, end };         let tween = Tween::new(ease_method, duration, lens);
+//         self.tween(tween)
+//     }
+
+//     #[inline]
+//     fn scale_from(
+//         self,
+//         start: Vec3,
+//         duration: Duration,
+//         ease_method: impl Into<EaseMethod>,
+//     ) -> Self {
+//         let end = self.get::<Transform>().unwrap().scale;
+//         let lens = TransformScaleLens { start, end };
+//         let tween = Tween::new(ease_method, duration, lens);
+//         self.tween(tween)
+//     }
+// }
 
 /// Event raised when a [`TweenAnim`] completed.
 #[derive(Copy, Clone, Event)]
@@ -1160,9 +1654,15 @@ pub enum TweeningError {
     /// The component of the given type is not registered.
     #[error("Component of type {0:?} is not registered in the World.")]
     ComponentNotRegistered(TypeId),
+    /// The resource of the given type is not registered.
+    #[error("Resource of type {0:?} is not registered in the World.")]
+    ResourceNotRegistered(TypeId),
     /// The asset container for the given asset type is not registered.
     #[error("Asset container Assets<A> for asset type A = {0:?} is not registered in the World.")]
     AssetNotRegistered(TypeId),
+    /// The component of the given type is not registered.
+    #[error("Component of type {0:?} is not present on entity {1:?}.")]
+    MissingComponent(TypeId, Entity),
     /// The asset cannot be found.
     #[error("Asset ID {0:?} is invalid.")]
     InvalidAssetId(UntypedAssetId),
@@ -1269,6 +1769,74 @@ impl ComponentAnimTarget {
     }
 }
 
+/// Resource animation target.
+///
+/// References a resource used as the target of a tweenable animation. The
+/// resource is identified by the ID of the resource type registered in the
+/// [`World`] where the animation is queued.
+///
+/// To animate assets, use an [`AssetAnimTarget`] instead.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ResourceAnimTarget {
+    /// Resource ID of the registered resource.
+    pub resource_id: ComponentId,
+}
+
+impl ResourceAnimTarget {
+    /// Create a new resource target.
+    ///
+    /// The resource type `R` must be registered in the input [`Components`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// fn my_system(components: &Components) {
+    ///     let target = ResourceAnimTarget::new::<Time>(components);
+    ///     // [...]
+    /// }
+    /// ```
+    pub fn new<R: Resource>(components: &Components) -> Result<Self, TweeningError> {
+        let resource_id = components
+            .resource_id::<R>()
+            .ok_or(TweeningError::ResourceNotRegistered(TypeId::of::<R>()))?;
+        Ok(Self { resource_id })
+    }
+
+    /// Create a new resource target from an `Assets<A>` type ID.
+    ///
+    /// The `resource_type_id` must reference a resource type registered in the
+    /// input [`Components`]. This is useful when the resource type is not
+    /// known at compile time; otherwise you should prefer [`new()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::any::TypeId;
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// fn my_system(components: &Components, asset_server: Res<AssetServer>) {
+    ///     let handle: Handle<Image> = asset_server.load("image.png");
+    ///     let handle = handle.untyped();
+    ///     let assets_type_id = TypeId::of::<Assets<Image>>();
+    ///     let target = AssetAnimTarget::new_untyped(components, assets_type_id, &handle);
+    ///     // [...]
+    /// }
+    /// ```
+    ///
+    /// [`new()`]: Self::new
+    pub fn new_untyped(
+        components: &Components,
+        resource_type_id: TypeId,
+    ) -> Result<Self, TweeningError> {
+        let resource_id = components
+            .get_resource_id(resource_type_id)
+            .ok_or(TweeningError::ResourceNotRegistered(resource_type_id))?;
+        Ok(Self { resource_id })
+    }
+}
+
 /// Asset animation target.
 ///
 /// References an asset used as the target of a tweenable animation. The asset
@@ -1316,7 +1884,7 @@ impl AssetAnimTarget {
     /// Create a new asset target from an `Assets<A>` type ID.
     ///
     /// The `assets_type_id` must reference an [`Assets<A>`] type registered in
-    /// the input [`Components`]. This is useful when the component type is not
+    /// the input [`Components`]. This is useful when the asset type is not
     /// known at compile time; otherwise you should prefer [`new()`].
     ///
     /// # Example
@@ -1354,17 +1922,19 @@ impl AssetAnimTarget {
 
 /// Animation target.
 ///
-/// References either a component or an asset used as the target of a tweenable
-/// animation. See [`ComponentAnimTarget`] and [`AssetAnimTarget`] for details.
-/// This is a lightweight reference (copyable) implicitly tied to a given
-/// [`World`].
+/// References an object used as the target of a tweenable animation. See
+/// [`ComponentAnimTarget`], [`ResourceAnimTarget`], and [`AssetAnimTarget`],
+/// for details. This is a lightweight reference (copyable) implicitly tied to a
+/// given [`World`].
 ///
-/// To create an animation target from a given component or asset, see the
-/// [`WorldTargetExtensions`] extension trait for [`World`].
+/// To create an animation target from a given component, resource, or asset,
+/// see the [`WorldTargetExtensions`] extension trait for [`World`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum AnimTarget {
     /// Component animation target.
     Component(ComponentAnimTarget),
+    /// Resource animation target.
+    Resource(ResourceAnimTarget),
     /// Asset animation target.
     Asset(AssetAnimTarget),
 }
@@ -1405,6 +1975,41 @@ impl AnimTarget {
             None
         }
     }
+    /// Check if the target is an [`AnimTarget::Resource`].
+    #[inline]
+    pub fn is_resource(&self) -> bool {
+        matches!(*self, AnimTarget::Resource(..))
+    }
+
+    /// Convert this target to a resource target if possible.
+    ///
+    /// # Returns
+    ///
+    /// Returns self as a [`ResourceAnimTarget`] if the value matches that enum
+    /// variant, or `None` if it doesn't.
+    #[inline]
+    pub fn as_resource(&self) -> Option<&ResourceAnimTarget> {
+        if let Self::Resource(resource) = self {
+            Some(resource)
+        } else {
+            None
+        }
+    }
+
+    /// Convert this target to a resource target if possible.
+    ///
+    /// # Returns
+    ///
+    /// Returns self as a [`ResourceAnimTarget`] if the value matches that enum
+    /// variant, or `None` if it doesn't.
+    #[inline]
+    pub fn as_resource_mut(&mut self) -> Option<&mut ResourceAnimTarget> {
+        if let Self::Resource(resource) = self {
+            Some(resource)
+        } else {
+            None
+        }
+    }
 
     /// Check if the target is an [`AnimTarget::Asset`].
     #[inline]
@@ -1449,15 +2054,22 @@ impl From<ComponentAnimTarget> for AnimTarget {
     }
 }
 
+impl From<ResourceAnimTarget> for AnimTarget {
+    fn from(value: ResourceAnimTarget) -> Self {
+        AnimTarget::Resource(value)
+    }
+}
+
 impl From<AssetAnimTarget> for AnimTarget {
     fn from(value: AssetAnimTarget) -> Self {
         AnimTarget::Asset(value)
     }
 }
 
-/// Extension trait for [`World`].
+/// Animation target extension trait for [`World`].
 ///
-/// This trait extends [`World`] with some helper functions.
+/// This trait extends [`World`] with some helper functions to create various
+/// animation targets, generally for manually spawning a [`TweenAnim`].
 pub trait WorldTargetExtensions {
     /// Get a [`ComponentAnimTarget`] for the given component type and entity
     /// pair.
@@ -1476,6 +2088,45 @@ pub trait WorldTargetExtensions {
         entity: Entity,
     ) -> Option<ComponentAnimTarget>;
 
+    /// Get a [`ComponentAnimTarget`] for the given component type and entity
+    /// pair.
+    ///
+    /// The target references the component instance held by the entity. The
+    /// entity must exist in the [`World`], and the component type must be
+    /// registered.
+    ///
+    /// # Returns
+    ///
+    /// Returns the animation target referencing the component instance.
+    fn try_get_anim_component_target<C: Component<Mutability = Mutable>>(
+        &self,
+        entity: Entity,
+    ) -> Result<ComponentAnimTarget, TweeningError>;
+
+    /// Get a [`ResourceAnimTarget`] for the given resource type.
+    ///
+    /// The target references the resource with the given type. The resource
+    /// type `R` must be registered.
+    ///
+    /// # Returns
+    ///
+    /// Returns the animation target referencing the asset instance, or
+    /// `None` if either the ID doesn't reference an existing asset or the asset
+    /// type is not registered.
+    fn get_anim_resource_target<R: Resource>(&self) -> Option<ResourceAnimTarget>;
+
+    /// Get a [`ResourceAnimTarget`] for the given resource type.
+    ///
+    /// The target references the resource with the given type. The resource
+    /// type `R` must be registered.
+    ///
+    /// # Returns
+    ///
+    /// Returns the animation target referencing the asset instance.
+    fn try_get_anim_resource_target<R: Resource>(
+        &self,
+    ) -> Result<ResourceAnimTarget, TweeningError>;
+
     /// Get an [`AssetAnimTarget`] for the given asset type and ID pair.
     ///
     /// The target references the asset instance with the given ID. The
@@ -1489,6 +2140,20 @@ pub trait WorldTargetExtensions {
     /// type is not registered.
     fn get_anim_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>)
         -> Option<AssetAnimTarget>;
+
+    /// Get an [`AssetAnimTarget`] for the given asset type and ID pair.
+    ///
+    /// The target references the asset instance with the given ID. The
+    /// ID must be valid, that is reference an existing asset in the `Assets<A>`
+    /// collection, and the asset type `A` must be registered.
+    ///
+    /// # Returns
+    ///
+    /// Returns the animation target referencing the asset instance.
+    fn try_get_anim_asset_target<A: Asset>(
+        &self,
+        id: impl Into<AssetId<A>>,
+    ) -> Result<AssetAnimTarget, TweeningError>;
 }
 
 impl WorldTargetExtensions for World {
@@ -1506,23 +2171,70 @@ impl WorldTargetExtensions for World {
         })
     }
 
-    fn get_anim_asset_target<A: Asset>(
+    fn try_get_anim_component_target<C: Component<Mutability = Mutable>>(
+        &self,
+        entity: Entity,
+    ) -> Result<ComponentAnimTarget, TweeningError> {
+        let component_id = self
+            .component_id::<C>()
+            .ok_or(TweeningError::ComponentNotRegistered(TypeId::of::<C>()))?;
+        if !self.entities().contains(entity) {
+            return Err(TweeningError::MissingComponent(TypeId::of::<C>(), entity));
+        }
+        Ok(ComponentAnimTarget {
+            component_id,
+            entity,
+        })
+    }
+
+    fn get_anim_resource_target<R: Resource>(&self) -> Option<ResourceAnimTarget> {
+        let resource_id = self.resource_id::<R>()?;
+        Some(ResourceAnimTarget { resource_id })
+    }
+
+    fn try_get_anim_resource_target<R: Resource>(
+        &self,
+    ) -> Result<ResourceAnimTarget, TweeningError> {
+        let resource_id = self
+            .resource_id::<R>()
+            .ok_or(TweeningError::ResourceNotRegistered(TypeId::of::<R>()))?;
+        Ok(ResourceAnimTarget { resource_id })
+    }
+
+    fn get_anim_asset_target<A: Asset>(
+        &self,
+        id: impl Into<AssetId<A>>,
+    ) -> Option<AssetAnimTarget> {
+        let id = id.into();
+        if !self.resource::<Assets<A>>().contains(id) {
+            return None;
+        }
+        let resource_id = self.resource_id::<Assets<A>>()?;
+        Some(AssetAnimTarget {
+            resource_id,
+            asset_id: id.untyped(),
+        })
+    }
+
+    fn try_get_anim_asset_target<A: Asset>(
         &self,
         id: impl Into<AssetId<A>>,
-    ) -> Option<AssetAnimTarget> {
+    ) -> Result<AssetAnimTarget, TweeningError> {
         let id = id.into();
         if !self.resource::<Assets<A>>().contains(id) {
-            return None;
+            return Err(TweeningError::InvalidAssetId(id.untyped()));
         }
-        let resource_id = self.resource_id::<Assets<A>>()?;
-        Some(AssetAnimTarget {
+        let resource_id = self
+            .resource_id::<Assets<A>>()
+            .ok_or(TweeningError::AssetNotRegistered(TypeId::of::<A>()))?;
+        Ok(AssetAnimTarget {
             resource_id,
             asset_id: id.untyped(),
         })
     }
 }
 
-/// Animation instance.
+/// Animation controller instance.
 ///
 /// The [`TweenAnim`] represents a single animation instance for a single
 /// target, component or asset. Each instance is independent, even if it mutates
@@ -1533,7 +2245,7 @@ impl WorldTargetExtensions for World {
 /// You can create this component yourself via [`new()`] and spawn it as a
 /// regular component, but doing so involves creating an [`AnimTarget`], which
 /// is now always convenient. Instead, it's often easier to use one of the
-/// extension functions provided by the [`EntityWorldMutTweeningExtensions`]
+/// extension functions provided by the [`TweeningExtensions`]
 /// trait, like [`tween()`]. Those extensions automatically create an approriate
 /// [`AnimTarget`] for you.
 ///
@@ -1541,12 +2253,13 @@ impl WorldTargetExtensions for World {
 /// [`Tween`] instead._
 ///
 /// [`new()`]: Self::new
-/// [`tween()`]: EntityWorldMutTweeningExtensions::tween
+/// [`tween()`]: TweeningExtensions::tween
 #[derive(Component)]
 pub struct TweenAnim {
-    /// Target [`Entity`] containing the component to animate, or target asset.
+    /// The target this animation mutates.
     target: AnimTarget,
-    /// Animation description.
+    /// The animation itself. Note that the tweenable is stateful, so can't be
+    /// shared with another [`TweenAnim`] instance.
     tweenable: BoxedTweenable,
     /// Control if the animation is played or not. Defaults to
     /// [`PlaybackState::Playing`].
@@ -1609,7 +2322,7 @@ impl TweenAnim {
         let tweenable = tweenable.into_boxed();
         assert!(
             tweenable.type_id().is_some(),
-            "The top-level Tweenable of a TweenAnim must be typed (type_id() returns Some)."
+            "The top-level Tweenable of a TweenAnim must be typed (Tweenable::type_id() returns Some)."
         );
         Self {
             target: target.into(),
@@ -1656,7 +2369,7 @@ impl TweenAnim {
     /// ```
     ///
     /// [`new()`]: Self::new
-    /// [`.tween()`]: crate::EntityWorldMutTweeningExtensions::tween
+    /// [`.tween()`]: crate::TweeningExtensions::tween
     pub fn for_component(
         components: &Components,
         target: Entity,
@@ -1667,6 +2380,48 @@ impl TweenAnim {
         Ok(Self::new(target, tweenable))
     }
 
+    /// Create a new tweenable animation for a specific resource target.
+    ///
+    /// This is a convenience helper which builds a [`ResourceAnimTarget`] then
+    /// calls [`new()`] with it. It's often useful in cases where you want to
+    /// manually insert the [`TweenAnim`] component to save its [`Entity`] so
+    /// you can reference it later, typically to control playback. Otherwise,
+    /// prefer using [`.tween()`] or similar to automatically create the
+    /// component and insert it.
+    ///
+    /// Note that the target resource type is automically derived from the input
+    /// `tweenable`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use std::any::TypeId;
+    /// # use bevy::{prelude::*, ecs::component::Components};
+    /// # use bevy_tweening::*;
+    /// # fn make_tween() -> Tween { unimplemented!() }
+    /// fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
+    ///     // Create the animation
+    ///     let tween = make_tween();
+    ///     let anim = TweenAnim::for_resource(components, tween)?;
+    ///     // Spawn the TweenAnim component on a new, separate Entity, and record that
+    ///     // Entity for later reference.
+    ///     let anim_entity = commands.spawn(anim).id();
+    ///     // [...]
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// [`new()`]: Self::new
+    /// [`.tween()`]: crate::TweeningExtensions::tween
+    pub fn for_resource(
+        components: &Components,
+        tweenable: impl Tweenable + 'static,
+    ) -> Result<Self, TweeningError> {
+        let type_id = tweenable.type_id().ok_or(TweeningError::UntypedTweenable)?;
+        let target = ResourceAnimTarget::new_untyped(components, type_id)?;
+        Ok(Self::new(target, tweenable))
+    }
+
     /// Step a single animation.
     ///
     /// _The [`step_all()`] function is called automatically by the animation
@@ -1797,7 +2552,7 @@ impl TweenAnim {
 
     fn step_impl(world: &mut World, delta_time: Duration, anims: &[(Entity, AnimTarget)]) {
         let mut to_remove = Vec::with_capacity(anims.len());
-        world.resource_scope(|world, asset_resolver: Mut<TweenResolver>| {
+        world.resource_scope(|world, resolver: Mut<TweenResolver>| {
             world.resource_scope(
                 |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
                     world.resource_scope(
@@ -1860,15 +2615,22 @@ impl TweenAnim {
                                             )
                                         }
                                     }
-                                    AnimTarget::Asset(asset_target) => asset_resolver
-                                        .resolve_scope(
-                                            world,
-                                            &asset_target,
-                                            *anim_entity,
-                                            delta_time,
-                                            cycle_events.reborrow(),
-                                            anim_events.reborrow(),
-                                        ),
+                                    AnimTarget::Resource(res_target) => resolver.resolve_resource(
+                                        world,
+                                        &res_target,
+                                        *anim_entity,
+                                        delta_time,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    ),
+                                    AnimTarget::Asset(asset_target) => resolver.resolve_asset(
+                                        world,
+                                        &asset_target,
+                                        *anim_entity,
+                                        delta_time,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    ),
                                 };
 
                                 let retain = ret.map(|ret| ret.retain).unwrap_or(false);
@@ -2114,14 +2876,20 @@ impl TweenAnim {
     }
 }
 
-type Resolver = Box<
-    dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
+type ResourceResolver = Box<
+    dyn for<'w> Fn(
+            &mut World,
+            Entity,
+            Duration,
+            Mut<Events<CycleCompletedEvent>>,
+            Mut<Events<AnimCompletedEvent>>,
+        ) -> Result<StepResult, TweeningError>
         + Send
         + Sync
         + 'static,
 >;
 
-type ScopedResolver = Box<
+type AssetResolver = Box<
     dyn for<'w> Fn(
             &mut World,
             UntypedAssetId,
@@ -2135,37 +2903,102 @@ type ScopedResolver = Box<
         + 'static,
 >;
 
+/// Resolver for resources and assets.
+///
+/// Bevy doesn't provide a suitable untyped API to access resources and assets
+/// at runtime without knowing their compile-time type.
+/// - For resources, most of the API is in place, but unfortunately there's no
+///   `World::resource_scope_untyped()` to temporarily extract a resource by ID
+///   to allow concurrent mutability of the resource with other parts of the
+///   [`World`], in particular the animation target.
+/// - For assets, there's simply no untyped API. [`Assets`] doesn't allow
+///   untyped asset access.
+///
+/// To work around those limitations, this resolver resource contains
+/// type-erased closures allowing to resolve an animation target definition into
+/// a mutable pointer [`MutUntyped`] to that instance, to allow the animation
+/// engine to apply the animation on it.
+///
+/// For users, this resource is important if you don't use the convenience
+/// [`tween_resource()`] or [`tween_asset()`], but instead manually insert the
+/// [`TweenAnim`] component. In that case, you should make sure to call once the
+/// [`register_resource_resolver_for()`] or [`register_asset_resolver_for()`],
+/// respectively, to register such a resolver.
 ///
+/// [`tween_resource()`]: crate::TweeningExtensions::tween_resource
+/// [`tween_asset()`]: crate::TweeningExtensions::tween_asset
+/// [`register_resource_resolver_for()`]: Self::register_resource_resolver_for
+/// [`register_asset_resolver_for()`]: Self::register_asset_resolver_for
 #[derive(Default, Resource)]
 pub struct TweenResolver {
+    /// Resource resolver allowing to call `World::resource_scope()` to extract
+    /// that resource type form the `World` while in parallel accessing mutably
+    /// the animation entity itself.
+    resource_resolver: HashMap<ComponentId, ResourceResolver>,
     /// Asset resolver allowing to convert a pair of { untyped pointer to
     /// `Assets<A>`, untyped `AssetId` } into an untyped pointer to the asset A
     /// itself. This is necessary because there's no UntypedAssets interface in
     /// Bevy. The TypeId key must be the type of the `Assets<A>` type itself.
     /// The resolver is allowed to fail (return `None`), for example when the
     /// asset ID doesn't reference a valid asset.
-    asset_resolver: HashMap<ComponentId, Resolver>,
-    scoped_resolver: HashMap<ComponentId, ScopedResolver>,
+    asset_resolver: HashMap<ComponentId, AssetResolver>,
 }
 
 impl TweenResolver {
+    /// Register a resolver for the given resource type.
     ///
-    pub fn resolve_asset(
-        &self,
-        component_id: ComponentId,
-    ) -> Option<
-        &(dyn for<'w> Fn(MutUntyped<'w>, UntypedAssetId) -> Option<MutUntyped<'w>>
-              + Send
-              + Sync
-              + 'static),
-    > {
-        self.asset_resolver
-            .get(&component_id)
-            .map(|resolver| resolver.as_ref())
+    /// This must be called once per resource type for every resource type being
+    /// animated. Using [`tween_resource()`] automatically calls it
+    /// automatically, so if you're only using that utility then you don't need
+    /// to manually call this function.
+    ///
+    /// [`tween_resource()`]: crate::TweeningExtensions::tween_resource
+    pub fn register_resource_resolver_for<R: Resource>(&mut self, components: &Components) {
+        let resource_id = components.resource_id::<R>().unwrap();
+        let resolver = |world: &mut World,
+                        entity: Entity,
+                        delta_time: Duration,
+                        mut cycle_events: Mut<Events<CycleCompletedEvent>>,
+                        mut anim_events: Mut<Events<AnimCompletedEvent>>|
+         -> Result<StepResult, TweeningError> {
+            // First, remove the resource R from the world so we can access it mutably in
+            // parallel of the TweenAnim
+            world.resource_scope(|world, resource: Mut<R>| {
+                let (mut entities, commands) = world.entities_and_commands();
+
+                // Resolve the TweenAnim component
+                let Ok([mut ent]) = entities.get_mut([entity]) else {
+                    return Err(TweeningError::EntityNotFound(entity));
+                };
+                let Some(mut anim) = ent.get_mut::<TweenAnim>() else {
+                    return Err(TweeningError::MissingTweenAnim(ent.id()));
+                };
+
+                // Finally, step the TweenAnim and mutate the target
+                anim.step_self(
+                    commands,
+                    entity,
+                    delta_time,
+                    resource.into(),
+                    cycle_events.reborrow(),
+                    anim_events.reborrow(),
+                )
+            })
+        };
+        self.resource_resolver
+            .entry(resource_id)
+            .or_insert(Box::new(resolver));
     }
 
+    /// Register a resolver for the given asset type.
     ///
-    pub fn register_scoped_for<A: Asset>(&mut self, components: &Components) {
+    /// This must be called once per asset type for every asset type being
+    /// animated. Using [`tween_asset()`] automatically calls it automatically,
+    /// so if you're only using that utility then you don't need to manually
+    /// call this function.
+    ///
+    /// [`tween_asset()`]: crate::TweeningExtensions::tween_asset
+    pub fn register_asset_resolver_for<A: Asset>(&mut self, components: &Components) {
         let resource_id = components.resource_id::<Assets<A>>().unwrap();
         let resolver = |world: &mut World,
                         asset_id: UntypedAssetId,
@@ -2205,13 +3038,31 @@ impl TweenResolver {
                 )
             })
         };
-        self.scoped_resolver
+        self.asset_resolver
             .entry(resource_id)
             .or_insert(Box::new(resolver));
     }
 
     #[inline]
-    pub(crate) fn resolve_scope(
+    pub(crate) fn resolve_resource(
+        &self,
+        world: &mut World,
+        target: &ResourceAnimTarget,
+        entity: Entity,
+        delta_time: Duration,
+        cycle_events: Mut<Events<CycleCompletedEvent>>,
+        anim_events: Mut<Events<AnimCompletedEvent>>,
+    ) -> Result<StepResult, TweeningError> {
+        let Some(resolver) = self.resource_resolver.get(&target.resource_id) else {
+            return Err(TweeningError::AssetResolverNotRegistered(
+                target.resource_id,
+            ));
+        };
+        resolver(world, entity, delta_time, cycle_events, anim_events)
+    }
+
+    #[inline]
+    pub(crate) fn resolve_asset(
         &self,
         world: &mut World,
         target: &AssetAnimTarget,
@@ -2220,7 +3071,7 @@ impl TweenResolver {
         cycle_events: Mut<Events<CycleCompletedEvent>>,
         anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Result<StepResult, TweeningError> {
-        let Some(resolver) = self.scoped_resolver.get(&target.resource_id) else {
+        let Some(resolver) = self.asset_resolver.get(&target.resource_id) else {
             return Err(TweeningError::AssetResolverNotRegistered(
                 target.resource_id,
             ));
@@ -2242,362 +3093,6 @@ pub(crate) struct StepResult {
     pub sent_commands: bool,
 }
 
-// /// Animator for tween-based animations.
-// ///
-// /// This resource stores all the active tweening animations for the entire
-// /// application. It's essentially a hash map from a [`Entity`] uniquely
-// /// identifying an active animation, to the [`TweenAnim`] runtime data of
-// that /// animation. Use this resource to lookup animations by ID and modify
-// their /// runtime data, for example their playback speed.
-// ///
-// /// # Active animations
-// ///
-// /// Animations queued into the [`TweenAnimator`] by default are pruned
-// /// automatically on completion, and only active animations are retained. If
-// you /// want the animator to retain completed animation instances, so you can
-// /// continue to access them, you can set [`TweenAnim::destroy_on_completion`]
-// to /// `false` to prevent this automated destruction. Note however that doing
-// so /// will retain the animation instance forever, until set to `true` again.
-// So /// you should avoid retaining all animations forever to prevent wasting
-// memory /// and degrading performances. In general, the default pruning
-// behavior is best /// suited for one-shot animations re-created each time
-// they're needed. /// Conversely, disabling auto-destruction on completion is
-// best suited to /// reusing the same animation instance again and again.
-// ///
-// /// # Lookup without `Entity`
-// ///
-// /// If you don't know the [`Entity`] of an animation, you can also lookup the
-// /// set of animations for a given target, either component on an entity or an
-// /// asset.
-// ///
-// /// ```
-// /// # use bevy::{prelude::*, ecs::component::Components};
-// /// # use bevy_tweening::*;
-// /// fn my_system(components: &Components, animator: Res<TweenAnimator>) ->
-// Result<()> { /// # let entity = Entity::PLACEHOLDER;
-// ///     // Create an AnimTarget::Component() from an Entity and a component
-// type ///     // let entity = ...
-// ///     let target = ComponentAnimTarget::new::<Transform>(components,
-// entity)?; ///     let target: AnimTarget = target.into();
-// ///
-// ///     // Lookup all active animations and filter by target
-// ///     let animations: Vec<&TweenAnim> = animator
-// ///         .iter()
-// ///         .filter_map(|(_id, anim)| {
-// ///             if *anim.target() == target {
-// ///                 Some(anim)
-// ///             } else {
-// ///                 None
-// ///             }
-// ///         })
-// ///         .collect::<_>();
-// ///
-// ///     Ok(())
-// /// }
-// /// ```
-
-// impl TweenAnimator {
-//     /// Add a new component animation to the animator queue.
-//     ///
-//     /// In general you don't need to call this directly. Instead, use the
-//     /// extensions provided by [`EntityWorldMutTweeningExtensions`] to
-// directly     /// create and queue tweenable animations on a given
-// [`EntityCommands`],     /// like this:
-//     ///
-//     /// ```
-//     /// # use bevy::prelude::*;
-//     /// # use bevy_tweening::{lens::*, *};
-//     /// # use std::time::Duration;
-//     /// # let mut world = World::default();
-//     /// # world.register_component::<Transform>();
-//     /// # world.register_resource::<TweenAnimator>();
-//     /// # world.init_resource::<TweenAnimator>();
-//     /// # let entity = world.spawn_empty().id();
-//     /// let tween = Tween::new(
-//     ///     EaseFunction::QuadraticInOut,
-//     ///     Duration::from_secs(1),
-//     ///     TransformPositionLens {
-//     ///         start: Vec3::ZERO,
-//     ///         end: Vec3::new(3.5, 0., 0.),
-//     ///     },
-//     /// );
-//     /// world.entity_mut(entity).tween(tween);
-//     /// ```
-//     ///
-//     /// This function is still useful if you want to store the [`Entity`] of
-//     /// the new animation, to later access it to dynamically modify the
-// playback     /// (e.g. speed).
-//     ///
-//     /// ```
-//     /// # use bevy::{prelude::*, ecs::component::Components};
-//     /// # use bevy_tweening::{lens::*, *};
-//     /// # use std::time::Duration;
-//     /// # fn make_tween() -> Tween { unimplemented!() }
-//     /// // Helper component to store a Entity
-//     /// #[derive(Component)]
-//     /// struct MyTweenId(pub Entity);
-//     ///
-//     /// // System which spawns the component and its animation
-//     /// fn my_spawn_system(
-//     ///     mut commands: Commands,
-//     ///     components: &Components,
-//     ///     mut animator: ResMut<TweenAnimator>,
-//     /// ) -> Result<()> {
-//     ///     # let tween = make_tween();
-//     ///     let entity = commands.spawn(Transform::default()).id();
-//     ///     // The component type is deducted from `tween` here
-//     ///     let tween_id = animator.add_component(components, entity,
-// tween)?;     ///     // Save the new Entity for later use
-//     ///     commands.entity(entity).insert(MyTweenId(tween_id));
-//     ///     Ok(())
-//     /// }
-//     ///
-//     /// // System which modifies the animation playback
-//     /// fn my_use_system(mut animator: ResMut<TweenAnimator>, query:
-// Query<&MyTweenId>) -> Option<()> {     ///     let tween_id =
-// query.single().ok()?.0;     ///     animator.get_mut(tween_id)?.speed = 1.2;
-// // 120% playback speed     ///     Some(())
-//     /// }
-//     /// ```
-//     ///
-//     /// Note in the above that at the time when the animation is queued into
-// the     /// animator, the component doesn't yet exist in the world, because
-// the     /// spawning is deffered via [`Commands`]. This is not an error; the
-//     /// [`TweenAnimator`] doesn't perform any check when this function is
-//     /// called, on purpose to allow patterns like inserting the returned
-//     /// [`Entity`] into a component or resource from within the same system
-//     /// which spawned the target, without having to apply deferred commands
-//     /// first. When the animation steps however, the target is validated, and
-// if     /// invalid (either because the entity doesn't exist or it doesn't
-// have the     /// target component) then the animation instance is destroyed.
-//     #[inline]
-//     pub fn add_component<T>(
-//         &mut self,
-//         components: &Components,
-//         entity: Entity,
-//         tweenable: T,
-//     ) -> Result<Entity, TweeningError>
-//     where
-//         T: Tweenable + 'static,
-//     {
-//         let Some(type_id) = tweenable.type_id() else {
-//             return Err(TweeningError::UntypedTweenable);
-//         };
-//         let target = ComponentAnimTarget::new_untyped(components, type_id,
-// entity)?.into();         Ok(self.add_component_target(target, tweenable))
-//     }
-
-//     /// Add a new component animation via an existing
-// [`ComponentAnimTarget`].     ///
-//     /// See [`add_component()`] for details. This variant is useful when you
-// can     /// build in advance a [`ComponentAnimTarget`], but at the same time
-// don't     /// readily have access to the [`Components`] of the world.
-//     ///
-//     /// Note that there's no equivalent for assets, because asset animations
-//     /// need to register some internal type-dependent resolver due to assets
-//     /// being only accessible through the typed [`Assets<A>`] API.
-//     ///
-//     /// [`add_component()`]: Self::add_component
-//     #[inline]
-//     pub fn add_component_target<T>(&mut self, target: ComponentAnimTarget,
-// tweenable: T) -> Entity     where
-//         T: Tweenable + 'static,
-//     {
-//         self.anims
-//             .insert(TweenAnim::new(target.into(), Box::new(tweenable)))
-//     }
-
-//     /// Add a new asset animation to the animator queue.
-//     ///
-//     /// ```
-//     /// # use bevy::{prelude::*, ecs::component::Components};
-//     /// # use bevy_tweening::{lens::*, *};
-//     /// # use std::time::Duration;
-//     /// # fn make_tween() -> Tween { unimplemented!() }
-//     /// #[derive(Asset, TypePath)]
-//     /// struct MyAsset;
-//     ///
-//     /// // Helper component to store a Entity
-//     /// #[derive(Resource)]
-//     /// struct MyTweenId(pub Entity);
-//     ///
-//     /// // System which spawns the asset animation
-//     /// fn my_spawn_system(
-//     ///     mut assets: ResMut<Assets<MyAsset>>,
-//     ///     components: &Components,
-//     ///     mut animator: ResMut<TweenAnimator>,
-//     ///     mut my_tween_id: ResMut<MyTweenId>,
-//     /// ) -> Result<()> {
-//     ///     # let tween = make_tween();
-//     ///     let handle = assets.add(MyAsset);
-//     ///     // The asset type is deducted from `tween` here
-//     ///     let tween_id = animator.add_asset(components, handle.id(),
-// tween)?;     ///     // Save the new Entity for later use
-//     ///     my_tween_id.0 = tween_id;
-//     ///     Ok(())
-//     /// }
-//     ///
-//     /// // System which modifies the animation playback
-//     /// fn my_use_system(
-//     ///     mut animator: ResMut<TweenAnimator>,
-//     ///     my_tween_id: Res<MyTweenId>,
-//     /// ) -> Option<()> {
-//     ///     let tween_id = my_tween_id.0;
-//     ///     animator.get_mut(tween_id)?.speed = 1.2; // 120% playback speed
-//     ///     Some(())
-//     /// }
-//     /// ```
-//     ///
-//     /// Note that unlike [`add_component()`], this function depends on the
-// asset     /// type. This is required to allow registering some internal
-// resolver to     /// extract the typed animation from its typed `Assets<A>`,
-// as this can't be     /// done via untyped references (unlike for components).
-//     ///
-//     /// [`get_asset_target()`]: WorldTargetExtensions::get_asset_target
-//     /// [`add_component()`]: Self::add_component
-//     #[inline]
-//     pub fn add_asset<T, A: Asset>(
-//         &mut self,
-//         components: &Components,
-//         asset_id: impl Into<AssetId<A>>,
-//         tweenable: T,
-//     ) -> Result<Entity, TweeningError>
-//     where
-//         T: Tweenable + 'static,
-//     {
-//         let Some(type_id) = tweenable.type_id() else {
-//             return Err(TweeningError::UntypedTweenable);
-//         };
-//         if type_id != TypeId::of::<A>() {
-//             return Err(TweeningError::InvalidAssetIdType {
-//                 expected: TypeId::of::<A>(),
-//                 actual: type_id,
-//             });
-//         }
-//         let asset_id = asset_id.into();
-//         let target = AssetAnimTarget::new(components, asset_id)?;
-//         self.asset_resolver.insert(
-//             target.resource_id,
-//             Box::new(
-//                 |assets: MutUntyped, asset_id: UntypedAssetId| -> Option<MutUntyped> {
-//                     // SAFETY: The correct type is captured from the outer
-// function                     #[allow(unsafe_code)]
-//                     let assets = unsafe { assets.with_type::<Assets<A>>() };
-//                     let asset_id = asset_id.try_typed::<A>().ok()?;
-//                     assets
-//                         .filter_map_unchanged(|assets|
-// assets.get_mut(asset_id))                         .map(Into::into)
-//                 },
-//             ),
-//         );
-//         Ok(self
-//             .anims
-//             .insert(TweenAnim::new(target.into(), Box::new(tweenable))))
-//     }
-
-//     /// Check if the animation with the given ID is queued.
-//     ///
-//     /// If this returns `false` then any animation which might have existed
-// with     /// this ID was destroyed, and this ID will forever be invalid and
-//     /// unused.
-//     ///
-//     /// # Returns
-//     ///
-//     /// Returns `true` if the animation is queued, either because it's
-// playing,     /// or because it's completed but
-// [`TweenAnim::destroy_on_completion`] was     /// set to `false`. In that case
-// the [`TweenAnim`] can be accessed by the     /// likes of [`get()`].
-//     ///
-//     /// [`get()`]: Self::get
-//     #[inline]
-//     pub fn contains(&self, id: Entity) -> bool {
-//         self.anims.contains_key(id)
-//     }
-
-//     /// Get a queued tweenable animation from its ID.
-//     ///
-//     /// This fails and returns `None` if the animation has completed and was
-//     /// removed from the animator's internal queue, or if the ID is invalid
-//     /// (notably, `Entity::PLACEHOLDER`).
-//     #[inline]
-//     pub fn get(&self, id: Entity) -> Option<&TweenAnim> {
-//         self.anims.get(id)
-//     }
-
-//     /// Get a queued tweenable animation from its ID.
-//     ///
-//     /// This fails and returns `None` if the animation has completed and was
-//     /// removed from the animator's internal queue, or if the ID is invalid
-//     /// (notably, `Entity::PLACEHOLDER`).
-//     #[inline]
-//     pub fn get_mut(&mut self, id: Entity) -> Option<&mut TweenAnim> {
-//         self.anims.get_mut(id)
-//     }
-
-//     /// Get a queued tweenable animation from its ID.
-//     ///
-//     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
-//     /// animation has completed and was removed from the animator's internal
-//     /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
-//     #[inline]
-//     pub fn try_get(&self, id: Entity) -> Result<&TweenAnim, TweeningError> {
-//         self.anims.get(id).ok_or(TweeningError::InvalidTweenId(id))
-//     }
-
-//     /// Get a queued tweenable animation from its ID.
-//     ///
-//     /// This fails and returns [`TweeningError::InvalidTweenId`] if the
-//     /// animation has completed and was removed from the animator's internal
-//     /// queue, or if the ID is invalid (notably, `Entity::PLACEHOLDER`).
-//     #[inline]
-//     pub fn try_get_mut(&mut self, id: Entity) -> Result<&mut TweenAnim,
-// TweeningError> {         self.anims
-//             .get_mut(id)
-//             .ok_or(TweeningError::InvalidTweenId(id))
-//     }
-
-//     /// Get an iterator over the queued tweenable animations.
-//     ///
-//     /// # Returns
-//     ///
-//     /// An iterator over pairs of (ID, animation) for all animations still in
-//     /// the internal queue.
-//     #[inline]
-//     pub fn iter(&self) -> impl Iterator<Item = (Entity, &TweenAnim)> {
-//         self.anims.iter()
-//     }
-
-//     /// Get a mutable iterator over the queued tweenable animations.
-//     ///
-//     /// # Returns
-//     ///
-//     /// An iterator over pairs of (ID, animation) for all animations still in
-//     /// the internal queue.
-//     #[inline]
-//     pub fn iter_mut(&mut self) -> impl Iterator<Item = (Entity, &mut
-// TweenAnim)> {         self.anims.iter_mut()
-//     }
-
-//     /// Remove a queued tweenable animation and return it.
-//     ///
-//     /// This immediately removes the animation, if it exists, without
-// modifying     /// further its target. After the animation is removed, the
-// `id` is     /// invalid and will never be reused. The animation cannot be
-// re-queued;     /// instead, a new animation sould be created with
-// [`add_component()`] or     /// [`add_asset()`], which will generate a
-// different ID.     ///
-//     /// # Returns
-//     ///
-//     /// If the ID was valid and an animation with this ID was removed,
-// returns     /// that animation. Otherwise returns `None`.
-//     ///
-//     /// [`add_component()`]: Self::add_component
-//     /// [`add_asset()`]: Self::add_asset
-//     #[inline]
-//     pub fn remove(&mut self, id: Entity) -> Option<TweenAnim> {
-//         self.anims.remove(id)
-//     }
-
 //     /// Retarget a queued animation.
 //     ///
 //     /// Attempt to change the target of a tweening animation already
@@ -2652,318 +3147,20 @@ pub(crate) struct StepResult {
 //         Ok(old_target)
 //     }
 
-//     /// Swap a queued animation.
-//     ///
-//     /// Attempt to change the tweenable of an animation already enqueued, and
-//     /// possibly already playing.
-//     ///
-//     /// If the tweenable is successfully swapped, this resets the
-//     /// [`TweenAnim::tween_state()`] to [`TweenState::Active`], even if the
-//     /// tweenable would otherwise be completed _e.g._ because its elapsed
-// time     /// is past its total duration. Conversely, this doesn't update the
-// target,     /// as this function doesn't have mutable access to it.
-//     ///
-//     /// To ensure the old and new animations have the same elapsed time (for
-//     /// example if they need to be synchronized), call [`set_elapsed()`]
-// first     ///   on the input `tweenable`, with the duration value of the old
-//     ///   tweenable as returned by [`elapsed()`].
-//     ///
-//     /// ```
-//     /// # use std::time::Duration;
-//     /// # use bevy::prelude::*;
-//     /// # use bevy_tweening::*;
-//     /// # fn sys(mut animator: ResMut<TweenAnimator>) {
-//     /// # let id = Entity::PLACEHOLDER;
-//     /// # let mut tweenable = Delay::new(Duration::from_secs(1));
-//     /// let elapsed = animator.get(id).unwrap().tweenable().elapsed();
-//     /// tweenable.set_elapsed(elapsed);
-//     /// animator.set_tweenable(id, tweenable);
-//     /// # }
-//     /// ```
-//     ///
-//     /// To recompute the actual tweenable animation state and force a target
-//     /// update, use [`step_one()`] with a [`Duration::ZERO`].
-//     ///
-//     /// # Returns
-//     ///
-//     /// On success, returns the previous tweenable which has been swapped
-// out.     ///
-//     /// [`set_elapsed()`]: crate::Tweenable::set_elapsed
-//     /// [`elapsed()`]: crate::Tweenable::elapsed
-//     /// [`step_one()`]: Self::step_one
-//     pub fn set_tweenable<T>(
-//         &mut self,
-//         id: Entity,
-//         tweenable: T,
-//     ) -> Result<BoxedTweenable, TweeningError>
-//     where
-//         T: Tweenable + 'static,
-//     {
-//         let anim = self
-//             .anims
-//             .get_mut(id)
-//             .ok_or(TweeningError::InvalidTweenId(id))?;
-//         let mut old_tweenable: BoxedTweenable = Box::new(tweenable);
-//         std::mem::swap(&mut anim.tweenable, &mut old_tweenable);
-//         // Reset tweening state, the new tweenable is at t=0
-//         anim.tween_state = TweenState::Active;
-//         Ok(old_tweenable)
-//     }
-
-//     /// Step the given queued animation.
-//     ///
-//     /// In general all animations are stepped automatically via
-// [`step_all()`],     /// which is called from a system added by the
-// [`TweeningPlugin`]. This     /// function can be used to step a single
-// animation, either in addition or     /// in place of that system or any call
-// to [`step_all()`]. If the `id` is     /// invalid, this function does
-// nothing.     ///
-//     /// One useful use of this function is to force a mutation on the target,
-//     /// for example because some specific animation change was made which
-//     /// couldn't directly mutate it. By passing [`Duration::ZERO`], this
-//     /// function effectively forces the target state to the current animation
-//     /// "position" without playing back the animation itself (the elapsed
-// time     /// is not modified).
-//     ///
-//     /// # Returns
-//     ///
-//     /// If the animation completed and was destroyed, returns a copy of that
-//     /// animation. Otherwise if the animation is still queued, returns
-// `None`.     ///
-//     /// [`step_all()`]: Self::step_all
-//     #[inline]
-//     pub fn step_one(
-//         &mut self,
-//         world: &mut World,
-//         id: Entity,
-//         delta_time: Duration,
-//     ) -> Option<TweenAnim> {
-//         world.resource_scope(|world, events:
-// Mut<Events<CycleCompletedEvent>>| {             world.resource_scope(|world,
-// anim_events: Mut<Events<AnimCompletedEvent>>| {                 let anim =
-// self.anims.get_mut(id)?;
-
-//                 let ret = Self::step_impl(
-//                     id,
-//                     anim,
-//                     &self.asset_resolver,
-//                     world,
-//                     delta_time,
-//                     events,
-//                     anim_events,
-//                 );
-
-//                 if let Ok(ret) = ret {
-//                     if ret.sent_commands {
-//                         world.flush();
-//                     }
-
-//                     if !ret.retain {
-//                         return Some(self.anims.remove(id).unwrap());
-//                     }
-//                 }
-//                 None
-//             })
-//         })
-//     }
-
-//     fn step_impl(
-//         tween_id: Entity,
-//         anim: &mut TweenAnim,
-//         asset_resolver: &HashMap<ComponentId, Resolver>,
-//         world: &mut World,
-//         delta_time: Duration,
-//         mut events: Mut<Events<CycleCompletedEvent>>,
-//         mut anim_events: Mut<Events<AnimCompletedEvent>>,
-//     ) -> Result<StepResult, TweeningError> {
-//         let mut queued_systems = Vec::with_capacity(8);
-//         let mut completed_events = Vec::with_capacity(8);
-//         let mut sent_commands = false;
-
-//         // Sanity checks on fields which can be freely modified by the user
-//         anim.speed = anim.speed.max(0.);
-
-//         // Retain completed animations only if requested
-//         if anim.tween_state == TweenState::Completed {
-//             let ret = StepResult {
-//                 retain: !anim.destroy_on_completion,
-//                 sent_commands: false,
-//             };
-//             return Ok(ret);
-//         }
-
-//         // Skip paused animations (but retain them)
-//         if anim.playback_state == PlaybackState::Paused || anim.speed <= 0. {
-//             let ret = StepResult {
-//                 retain: true,
-//                 sent_commands: false,
-//             };
-//             return Ok(ret);
-//         }
-
-//         // Resolve the (untyped) target as a MutUntyped<T>
-//         let Some(mut mut_untyped) = (match &anim.target {
-//             AnimTarget::Component(ComponentAnimTarget {
-//                 entity,
-//                 component_id,
-//             }) => world.get_mut_by_id(*entity, *component_id),
-//             AnimTarget::Asset(AssetAnimTarget {
-//                 resource_id,
-//                 asset_id,
-//             }) => {
-//                 if let Some(assets) =
-// world.get_resource_mut_by_id(*resource_id) {                     if let
-// Some(resolver) = asset_resolver.get(resource_id) {
-// resolver(assets, *asset_id)                     } else {
-//                         None
-//                     }
-//                 } else {
-//                     None
-//                 }
-//             }
-//         }) else {
-//             let ret = StepResult {
-//                 retain: false,
-//                 sent_commands: false,
-//             };
-//             return Ok(ret);
-//         };
-
-//         // Scale delta time by this animation's speed. Reject negative
-// speeds; use         // backward playback to play in reverse direction.
-//         // Note: must use f64 for precision; f32 produces visible roundings.
-//         let delta_time = delta_time.mul_f64(anim.speed);
-
-//         // Step the tweenable animation
-//         let entity = anim.target.as_component().map(|comp| comp.entity);
-//         let mut notify_completed = || {
-//             completed_events.push((
-//                 CycleCompletedEvent {
-//                     id: tween_id,
-//                     target: anim.target,
-//                 },
-//                 entity,
-//             ));
-//         };
-//         let mut queue_system = |system_id: SystemId| {
-//             queued_systems.push(system_id);
-//         };
-//         let state = anim.tweenable.step(
-//             tween_id,
-//             delta_time,
-//             mut_untyped.reborrow(),
-//             &mut notify_completed,
-//             &mut queue_system,
-//         );
-//         anim.tween_state = state;
-
-//         // Send tween completed events once we reclaimed mut access to world
-// and can get         // a Commands.
-//         if !completed_events.is_empty() {
-//             let mut commands = world.commands();
-//             sent_commands = true;
-
-//             for (event, entity) in completed_events.drain(..) {
-//                 // Send buffered event
-//                 events.send(event);
-
-//                 // Trigger all entity-scoped observers
-//                 if let Some(entity) = entity {
-//                     commands.trigger_targets(event, entity);
-//                 }
-//             }
-//         }
-
-//         // Execute one-shot systems
-//         for sys_id in queued_systems.drain(..) {
-//             let _ = world.run_system(sys_id);
-//         }
-
-//         // Raise animation completed event
-//         if state == TweenState::Completed {
-//             let event = AnimCompletedEvent {
-//                 id: tween_id,
-//                 target: anim.target,
-//             };
-
-//             // Send buffered event
-//             anim_events.send(event);
-
-//             // Trigger all entity-scoped observers
-//             if let Some(entity) = entity {
-//                 let mut commands = world.commands();
-//                 sent_commands = true;
-//                 commands.trigger_targets(event, entity);
-//             }
-//         }
-
-//         let ret = StepResult {
-//             retain: state == TweenState::Active ||
-// !anim.destroy_on_completion,             sent_commands,
-//         };
-//         Ok(ret)
-//     }
-
-//     /// Step all queued animations.
-//     ///
-//     /// Loop over the internal queue of tweenable animations, apply them to
-//     /// their respective target, and prune all the completed ones (the ones
-//     /// returning [`TweenState::Completed`]). In the later case, send
-//     /// [`AnimCompletedEvent`]s.
-//     ///
-//     /// If you use the [`TweeningPlugin`], this is automatically called by
-// the     /// animation system the plugin registers. See the
-//     /// [`AnimationSystem::AnimationUpdate`] system set.
-//     ///
-//     /// Note that the order in which the animations are iterated over and
-//     /// played, and therefore also the order in which any event is raised or
-// any     /// one-shot system is executed, is an unspecified implementation
-// detail.     /// There is no guarantee on that order nor its stability frame
-// to     /// frame.
-//     pub fn step_all(&mut self, world: &mut World, delta_time: Duration) {
-//         world.resource_scope(|world, mut events:
-// Mut<Events<CycleCompletedEvent>>| {             world.resource_scope(|world,
-// mut anim_events: Mut<Events<AnimCompletedEvent>>| {                 let mut
-// sent_commands = false;
-
-//                 // Loop over active animations, tick them, and retain those
-// which are still                 // active after that
-//                 self.anims.retain(|tween_id, anim| {
-//                     let ret = Self::step_impl(
-//                         tween_id,
-//                         anim,
-//                         &self.asset_resolver,
-//                         world,
-//                         delta_time,
-//                         events.reborrow(),
-//                         anim_events.reborrow(),
-//                     );
-//                     if let Ok(ret) = ret {
-//                         sent_commands = sent_commands || ret.sent_commands;
-//                         return ret.retain;
-//                     }
-//                     false
-//                 });
-
-//                 // Flush commands
-//                 if sent_commands {
-//                     world.flush();
-//                 }
-//             });
-//         });
-//     }
-// }
-
 /// Extension trait to interpolate between two colors.
 ///
 /// This adds a [`Color::lerp()`] function which linearly interpolates the
-/// `LinearRgba` values component-wise.
+/// `LinearRgba` values component-wise, by converting the input color to
+/// [`LinearRgba`] space.
 ///
 /// Note that this is a convenience helper with naive color interpolation. In
 /// general, to get more accurrate colors, you should create your own [`Lens`]
 /// and apply a better interpolation, for example based on luminosity. There's
 /// no "canonical" color interpolation, and the best answer varies depending on
-/// the context.
+/// the context and the color space used. This utility does a reasonable job for
+/// simple cases where the color accuracy is less critical, like animating some
+/// colors in UI. You should probably not use it to animate in-game colors on
+/// _e.g._ materials, especially if you're using Bevy's PBR rendering engine.
 #[allow(dead_code)]
 #[cfg(any(feature = "bevy_sprite", feature = "bevy_ui", feature = "bevy_text"))]
 trait ColorLerper {
@@ -3003,6 +3200,11 @@ mod tests {
         value: f32,
     }
 
+    #[derive(Debug, Default, Clone, Copy, Resource)]
+    struct DummyResource {
+        value: f32,
+    }
+
     #[derive(Asset, Debug, Default, Reflect)]
     struct DummyAsset {
         value: f32,
@@ -3036,11 +3238,39 @@ mod tests {
 
                 assert!(target.is_changed());
             }
-
             assert_approx_eq!(c.value, r);
         }
     }
 
+    impl Lens<DummyResource> for DummyLens {
+        fn lerp(&mut self, mut target: Mut<DummyResource>, ratio: f32) {
+            target.value = self.start.lerp(self.end, ratio);
+        }
+    }
+
+    #[test]
+    fn dummy_lens_resource() {
+        let mut res = DummyResource::default();
+        let mut l = DummyLens { start: 0., end: 1. };
+        for r in [0_f32, 0.01, 0.3, 0.5, 0.9, 0.999, 1.] {
+            {
+                let mut added = Tick::new(0);
+                let mut last_changed = Tick::new(0);
+                let mut caller = MaybeLocation::caller();
+                let mut target = Mut::new(
+                    &mut res,
+                    &mut added,
+                    &mut last_changed,
+                    Tick::new(0),
+                    Tick::new(0),
+                    caller.as_mut(),
+                );
+                l.lerp(target.reborrow(), r);
+            }
+            assert_approx_eq!(res.value, r);
+        }
+    }
+
     impl Lens<DummyAsset> for DummyLens {
         fn lerp(&mut self, mut target: Mut<DummyAsset>, ratio: f32) {
             target.value = self.start.lerp(self.end, ratio);
@@ -3151,15 +3381,6 @@ mod tests {
         assert_eq!(1., ease.sample(0.));
     }
 
-    // #[test]
-    // fn animator_default() {
-    //     let mut animator = TweenAnimator::default();
-    //     assert!(animator.get(Entity::PLACEHOLDER).is_none());
-    //     assert!(animator.iter().next().is_none());
-    //     assert!(animator.iter_mut().next().is_none());
-    //     assert!(animator.remove(Entity::PLACEHOLDER).is_none());
-    // }
-
     // TweenAnim::playback_state is entirely user-controlled; stepping animations
     // won't change it.
     #[test]
@@ -3206,7 +3427,7 @@ mod tests {
             DummyLens { start: 0., end: 1. },
         )
         .with_repeat_count(2)
-        .with_completed_event(true);
+        .with_cycle_completed_event(true);
         let mut env = TestEnv::<DummyComponent>::new(tween);
 
         // Tick until one cycle is completed, but not the entire animation
@@ -3256,7 +3477,7 @@ mod tests {
             DummyLens { start: 0., end: 1. },
         )
         .with_repeat_count(2)
-        .with_completed_event(true);
+        .with_cycle_completed_event(true);
         let mut env = TestEnv::<DummyComponent>::new(tween);
 
         env.world.init_resource::<Count<CycleCompletedEvent>>();
diff --git a/src/plugin.rs b/src/plugin.rs
index c1b4bcd..13eb57b 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -9,6 +9,16 @@ use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenResolver};
 /// tweenable animations. That system runs in the
 /// [`AnimationSystem::AnimationUpdate`] system set, during the [`Update`]
 /// schedule.
+///
+/// ```no_run
+/// use bevy::prelude::*;
+/// use bevy_tweening::*;
+///
+/// App::default()
+///     .add_plugins(DefaultPlugins)
+///     .add_plugins(TweeningPlugin)
+///     .run();
+/// ```
 #[derive(Debug, Clone, Copy)]
 pub struct TweeningPlugin;
 
@@ -63,7 +73,7 @@ mod tests {
                 end: Vec3::ONE,
             },
         )
-        .with_completed_event(true);
+        .with_cycle_completed_event(true);
         let mut env = TestEnv::<Transform>::new(tween);
 
         env.step_all(Duration::ZERO);
@@ -85,7 +95,7 @@ mod tests {
                 end: Vec3::ONE,
             },
         )
-        .with_completed_event(true);
+        .with_cycle_completed_event(true);
 
         let mut env = TestEnv::<Transform>::new(tween);
 
@@ -165,7 +175,7 @@ mod tests {
                 defer: Arc::clone(&defer),
             },
         )
-        .with_completed_event(true);
+        .with_cycle_completed_event(true);
 
         let mut env = TestEnv::<DummyComponent>::new(tween);
 
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 7022cbd..c85bde8 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -419,7 +419,8 @@ impl Ord for TotalDuration {
     }
 }
 
-/// An animatable entity, either a single [`Tween`] or a collection of them.
+/// Tweening animation description, either a single [`Tween`] or a collection of
+/// them.
 pub trait Tweenable: Send + Sync {
     /// Get the duration of a single cycle of the animation.
     ///
@@ -497,7 +498,7 @@ pub trait Tweenable: Send + Sync {
         tween_id: Entity,
         delta: Duration,
         target: MutUntyped,
-        notify_completed: &mut dyn FnMut(),
+        notify_cycle_completed: &mut dyn FnMut(),
     ) -> TweenState;
 
     /// Rewind the animation to its starting state.
@@ -568,6 +569,26 @@ impl_boxed!(Delay);
 
 type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 
+/// Configuration to create a [`Tween`].
+///
+/// This is largely an internal type, only exposed due to other constraints.
+#[doc(hidden)]
+#[derive(Default, Clone, Copy)]
+pub struct TweenConfig {
+    ///
+    pub ease_method: EaseMethod,
+    ///
+    pub playback_direction: PlaybackDirection,
+    ///
+    pub send_cycle_completed_event: bool,
+    ///
+    pub cycle_duration: Duration,
+    ///
+    pub repeat_count: RepeatCount,
+    ///
+    pub repeat_strategy: RepeatStrategy,
+}
+
 /// Single tweening animation description.
 ///
 /// A _tween_ is the basic building block of an animation. It describes a single
@@ -621,16 +642,19 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 /// duration of the animation. This is a property of an active animation, and is
 /// available per instance from the [`TweenAnim`] representing the instance. So
 /// a tween itself, which describes an animation without a specific target to
-/// animate, doesn't have an elapsed time.
+/// animate, doesn't have an elapsed time. You can think of the elapsed time as
+/// the current time position on some animation timeline.
 ///
 /// The tween however has a _playback direction_. By default, the playback
 /// direction is [`PlaybackDirection::Forward`], and the animation plays forward
 /// as described above. By instead using [`PlaybackDirection::Backward`], the
 /// tween plays in reverse from end to start. Practically, this means that the
 /// elapsed time _decreases_ from its current value back to zero, and the
-/// animation completes at `t=0`. Note that as a result, because infinite
-/// animations ([`RepeatCount::Infinite`]) don't have an end time, they cannot
-/// be rewinded when the playback direction is backward.
+/// animation completes at `t=0`. You can think of the playback direction as the
+/// direction in which the time position moves on some animation timeline. Note
+/// that as a result, because infinite animations ([`RepeatCount::Infinite`])
+/// don't have an end time, they cannot be rewinded when the playback direction
+/// is backward.
 ///
 /// # Completion events and one-shot systems
 ///
@@ -642,23 +666,22 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 ///   [`CycleCompletedEvent`]. The event is emitted as a buffered event, to be
 ///   read by another system through an [`EventReader`]. For component targets,
 ///   observers are also triggered. Both of these are enabled through
-///   [`with_completed_event()`] and [`set_completed_event()`]. Per-cycle events
-///   are disabled by default.
+///   [`with_cycle_completed_event()`] and [`set_cycle_completed_event()`].
+///   Per-cycle events are disabled by default.
 /// - At the end of all cycles, when the animation itself completes, the tween
 ///   emits an [`AnimCompletedEvent`]. This event is always emitted.
 ///
 /// [`TweenAnim`]: crate::TweenAnim
-/// [`with_completed_event()`]: Self::with_completed_event
-/// [`set_completed_event()`]: Self::set_completed_event
+/// [`with_cycle_completed_event()`]: Self::with_cycle_completed_event
+/// [`set_cycle_completed_event()`]: Self::set_cycle_completed_event
 /// [`AnimCompletedEvent`]: crate::AnimCompletedEvent
-/// [`TweenAnimator`]: crate::TweenAnimator
 pub struct Tween {
     ease_method: EaseMethod,
     clock: AnimClock,
     /// Direction of playback the user asked for.
     playback_direction: PlaybackDirection,
     action: Box<TargetAction>,
-    send_completed_event: bool,
+    send_cycle_completed_event: bool,
     /// Type ID of the target.
     type_id: TypeId,
 }
@@ -709,11 +732,35 @@ impl Tween {
             clock: AnimClock::new(cycle_duration),
             playback_direction: PlaybackDirection::Forward,
             action: Box::new(action),
-            send_completed_event: false,
+            send_cycle_completed_event: false,
             type_id: TypeId::of::<T>(),
         }
     }
 
+    #[inline]
+    #[must_use]
+    pub(crate) fn from_config<T, L>(config: TweenConfig, mut lens: L) -> Self
+    where
+        T: 'static,
+        L: Lens<T> + Send + Sync + 'static,
+    {
+        let action = move |ptr: MutUntyped, ratio: f32| {
+            // SAFETY: ptr was obtained from the same type, via the type_id saved below.
+            #[allow(unsafe_code)]
+            let target = unsafe { ptr.with_type::<T>() };
+            lens.lerp(target, ratio);
+        };
+        let this = Self {
+            ease_method: config.ease_method,
+            clock: AnimClock::new(config.cycle_duration),
+            playback_direction: config.playback_direction,
+            action: Box::new(action),
+            send_cycle_completed_event: config.send_cycle_completed_event,
+            type_id: TypeId::of::<T>(),
+        };
+        this.with_repeat(config.repeat_count, config.repeat_strategy)
+    }
+
     /// Set the number of times to repeat the animation.
     ///
     /// The repeat count determines the number of cycles of the animation. See
@@ -727,6 +774,17 @@ impl Tween {
         self
     }
 
+    /// Set the number of times to repeat the animation.
+    ///
+    /// The repeat count determines the number of cycles of the animation. See
+    /// [the top-level `Tween` documentation] for details.
+    ///
+    /// [the top-level `Tween` documentation]: crate::Tween#cycles
+    pub fn set_repeat_count(&mut self, count: impl Into<RepeatCount>) {
+        self.clock.total_duration =
+            TotalDuration::from_cycles(self.clock.cycle_duration, count.into());
+    }
+
     /// Configure how the cycles repeat.
     ///
     /// This enables or disables cycle mirroring. See [the top-level `Tween`
@@ -739,6 +797,42 @@ impl Tween {
         self
     }
 
+    /// Configure how the cycles repeat.
+    ///
+    /// This enables or disables cycle mirroring. See [the top-level `Tween`
+    /// documentation] for details.
+    ///
+    /// [the top-level `Tween` documentation]: crate::Tween#cycles
+    pub fn set_repeat_strategy(&mut self, strategy: RepeatStrategy) {
+        self.clock.strategy = strategy;
+    }
+
+    /// Configure the animation repeat parameters.
+    ///
+    /// The repeat count determines the number of cycles of the animation. The
+    /// repeat strategy enables or disables cycle mirrored repeat. See
+    /// [the top-level `Tween` documentation] for details.
+    ///
+    /// [the top-level `Tween` documentation]: crate::Tween#cycles
+    #[must_use]
+    #[inline]
+    pub fn with_repeat(self, count: impl Into<RepeatCount>, strategy: RepeatStrategy) -> Self {
+        self.with_repeat_count(count).with_repeat_strategy(strategy)
+    }
+
+    /// Configure the animation repeat parameters.
+    ///
+    /// The repeat count determines the number of cycles of the animation. The
+    /// repeat strategy enables or disables cycle mirrored repeat. See
+    /// [the top-level `Tween` documentation] for details.
+    ///
+    /// [the top-level `Tween` documentation]: crate::Tween#cycles
+    #[inline]
+    pub fn set_repeat(&mut self, count: impl Into<RepeatCount>, strategy: RepeatStrategy) {
+        self.set_repeat_count(count);
+        self.set_repeat_strategy(strategy);
+    }
+
     /// Enable raising a event on cycle completion.
     ///
     /// If enabled, the tween will raise a [`CycleCompletedEvent`] each time
@@ -764,7 +858,7 @@ impl Tween {
     /// #    },
     /// )
     /// // Raise a CycleCompletedEvent each cycle
-    /// .with_completed_event(true);
+    /// .with_cycle_completed_event(true);
     ///
     /// fn my_system(mut reader: EventReader<CycleCompletedEvent>) {
     ///     for ev in reader.read() {
@@ -777,18 +871,18 @@ impl Tween {
     /// }
     /// ```
     #[must_use]
-    pub fn with_completed_event(mut self, send: bool) -> Self {
-        self.send_completed_event = send;
+    pub fn with_cycle_completed_event(mut self, send: bool) -> Self {
+        self.send_cycle_completed_event = send;
         self
     }
 
     /// Set whether the tween emits [`CycleCompletedEvent`].
     ///
-    /// See [`with_completed_event()`] for details.
+    /// See [`with_cycle_completed_event()`] for details.
     ///
-    /// [`with_completed_event()`]: Self::with_completed_event
-    pub fn set_completed_event(&mut self, send: bool) {
-        self.send_completed_event = send;
+    /// [`with_cycle_completed_event()`]: Self::with_cycle_completed_event
+    pub fn set_cycle_completed_event(&mut self, send: bool) {
+        self.send_cycle_completed_event = send;
     }
 
     /// Set the playback direction of the tween.
@@ -926,7 +1020,7 @@ impl Tweenable for Tween {
         _tween_id: Entity,
         delta: Duration,
         target: MutUntyped,
-        notify_completed: &mut dyn FnMut(),
+        notify_cycle_completed: &mut dyn FnMut(),
     ) -> TweenState {
         if self.clock.state(self.playback_direction) == TweenState::Completed {
             return TweenState::Completed;
@@ -946,8 +1040,8 @@ impl Tweenable for Tween {
         (self.action)(target, fraction);
 
         // If completed at least once this frame, notify the user
-        if times_completed != 0 && self.send_completed_event {
-            notify_completed();
+        if times_completed != 0 && self.send_cycle_completed_event {
+            notify_cycle_completed();
         }
 
         state
@@ -962,7 +1056,7 @@ impl Tweenable for Tween {
     }
 }
 
-/// A sequence of tweens played back in order one after the other.
+/// A sequence of tweenable animations played in order one after the other.
 pub struct Sequence {
     tweens: Vec<BoxedTweenable>,
     index: usize,
@@ -1550,9 +1644,9 @@ mod tests {
                     .with_playback_direction(playback_direction)
                     .with_repeat_count(count)
                     .with_repeat_strategy(strategy)
-                    .with_completed_event(true);
+                    .with_cycle_completed_event(true);
                 assert_eq!(tween.playback_direction(), playback_direction);
-                assert!(tween.send_completed_event);
+                assert!(tween.send_cycle_completed_event);
 
                 // Note: for infinite duration playing backward, we need to start *somewhere*
                 // since we can't start at infinity. So pick t=1s which is shorter than 11
@@ -1865,8 +1959,8 @@ mod tests {
                 }
 
                 // Clear event sending
-                tween.set_completed_event(false);
-                assert!(!tween.send_completed_event);
+                tween.set_cycle_completed_event(false);
+                assert!(!tween.send_cycle_completed_event);
             }
         }
     }

From 632381c02563c9c23cc28fa18865a1cb459d1a0d Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Fri, 1 Aug 2025 21:31:24 +0100
Subject: [PATCH 54/66] Make `AnimatedEntityCommands` owns by value

---
 src/lib.rs | 110 +++++++++++++++--------------------------------------
 1 file changed, 30 insertions(+), 80 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index c32edae..797dab5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1202,7 +1202,7 @@ impl TweenCommand for ScaleFromCommand {
 ///
 /// [`reborrow()`]: bevy::prelude::EntityCommands::reborrow
 pub struct AnimatedEntityCommands<'a, C: TweenCommand> {
-    commands: Option<EntityCommands<'a>>,
+    commands: EntityCommands<'a>,
     cmd: Option<C>,
 }
 
@@ -1210,7 +1210,7 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
     /// Wrap an [`EntityCommands`] into an animated one.
     pub fn new(commands: EntityCommands<'a>, cmd: C) -> Self {
         Self {
-            commands: Some(commands),
+            commands,
             cmd: Some(cmd),
         }
     }
@@ -1250,7 +1250,18 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
     /// commands queue is returned.
     pub fn into_inner(mut self) -> EntityCommands<'a> {
         self.flush();
-        self.commands.take().unwrap()
+        // Since we already flushed above, we don't need Drop. And trying to keep would
+        // allow it to access self.commands after it was stolen (even though we know the
+        // implementation doesn't in practice). Still, it's safer to just short-circuit
+        // Drop here.
+        let this = std::mem::ManuallyDrop::new(self);
+        // SAFETY: We have flushed self.cmd which is now None, and we're stealing
+        // self.commands, after which the this object is forgotten and never
+        // accessed again.
+        #[allow(unsafe_code)]
+        unsafe {
+            std::ptr::read(&this.commands)
+        }
     }
 
     /// Flush the current animation, inserting it into the commands queue.
@@ -1268,50 +1279,44 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
 impl<'a, C: TweenCommand> EntityCommandsTweeningExtensions<'a> for AnimatedEntityCommands<'a, C> {
     #[inline]
     fn move_to(
-        mut self,
+        self,
         end: Vec3,
         cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.flush();
-        let commands = self.commands.take().unwrap();
-        commands.move_to(end, cycle_duration, ease_method)
+        self.into_inner().move_to(end, cycle_duration, ease_method)
     }
 
     #[inline]
     fn move_from(
-        mut self,
+        self,
         start: Vec3,
         cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.flush();
-        let commands = self.commands.take().unwrap();
-        commands.move_from(start, cycle_duration, ease_method)
+        self.into_inner()
+            .move_from(start, cycle_duration, ease_method)
     }
 
     #[inline]
     fn scale_to(
-        mut self,
+        self,
         end: Vec3,
         cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.flush();
-        let commands = self.commands.take().unwrap();
-        commands.scale_to(end, cycle_duration, ease_method)
+        self.into_inner().scale_to(end, cycle_duration, ease_method)
     }
 
     #[inline]
     fn scale_from(
-        mut self,
+        self,
         start: Vec3,
         cycle_duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.flush();
-        let commands = self.commands.take().unwrap();
-        commands.scale_from(start, cycle_duration, ease_method)
+        self.into_inner()
+            .scale_from(start, cycle_duration, ease_method)
     }
 }
 
@@ -1319,14 +1324,14 @@ impl<'a, C: TweenCommand> Deref for AnimatedEntityCommands<'a, C> {
     type Target = EntityCommands<'a>;
 
     fn deref(&self) -> &Self::Target {
-        self.commands.as_ref().unwrap()
+        &self.commands
     }
 }
 
 impl<'a, C: TweenCommand> DerefMut for AnimatedEntityCommands<'a, C> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.flush();
-        self.commands.as_mut().unwrap()
+        &mut self.commands
     }
 }
 
@@ -1463,7 +1468,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
 impl<'a, C: TweenCommand> TweeningExtensions<'a> for AnimatedEntityCommands<'a, C> {
     #[inline]
     fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut AnimatedEntityCommands<'a, C> {
-        self.commands.as_mut().unwrap().tween(tweenable);
+        self.commands.tween(tweenable);
         self
     }
 
@@ -1473,19 +1478,13 @@ impl<'a, C: TweenCommand> TweeningExtensions<'a> for AnimatedEntityCommands<'a,
         entity: Entity,
         tweenable: impl IntoBoxedTweenable,
     ) -> &mut AnimatedEntityCommands<'a, C> {
-        self.commands
-            .as_mut()
-            .unwrap()
-            .tween_component(entity, tweenable);
+        self.commands.tween_component(entity, tweenable);
         self
     }
 
     #[inline]
     fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
-        self.commands
-            .as_mut()
-            .unwrap()
-            .tween_resource::<R>(tweenable);
+        self.commands.tween_resource::<R>(tweenable);
         self
     }
 
@@ -1494,10 +1493,7 @@ impl<'a, C: TweenCommand> TweeningExtensions<'a> for AnimatedEntityCommands<'a,
         id: impl Into<AssetId<A>>,
         tweenable: impl IntoBoxedTweenable,
     ) -> &mut Self {
-        self.commands
-            .as_mut()
-            .unwrap()
-            .tween_asset::<A>(id, tweenable);
+        self.commands.tween_asset::<A>(id, tweenable);
         self
     }
 }
@@ -1574,52 +1570,6 @@ impl<'a> TweeningExtensions<'a> for EntityWorldMut<'a> {
     }
 }
 
-// impl<'a> TweeningExtensions<'a> for EntityWorldMut<'a> {
-//     type Output = Self;
-
-//     #[inline]
-//     fn move_to(self, end: Vec3, duration: Duration, ease_method: impl
-// Into<EaseMethod>) -> Self {         let start =
-// self.get::<Transform>().unwrap().translation;         let lens =
-// TransformPositionLens { start, end };         let tween =
-// Tween::new(ease_method, duration, lens);         self.tween(tween)
-//     }
-
-//     #[inline]
-//     fn move_from(
-//         self,
-//         start: Vec3,
-//         duration: Duration,
-//         ease_method: impl Into<EaseMethod>,
-//     ) -> Self {
-//         let end = self.get::<Transform>().unwrap().translation;
-//         let lens = TransformPositionLens { start, end };
-//         let tween = Tween::new(ease_method, duration, lens);
-//         self.tween(tween)
-//     }
-
-//     #[inline]
-//     fn scale_to(self, end: Vec3, duration: Duration, ease_method: impl
-// Into<EaseMethod>) -> Self {         let start =
-// self.get::<Transform>().unwrap().scale;         let lens = TransformScaleLens
-// { start, end };         let tween = Tween::new(ease_method, duration, lens);
-//         self.tween(tween)
-//     }
-
-//     #[inline]
-//     fn scale_from(
-//         self,
-//         start: Vec3,
-//         duration: Duration,
-//         ease_method: impl Into<EaseMethod>,
-//     ) -> Self {
-//         let end = self.get::<Transform>().unwrap().scale;
-//         let lens = TransformScaleLens { start, end };
-//         let tween = Tween::new(ease_method, duration, lens);
-//         self.tween(tween)
-//     }
-// }
-
 /// Event raised when a [`TweenAnim`] completed.
 #[derive(Copy, Clone, Event)]
 pub struct AnimCompletedEvent {

From 0de4630d9bf1c6e70c428b40836b9a46912a2553 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Fri, 1 Aug 2025 21:54:05 +0100
Subject: [PATCH 55/66] Fix example launch command

---
 Cargo.toml       | 2 +-
 run_examples.bat | 1 +
 run_examples.sh  | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index c75c5e9..264816f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ bevy-inspector-egui = { version = "0.31" }
 
 [[example]]
 name = "ambient_light"
-required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking", "bevy/bevy_pbr"]
+required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking", "bevy/bevy_pbr", "bevy/hdr", "bevy/tonemapping_luts"]
 
 [[example]]
 name = "menu"
diff --git a/run_examples.bat b/run_examples.bat
index 45a3263..a264d2c 100644
--- a/run_examples.bat
+++ b/run_examples.bat
@@ -5,6 +5,7 @@ cargo r --example menu --no-default-features --features="bevy_ui bevy_text bevy/
 cargo r --example transform_translation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example transform_rotation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
+cargo r --example ambient_light --no-default-features --features="bevy_ui bevy_text bevy/bevy_winit bevy/bevy_picking bevy/bevy_pbr bevy/hdr bevy/tonemapping_luts"
 REM bevy_sprite
 cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example colormaterial_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
diff --git a/run_examples.sh b/run_examples.sh
index c32280e..e6df2e9 100755
--- a/run_examples.sh
+++ b/run_examples.sh
@@ -4,6 +4,7 @@ cargo r --example menu --no-default-features --features="bevy_ui bevy_text bevy/
 cargo r --example transform_translation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example transform_rotation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
+cargo r --example ambient_light --no-default-features --features="bevy_ui bevy_text bevy/bevy_winit bevy/bevy_picking bevy/bevy_pbr bevy/hdr bevy/tonemapping_luts"
 # bevy_sprite
 cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example colormaterial_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"

From 44e2894e6256543acf98c7b27ffacf08223265b7 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Fri, 1 Aug 2025 22:01:29 +0100
Subject: [PATCH 56/66] Settle on `duration` for `move_to()` etc.

---
 src/lib.rs | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 797dab5..b24327e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -872,7 +872,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     fn move_to(
         self,
         end: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 
@@ -912,7 +912,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     fn move_from(
         self,
         start: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 
@@ -952,7 +952,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     fn scale_to(
         self,
         end: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 
@@ -992,7 +992,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     fn scale_from(
         self,
         start: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 }
@@ -1281,42 +1281,42 @@ impl<'a, C: TweenCommand> EntityCommandsTweeningExtensions<'a> for AnimatedEntit
     fn move_to(
         self,
         end: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.into_inner().move_to(end, cycle_duration, ease_method)
+        self.into_inner().move_to(end, duration, ease_method)
     }
 
     #[inline]
     fn move_from(
         self,
         start: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
         self.into_inner()
-            .move_from(start, cycle_duration, ease_method)
+            .move_from(start, duration, ease_method)
     }
 
     #[inline]
     fn scale_to(
         self,
         end: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.into_inner().scale_to(end, cycle_duration, ease_method)
+        self.into_inner().scale_to(end, duration, ease_method)
     }
 
     #[inline]
     fn scale_from(
         self,
         start: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
         self.into_inner()
-            .scale_from(start, cycle_duration, ease_method)
+            .scale_from(start, duration, ease_method)
     }
 }
 
@@ -1388,7 +1388,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     fn move_to(
         self,
         end: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
         AnimatedEntityCommands::new(
@@ -1397,7 +1397,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
                 end,
                 config: TweenConfig {
                     ease_method: ease_method.into(),
-                    cycle_duration,
+                    cycle_duration: duration,
                     ..default()
                 },
             },
@@ -1408,7 +1408,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     fn move_from(
         self,
         start: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
         AnimatedEntityCommands::new(
@@ -1417,7 +1417,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
                 start,
                 config: TweenConfig {
                     ease_method: ease_method.into(),
-                    cycle_duration,
+                    cycle_duration: duration,
                     ..default()
                 },
             },
@@ -1428,7 +1428,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     fn scale_to(
         self,
         end: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
         AnimatedEntityCommands::new(
@@ -1437,7 +1437,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
                 end,
                 config: TweenConfig {
                     ease_method: ease_method.into(),
-                    cycle_duration,
+                    cycle_duration: duration,
                     ..default()
                 },
             },
@@ -1448,7 +1448,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     fn scale_from(
         self,
         start: Vec3,
-        cycle_duration: Duration,
+        duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
         AnimatedEntityCommands::new(
@@ -1457,7 +1457,7 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
                 start,
                 config: TweenConfig {
                     ease_method: ease_method.into(),
-                    cycle_duration,
+                    cycle_duration: duration,
                     ..default()
                 },
             },

From eba6aa342b87fe9526b16046b58f9df0a0353f5f Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Fri, 1 Aug 2025 22:06:28 +0100
Subject: [PATCH 57/66] Fix animation event on sequence example

---
 examples/sequence.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/sequence.rs b/examples/sequence.rs
index fc5a340..30052ae 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -278,7 +278,7 @@ fn update_text(
     q_tween_anims: Query<&TweenAnim>,
     q_anim_red: Single<Option<&TweenAnim>, With<RedAnimMarker>>,
     q_anim_blue: Query<&BlueSprite>,
-    mut q_event_completed: EventReader<CycleCompletedEvent>,
+    mut q_event_completed: EventReader<AnimCompletedEvent>,
 ) {
     let anim_red = *q_anim_red;
     let progress_red = if let Some(anim) = anim_red {
@@ -302,8 +302,8 @@ fn update_text(
 
     for ev in q_event_completed.read() {
         println!(
-            "Event: CycleCompletedEvent tween_id={:?} target={:?}",
-            ev.id, ev.target
+            "Event: AnimCompletedEvent anim_entity={:?} target={:?}",
+            ev.anim_entity, ev.target
         );
     }
 }

From 3a9706b6861582997ba2627e56f0d96ff05e672d Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Thu, 7 Aug 2025 21:26:02 +0100
Subject: [PATCH 58/66] `AnimTarget` as component with auto-register

---
 Cargo.toml                |    4 +
 examples/ambient_light.rs |   70 +-
 examples/follow.rs        |  157 +++
 src/lens.rs               |   99 ++
 src/lib.rs                | 2062 ++++++++++++++++---------------------
 src/plugin.rs             |    2 +-
 src/test_utils.rs         |   11 +-
 src/tweenable.rs          |   43 +-
 8 files changed, 1217 insertions(+), 1231 deletions(-)
 create mode 100644 examples/follow.rs

diff --git a/Cargo.toml b/Cargo.toml
index 264816f..2c1b6dd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,6 +36,10 @@ bevy-inspector-egui = { version = "0.31" }
 name = "ambient_light"
 required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking", "bevy/bevy_pbr", "bevy/hdr", "bevy/tonemapping_luts"]
 
+[[example]]
+name = "follow"
+required-features = ["bevy_sprite", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking"]
+
 [[example]]
 name = "menu"
 required-features = ["bevy_ui", "bevy_text", "bevy/bevy_winit", "bevy/bevy_picking"]
diff --git a/examples/ambient_light.rs b/examples/ambient_light.rs
index ba34b40..2a3df7b 100644
--- a/examples/ambient_light.rs
+++ b/examples/ambient_light.rs
@@ -2,9 +2,14 @@
 //!
 //! The example animates the `AmbientLight` resource of Bevy's PBR renderer.
 //! This is mostly for example purpose; you probably want to animate some other
-//! (custom) resource.
+//! (custom) resource. It also moves a capsule object back and forth with the
+//! `move_to()` command extension, and make it "resonate" by quickly scaling it
+//! between 100% and 110% size with the `scale_to()` command extension.
 
-use std::{f32::consts::FRAC_PI_2, time::Duration};
+use std::{
+    f32::consts::{FRAC_PI_2, FRAC_PI_4},
+    time::Duration,
+};
 
 use bevy::{color::palettes::css::*, core_pipeline::bloom::Bloom, prelude::*};
 use bevy_tweening::{lens::*, *};
@@ -65,17 +70,19 @@ fn setup(
 
     // Set some default ambient color, and zero out brightness for now
     ambient_light.color = Color::linear_rgb(1., 1., 1.);
-    ambient_light.brightness = 0.0;
+    ambient_light.brightness = 40.0;
 
-    // Some sample "ground" circle, not animated.
-    commands.spawn((
-        Mesh3d(meshes.add(Circle::new(4.))),
-        MeshMaterial3d(materials.add(StandardMaterial {
-            base_color: LIGHT_GREEN.into(),
-            ..default()
-        })),
-        Transform::default(),
-    ));
+    // Some sample "ground" circle, slowly rotating.
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Circle::new(4.))),
+            MeshMaterial3d(materials.add(StandardMaterial {
+                base_color: LIGHT_GREEN.into(),
+                ..default()
+            })),
+            Transform::default(),
+        ))
+        .rotate_z(Duration::from_secs(20));
 
     // Animate the ambient light's brightness between fairly extreme values, for
     // example purpose only (please don't do that).
@@ -83,12 +90,15 @@ fn setup(
         EaseFunction::CubicIn,
         Duration::from_secs(2),
         AmbientLightBrightnessLens {
-            start: 0.0,   // pitch black
-            end: 100000., // ahhhh, my eyes!
+            start: 40.0, // very dark
+            end: 10000., // ahhhh, my eyes!
         },
     )
     .with_repeat(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat);
-    commands.spawn_empty().tween_resource::<AmbientLight>(tween);
+    commands.spawn((
+        TweenAnim::new(tween),
+        AnimTarget::resource::<AmbientLight>(),
+    ));
 
     // Spawn some animated character-like capsule...
     commands
@@ -110,17 +120,43 @@ fn setup(
         .with_repeat(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat)
         // This demonstrates that we can continue using the regular EntityCommands to insert more
         // components on the current entity for example.
-        .insert(Name::new("haha"))
+        .insert(Name::new("NPC"))
         // However, after doing so reborrow() is required because insert() returns &mut
         // EntityCommands, but the animation extensions need it by value.
         .reborrow()
         // ...slightly scaling up and back to normal size (the start scale is the Transform::scale).
         .scale_to(
             Vec3::splat(1.1),
-            Duration::from_secs(1),
+            Duration::from_millis(200),
             EaseFunction::BounceInOut,
         )
         .with_repeat(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat);
 
+    // A gold cube rotating indefinitely over itself
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Cuboid::from_length(1.))),
+            MeshMaterial3d(materials.add(StandardMaterial {
+                base_color: GOLD.into(),
+                ..default()
+            })),
+            Transform::from_rotation(Quat::from_axis_angle(Vec3::ONE, FRAC_PI_4))
+                .with_translation(Vec3::new(4., 0., 2.)),
+        ))
+        .rotate_x(Duration::from_secs(5));
+
+    // A blue cuboid rotating back and forth
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Cuboid::new(1., 1., 2.))),
+            MeshMaterial3d(materials.add(StandardMaterial {
+                base_color: BLUE.into(),
+                ..default()
+            })),
+            Transform::from_translation(Vec3::new(-4., 0., 1.5)),
+        ))
+        .rotate_x_by(FRAC_PI_2, Duration::from_secs(2), EaseFunction::BounceInOut)
+        .with_repeat(RepeatCount::Infinite, RepeatStrategy::MirroredRepeat);
+
     Ok(())
 }
diff --git a/examples/follow.rs b/examples/follow.rs
new file mode 100644
index 0000000..616b735
--- /dev/null
+++ b/examples/follow.rs
@@ -0,0 +1,157 @@
+//! Example demonstrating resource animation and various transform shortcuts.
+//!
+//! The example animates the `AmbientLight` resource of Bevy's PBR renderer.
+//! This is mostly for example purpose; you probably want to animate some other
+//! (custom) resource.
+
+use std::time::Duration;
+
+use bevy::{color::palettes::css::*, prelude::*};
+use bevy_tweening::{lens::TransformPositionLens, *};
+
+mod utils;
+
+#[derive(Component)]
+struct Follower;
+
+#[derive(Debug, Default, Clone, Copy)]
+enum AnimOption {
+    OverwriteComponent,
+    #[default]
+    CallSetTweenable,
+}
+
+// Simple way to toggle between the two options. Don't do that in real code.
+impl std::ops::Not for AnimOption {
+    type Output = Self;
+
+    fn not(self) -> Self::Output {
+        match self {
+            Self::OverwriteComponent => Self::CallSetTweenable,
+            Self::CallSetTweenable => Self::OverwriteComponent,
+        }
+    }
+}
+
+#[derive(Default, Component)]
+struct Anim {
+    pub option: AnimOption,
+}
+
+fn main() {
+    App::default()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "Follow".to_string(),
+                resolution: (1200., 600.).into(),
+                present_mode: bevy::window::PresentMode::Fifo, // vsync
+                ..default()
+            }),
+            ..default()
+        }))
+        .add_systems(Update, utils::close_on_esc)
+        .add_plugins(TweeningPlugin)
+        .add_systems(Startup, setup)
+        .add_systems(PreUpdate, change_option)
+        .add_systems(Update, follow)
+        .run();
+}
+
+fn make_tween(start: Vec3, end: Vec3) -> Tween {
+    let lens = TransformPositionLens { start, end };
+    Tween::new(
+        // Start fast to catch-up with target, slow down when closer
+        EaseFunction::QuadraticOut,
+        // Short duration for the appareance to remain snappy
+        Duration::from_millis(200),
+        lens,
+    )
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    commands.spawn(Camera2d::default());
+
+    // Spawn the follower entity
+    let entity = commands
+        .spawn((
+            Mesh2d(meshes.add(Rectangle::new(10., 10.))),
+            MeshMaterial2d(materials.add(ColorMaterial {
+                color: PURPLE.into(),
+                ..default()
+            })),
+            Follower,
+        ))
+        .id();
+
+    // Spawn the TweenAnim animating the follower. We want to keep overwriting it as
+    // the cursor move, so we need to remember its Entity (we use a marker component
+    // here).
+    commands.spawn((
+        // Our marker
+        Anim::default(),
+        // The animation itself
+        TweenAnim::new(make_tween(Vec3::ZERO, Vec3::ZERO))
+            // For performance reason, we keep this animation around and overwrite it. Otherwise it
+            // will keep being removed and re-inserted.
+            .with_destroy_on_completed(false),
+        // The target of the animation, here a component on the given entity
+        AnimTarget::Component(entity),
+    ));
+}
+
+fn change_option(keyboard: Res<ButtonInput<KeyCode>>, mut q_anim: Single<&mut Anim>) {
+    if keyboard.just_pressed(KeyCode::Space) {
+        q_anim.option = !q_anim.option;
+        println!("Anim option : {:?}", q_anim.option);
+    }
+}
+
+fn follow(
+    mut commands: Commands,
+    mut ev: EventReader<CursorMoved>,
+    q_follower: Single<&Transform, With<Follower>>,
+    q_camera: Single<(&GlobalTransform, &Camera)>,
+    mut q_anim: Single<(Entity, &Anim, &mut TweenAnim)>,
+) {
+    let Some(ev) = ev.read().last() else {
+        return;
+    };
+    let (camera_transform, camera) = *q_camera;
+
+    let target_transform = *q_follower;
+    if let Ok(pos) = camera.viewport_to_world_2d(camera_transform, ev.position) {
+        if pos != target_transform.translation.truncate() {
+            // Note: Do NOT use move_to(), because it spawns a new separate TweenAnim and
+            // Entity each time, and we will end up with multiple of them animating the same
+            // target but aiming at different end positions, which will produce some visual
+            // jittering. We want to overwrite the same TweenAnim again and again with a new
+            // target position.
+
+            match q_anim.1.option {
+                // Option 1. Use the fact spawning a component overwrites a previous instance.
+                AnimOption::OverwriteComponent => {
+                    commands.entity(q_anim.0).insert(
+                        TweenAnim::new(make_tween(target_transform.translation, pos.extend(0.)))
+                            // We again keep that component around even when the animation
+                            // completed, both for performance and because we use a Single<> query
+                            // which otherwise would fail once the animation completed and the
+                            // TweenAnim was auto-destroyed.
+                            .with_destroy_on_completed(false),
+                    );
+                }
+                // Option 2. Keep the same component, simply use set_tweenable() to
+                // update the Tween with a new one targetting the new cursor position.
+                AnimOption::CallSetTweenable => {
+                    q_anim
+                        .2
+                        .set_tweenable(make_tween(target_transform.translation, pos.extend(0.)))
+                        .unwrap();
+                }
+            }
+        }
+    }
+}
diff --git a/src/lens.rs b/src/lens.rs
index 89b81ab..2a5bfa4 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -224,6 +224,105 @@ impl Lens<Transform> for TransformRotateZLens {
     }
 }
 
+/// A lens to rotate a [`Transform`] component around its local X axis
+/// additively.
+///
+/// This lens interpolates the rotation angle of a local rotation from
+/// a `start` value to an `end` value, for a rotation around the local X axis,
+/// and compose this with the `base_rotation`, applying the result to a
+/// [`Transform`] component. Unlike [`TransformRotationLens`], it can produce an
+/// animation that rotates the entity any number of turns around its local X
+/// axis.
+///
+/// See the [top-level `lens` module documentation] for a comparison of rotation
+/// lenses.
+///
+/// [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
+/// [top-level `lens` module documentation]: crate::lens
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct TransformRotateAdditiveXLens {
+    /// The base rotation of the object, which is composed with the animated
+    /// rotation.
+    pub base_rotation: Quat,
+    /// Start value of the rotation angle, in radians.
+    pub start: f32,
+    /// End value of the rotation angle, in radians.
+    pub end: f32,
+}
+
+impl Lens<Transform> for TransformRotateAdditiveXLens {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
+        let angle = (self.end - self.start).mul_add(ratio, self.start);
+        target.rotation = self.base_rotation * Quat::from_rotation_x(angle);
+    }
+}
+
+/// A lens to rotate a [`Transform`] component around its local Y axis
+/// additively.
+///
+/// This lens interpolates the rotation angle of a local rotation from
+/// a `start` value to an `end` value, for a rotation around the local Y axis,
+/// and compose this with the `base_rotation`, applying the result to a
+/// [`Transform`] component. Unlike [`TransformRotationLens`], it can produce an
+/// animation that rotates the entity any number of turns around its local Y
+/// axis.
+///
+/// See the [top-level `lens` module documentation] for a comparison of rotation
+/// lenses.
+///
+/// [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
+/// [top-level `lens` module documentation]: crate::lens
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct TransformRotateAdditiveYLens {
+    /// The base rotation of the object, which is composed with the animated
+    /// rotation.
+    pub base_rotation: Quat,
+    /// Start value of the rotation angle, in radians.
+    pub start: f32,
+    /// End value of the rotation angle, in radians.
+    pub end: f32,
+}
+
+impl Lens<Transform> for TransformRotateAdditiveYLens {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
+        let angle = (self.end - self.start).mul_add(ratio, self.start);
+        target.rotation = self.base_rotation * Quat::from_rotation_y(angle);
+    }
+}
+
+/// A lens to rotate a [`Transform`] component around its local Z axis
+/// additively.
+///
+/// This lens interpolates the rotation angle of a local rotation from
+/// a `start` value to an `end` value, for a rotation around the local Z axis,
+/// and compose this with the `base_rotation`, applying the result to a
+/// [`Transform`] component. Unlike [`TransformRotationLens`], it can produce an
+/// animation that rotates the entity any number of turns around its local Z
+/// axis.
+///
+/// See the [top-level `lens` module documentation] for a comparison of rotation
+/// lenses.
+///
+/// [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
+/// [top-level `lens` module documentation]: crate::lens
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct TransformRotateAdditiveZLens {
+    /// The base rotation of the object, which is composed with the animated
+    /// rotation.
+    pub base_rotation: Quat,
+    /// Start value of the rotation angle, in radians.
+    pub start: f32,
+    /// End value of the rotation angle, in radians.
+    pub end: f32,
+}
+
+impl Lens<Transform> for TransformRotateAdditiveZLens {
+    fn lerp(&mut self, mut target: Mut<Transform>, ratio: f32) {
+        let angle = (self.end - self.start).mul_add(ratio, self.start);
+        target.rotation = self.base_rotation * Quat::from_rotation_z(angle);
+    }
+}
+
 /// A lens to rotate a [`Transform`] component around a given fixed axis.
 ///
 /// This lens interpolates the rotation angle of a [`Transform`] component from
diff --git a/src/lib.rs b/src/lib.rs
index b24327e..cd69370 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -358,6 +358,9 @@ use bevy::{
     prelude::*,
 };
 pub use lens::Lens;
+use lens::{
+    TransformRotateAdditiveXLens, TransformRotateAdditiveYLens, TransformRotateAdditiveZLens,
+};
 pub use plugin::{AnimationSystem, TweeningPlugin};
 use thiserror::Error;
 pub use tweenable::{
@@ -585,245 +588,12 @@ impl std::ops::Not for PlaybackDirection {
     }
 }
 
-/// Extensions to queue tween-based animations.
-///
-/// This trait provide extension functions to [`EntityWorldMut`] and
-/// [`EntityCommands`], allowing convenient syntaxes like inserting a new
-/// component and immediately attaching a tweenable animation to it in a single
-/// call.
-///
-/// ```
-/// # use bevy::{prelude::*, ecs::world::CommandQueue};
-/// # use bevy_tweening::{*, lens::TransformPositionLens};
-/// # use std::time::Duration;
-/// # let mut queue = CommandQueue::default();
-/// # let mut world = World::default();
-/// # let mut commands = Commands::new(&mut queue, &mut world);
-/// let tween = Tween::new(
-///     EaseFunction::QuadraticIn,
-///     Duration::from_secs(1),
-///     TransformPositionLens {
-///         start: Vec3::ZERO,
-///         end: Vec3::new(3.5, 0., 0.),
-///     },
-/// );
-/// commands.spawn(Transform::default()).tween(tween);
-/// ```
-///
-/// The extension offers 4 main functions, grouped into 2 core use cases:
-/// - If you want to animate a component on the _current_ entity, use
-///   [`tween()`]. This spawns a new separate empty entity with a new
-///   [`TweenAnim`], which targets a component on the current entity. There's no
-///   equivalent for assets, since an asset cannot be owned by an entity.
-/// - If you want the _current entity to own the [`TweenAnim`]_:
-///   - [`tween_component()`] animates a given target component.
-///   - [`tween_resource()`] animates a given target resource.
-///   - [`tween_asset()`] animates a given target asset.
-///
-/// This convenience comes at the price of reduced control and error checking.
-/// Additional information like the [`Entity`] of a newly created [`TweenAnim`]
-/// cannot be retrieved. And any error (_e.g._ trying to insert an animation
-/// with a tweenable of a component type while the entity doesn't have that
-/// component) cannot be forwarded back to the caller, so will produce a panic
-/// instead. This is best used for cases where you know those conditions at
-/// build time. To avoid a panic, prefer manually queuing a new tweenable
-/// animation by spawning a [`TweenAnim`] component yourself.
-///
-/// [`tween()`]: Self::tween
-/// [`tween_component()`]: Self::tween_component
-/// [`tween_resource()`]: Self::tween_resource
-/// [`tween_asset()`]: Self::tween_asset
-pub trait TweeningExtensions<'a> {
-    /// Queue the given [`Tweenable`] to animate the current entity.
-    ///
-    /// This inserts a new [`TweenAnim`] on a newly spawned entity, which
-    /// animates the current entity. The proper component to animate on the
-    /// current entity is based on the type of the lens stored inside the
-    /// tweenable (see [`Tweenable::type_id()`]). That component must exist
-    /// on the current entity.
-    ///
-    /// Because this function spawns a new entity for each animation, you can
-    /// use it multiple times on the same source entity, including with the same
-    /// component.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
-    /// # use bevy_tweening::{*, lens::TransformPositionLens};
-    /// # use std::time::Duration;
-    /// # let mut queue = CommandQueue::default();
-    /// # let mut world = World::default();
-    /// # let mut commands = Commands::new(&mut queue, &mut world);
-    /// let tween = Tween::new(
-    ///     EaseFunction::QuadraticIn,
-    ///     Duration::from_secs(1),
-    ///     TransformPositionLens {
-    ///         start: Vec3::ZERO,
-    ///         end: Vec3::new(3.5, 0., 0.),
-    ///     },
-    /// );
-    /// // Spawn Transform on a first entity, and TweenAnim on a second one,
-    /// // animating the Transform one.
-    /// commands.spawn(Transform::default()).tween(tween);
-    /// ```
-    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self;
-
-    /// Queue the given [`Tweenable`] to animate a target component.
-    ///
-    /// This inserts a new [`TweenAnim`] on the current entity, which
-    /// animates a given target component identified by the entity which owns
-    /// it. The type of the component to animate on that target entity is based
-    /// on the type of the lens stored inside the tweenable (see
-    /// [`Tweenable::type_id()`]).
-    ///
-    /// Because this function spawns a new [`TweenAnim`] on the current entity,
-    /// it cannot be called more than once.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
-    /// # use bevy_tweening::{*, lens::TransformPositionLens};
-    /// # use std::time::Duration;
-    /// # let mut queue = CommandQueue::default();
-    /// # let mut world = World::default();
-    /// # let mut commands = Commands::new(&mut queue, &mut world);
-    /// #[derive(Component)]
-    /// struct AnimMarker;
-    ///
-    /// let tween = Tween::new(
-    ///     EaseFunction::QuadraticIn,
-    ///     Duration::from_secs(1),
-    ///     TransformPositionLens {
-    ///         start: Vec3::ZERO,
-    ///         end: Vec3::new(3.5, 0., 0.),
-    ///     },
-    /// );
-    /// let target = commands.spawn(Transform::default()).id();
-    /// // Spawn (AnimMarker, TweenAnim) on a new entity
-    /// commands.spawn(AnimMarker).tween_component(target, tween);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This call panics, or queue a command which later panics, if a
-    /// [`TweenAnim`] component already exists on the current entity, whether
-    /// from another prior call to [`tween_component()`] or [`tween_resource()`]
-    /// or [`tween_asset()`], or from manually inserting the component.
-    ///
-    /// [`tween_component()`]: Self::tween_component
-    /// [`tween_resource()`]: Self::tween_resource
-    /// [`tween_asset()`]: Self::tween_asset
-    fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self;
-
-    /// Queue the given [`Tweenable`] to animate a target resource.
-    ///
-    /// This inserts a new [`TweenAnim`] on the current entity, which
-    /// animates a given target resource. The type of the resource `R` to
-    /// animate is validated against the type of the lens stored inside the
-    /// tweenable (see [`Tweenable::type_id()`]).
-    ///
-    /// Because this function spawns a new [`TweenAnim`] on the current entity,
-    /// it cannot be called more than once.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
-    /// # use bevy_tweening::{*, lens::TransformPositionLens};
-    /// # use std::time::Duration;
-    /// # let mut queue = CommandQueue::default();
-    /// # let mut world = World::default();
-    /// # let mut commands = Commands::new(&mut queue, &mut world);
-    /// #[derive(Component)]
-    /// struct AnimMarker;
-    ///
-    /// let tween = Tween::new(
-    ///     EaseFunction::QuadraticIn,
-    ///     Duration::from_secs(1),
-    ///     TimeLens { start: 0., end: 1. },
-    /// );
-    /// // Spawn (AnimMarker, TweenAnim) on a new entity
-    /// commands.spawn(AnimMarker).tween_resource(target, tween);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This call panics, or queue a command which later panics, if a
-    /// [`TweenAnim`] component already exists on the current entity, whether
-    /// from another prior call to [`tween_component()`] or [`tween_resource()`]
-    /// or [`tween_asset()`], or from manually inserting the component.
-    ///
-    /// This calls panics if the tweenable type ([`Tweenable::type_id()`]) is
-    /// not `R`.
-    ///
-    /// [`tween_component()`]: Self::tween_component
-    /// [`tween_resource()`]: Self::tween_resource
-    /// [`tween_asset()`]: Self::tween_asset
-    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self;
-
-    /// Queue the given [`Tweenable`] to animate a target asset.
-    ///
-    /// This inserts a new [`TweenAnim`] on the current entity, which
-    /// animates a given target asset. The asset type to animate is validated
-    /// against the one on the type of the lens stored inside the
-    /// tweenable (see [`Tweenable::type_id()`]).
-    ///
-    /// # Panics
-    ///
-    /// This call panics, or queue a command which later panics, if the type of
-    /// the asset `A` is different from the type the `tweenable` is referencing
-    /// through its [`Lens`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
-    /// # use bevy_tweening::{*, lens::TransformPositionLens};
-    /// # use std::time::Duration;
-    /// # fn make_tween() -> Tween { unimplemented!() }
-    /// #[derive(Asset, TypePath)]
-    /// struct MyAsset;
-    ///
-    /// #[derive(Component)]
-    /// struct MyAssetRef(pub Handle<MyAsset>);
-    ///
-    /// fn my_system(mut commands: Commands, asset_server: Res<AssetServer>) {
-    ///     let handle: Handle<MyAsset> = asset_server.load("my_asset");
-    ///     let tween = make_tween();
-    ///     // Spawn (MyAssetRef, TweenAnim) on a new entity
-    ///     commands
-    ///         .spawn(MyAssetRef(handle.clone()))
-    ///         .tween_asset(&handle, tween);
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This call panics, or queue a command which later panics, if a
-    /// [`TweenAnim`] component already exists on the current entity, whether
-    /// from another prior call to [`tween_component()`] or [`tween_resource()`]
-    /// or [`tween_asset()`], or from manually inserting the component.
-    ///
-    /// [`tween_component()`]: Self::tween_component
-    /// [`tween_resource()`]: Self::tween_resource
-    /// [`tween_asset()`]: Self::tween_asset
-    fn tween_asset<A: Asset>(
-        &mut self,
-        id: impl Into<AssetId<A>>,
-        tweenable: impl IntoBoxedTweenable,
-    ) -> &mut Self;
-}
-
 /// Extension trait for [`EntityCommands`], adding animation functionalities for
 /// commonly used tweening animations.
 ///
 /// This trait extends [`EntityCommands`] to provide convenience helpers to
-/// common tweening animations like moving the position of an entity. Those
-/// helpers come as an additional layer on top of the [`TweeningExtensions`]
-/// already available for [`EntityCommands`], and further reduce the boilerplate
-/// to creating some common animations.
+/// common tweening animations like moving the position of an entity by
+/// animating its [`Transform::translation`].
 ///
 /// One of the major source of convenience provided by these helpers is the fact
 /// that some of the data necessary to create the tween animation is
@@ -848,7 +618,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`Entity`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the entity and control
     /// the animation playback, you should spawn a [`TweenAnim`] component
     /// manually.
     ///
@@ -888,7 +658,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`Entity`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the entity and control
     /// the animation playback, you should spawn a [`TweenAnim`] component
     /// manually.
     ///
@@ -928,7 +698,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`Entity`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the entity and control
     /// the animation playback, you should spawn a [`TweenAnim`] component
     /// manually.
     ///
@@ -968,7 +738,7 @@ pub trait EntityCommandsTweeningExtensions<'a> {
     /// [`apply_deferred()`] will be taken into account.
     ///
     /// This function is a fire-and-forget convenience helper, and doesn't give
-    /// access to the [`Entity`] created. To retrieve the ID and control
+    /// access to the [`Entity`] created. To retrieve the entity and control
     /// the animation playback, you should spawn a [`TweenAnim`] component
     /// manually.
     ///
@@ -995,6 +765,183 @@ pub trait EntityCommandsTweeningExtensions<'a> {
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
+
+    /// Queue a new tween animation to rotate the current entity around its X
+    /// axis continuously (repeats forever, linearly).
+    ///
+    /// The entity must have a [`Transform`] component.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`Entity`] created. To retrieve the entity and control
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands
+    ///     .spawn(Transform::default())
+    ///     .rotate_x(Duration::from_secs(1));
+    /// ```
+    fn rotate_x(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand>;
+
+    /// Queue a new tween animation to rotate the current entity around its Y
+    /// axis continuously (repeats forever, linearly).
+    ///
+    /// The entity must have a [`Transform`] component.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`Entity`] created. To retrieve the entity and control
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands
+    ///     .spawn(Transform::default())
+    ///     .rotate_y(Duration::from_secs(1));
+    /// ```
+    fn rotate_y(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand>;
+
+    /// Queue a new tween animation to rotate the current entity around its Z
+    /// axis continuously (repeats forever, linearly).
+    ///
+    /// The entity must have a [`Transform`] component.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`Entity`] created. To retrieve the entity and control
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands
+    ///     .spawn(Transform::default())
+    ///     .rotate_z(Duration::from_secs(1));
+    /// ```
+    fn rotate_z(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand>;
+
+    /// Queue a new tween animation to rotate the current entity around its X
+    /// axis by a given angle.
+    ///
+    /// The entity must have a [`Transform`] component. The animation applies a
+    /// rotation on top of the value of the [`Transform`] at the time the
+    /// animation is queued.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`Entity`] created. To retrieve the entity and control
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands.spawn(Transform::default()).rotate_x_by(
+    ///     std::f32::consts::FRAC_PI_4,
+    ///     Duration::from_secs(1),
+    ///     EaseFunction::QuadraticIn,
+    /// );
+    /// ```
+    fn rotate_x_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
+
+    /// Queue a new tween animation to rotate the current entity around its Y
+    /// axis by a given angle.
+    ///
+    /// The entity must have a [`Transform`] component. The animation applies a
+    /// rotation on top of the value of the [`Transform`] at the time the
+    /// animation is queued.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`Entity`] created. To retrieve the entity and control
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands.spawn(Transform::default()).rotate_y_by(
+    ///     std::f32::consts::FRAC_PI_4,
+    ///     Duration::from_secs(1),
+    ///     EaseFunction::QuadraticIn,
+    /// );
+    /// ```
+    fn rotate_y_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
+
+    /// Queue a new tween animation to rotate the current entity around its Z
+    /// axis by a given angle.
+    ///
+    /// The entity must have a [`Transform`] component. The animation applies a
+    /// rotation on top of the value of the [`Transform`] at the time the
+    /// animation is queued.
+    ///
+    /// This function is a fire-and-forget convenience helper, and doesn't give
+    /// access to the [`Entity`] created. To retrieve the entity and control
+    /// the animation playback, you should spawn a [`TweenAnim`] component
+    /// manually.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use bevy::{prelude::*, ecs::world::CommandQueue};
+    /// # use bevy_tweening::*;
+    /// # use std::time::Duration;
+    /// # let mut queue = CommandQueue::default();
+    /// # let mut world = World::default();
+    /// # let mut commands = Commands::new(&mut queue, &mut world);
+    /// commands.spawn(Transform::default()).rotate_z_by(
+    ///     std::f32::consts::FRAC_PI_4,
+    ///     Duration::from_secs(1),
+    ///     EaseFunction::QuadraticIn,
+    /// );
+    /// ```
+    fn rotate_z_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand>;
 }
 
 /// Helper trait to abstract a tweening animation command.
@@ -1027,7 +974,10 @@ impl EntityCommand for MoveToCommand {
                 end: self.end,
             };
             let tween = Tween::from_config(self.config, lens);
-            entity.tween(tween);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
         }
     }
 }
@@ -1059,7 +1009,10 @@ impl EntityCommand for MoveFromCommand {
                 end,
             };
             let tween = Tween::from_config(self.config, lens);
-            entity.tween(tween);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
         }
     }
 }
@@ -1091,7 +1044,10 @@ impl EntityCommand for ScaleToCommand {
                 end: self.end,
             };
             let tween = Tween::from_config(self.config, lens);
-            entity.tween(tween);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
         }
     }
 }
@@ -1123,7 +1079,10 @@ impl EntityCommand for ScaleFromCommand {
                 end,
             };
             let tween = Tween::from_config(self.config, lens);
-            entity.tween(tween);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
         }
     }
 }
@@ -1140,47 +1099,263 @@ impl TweenCommand for ScaleFromCommand {
     }
 }
 
-/// Wrapper over an [`EntityCommands`] which stores an animation command.
-///
-/// The wrapper acts as, and dereferences to, a regular [`EntityCommands`] as
-/// _e.g._ returned by [`Commands::spawn()`]. In addition, it stores a pending
-/// animation command, which can be further tweaked before being queued into the
-/// entity commands queue. This deferred queuing allows fluent patterns like:
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use bevy_tweening::*;
-/// # fn my_system(mut commands: Commands) {
-/// commands.spawn(Transform::default())
-///     // Consume the EntityCommands, and wrap it into an AnimatedEntityCommands,
-///     // which stores a MoveToCommand animation command.
-///     .move_to(
-///         Vec3::ONE,
-///         Duration::from_millis(400)
-///         EaseFunction::QuadraticIn,
-///     )
-///     // Tweak the MoveToCommand to configure the repeat count of the Tween
-///     .repeat_count(2);
-/// # }
-/// ```
-///
-/// The animation commands always stores the last animation inserted. When the
-/// commands is mutably dereferenced, it first flushes any pending (single)
-/// animation command by inserting it into the underlying [`EntityCommands`]
-/// queue.
-///
-/// To move from an [`AnimatedEntityCommands`] to its underlying
-/// [`EntityCommands`], the former automatically dereferences to the latter.
-/// Note however that once you're back on the base [`EntityCommands`], you can
-/// only get a new [`AnimatedEntityCommands`] via functions consuming the
-/// [`EntityCommands`] by value. In that case, you need to call [`reborrow()`]:
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use bevy_tweening::*;
-/// # fn my_system(mut commands: Commands) {
-/// commands.spawn(Transform::default())
-///     .move_to(
+/// Animation command to rotate an entity around its X axis.
+#[derive(Clone, Copy)]
+pub(crate) struct RotateXCommand {
+    config: TweenConfig,
+}
+
+impl EntityCommand for RotateXCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(base_rotation) = entity.get::<Transform>().map(|tr| tr.rotation) {
+            let lens = TransformRotateAdditiveXLens {
+                base_rotation,
+                start: 0.,
+                end: std::f32::consts::TAU,
+            };
+            let tween = Tween::from_config(self.config, lens)
+                .with_repeat(RepeatCount::Infinite, RepeatStrategy::Repeat);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
+        }
+    }
+}
+
+impl TweenCommand for RotateXCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to rotate an entity around its Y axis.
+#[derive(Clone, Copy)]
+pub(crate) struct RotateYCommand {
+    config: TweenConfig,
+}
+
+impl EntityCommand for RotateYCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(base_rotation) = entity.get::<Transform>().map(|tr| tr.rotation) {
+            let lens = TransformRotateAdditiveYLens {
+                base_rotation,
+                start: 0.,
+                end: std::f32::consts::TAU,
+            };
+            let tween = Tween::from_config(self.config, lens)
+                .with_repeat(RepeatCount::Infinite, RepeatStrategy::Repeat);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
+        }
+    }
+}
+
+impl TweenCommand for RotateYCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to rotate an entity around its Z axis.
+#[derive(Clone, Copy)]
+pub(crate) struct RotateZCommand {
+    config: TweenConfig,
+}
+
+impl EntityCommand for RotateZCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(base_rotation) = entity.get::<Transform>().map(|tr| tr.rotation) {
+            let lens = TransformRotateAdditiveZLens {
+                base_rotation,
+                start: 0.,
+                end: std::f32::consts::TAU,
+            };
+            let tween = Tween::from_config(self.config, lens)
+                .with_repeat(RepeatCount::Infinite, RepeatStrategy::Repeat);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
+        }
+    }
+}
+
+impl TweenCommand for RotateZCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to rotate an entity around its X axis by a given angle.
+#[derive(Clone, Copy)]
+pub(crate) struct RotateXByCommand {
+    angle: f32,
+    config: TweenConfig,
+}
+
+impl EntityCommand for RotateXByCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(base_rotation) = entity.get::<Transform>().map(|tr| tr.rotation) {
+            let lens = TransformRotateAdditiveXLens {
+                base_rotation,
+                start: 0.,
+                end: self.angle,
+            };
+            let tween = Tween::from_config(self.config, lens);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
+        }
+    }
+}
+
+impl TweenCommand for RotateXByCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to rotate an entity around its Y axis by a given angle.
+#[derive(Clone, Copy)]
+pub(crate) struct RotateYByCommand {
+    angle: f32,
+    config: TweenConfig,
+}
+
+impl EntityCommand for RotateYByCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(base_rotation) = entity.get::<Transform>().map(|tr| tr.rotation) {
+            let lens = TransformRotateAdditiveYLens {
+                base_rotation,
+                start: 0.,
+                end: self.angle,
+            };
+            let tween = Tween::from_config(self.config, lens);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
+        }
+    }
+}
+
+impl TweenCommand for RotateYByCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Animation command to rotate an entity around its Z axis by a given angle.
+#[derive(Clone, Copy)]
+pub(crate) struct RotateZByCommand {
+    angle: f32,
+    config: TweenConfig,
+}
+
+impl EntityCommand for RotateZByCommand {
+    fn apply(self, mut entity: EntityWorldMut) {
+        if let Some(base_rotation) = entity.get::<Transform>().map(|tr| tr.rotation) {
+            let lens = TransformRotateAdditiveZLens {
+                base_rotation,
+                start: 0.,
+                end: self.angle,
+            };
+            let tween = Tween::from_config(self.config, lens);
+            let anim_target = AnimTarget::component::<Transform>(entity.id());
+            entity.world_scope(|world| {
+                world.spawn((TweenAnim::new(tween), anim_target));
+            });
+        }
+    }
+}
+
+impl TweenCommand for RotateZByCommand {
+    #[inline]
+    fn config(&self) -> &TweenConfig {
+        &self.config
+    }
+
+    #[inline]
+    fn config_mut(&mut self) -> &mut TweenConfig {
+        &mut self.config
+    }
+}
+
+/// Wrapper over an [`EntityCommands`] which stores an animation command.
+///
+/// The wrapper acts as, and dereferences to, a regular [`EntityCommands`] as
+/// _e.g._ returned by [`Commands::spawn()`]. In addition, it stores a pending
+/// animation command, which can be further tweaked before being queued into the
+/// entity commands queue. This deferred queuing allows fluent patterns like:
+///
+/// ```
+/// # use bevy::prelude::*;
+/// # use bevy_tweening::*;
+/// # fn my_system(mut commands: Commands) {
+/// commands.spawn(Transform::default())
+///     // Consume the EntityCommands, and wrap it into an AnimatedEntityCommands,
+///     // which stores a MoveToCommand animation command.
+///     .move_to(
+///         Vec3::ONE,
+///         Duration::from_millis(400)
+///         EaseFunction::QuadraticIn,
+///     )
+///     // Tweak the MoveToCommand to configure the repeat count of the Tween
+///     .repeat_count(2);
+/// # }
+/// ```
+///
+/// The animation commands always stores the last animation inserted. When the
+/// commands is mutably dereferenced, it first flushes any pending (single)
+/// animation command by inserting it into the underlying [`EntityCommands`]
+/// queue.
+///
+/// To move from an [`AnimatedEntityCommands`] to its underlying
+/// [`EntityCommands`], the former automatically dereferences to the latter.
+/// Note however that once you're back on the base [`EntityCommands`], you can
+/// only get a new [`AnimatedEntityCommands`] via functions consuming the
+/// [`EntityCommands`] by value. In that case, you need to call [`reborrow()`]:
+///
+/// ```
+/// # use bevy::prelude::*;
+/// # use bevy_tweening::*;
+/// # fn my_system(mut commands: Commands) {
+/// commands.spawn(Transform::default())
+///     .move_to(
 ///         Vec3::ONE,
 ///         Duration::from_millis(400)
 ///         EaseFunction::QuadraticIn,
@@ -1294,8 +1469,7 @@ impl<'a, C: TweenCommand> EntityCommandsTweeningExtensions<'a> for AnimatedEntit
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.into_inner()
-            .move_from(start, duration, ease_method)
+        self.into_inner().move_from(start, duration, ease_method)
     }
 
     #[inline]
@@ -1315,8 +1489,52 @@ impl<'a, C: TweenCommand> EntityCommandsTweeningExtensions<'a> for AnimatedEntit
         duration: Duration,
         ease_method: impl Into<EaseMethod>,
     ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
-        self.into_inner()
-            .scale_from(start, duration, ease_method)
+        self.into_inner().scale_from(start, duration, ease_method)
+    }
+
+    #[inline]
+    fn rotate_x(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.into_inner().rotate_x(cycle_duration)
+    }
+
+    #[inline]
+    fn rotate_y(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.into_inner().rotate_y(cycle_duration)
+    }
+
+    #[inline]
+    fn rotate_z(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.into_inner().rotate_z(cycle_duration)
+    }
+
+    #[inline]
+    fn rotate_x_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.into_inner().rotate_x_by(angle, duration, ease_method)
+    }
+
+    #[inline]
+    fn rotate_y_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.into_inner().rotate_y_by(angle, duration, ease_method)
+    }
+
+    #[inline]
+    fn rotate_z_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        self.into_inner().rotate_z_by(angle, duration, ease_method)
     }
 }
 
@@ -1341,48 +1559,6 @@ impl<'a, C: TweenCommand> Drop for AnimatedEntityCommands<'a, C> {
     }
 }
 
-impl<'a> TweeningExtensions<'a> for EntityCommands<'a> {
-    #[inline]
-    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut EntityCommands<'a> {
-        let tweenable = tweenable.into_boxed();
-        self.queue(move |mut this: EntityWorldMut| {
-            this.tween(tweenable);
-        })
-    }
-
-    #[inline]
-    fn tween_component(
-        &mut self,
-        entity: Entity,
-        tweenable: impl IntoBoxedTweenable,
-    ) -> &mut EntityCommands<'a> {
-        let tweenable = tweenable.into_boxed();
-        self.queue(move |mut this: EntityWorldMut| {
-            this.tween_component(entity, tweenable);
-        })
-    }
-
-    #[inline]
-    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
-        let tweenable = tweenable.into_boxed();
-        self.queue(move |mut entity: EntityWorldMut| {
-            entity.tween_resource::<R>(tweenable);
-        })
-    }
-
-    fn tween_asset<A: Asset>(
-        &mut self,
-        id: impl Into<AssetId<A>>,
-        tweenable: impl IntoBoxedTweenable,
-    ) -> &mut Self {
-        let id = id.into();
-        let tweenable = tweenable.into_boxed();
-        self.queue(move |mut entity: EntityWorldMut| {
-            entity.tween_asset(id, tweenable);
-        })
-    }
-}
-
 impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
     #[inline]
     fn move_to(
@@ -1463,724 +1639,271 @@ impl<'a> EntityCommandsTweeningExtensions<'a> for EntityCommands<'a> {
             },
         )
     }
-}
 
-impl<'a, C: TweenCommand> TweeningExtensions<'a> for AnimatedEntityCommands<'a, C> {
     #[inline]
-    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut AnimatedEntityCommands<'a, C> {
-        self.commands.tween(tweenable);
-        self
+    fn rotate_x(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            RotateXCommand {
+                config: TweenConfig {
+                    ease_method: EaseFunction::Linear.into(),
+                    cycle_duration,
+                    ..default()
+                },
+            },
+        )
     }
 
     #[inline]
-    fn tween_component(
-        &mut self,
-        entity: Entity,
-        tweenable: impl IntoBoxedTweenable,
-    ) -> &mut AnimatedEntityCommands<'a, C> {
-        self.commands.tween_component(entity, tweenable);
-        self
+    fn rotate_y(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            RotateYCommand {
+                config: TweenConfig {
+                    ease_method: EaseFunction::Linear.into(),
+                    cycle_duration,
+                    ..default()
+                },
+            },
+        )
     }
 
     #[inline]
-    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
-        self.commands.tween_resource::<R>(tweenable);
-        self
+    fn rotate_z(self, cycle_duration: Duration) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            RotateZCommand {
+                config: TweenConfig {
+                    ease_method: EaseFunction::Linear.into(),
+                    cycle_duration,
+                    ..default()
+                },
+            },
+        )
     }
 
-    fn tween_asset<A: Asset>(
-        &mut self,
-        id: impl Into<AssetId<A>>,
-        tweenable: impl IntoBoxedTweenable,
-    ) -> &mut Self {
-        self.commands.tween_asset::<A>(id, tweenable);
-        self
-    }
-}
-
-impl<'a> TweeningExtensions<'a> for EntityWorldMut<'a> {
     #[inline]
-    fn tween(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
-        let entity = self.id();
-        let tweenable = tweenable.into_boxed();
-        let type_id = tweenable.type_id().unwrap();
-        let component_id = self.world().components().get_id(type_id).unwrap();
-        let target = ComponentAnimTarget {
-            component_id,
-            entity,
-        };
-        self.world_scope(|world| {
-            world.spawn(TweenAnim::new(target, tweenable));
-        });
-        self
-    }
-
-    fn tween_component(&mut self, entity: Entity, tweenable: impl IntoBoxedTweenable) -> &mut Self {
-        let tweenable = tweenable.into_boxed();
-        let type_id = tweenable.type_id().unwrap();
-        let component_id = self.world().components().get_id(type_id).unwrap();
-        let target = ComponentAnimTarget {
-            component_id,
-            entity,
-        };
-        self.insert(TweenAnim::new(target, tweenable));
-        self
-    }
-
-    fn tween_resource<R: Resource>(&mut self, tweenable: impl IntoBoxedTweenable) -> &mut Self {
-        let tweenable = tweenable.into_boxed();
-        let type_id = tweenable.type_id().unwrap();
-        assert_eq!(type_id, TypeId::of::<R>());
-
-        self.world_scope(|world| {
-            world.resource_scope(|world: &mut World, mut resolver: Mut<TweenResolver>| {
-                resolver.register_resource_resolver_for::<R>(world.components());
-            });
-        });
-
-        let resource_id = self.world().resource_id::<R>().unwrap();
-        let target = ResourceAnimTarget { resource_id };
-        self.insert(TweenAnim::new(target, tweenable));
-        self
-    }
-
-    fn tween_asset<A: Asset>(
-        &mut self,
-        id: impl Into<AssetId<A>>,
-        tweenable: impl IntoBoxedTweenable,
-    ) -> &mut Self {
-        let tweenable = tweenable.into_boxed();
-        let asset_id = id.into().untyped();
-        let type_id = tweenable.type_id().unwrap();
-        assert_eq!(type_id, TypeId::of::<A>());
-
-        self.world_scope(|world| {
-            world.resource_scope(|world: &mut World, mut resolver: Mut<TweenResolver>| {
-                resolver.register_asset_resolver_for::<A>(world.components());
-            });
-        });
-
-        let resource_id = self.world().resource_id::<Assets<A>>().unwrap();
-        let target = AssetAnimTarget {
-            resource_id,
-            asset_id,
-        };
-        self.insert(TweenAnim::new(target, tweenable));
-        self
-    }
-}
-
-/// Event raised when a [`TweenAnim`] completed.
-#[derive(Copy, Clone, Event)]
-pub struct AnimCompletedEvent {
-    /// The entity owning the [`TweenAnim`] which completed.
-    ///
-    /// Note that commonly the [`TweenAnim`] is despawned on completion, so
-    /// can't be queried anymore with this entity. You can prevent a completed
-    /// animation from being automatically destroyed by
-    /// setting [`TweenAnim::destroy_on_completion`] to `false`.
-    pub anim_entity: Entity,
-    /// The animation target.
-    ///
-    /// This is provided both as a convenience for [`TweenAnim`]s not destroyed
-    /// on completion, and because for those animations which are destroyed
-    /// on completion the information is not available anymore when this
-    /// event is received.
-    pub target: AnimTarget,
-}
-
-/// Errors returned by various animation functions.
-#[derive(Debug, Error, Clone, Copy)]
-pub enum TweeningError {
-    /// The asset resolver for the given asset is not registered.
-    #[error("Asset resolver for asset with resource ID {0:?} is not registered.")]
-    AssetResolverNotRegistered(ComponentId),
-    /// The entity was not found in the World.
-    #[error("Entity {0:?} not found in the World.")]
-    EntityNotFound(Entity),
-    /// The entity should have had a TweenAnim but it was not found.
-    #[error("Entity {0:?} doesn't have a TweenAnim.")]
-    MissingTweenAnim(Entity),
-    /// The component of the given type is not registered.
-    #[error("Component of type {0:?} is not registered in the World.")]
-    ComponentNotRegistered(TypeId),
-    /// The resource of the given type is not registered.
-    #[error("Resource of type {0:?} is not registered in the World.")]
-    ResourceNotRegistered(TypeId),
-    /// The asset container for the given asset type is not registered.
-    #[error("Asset container Assets<A> for asset type A = {0:?} is not registered in the World.")]
-    AssetNotRegistered(TypeId),
-    /// The component of the given type is not registered.
-    #[error("Component of type {0:?} is not present on entity {1:?}.")]
-    MissingComponent(TypeId, Entity),
-    /// The asset cannot be found.
-    #[error("Asset ID {0:?} is invalid.")]
-    InvalidAssetId(UntypedAssetId),
-    /// The asset ID references a different type than expected.
-    #[error("Expected type of asset ID to be {expected:?} but got {actual:?} instead.")]
-    InvalidAssetIdType {
-        /// The expected asset type.
-        expected: TypeId,
-        /// The actual type the asset ID references.
-        actual: TypeId,
-    },
-    /// Expected [`Tweenable::type_id()`] to return a value, but it returned
-    /// `None`.
-    #[error("Expected a typed Tweenable.")]
-    UntypedTweenable,
-    /// Invalid [`Entity`].
-    #[error("Invalid Entity {0:?}.")]
-    InvalidTweenId(Entity),
-    /// Cannot change target kind.
-    #[error("Unexpected target kind: was component={0}, now component={1}")]
-    MismatchingTargetKind(bool, bool),
-    /// Cannot change component type.
-    #[error("Cannot change component type: was component_id={0:?}, now component_id={1:?}")]
-    MismatchingComponentId(ComponentId, ComponentId),
-    /// Cannot change asset type.
-    #[error("Cannot change asset type: was component_id={0:?}, now component_id={1:?}")]
-    MismatchingAssetResourceId(ComponentId, ComponentId),
-}
-
-/// Component animation target.
-///
-/// References a component used as the target of a tweenable animation. The
-/// component is identified by the ID of the component type as registered in the
-/// [`World`] where the animation is queued, and the [`Entity`] holding the
-/// component instance of that type.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ComponentAnimTarget {
-    /// Component ID of the registered component being animated.
-    pub component_id: ComponentId,
-    /// Entity holding the component instance being animated.
-    pub entity: Entity,
-}
-
-impl ComponentAnimTarget {
-    /// Create a new component target.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use std::any::TypeId;
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// fn my_system(mut commands: Commands, components: &Components) {
-    ///     let entity = commands.spawn(Transform::default()).id();
-    ///     let target = ComponentAnimTarget::new::<Transform>(components, entity);
-    ///     // [...]
-    /// }
-    /// ```
-    pub fn new<C: Component<Mutability = Mutable>>(
-        components: &Components,
-        entity: Entity,
-    ) -> Result<Self, TweeningError> {
-        let component_id = components
-            .component_id::<C>()
-            .ok_or(TweeningError::ComponentNotRegistered(TypeId::of::<C>()))?;
-        Ok(Self {
-            component_id,
-            entity,
-        })
-    }
-
-    /// Create a new component target from a component type ID.
-    ///
-    /// This is useful when the component type is not known at compile time;
-    /// otherwise you should prefer [`new()`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use std::any::TypeId;
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// fn my_system(mut commands: Commands, components: &Components) {
-    ///     let entity = commands.spawn(Transform::default()).id();
-    ///     let type_id = TypeId::of::<Transform>();
-    ///     let target = ComponentAnimTarget::new_untyped(components, type_id, entity);
-    ///     // [...]
-    /// }
-    /// ```
-    ///
-    /// [`new()`]: Self::new
-    pub fn new_untyped(
-        components: &Components,
-        type_id: TypeId,
-        entity: Entity,
-    ) -> Result<Self, TweeningError> {
-        let component_id = components
-            .get_id(type_id)
-            .ok_or(TweeningError::ComponentNotRegistered(type_id))?;
-        Ok(Self {
-            component_id,
-            entity,
-        })
-    }
-}
-
-/// Resource animation target.
-///
-/// References a resource used as the target of a tweenable animation. The
-/// resource is identified by the ID of the resource type registered in the
-/// [`World`] where the animation is queued.
-///
-/// To animate assets, use an [`AssetAnimTarget`] instead.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ResourceAnimTarget {
-    /// Resource ID of the registered resource.
-    pub resource_id: ComponentId,
-}
-
-impl ResourceAnimTarget {
-    /// Create a new resource target.
-    ///
-    /// The resource type `R` must be registered in the input [`Components`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// fn my_system(components: &Components) {
-    ///     let target = ResourceAnimTarget::new::<Time>(components);
-    ///     // [...]
-    /// }
-    /// ```
-    pub fn new<R: Resource>(components: &Components) -> Result<Self, TweeningError> {
-        let resource_id = components
-            .resource_id::<R>()
-            .ok_or(TweeningError::ResourceNotRegistered(TypeId::of::<R>()))?;
-        Ok(Self { resource_id })
-    }
-
-    /// Create a new resource target from an `Assets<A>` type ID.
-    ///
-    /// The `resource_type_id` must reference a resource type registered in the
-    /// input [`Components`]. This is useful when the resource type is not
-    /// known at compile time; otherwise you should prefer [`new()`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use std::any::TypeId;
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// fn my_system(components: &Components, asset_server: Res<AssetServer>) {
-    ///     let handle: Handle<Image> = asset_server.load("image.png");
-    ///     let handle = handle.untyped();
-    ///     let assets_type_id = TypeId::of::<Assets<Image>>();
-    ///     let target = AssetAnimTarget::new_untyped(components, assets_type_id, &handle);
-    ///     // [...]
-    /// }
-    /// ```
-    ///
-    /// [`new()`]: Self::new
-    pub fn new_untyped(
-        components: &Components,
-        resource_type_id: TypeId,
-    ) -> Result<Self, TweeningError> {
-        let resource_id = components
-            .get_resource_id(resource_type_id)
-            .ok_or(TweeningError::ResourceNotRegistered(resource_type_id))?;
-        Ok(Self { resource_id })
-    }
-}
-
-/// Asset animation target.
-///
-/// References an asset used as the target of a tweenable animation. The asset
-/// is identified by the ID of the [`Assets`] resource type registered in the
-/// [`World`] where the animation is queued, and the unique asset ID identifying
-/// the asset instance inside that [`Assets`] resource.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct AssetAnimTarget {
-    /// Resource ID of the registered [`Assets`] asset container.
-    pub resource_id: ComponentId,
-    /// Asset ID of the target asset being animated.
-    pub asset_id: UntypedAssetId,
-}
-
-impl AssetAnimTarget {
-    /// Create a new asset target.
-    ///
-    /// The asset type `A` must be such that [`Assets<A>`] is registered in the
-    /// input [`Components`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// fn my_system(components: &Components, asset_server: Res<AssetServer>) {
-    ///     let handle: Handle<Image> = asset_server.load("image.png");
-    ///     let target = AssetAnimTarget::new::<Image>(components, &handle);
-    ///     // [...]
-    /// }
-    /// ```
-    pub fn new<A: Asset>(
-        components: &Components,
-        asset_id: impl Into<AssetId<A>>,
-    ) -> Result<Self, TweeningError> {
-        let resource_id = components
-            .resource_id::<Assets<A>>()
-            .ok_or(TweeningError::AssetNotRegistered(TypeId::of::<A>()))?;
-        Ok(Self {
-            resource_id,
-            asset_id: asset_id.into().untyped(),
-        })
-    }
-
-    /// Create a new asset target from an `Assets<A>` type ID.
-    ///
-    /// The `assets_type_id` must reference an [`Assets<A>`] type registered in
-    /// the input [`Components`]. This is useful when the asset type is not
-    /// known at compile time; otherwise you should prefer [`new()`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use std::any::TypeId;
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// fn my_system(components: &Components, asset_server: Res<AssetServer>) {
-    ///     let handle: Handle<Image> = asset_server.load("image.png");
-    ///     let handle = handle.untyped();
-    ///     let assets_type_id = TypeId::of::<Assets<Image>>();
-    ///     let target = AssetAnimTarget::new_untyped(components, assets_type_id, &handle);
-    ///     // [...]
-    /// }
-    /// ```
-    ///
-    /// [`new()`]: Self::new
-    pub fn new_untyped(
-        components: &Components,
-        assets_type_id: TypeId,
-        asset_id: impl Into<UntypedAssetId>,
-    ) -> Result<Self, TweeningError> {
-        let asset_id = asset_id.into();
-        // Note: asset_id.type_id() is A, whereas assets_type_id is Assets<A>
-        let resource_id = components
-            .get_resource_id(assets_type_id)
-            .ok_or(TweeningError::AssetNotRegistered(assets_type_id))?;
-        Ok(Self {
-            resource_id,
-            asset_id,
-        })
-    }
-}
-
-/// Animation target.
-///
-/// References an object used as the target of a tweenable animation. See
-/// [`ComponentAnimTarget`], [`ResourceAnimTarget`], and [`AssetAnimTarget`],
-/// for details. This is a lightweight reference (copyable) implicitly tied to a
-/// given [`World`].
-///
-/// To create an animation target from a given component, resource, or asset,
-/// see the [`WorldTargetExtensions`] extension trait for [`World`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum AnimTarget {
-    /// Component animation target.
-    Component(ComponentAnimTarget),
-    /// Resource animation target.
-    Resource(ResourceAnimTarget),
-    /// Asset animation target.
-    Asset(AssetAnimTarget),
-}
-
-impl AnimTarget {
-    /// Check if the target is an [`AnimTarget::Component`].
-    #[inline]
-    pub fn is_component(&self) -> bool {
-        matches!(*self, AnimTarget::Component(..))
-    }
-
-    /// Convert this target to a component target if possible.
-    ///
-    /// # Returns
-    ///
-    /// Returns self as a [`ComponentAnimTarget`] if the value matches that enum
-    /// variant, or `None` if it doesn't.
-    #[inline]
-    pub fn as_component(&self) -> Option<&ComponentAnimTarget> {
-        if let Self::Component(component) = self {
-            Some(component)
-        } else {
-            None
-        }
-    }
-
-    /// Convert this target to a component target if possible.
-    ///
-    /// # Returns
-    ///
-    /// Returns self as a [`ComponentAnimTarget`] if the value matches that enum
-    /// variant, or `None` if it doesn't.
-    #[inline]
-    pub fn as_component_mut(&mut self) -> Option<&mut ComponentAnimTarget> {
-        if let Self::Component(component) = self {
-            Some(component)
-        } else {
-            None
-        }
-    }
-    /// Check if the target is an [`AnimTarget::Resource`].
-    #[inline]
-    pub fn is_resource(&self) -> bool {
-        matches!(*self, AnimTarget::Resource(..))
-    }
-
-    /// Convert this target to a resource target if possible.
-    ///
-    /// # Returns
-    ///
-    /// Returns self as a [`ResourceAnimTarget`] if the value matches that enum
-    /// variant, or `None` if it doesn't.
-    #[inline]
-    pub fn as_resource(&self) -> Option<&ResourceAnimTarget> {
-        if let Self::Resource(resource) = self {
-            Some(resource)
-        } else {
-            None
-        }
-    }
-
-    /// Convert this target to a resource target if possible.
-    ///
-    /// # Returns
-    ///
-    /// Returns self as a [`ResourceAnimTarget`] if the value matches that enum
-    /// variant, or `None` if it doesn't.
-    #[inline]
-    pub fn as_resource_mut(&mut self) -> Option<&mut ResourceAnimTarget> {
-        if let Self::Resource(resource) = self {
-            Some(resource)
-        } else {
-            None
-        }
-    }
-
-    /// Check if the target is an [`AnimTarget::Asset`].
-    #[inline]
-    pub fn is_asset(&self) -> bool {
-        matches!(*self, AnimTarget::Asset(..))
+    fn rotate_x_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            RotateXByCommand {
+                angle,
+                config: TweenConfig {
+                    ease_method: ease_method.into(),
+                    cycle_duration: duration,
+                    ..default()
+                },
+            },
+        )
     }
 
-    /// Convert this target to an asset target if possible.
-    ///
-    /// # Returns
-    ///
-    /// Returns self as an [`AssetAnimTarget`] if the value matches that enum
-    /// variant, or `None` if it doesn't.
     #[inline]
-    pub fn as_asset(&self) -> Option<&AssetAnimTarget> {
-        if let Self::Asset(asset) = self {
-            Some(asset)
-        } else {
-            None
-        }
+    fn rotate_y_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            RotateYByCommand {
+                angle,
+                config: TweenConfig {
+                    ease_method: ease_method.into(),
+                    cycle_duration: duration,
+                    ..default()
+                },
+            },
+        )
     }
 
-    /// Convert this target to an asset target if possible.
-    ///
-    /// # Returns
-    ///
-    /// Returns self as an [`AssetAnimTarget`] if the value matches that enum
-    /// variant, or `None` if it doesn't.
     #[inline]
-    pub fn as_asset_mut(&mut self) -> Option<&mut AssetAnimTarget> {
-        if let Self::Asset(asset) = self {
-            Some(asset)
-        } else {
-            None
-        }
-    }
-}
-
-impl From<ComponentAnimTarget> for AnimTarget {
-    fn from(value: ComponentAnimTarget) -> Self {
-        AnimTarget::Component(value)
+    fn rotate_z_by(
+        self,
+        angle: f32,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> AnimatedEntityCommands<'a, impl TweenCommand> {
+        AnimatedEntityCommands::new(
+            self,
+            RotateZByCommand {
+                angle,
+                config: TweenConfig {
+                    ease_method: ease_method.into(),
+                    cycle_duration: duration,
+                    ..default()
+                },
+            },
+        )
     }
 }
 
-impl From<ResourceAnimTarget> for AnimTarget {
-    fn from(value: ResourceAnimTarget) -> Self {
-        AnimTarget::Resource(value)
-    }
+/// Event raised when a [`TweenAnim`] completed.
+#[derive(Debug, Clone, Copy, Event)]
+pub struct AnimCompletedEvent {
+    /// The entity owning the [`TweenAnim`] which completed.
+    ///
+    /// Note that commonly the [`TweenAnim`] is despawned on completion, so
+    /// can't be queried anymore with this entity. You can prevent a completed
+    /// animation from being automatically destroyed by
+    /// setting [`TweenAnim::destroy_on_completion`] to `false`.
+    pub anim_entity: Entity,
+    /// The animation target.
+    ///
+    /// This is provided both as a convenience for [`TweenAnim`]s not destroyed
+    /// on completion, and because for those animations which are destroyed
+    /// on completion the information is not available anymore when this
+    /// event is received.
+    pub target: AnimTargetKind,
 }
 
-impl From<AssetAnimTarget> for AnimTarget {
-    fn from(value: AssetAnimTarget) -> Self {
-        AnimTarget::Asset(value)
-    }
+/// Errors returned by various animation functions.
+#[derive(Debug, Error, Clone, Copy)]
+pub enum TweeningError {
+    /// The asset resolver for the given asset is not registered.
+    #[error("Asset resolver for asset with resource ID {0:?} is not registered.")]
+    AssetResolverNotRegistered(ComponentId),
+    /// The entity was not found in the World.
+    #[error("Entity {0:?} not found in the World.")]
+    EntityNotFound(Entity),
+    /// The entity should have had a TweenAnim but it was not found.
+    #[error("Entity {0:?} doesn't have a TweenAnim.")]
+    MissingTweenAnim(Entity),
+    /// The component of the given type is not registered.
+    #[error("Component of type {0:?} is not registered in the World.")]
+    ComponentNotRegistered(TypeId),
+    /// The resource of the given type is not registered.
+    #[error("Resource of type {0:?} is not registered in the World.")]
+    ResourceNotRegistered(TypeId),
+    /// The asset container for the given asset type is not registered.
+    #[error("Asset container Assets<A> for asset type A = {0:?} is not registered in the World.")]
+    AssetNotRegistered(TypeId),
+    /// The component of the given type is not registered.
+    #[error("Component of type {0:?} is not present on entity {1:?}.")]
+    MissingComponent(TypeId, Entity),
+    /// The asset cannot be found.
+    #[error("Asset ID {0:?} is invalid.")]
+    InvalidAssetId(UntypedAssetId),
+    /// The asset ID references a different type than expected.
+    #[error("Expected type of asset ID to be {expected:?} but got {actual:?} instead.")]
+    InvalidAssetIdType {
+        /// The expected asset type.
+        expected: TypeId,
+        /// The actual type the asset ID references.
+        actual: TypeId,
+    },
+    /// Expected [`Tweenable::type_id()`] to return a value, but it returned
+    /// `None`.
+    #[error("Expected a typed Tweenable.")]
+    UntypedTweenable,
+    /// Invalid [`Entity`].
+    #[error("Invalid Entity {0:?}.")]
+    InvalidTweenId(Entity),
+    /// Cannot change target kind.
+    #[error("Unexpected target kind: was component={0}, now component={1}")]
+    MismatchingTargetKind(bool, bool),
+    /// Cannot change component type.
+    #[error("Cannot change component type: was component_id={0:?}, now component_id={1:?}")]
+    MismatchingComponentId(ComponentId, ComponentId),
+    /// Cannot change asset type.
+    #[error("Cannot change asset type: was component_id={0:?}, now component_id={1:?}")]
+    MismatchingAssetResourceId(ComponentId, ComponentId),
 }
 
-/// Animation target extension trait for [`World`].
-///
-/// This trait extends [`World`] with some helper functions to create various
-/// animation targets, generally for manually spawning a [`TweenAnim`].
-pub trait WorldTargetExtensions {
-    /// Get a [`ComponentAnimTarget`] for the given component type and entity
-    /// pair.
-    ///
-    /// The target references the component instance held by the entity. The
-    /// entity must exist in the [`World`], and the component type must be
-    /// registered.
-    ///
-    /// # Returns
-    ///
-    /// Returns the animation target referencing the component instance, or
-    /// `None` if either the entity doesn't exist or the component type is not
-    /// registered.
-    fn get_anim_component_target<C: Component<Mutability = Mutable>>(
-        &self,
-        entity: Entity,
-    ) -> Option<ComponentAnimTarget>;
+type RegisterAction = dyn Fn(&Components, &mut TweenResolver) + Send + Sync + 'static;
 
-    /// Get a [`ComponentAnimTarget`] for the given component type and entity
-    /// pair.
-    ///
-    /// The target references the component instance held by the entity. The
-    /// entity must exist in the [`World`], and the component type must be
-    /// registered.
-    ///
-    /// # Returns
-    ///
-    /// Returns the animation target referencing the component instance.
-    fn try_get_anim_component_target<C: Component<Mutability = Mutable>>(
-        &self,
+/// Enumeration of the types of animation target.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum AnimTargetKind {
+    /// Component animation target.
+    Component {
+        /// The entity owning the component instance.
         entity: Entity,
-    ) -> Result<ComponentAnimTarget, TweeningError>;
-
-    /// Get a [`ResourceAnimTarget`] for the given resource type.
-    ///
-    /// The target references the resource with the given type. The resource
-    /// type `R` must be registered.
-    ///
-    /// # Returns
-    ///
-    /// Returns the animation target referencing the asset instance, or
-    /// `None` if either the ID doesn't reference an existing asset or the asset
-    /// type is not registered.
-    fn get_anim_resource_target<R: Resource>(&self) -> Option<ResourceAnimTarget>;
-
-    /// Get a [`ResourceAnimTarget`] for the given resource type.
-    ///
-    /// The target references the resource with the given type. The resource
-    /// type `R` must be registered.
-    ///
-    /// # Returns
-    ///
-    /// Returns the animation target referencing the asset instance.
-    fn try_get_anim_resource_target<R: Resource>(
-        &self,
-    ) -> Result<ResourceAnimTarget, TweeningError>;
+    },
+    /// Resource animation target.
+    Resource,
+    /// Asset animation target.
+    Asset {
+        /// The asset ID inside the [`Assets`] collection.
+        asset_id: UntypedAssetId,
+    },
+}
 
-    /// Get an [`AssetAnimTarget`] for the given asset type and ID pair.
-    ///
-    /// The target references the asset instance with the given ID. The
-    /// ID must be valid, that is reference an existing asset in the `Assets<A>`
-    /// collection, and the asset type `A` must be registered.
-    ///
-    /// # Returns
-    ///
-    /// Returns the animation target referencing the asset instance, or
-    /// `None` if either the ID doesn't reference an existing asset or the asset
-    /// type is not registered.
-    fn get_anim_asset_target<A: Asset>(&self, id: impl Into<AssetId<A>>)
-        -> Option<AssetAnimTarget>;
+/// Animation target.
+///
+/// References an object used as the target of a tweenable animation.
+#[derive(Component)]
+pub struct AnimTarget {
+    /// Target kind.
+    pub kind: AnimTargetKind,
 
-    /// Get an [`AssetAnimTarget`] for the given asset type and ID pair.
-    ///
-    /// The target references the asset instance with the given ID. The
-    /// ID must be valid, that is reference an existing asset in the `Assets<A>`
-    /// collection, and the asset type `A` must be registered.
-    ///
-    /// # Returns
-    ///
-    /// Returns the animation target referencing the asset instance.
-    fn try_get_anim_asset_target<A: Asset>(
-        &self,
-        id: impl Into<AssetId<A>>,
-    ) -> Result<AssetAnimTarget, TweeningError>;
+    /// Self-registering action for assets and resources.
+    pub(crate) register_action: Option<Box<RegisterAction>>,
 }
 
-impl WorldTargetExtensions for World {
-    fn get_anim_component_target<C: Component<Mutability = Mutable>>(
-        &self,
-        entity: Entity,
-    ) -> Option<ComponentAnimTarget> {
-        let component_id = self.component_id::<C>()?;
-        if !self.entities().contains(entity) {
-            return None;
+impl AnimTarget {
+    /// Create a target mutating a component on the given entity.
+    pub fn component<C: Component<Mutability = Mutable>>(entity: Entity) -> Self {
+        Self {
+            kind: AnimTargetKind::Component { entity },
+            register_action: None,
         }
-        Some(ComponentAnimTarget {
-            component_id,
-            entity,
-        })
     }
 
-    fn try_get_anim_component_target<C: Component<Mutability = Mutable>>(
-        &self,
-        entity: Entity,
-    ) -> Result<ComponentAnimTarget, TweeningError> {
-        let component_id = self
-            .component_id::<C>()
-            .ok_or(TweeningError::ComponentNotRegistered(TypeId::of::<C>()))?;
-        if !self.entities().contains(entity) {
-            return Err(TweeningError::MissingComponent(TypeId::of::<C>(), entity));
+    /// Create a target mutating the given resource.
+    pub fn resource<R: Resource>() -> Self {
+        let register_action = |components: &Components, resolver: &mut TweenResolver| {
+            resolver.register_resource_resolver_for::<R>(components);
+        };
+        Self {
+            kind: AnimTargetKind::Resource,
+            register_action: Some(Box::new(register_action)),
+        }
+    }
+
+    /// Create a target mutating the given asset.
+    ///
+    /// The asset is identified by its type, and its [`AssetId`].
+    pub fn asset<A: Asset>(asset_id: impl Into<AssetId<A>>) -> Self {
+        let register_action = |components: &Components, resolver: &mut TweenResolver| {
+            resolver.register_asset_resolver_for::<A>(components);
+        };
+        Self {
+            kind: AnimTargetKind::Asset {
+                asset_id: asset_id.into().untyped(),
+            },
+            register_action: Some(Box::new(register_action)),
         }
-        Ok(ComponentAnimTarget {
-            component_id,
-            entity,
-        })
     }
 
-    fn get_anim_resource_target<R: Resource>(&self) -> Option<ResourceAnimTarget> {
-        let resource_id = self.resource_id::<R>()?;
-        Some(ResourceAnimTarget { resource_id })
+    /// Register any resolver for this target.
+    pub(crate) fn register(&self, components: &Components, resolver: &mut TweenResolver) {
+        if let Some(register_action) = self.register_action.as_ref() {
+            register_action(components, resolver);
+        }
     }
 
-    fn try_get_anim_resource_target<R: Resource>(
-        &self,
-    ) -> Result<ResourceAnimTarget, TweeningError> {
-        let resource_id = self
-            .resource_id::<R>()
-            .ok_or(TweeningError::ResourceNotRegistered(TypeId::of::<R>()))?;
-        Ok(ResourceAnimTarget { resource_id })
+    /// Check if the target is an [`AnimTarget::Component`].
+    #[inline]
+    pub fn is_component(&self) -> bool {
+        matches!(self.kind, AnimTargetKind::Component { .. })
     }
 
-    fn get_anim_asset_target<A: Asset>(
-        &self,
-        id: impl Into<AssetId<A>>,
-    ) -> Option<AssetAnimTarget> {
-        let id = id.into();
-        if !self.resource::<Assets<A>>().contains(id) {
-            return None;
-        }
-        let resource_id = self.resource_id::<Assets<A>>()?;
-        Some(AssetAnimTarget {
-            resource_id,
-            asset_id: id.untyped(),
-        })
+    /// Check if the target is an [`AnimTarget::Resource`].
+    #[inline]
+    pub fn is_resource(&self) -> bool {
+        matches!(self.kind, AnimTargetKind::Resource)
     }
 
-    fn try_get_anim_asset_target<A: Asset>(
-        &self,
-        id: impl Into<AssetId<A>>,
-    ) -> Result<AssetAnimTarget, TweeningError> {
-        let id = id.into();
-        if !self.resource::<Assets<A>>().contains(id) {
-            return Err(TweeningError::InvalidAssetId(id.untyped()));
-        }
-        let resource_id = self
-            .resource_id::<Assets<A>>()
-            .ok_or(TweeningError::AssetNotRegistered(TypeId::of::<A>()))?;
-        Ok(AssetAnimTarget {
-            resource_id,
-            asset_id: id.untyped(),
-        })
+    /// Check if the target is an [`AnimTarget::Asset`].
+    #[inline]
+    pub fn is_asset(&self) -> bool {
+        matches!(self.kind, AnimTargetKind::Asset { .. })
     }
 }
 
@@ -2206,8 +1929,6 @@ impl WorldTargetExtensions for World {
 /// [`tween()`]: TweeningExtensions::tween
 #[derive(Component)]
 pub struct TweenAnim {
-    /// The target this animation mutates.
-    target: AnimTarget,
     /// The animation itself. Note that the tweenable is stateful, so can't be
     /// shared with another [`TweenAnim`] instance.
     tweenable: BoxedTweenable,
@@ -2268,14 +1989,13 @@ impl TweenAnim {
     /// as part of a [`Sequence`], provided there's at least one other typed
     /// tweenable in the sequence to make it typed too.
     #[inline]
-    pub fn new(target: impl Into<AnimTarget>, tweenable: impl IntoBoxedTweenable) -> Self {
+    pub fn new(tweenable: impl IntoBoxedTweenable) -> Self {
         let tweenable = tweenable.into_boxed();
         assert!(
-            tweenable.type_id().is_some(),
-            "The top-level Tweenable of a TweenAnim must be typed (Tweenable::type_id() returns Some)."
+            tweenable.target_type_id().is_some(),
+            "The top-level Tweenable of a TweenAnim must be typed (Tweenable::target_type_id() returns Some)."
         );
         Self {
-            target: target.into(),
             tweenable,
             playback_state: PlaybackState::Playing,
             speed: 1.,
@@ -2284,92 +2004,16 @@ impl TweenAnim {
         }
     }
 
-    /// Create a new tweenable animation for a specific component target.
-    ///
-    /// This is a convenience helper which builds a [`ComponentAnimTarget`] then
-    /// calls [`new()`] with it. It's often useful in cases where you want to
-    /// manually insert the [`TweenAnim`] component to save its [`Entity`] so
-    /// you can reference it later, typically to control playback. Otherwise,
-    /// prefer using [`.tween()`] or similar to automatically create the
-    /// component and insert it.
-    ///
-    /// Note that the target component type is automically derived from the
-    /// input `tweenable`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use std::any::TypeId;
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// # fn make_tween() -> Tween { unimplemented!() }
-    /// fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
-    ///     // Get the entity holding the target component to animate. It doesn't need
-    ///     // to be spawned here, it only needs to exist.
-    ///     let target_entity = commands.spawn(Transform::default()).id();
-    ///     // Create the animation
-    ///     let tween = make_tween();
-    ///     let anim = TweenAnim::for_component(components, target_entity, tween)?;
-    ///     // Spawn the TweenAnim component on a new, separate Entity, and record that
-    ///     // Entity for later reference.
-    ///     let anim_entity = commands.spawn(anim).id();
-    ///     // [...]
-    ///     Ok(())
-    /// }
-    /// ```
     ///
-    /// [`new()`]: Self::new
-    /// [`.tween()`]: crate::TweeningExtensions::tween
-    pub fn for_component(
-        components: &Components,
-        target: Entity,
-        tweenable: impl Tweenable + 'static,
-    ) -> Result<Self, TweeningError> {
-        let type_id = tweenable.type_id().ok_or(TweeningError::UntypedTweenable)?;
-        let target = ComponentAnimTarget::new_untyped(components, type_id, target)?;
-        Ok(Self::new(target, tweenable))
+    pub fn with_speed(mut self, speed: f64) -> Self {
+        self.speed = speed;
+        self
     }
 
-    /// Create a new tweenable animation for a specific resource target.
-    ///
-    /// This is a convenience helper which builds a [`ResourceAnimTarget`] then
-    /// calls [`new()`] with it. It's often useful in cases where you want to
-    /// manually insert the [`TweenAnim`] component to save its [`Entity`] so
-    /// you can reference it later, typically to control playback. Otherwise,
-    /// prefer using [`.tween()`] or similar to automatically create the
-    /// component and insert it.
-    ///
-    /// Note that the target resource type is automically derived from the input
-    /// `tweenable`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use std::any::TypeId;
-    /// # use bevy::{prelude::*, ecs::component::Components};
-    /// # use bevy_tweening::*;
-    /// # fn make_tween() -> Tween { unimplemented!() }
-    /// fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
-    ///     // Create the animation
-    ///     let tween = make_tween();
-    ///     let anim = TweenAnim::for_resource(components, tween)?;
-    ///     // Spawn the TweenAnim component on a new, separate Entity, and record that
-    ///     // Entity for later reference.
-    ///     let anim_entity = commands.spawn(anim).id();
-    ///     // [...]
-    ///     Ok(())
-    /// }
-    /// ```
     ///
-    /// [`new()`]: Self::new
-    /// [`.tween()`]: crate::TweeningExtensions::tween
-    pub fn for_resource(
-        components: &Components,
-        tweenable: impl Tweenable + 'static,
-    ) -> Result<Self, TweeningError> {
-        let type_id = tweenable.type_id().ok_or(TweeningError::UntypedTweenable)?;
-        let target = ResourceAnimTarget::new_untyped(components, type_id)?;
-        Ok(Self::new(target, tweenable))
+    pub fn with_destroy_on_completed(mut self, destroy_on_completed: bool) -> Self {
+        self.destroy_on_completion = destroy_on_completed;
+        self
     }
 
     /// Step a single animation.
@@ -2468,11 +2112,15 @@ impl TweenAnim {
     ///
     /// [`step_all()`]: Self::step_all
     pub fn step_many(world: &mut World, delta_time: Duration, anims: &[Entity]) -> usize {
-        let mut q_anims = world.query::<&TweenAnim>();
+        let mut q_anims = world.query::<(Entity, &TweenAnim, Option<&AnimTarget>)>();
         let mut targets = Vec::with_capacity(anims.len());
         for entity in anims {
-            if let Ok(target) = q_anims.get(world, *entity).map(|anim| anim.target) {
-                targets.push((*entity, target));
+            if let Ok((entity, anim, maybe_target)) = q_anims.get(world, *entity) {
+                if let Ok((component_id, target)) =
+                    Self::resolve_target(world.components(), maybe_target, entity, anim.tweenable())
+                {
+                    targets.push((entity, component_id, target));
+                }
             }
         }
         Self::step_impl(world, delta_time, &targets[..]);
@@ -2490,17 +2138,77 @@ impl TweenAnim {
     /// time may be useful to force the current animation state to be
     /// applied to a target, in case you made change which do not
     /// automatically do so (for example, retargeting an animation).
-    pub fn step_all(world: &mut World, delta_time: Duration) -> Result<(), TweeningError> {
-        let mut q_anims = world.query::<(Entity, &TweenAnim)>();
-        let targets = q_anims
-            .iter(world)
-            .map(|(entity, anim)| (entity, anim.target))
-            .collect::<Vec<_>>();
+    pub fn step_all(world: &mut World, delta_time: Duration) {
+        let targets = world.resource_scope(|world, mut resolver: Mut<TweenResolver>| {
+            let mut q_anims = world.query::<(Entity, &TweenAnim, Option<&AnimTarget>)>();
+            q_anims
+                .iter(world)
+                .filter_map(|(entity, anim, maybe_target)| {
+                    if let Some(anim_target) = maybe_target {
+                        anim_target.register(world.components(), &mut resolver);
+                    }
+                    match Self::resolve_target(
+                        world.components(),
+                        maybe_target,
+                        entity,
+                        anim.tweenable(),
+                    ) {
+                        Ok((component_id, target)) => Some((entity, component_id, target)),
+                        Err(err) => {
+                            println!("err: {:?}", err);
+                            None
+                        }
+                    }
+                })
+                .collect::<Vec<_>>()
+        });
         Self::step_impl(world, delta_time, &targets[..]);
-        Ok(())
     }
 
-    fn step_impl(world: &mut World, delta_time: Duration, anims: &[(Entity, AnimTarget)]) {
+    fn resolve_target(
+        components: &Components,
+        maybe_target: Option<&AnimTarget>,
+        self_entity: Entity,
+        tweenable: &dyn Tweenable,
+    ) -> Result<(ComponentId, AnimTargetKind), TweeningError> {
+        let type_id = tweenable
+            .target_type_id()
+            .ok_or(TweeningError::UntypedTweenable)?;
+        if let Some(target) = maybe_target {
+            // Target explicitly specified with AnimTarget component
+            let component_id = match &target.kind {
+                AnimTargetKind::Component { .. } => components
+                    .get_id(type_id)
+                    .ok_or(TweeningError::ComponentNotRegistered(type_id))?,
+                AnimTargetKind::Resource => components
+                    .get_resource_id(type_id)
+                    .ok_or(TweeningError::ResourceNotRegistered(type_id))?,
+                AnimTargetKind::Asset { .. } => components
+                    .get_resource_id(type_id)
+                    .ok_or(TweeningError::AssetNotRegistered(type_id))?,
+            };
+            Ok((component_id, target.kind))
+        } else {
+            // Target implicitly self; this can only be a component target
+            if let Some(component_id) = components.get_id(type_id) {
+                Ok((
+                    component_id,
+                    AnimTargetKind::Component {
+                        entity: self_entity,
+                    },
+                ))
+            } else {
+                // We can't implicitly target an asset without its AssetId
+                Err(TweeningError::ComponentNotRegistered(type_id))
+            }
+        }
+    }
+
+    fn step_impl(
+        world: &mut World,
+        delta_time: Duration,
+        anims: &[(Entity, ComponentId, AnimTargetKind)],
+    ) {
         let mut to_remove = Vec::with_capacity(anims.len());
         world.resource_scope(|world, resolver: Mut<TweenResolver>| {
             world.resource_scope(
@@ -2508,22 +2216,23 @@ impl TweenAnim {
                     world.resource_scope(
                         |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
                             let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
-                            for (anim_entity, anim_target) in anims {
+                            for (anim_entity, component_id, anim_target) in anims {
                                 let ret = match anim_target {
-                                    AnimTarget::Component(comp_target) => {
+                                    AnimTargetKind::Component {
+                                        entity: comp_entity,
+                                    } => {
                                         let (mut entities, commands) =
                                             world.entities_and_commands();
-                                        if *anim_entity == comp_target.entity {
+                                        if *anim_entity == *comp_entity {
                                             // The TweenAnim animates another component on the same
                                             // entity
                                             let Ok([mut ent]) = entities.get_mut([*anim_entity])
                                             else {
                                                 continue;
                                             };
-                                            let Ok([anim, target]) = ent.get_mut_by_id([
-                                                anim_comp_id,
-                                                comp_target.component_id,
-                                            ]) else {
+                                            let Ok([anim, target]) =
+                                                ent.get_mut_by_id([anim_comp_id, *component_id])
+                                            else {
                                                 continue;
                                             };
                                             // SAFETY: We fetched the EntityMut from the component
@@ -2535,6 +2244,7 @@ impl TweenAnim {
                                                 commands,
                                                 *anim_entity,
                                                 delta_time,
+                                                anim_target,
                                                 target,
                                                 cycle_events.reborrow(),
                                                 anim_events.reborrow(),
@@ -2542,16 +2252,15 @@ impl TweenAnim {
                                         } else {
                                             // The TweenAnim animates a component on a different
                                             // entity
-                                            let Ok([mut anim, mut target]) = entities
-                                                .get_mut([*anim_entity, comp_target.entity])
+                                            let Ok([mut anim, mut target]) =
+                                                entities.get_mut([*anim_entity, *comp_entity])
                                             else {
                                                 continue;
                                             };
                                             let Some(mut anim) = anim.get_mut::<TweenAnim>() else {
                                                 continue;
                                             };
-                                            let Ok(target) =
-                                                target.get_mut_by_id(comp_target.component_id)
+                                            let Ok(target) = target.get_mut_by_id(*component_id)
                                             else {
                                                 continue;
                                             };
@@ -2559,23 +2268,25 @@ impl TweenAnim {
                                                 commands,
                                                 *anim_entity,
                                                 delta_time,
+                                                anim_target,
                                                 target,
                                                 cycle_events.reborrow(),
                                                 anim_events.reborrow(),
                                             )
                                         }
                                     }
-                                    AnimTarget::Resource(res_target) => resolver.resolve_resource(
+                                    AnimTargetKind::Resource => resolver.resolve_resource(
                                         world,
-                                        &res_target,
+                                        *component_id,
                                         *anim_entity,
                                         delta_time,
                                         cycle_events.reborrow(),
                                         anim_events.reborrow(),
                                     ),
-                                    AnimTarget::Asset(asset_target) => resolver.resolve_asset(
+                                    AnimTargetKind::Asset { asset_id } => resolver.resolve_asset(
                                         world,
-                                        &asset_target,
+                                        *component_id,
+                                        *asset_id,
                                         *anim_entity,
                                         delta_time,
                                         cycle_events.reborrow(),
@@ -2606,6 +2317,7 @@ impl TweenAnim {
         mut commands: Commands,
         anim_entity: Entity,
         delta_time: Duration,
+        target_kind: &AnimTargetKind,
         mut mut_untyped: MutUntyped,
         mut cycle_events: Mut<Events<CycleCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
@@ -2643,7 +2355,7 @@ impl TweenAnim {
         let mut notify_completed = || {
             completed_events.push(CycleCompletedEvent {
                 id: anim_entity,
-                target: self.target,
+                target: *target_kind,
             });
         };
         let state = self.tweenable.step(
@@ -2672,7 +2384,7 @@ impl TweenAnim {
         if state == TweenState::Completed {
             let event: AnimCompletedEvent = AnimCompletedEvent {
                 anim_entity,
-                target: self.target,
+                target: *target_kind,
             };
 
             // Send buffered event
@@ -2706,14 +2418,6 @@ impl TweenAnim {
         self.tween_state = TweenState::Active;
     }
 
-    /// Get the target this animation is mutating.
-    ///
-    /// To change the target, use [`TweenAnim::set_target()`].
-    #[inline]
-    pub fn target(&self) -> &AnimTarget {
-        &self.target
-    }
-
     /// Get the tweenable describing this animation.
     ///
     /// To change the tweenable, use [`TweenAnim::set_tweenable()`].
@@ -2772,48 +2476,6 @@ impl TweenAnim {
         Ok(old_tweenable)
     }
 
-    /// Retarget this animation.
-    ///
-    /// Attempt to change the target of this animation, even if it's already
-    /// playing. This function performs a number of checks on the new target
-    /// to ensure it's compatible with the previous target currently set. In
-    /// particular, the new target needs to have:
-    /// - the same kind (component or asset);
-    /// - the same type.
-    ///
-    /// # Returns
-    ///
-    /// On success, returns the previous target which has been replaced.
-    pub fn set_target(&mut self, target: AnimTarget) -> Result<AnimTarget, TweeningError> {
-        match (self.target, target) {
-            (AnimTarget::Component(old_component), AnimTarget::Component(new_component)) => {
-                if old_component.component_id != new_component.component_id {
-                    return Err(TweeningError::MismatchingComponentId(
-                        old_component.component_id,
-                        new_component.component_id,
-                    ));
-                }
-            }
-            (AnimTarget::Asset(old_asset), AnimTarget::Asset(new_asset)) => {
-                if old_asset.resource_id != new_asset.resource_id {
-                    return Err(TweeningError::MismatchingAssetResourceId(
-                        old_asset.resource_id,
-                        new_asset.resource_id,
-                    ));
-                }
-            }
-            _ => {
-                return Err(TweeningError::MismatchingTargetKind(
-                    self.target.is_component(),
-                    target.is_component(),
-                ))
-            }
-        }
-        let old_target = self.target;
-        self.target = target;
-        Ok(old_target)
-    }
-
     /// Get the tweening completion state.
     ///
     /// In general this is [`TweenState::Active`], unless the animation
@@ -2914,6 +2576,8 @@ impl TweenResolver {
             // First, remove the resource R from the world so we can access it mutably in
             // parallel of the TweenAnim
             world.resource_scope(|world, resource: Mut<R>| {
+                let target = AnimTargetKind::Resource;
+
                 let (mut entities, commands) = world.entities_and_commands();
 
                 // Resolve the TweenAnim component
@@ -2929,6 +2593,7 @@ impl TweenResolver {
                     commands,
                     entity,
                     delta_time,
+                    &target,
                     resource.into(),
                     cycle_events.reborrow(),
                     anim_events.reborrow(),
@@ -2967,6 +2632,10 @@ impl TweenResolver {
                     return Err(TweeningError::InvalidAssetId(asset_id.into()));
                 };
 
+                let target = AnimTargetKind::Asset {
+                    asset_id: asset_id.untyped(),
+                };
+
                 let (mut entities, commands) = world.entities_and_commands();
 
                 // Resolve the TweenAnim component
@@ -2982,6 +2651,7 @@ impl TweenResolver {
                     commands,
                     entity,
                     delta_time,
+                    &target,
                     asset.into(),
                     cycle_events.reborrow(),
                     anim_events.reborrow(),
@@ -2997,16 +2667,15 @@ impl TweenResolver {
     pub(crate) fn resolve_resource(
         &self,
         world: &mut World,
-        target: &ResourceAnimTarget,
+        resource_id: ComponentId,
         entity: Entity,
         delta_time: Duration,
         cycle_events: Mut<Events<CycleCompletedEvent>>,
         anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Result<StepResult, TweeningError> {
-        let Some(resolver) = self.resource_resolver.get(&target.resource_id) else {
-            return Err(TweeningError::AssetResolverNotRegistered(
-                target.resource_id,
-            ));
+        let Some(resolver) = self.resource_resolver.get(&resource_id) else {
+            println!("ERROR: resource not registered {:?}", resource_id);
+            return Err(TweeningError::AssetResolverNotRegistered(resource_id));
         };
         resolver(world, entity, delta_time, cycle_events, anim_events)
     }
@@ -3015,20 +2684,20 @@ impl TweenResolver {
     pub(crate) fn resolve_asset(
         &self,
         world: &mut World,
-        target: &AssetAnimTarget,
+        resource_id: ComponentId,
+        untyped_asset_id: UntypedAssetId,
         entity: Entity,
         delta_time: Duration,
         cycle_events: Mut<Events<CycleCompletedEvent>>,
         anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Result<StepResult, TweeningError> {
-        let Some(resolver) = self.asset_resolver.get(&target.resource_id) else {
-            return Err(TweeningError::AssetResolverNotRegistered(
-                target.resource_id,
-            ));
+        let Some(resolver) = self.asset_resolver.get(&resource_id) else {
+            println!("ERROR: asset not registered {:?}", resource_id);
+            return Err(TweeningError::AssetResolverNotRegistered(resource_id));
         };
         resolver(
             world,
-            target.asset_id,
+            untyped_asset_id,
             entity,
             delta_time,
             cycle_events,
@@ -3131,6 +2800,33 @@ impl ColorLerper for Color {
     }
 }
 
+///
+pub trait TweeningTransform {
+    ///
+    fn move_to(
+        self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> TweenAnim;
+}
+
+impl TweeningTransform for Transform {
+    fn move_to(
+        self,
+        end: Vec3,
+        duration: Duration,
+        ease_method: impl Into<EaseMethod>,
+    ) -> TweenAnim {
+        let lens = TransformPositionLens {
+            start: self.translation,
+            end,
+        };
+        let tween = Tween::new(ease_method.into(), duration, lens);
+        TweenAnim::new(tween)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::marker::PhantomData;
diff --git a/src/plugin.rs b/src/plugin.rs
index 13eb57b..8811ca5 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -48,7 +48,7 @@ pub enum AnimationSystem {
 /// `delta_time` equal to [`Time::delta()`].
 pub(crate) fn animator_system(world: &mut World) {
     let delta_time = world.resource::<Time>().delta();
-    let _ = TweenAnim::step_all(world, delta_time);
+    TweenAnim::step_all(world, delta_time);
 }
 
 #[cfg(test)]
diff --git a/src/test_utils.rs b/src/test_utils.rs
index ea739ad..cec36e2 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -117,10 +117,7 @@ macro_rules! assert_approx_eq {
 
 pub(crate) use assert_approx_eq;
 
-use crate::{
-    AnimCompletedEvent, ComponentAnimTarget, CycleCompletedEvent, TweenAnim, TweenResolver,
-    Tweenable,
-};
+use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenResolver, Tweenable};
 
 /// A simple isolated test environment with a [`World`] and a single
 /// [`Entity`] in it.
@@ -144,11 +141,7 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
         let mut system = IntoSystem::into_system(crate::plugin::animator_system);
         system.initialize(&mut world);
 
-        let entity = world.spawn(T::default()).id();
-        let target = ComponentAnimTarget::new::<T>(world.components(), entity).unwrap();
-        world
-            .entity_mut(entity)
-            .insert(TweenAnim::new(target, tweenable));
+        let entity = world.spawn((T::default(), TweenAnim::new(tweenable))).id();
 
         Self {
             world,
diff --git a/src/tweenable.rs b/src/tweenable.rs
index c85bde8..8e56848 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -2,7 +2,7 @@ use std::{any::TypeId, cmp::Ordering, time::Duration};
 
 use bevy::{ecs::change_detection::MutUntyped, prelude::*};
 
-use crate::{AnimTarget, EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy};
+use crate::{AnimTargetKind, EaseMethod, Lens, PlaybackDirection, RepeatCount, RepeatStrategy};
 
 /// The dynamic tweenable type.
 ///
@@ -116,10 +116,14 @@ pub struct CycleCompletedEvent {
     /// [`TweenAnim`]: crate::TweenAnim
     pub id: Entity,
     /// The target the tweenable which completed and the [`TweenAnim`] it's
-    /// part of are mutating.
+    /// part of are mutating. Note that an actual [`AnimTarget`] component might
+    /// not be spawned in the ECS world, if the target is a component on the
+    /// same entity as the one owning the [`TweenAnim`] ("implicit component
+    /// targetting"). But this field is always equal to the valid value that
+    /// would otherwise exist as component.
     ///
     /// [`TweenAnim`]: crate::TweenAnim
-    pub target: AnimTarget,
+    pub target: AnimTargetKind,
 }
 
 #[derive(Debug)]
@@ -549,7 +553,7 @@ pub trait Tweenable: Send + Sync {
     ///
     /// [`TweenAnim`]: crate::TweenAnim
     #[must_use]
-    fn type_id(&self) -> Option<TypeId>;
+    fn target_type_id(&self) -> Option<TypeId>;
 }
 
 macro_rules! impl_boxed {
@@ -1051,7 +1055,7 @@ impl Tweenable for Tween {
         self.clock.rewind(self.playback_direction);
     }
 
-    fn type_id(&self) -> Option<TypeId> {
+    fn target_type_id(&self) -> Option<TypeId> {
         Some(self.type_id)
     }
 }
@@ -1247,12 +1251,12 @@ impl Tweenable for Sequence {
         }
     }
 
-    fn type_id(&self) -> Option<TypeId> {
+    fn target_type_id(&self) -> Option<TypeId> {
         // Loop over all children, because we want to skip all untyped ones (Delay).
         // Otherwise the animator will panic, because we can't create an untyped
         // animation.
         for tween in &self.tweens {
-            if let Some(type_id) = tween.type_id() {
+            if let Some(type_id) = tween.target_type_id() {
                 return Some(type_id);
             }
         }
@@ -1366,7 +1370,7 @@ impl Tweenable for Delay {
         self.timer.reset();
     }
 
-    fn type_id(&self) -> Option<TypeId> {
+    fn target_type_id(&self) -> Option<TypeId> {
         None
     }
 }
@@ -1382,7 +1386,7 @@ mod tests {
     };
 
     use super::*;
-    use crate::{lens::*, test_utils::assert_approx_eq, ComponentAnimTarget};
+    use crate::{lens::*, test_utils::assert_approx_eq};
 
     // #[derive(Default, Copy, Clone)]
     // struct CallbackMonitor {
@@ -1531,11 +1535,7 @@ mod tests {
                 let component_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
                 if let Ok(mut target) = entity_mut.get_mut_by_id(component_id) {
-                    let world_target = ComponentAnimTarget {
-                        entity,
-                        component_id,
-                    }
-                    .into();
+                    let world_target = AnimTargetKind::Component { entity };
                     let mut notify_completed = || {
                         events.send(CycleCompletedEvent {
                             id: tween_id,
@@ -1893,18 +1893,19 @@ mod tests {
 
                     // Events are only sent when playing forward
                     if playback_direction.is_forward() {
-                        let component_id = world.component_id::<Transform>().unwrap();
+                        //let component_id = world.component_id::<Transform>().unwrap();
                         let mut event_reader = event_reader_system_state.get_mut(&mut world);
                         let event = event_reader.read().next();
                         if just_completed {
                             assert!(event.is_some());
                             if let Some(event) = event {
-                                let comp_target = event
-                                    .target
-                                    .as_component()
-                                    .expect("Expected a component target, got an asset one.");
-                                assert_eq!(comp_target.entity, entity);
-                                assert_eq!(comp_target.component_id, component_id);
+                                let AnimTargetKind::Component {
+                                    entity: comp_target,
+                                } = &event.target
+                                else {
+                                    panic!("Expected AnimTargetKind::Component");
+                                };
+                                assert_eq!(*comp_target, entity);
                             }
                         } else {
                             assert!(event.is_none());

From b7f009c32f64e25f1f15278d843f7a756118ee3a Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sun, 10 Aug 2025 10:28:49 +0100
Subject: [PATCH 59/66] Fix asset anim and all examples

---
 examples/colormaterial_color.rs   |  14 +--
 examples/follow.rs                |   2 +-
 examples/menu.rs                  |  76 ++++++++----
 examples/sequence.rs              |  91 ++++----------
 examples/sprite_color.rs          | 190 +++++++++++++++---------------
 examples/text_color.rs            |  53 +++++----
 examples/transform_rotation.rs    |  14 ++-
 examples/transform_translation.rs |  14 ++-
 examples/ui_position.rs           |  41 +++----
 src/lib.rs                        |  27 +++--
 10 files changed, 260 insertions(+), 262 deletions(-)

diff --git a/examples/colormaterial_color.rs b/examples/colormaterial_color.rs
index e688bab..d4f2f62 100644
--- a/examples/colormaterial_color.rs
+++ b/examples/colormaterial_color.rs
@@ -88,13 +88,13 @@ fn setup(
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands
-            .spawn((
-                Mesh2d(quad_mesh.clone()),
-                MeshMaterial2d(unique_material.clone()),
-                Transform::from_translation(Vec3::new(x, y, 0.)).with_scale(Vec3::splat(size)),
-            ))
-            .tween_asset(&unique_material, tween);
+        commands.spawn((
+            Mesh2d(quad_mesh.clone()),
+            MeshMaterial2d(unique_material.clone()),
+            Transform::from_translation(Vec3::new(x, y, 0.)).with_scale(Vec3::splat(size)),
+            TweenAnim::new(tween),
+            AnimTarget::asset(&unique_material),
+        ));
 
         y -= size * spacing;
         if y < -screen_y {
diff --git a/examples/follow.rs b/examples/follow.rs
index 616b735..3c7e277 100644
--- a/examples/follow.rs
+++ b/examples/follow.rs
@@ -99,7 +99,7 @@ fn setup(
             // will keep being removed and re-inserted.
             .with_destroy_on_completed(false),
         // The target of the animation, here a component on the given entity
-        AnimTarget::Component(entity),
+        AnimTarget::component::<Transform>(entity),
     ));
 }
 
diff --git a/examples/menu.rs b/examples/menu.rs
index 1068252..c32e5d4 100644
--- a/examples/menu.rs
+++ b/examples/menu.rs
@@ -20,11 +20,12 @@ struct InitialAnimMarker;
 ///
 /// The logic is handled as:
 /// 1. Appearance animations send an `AnimCompletedEvent`
-/// 2. The `enable_interaction_after_initial_animation()` system adds a marker
-///    component `InitTransitionDone` to any button component which completed
-///    its appearance animation, to mark it as active.
-/// 3. The `interaction()` system only queries buttons with a
-///    `InitTransitionDone` marker.
+/// 2. The `enable_interaction_after_initial_animation()` system adds a
+///    `HoverAnim` component to any button component which completed its
+///    appearance animation, to mark it as active. This component also contains
+///    the entity of the current hover animation being played, if any.
+/// 3. The `interaction()` system only queries buttons with a `HoverAnim`
+///    component, and override the tweenable animation based on the hover state.
 ///
 /// For simplicity step 2. is handled via an observer. Note that the observer is
 /// on the Entity which owns the TweenAnim, and not on the one owning the
@@ -135,9 +136,12 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                     tween_scale.into_boxed()
                 };
                 container
-                    .spawn(InitialAnimMarker)
-                    .observe(enable_interaction_after_initial_animation)
-                    .tween_component(target, tweenable);
+                    .spawn((
+                        InitialAnimMarker,
+                        TweenAnim::new(tweenable),
+                        AnimTarget::component::<Transform>(target),
+                    ))
+                    .observe(enable_interaction_after_initial_animation);
 
                 start_time_ms += 500;
             }
@@ -149,23 +153,35 @@ fn enable_interaction_after_initial_animation(
     mut commands: Commands,
     q_names: Query<&Name>,
 ) {
-    if let AnimTarget::Component(comp_target) = &trigger.target {
+    if let AnimTargetKind::Component {
+        entity: target_entity,
+    } = &trigger.target
+    {
         // Resolve the Entity to a friendly name through the Name component. This is
         // optional, just to make the message nicer.
         let name = q_names
-            .get(comp_target.entity)
+            .get(*target_entity)
             .ok()
             .map(Into::into)
-            .unwrap_or(format!("{:?}", comp_target.entity));
+            .unwrap_or(format!("{:?}", target_entity));
+
         println!("Button on entity {name} completed initial animation, activating...",);
+
+        // Spawn an Entity to hold the animation itself. We add the AnimTarget, which
+        // doesn't change, but not yet any TweenAnim since we have no animation to play.
+        let anim_entity = commands
+            .spawn(AnimTarget::component::<Transform>(*target_entity))
+            .id();
+
+        // Add the HoverAnim component which also acts as a marker
         commands
-            .entity(comp_target.entity)
-            .insert(InitTransitionDone);
+            .entity(*target_entity)
+            .insert(HoverAnim(anim_entity));
     }
 }
 
 #[derive(Component)]
-struct InitTransitionDone;
+struct HoverAnim(pub Entity);
 
 #[derive(Component, Clone, Copy)]
 enum ButtonLabel {
@@ -179,16 +195,18 @@ fn interaction(
     mut commands: Commands,
     mut interaction_query: Query<
         (
-            Entity,
             &Transform,
             &Interaction,
             &mut BackgroundColor,
             &ButtonLabel,
+            &HoverAnim,
         ),
-        (Changed<Interaction>, With<InitTransitionDone>),
+        Changed<Interaction>,
     >,
 ) {
-    for (entity, transform, interaction, mut color, button_label) in &mut interaction_query {
+    for (transform, interaction, mut color, button_label, hover_anim) in &mut interaction_query {
+        let anim_entity = hover_anim.0;
+
         match *interaction {
             Interaction::Pressed => {
                 *color = CLICK_COLOR.into();
@@ -210,27 +228,35 @@ fn interaction(
             }
             Interaction::Hovered => {
                 *color = HOVER_COLOR.into();
-                commands.entity(entity).tween(Tween::new(
+                let tween = Tween::new(
                     EaseFunction::QuadraticIn,
                     Duration::from_millis(200),
                     TransformScaleLens {
-                        start: Vec3::ONE,
+                        start: transform.scale,
                         end: Vec3::splat(1.1),
                     },
-                ));
+                );
+
+                // Set the animation by overwriting the TweenAnim component. This way we don't
+                // need to check if the previous animation was finished or not (and therefore if
+                // the TweenAnim component was deleted or not).
+                commands.entity(anim_entity).insert(TweenAnim::new(tween));
             }
             Interaction::None => {
                 *color = NORMAL_COLOR.into();
-                let start_scale = transform.scale;
-
-                commands.entity(entity).tween(Tween::new(
+                let tween = Tween::new(
                     EaseFunction::QuadraticIn,
                     Duration::from_millis(200),
                     TransformScaleLens {
-                        start: start_scale,
+                        start: transform.scale,
                         end: Vec3::ONE,
                     },
-                ));
+                );
+
+                // Set the animation by overwriting the TweenAnim component. This way we don't
+                // need to check if the previous animation was finished or not (and therefore if
+                // the TweenAnim component was deleted or not).
+                commands.entity(anim_entity).insert(TweenAnim::new(tween));
             }
         }
     }
diff --git a/examples/sequence.rs b/examples/sequence.rs
index 30052ae..3129aef 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -30,36 +30,15 @@ struct RedProgress;
 struct BlueProgress;
 
 #[derive(Component)]
-struct RedSprite {
-    /// ID of the tween making the red sprite move along a path around the
-    /// screen.
-    #[allow(unused)]
-    pub path_id: Entity,
-    /// ID of the tween making the red sprite rotate on itself back and forth.
-    #[allow(unused)]
-    pub rotate_id: Entity,
-}
-
-#[derive(Component)]
-struct BlueSprite {
-    /// ID of the tween making the blue sprite move along a path, then rotate.
-    pub move_and_rotate_id: Entity,
-    /// ID of the tween making the blue sprite scale.
-    #[allow(unused)]
-    pub scale_id: Entity,
-}
+struct RedAnimMarker;
 
 #[derive(Component)]
-struct RedAnimMarker;
+struct BlueAnimMarker;
 
 #[derive(Component)]
 struct ProgressValue;
 
-fn setup(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    components: &Components,
-) -> Result<()> {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) -> Result<()> {
     commands.spawn(Camera2d::default());
 
     let font = asset_server.load("fonts/FiraMono-Regular.ttf");
@@ -142,6 +121,9 @@ fn setup(
                 custom_size: Some(Vec2::new(size, size)),
                 ..default()
             })
+            // Insert a rotation animation via the commands extension, to rotate over self, forever.
+            // This will continue even after the move along path animation added below finished.
+            .rotate_z(Duration::from_secs(2))
             .id();
 
         // Build a sequence from an iterator over a Tweenable
@@ -155,40 +137,11 @@ fn setup(
                 },
             )
         }));
-
-        // Rotate over self, forever. This will continue even after the move along path
-        // above finished.
-        let anim_rotate_back_and_forth = Tween::new(
-            EaseFunction::QuadraticInOut,
-            Duration::from_millis(250),
-            TransformRotateZLens {
-                start: 0.,
-                end: 180_f32.to_radians(),
-            },
-        )
-        .with_repeat_count(RepeatCount::Infinite)
-        .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
-
-        // Because we want to monitor the progress of the animations, we need to fetch
-        // their Entity. There's essentially two possibilities for this.
-        // 1) Spawn a new entity, which here we augment with a marker component to
-        //    identify it later, and call tween_component() to spawn the TweenAnim an
-        //    automatically make it target the given entity.
-        let path_tween_id = commands
-            // Spawns (RedAnimMarker, TweenAnim) on same entity
-            .spawn(RedAnimMarker)
-            .tween_component(entity, anim_move_along_path)
-            .id();
-        // 2) Alternatively, we can manually create the TweenAnim with for_component(),
-        //    and insert it like any other component.
-        let anim = TweenAnim::for_component(components, entity, anim_rotate_back_and_forth)?;
-        let rotate_tween_id = commands.spawn(anim).id();
-        // Then we save both entities into RedSprite. We don't really need the first one
-        // since we have the RedAnimMarker component too.
-        commands.entity(entity).insert(RedSprite {
-            path_id: path_tween_id,
-            rotate_id: rotate_tween_id,
-        });
+        commands.spawn((
+            RedAnimMarker,
+            TweenAnim::new(anim_move_along_path),
+            AnimTarget::component::<Transform>(entity),
+        ));
     }
 
     // Blue sprite
@@ -260,12 +213,15 @@ fn setup(
         // Because we want to monitor the progress of the animations, we need to fetch
         // their Entity. This requires inserting them manually in the TweenAnimator
         // resource, instead of using the extensions of EntityCommands.
-        let move_and_rotate_id = commands.spawn_empty().tween_component(entity, seq1).id();
-        let scale_id = commands.spawn_empty().tween_component(entity, seq2).id();
-        commands.entity(entity).insert(BlueSprite {
-            move_and_rotate_id,
-            scale_id,
-        });
+        commands.spawn((
+            BlueAnimMarker,
+            TweenAnim::new(seq1),
+            AnimTarget::component::<Transform>(entity),
+        ));
+        commands.spawn((
+            TweenAnim::new(seq2),
+            AnimTarget::component::<Transform>(entity),
+        ));
     }
 
     Ok(())
@@ -275,9 +231,8 @@ fn update_text(
     red_text_children: Single<&Children, With<RedProgress>>,
     blue_text_children: Single<&Children, With<BlueProgress>>,
     mut q_textspans: Query<&mut TextSpan, With<ProgressValue>>,
-    q_tween_anims: Query<&TweenAnim>,
     q_anim_red: Single<Option<&TweenAnim>, With<RedAnimMarker>>,
-    q_anim_blue: Query<&BlueSprite>,
+    q_anim_blue: Single<Option<&TweenAnim>, With<BlueAnimMarker>>,
     mut q_event_completed: EventReader<AnimCompletedEvent>,
 ) {
     let anim_red = *q_anim_red;
@@ -287,8 +242,8 @@ fn update_text(
         1.
     };
 
-    let anim_blue = q_anim_blue.single().unwrap();
-    let progress_blue = if let Ok(anim) = q_tween_anims.get(anim_blue.move_and_rotate_id) {
+    let anim_blue = *q_anim_blue;
+    let progress_blue = if let Some(anim) = anim_blue {
         anim.tweenable().cycle_fraction()
     } else {
         1.
diff --git a/examples/sprite_color.rs b/examples/sprite_color.rs
index 71182f1..31b682f 100644
--- a/examples/sprite_color.rs
+++ b/examples/sprite_color.rs
@@ -1,94 +1,96 @@
-use bevy::{color::palettes::css::*, prelude::*};
-use bevy_tweening::{lens::*, *};
-
-mod utils;
-
-fn main() {
-    App::default()
-        .add_plugins(DefaultPlugins.set(WindowPlugin {
-            primary_window: Some(Window {
-                title: "SpriteColorLens".to_string(),
-                resolution: (1200., 600.).into(),
-                present_mode: bevy::window::PresentMode::Fifo, // vsync
-                ..default()
-            }),
-            ..default()
-        }))
-        .add_systems(Update, utils::close_on_esc)
-        .add_plugins(TweeningPlugin)
-        .add_systems(Startup, setup)
-        .run();
-}
-
-fn setup(mut commands: Commands) {
-    commands.spawn(Camera2d::default());
-
-    let size = 80.;
-
-    let spacing = 1.25;
-    let screen_x = 450.;
-    let screen_y = 120.;
-    let mut x = -screen_x;
-    let mut y = screen_y;
-
-    for ease_function in &[
-        EaseFunction::QuadraticIn,
-        EaseFunction::QuadraticOut,
-        EaseFunction::QuadraticInOut,
-        EaseFunction::CubicIn,
-        EaseFunction::CubicOut,
-        EaseFunction::CubicInOut,
-        EaseFunction::QuarticIn,
-        EaseFunction::QuarticOut,
-        EaseFunction::QuarticInOut,
-        EaseFunction::QuinticIn,
-        EaseFunction::QuinticOut,
-        EaseFunction::QuinticInOut,
-        EaseFunction::SineIn,
-        EaseFunction::SineOut,
-        EaseFunction::SineInOut,
-        EaseFunction::CircularIn,
-        EaseFunction::CircularOut,
-        EaseFunction::CircularInOut,
-        EaseFunction::ExponentialIn,
-        EaseFunction::ExponentialOut,
-        EaseFunction::ExponentialInOut,
-        EaseFunction::ElasticIn,
-        EaseFunction::ElasticOut,
-        EaseFunction::ElasticInOut,
-        EaseFunction::BackIn,
-        EaseFunction::BackOut,
-        EaseFunction::BackInOut,
-        EaseFunction::BounceIn,
-        EaseFunction::BounceOut,
-        EaseFunction::BounceInOut,
-    ] {
-        let tween = Tween::new(
-            *ease_function,
-            std::time::Duration::from_secs(1),
-            SpriteColorLens {
-                start: RED.into(),
-                end: BLUE.into(),
-            },
-        )
-        .with_repeat_count(RepeatCount::Infinite)
-        .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
-
-        commands
-            .spawn((
-                Transform::from_translation(Vec3::new(x, y, 0.)),
-                Sprite {
-                    color: Color::BLACK,
-                    custom_size: Some(Vec2::new(size, size)),
-                    ..default()
-                },
-            ))
-            .tween(tween);
-
-        y -= size * spacing;
-        if y < -screen_y {
-            x += size * spacing;
-            y = screen_y;
-        }
-    }
-}
+use bevy::{color::palettes::css::*, prelude::*};
+use bevy_tweening::{lens::*, *};
+
+mod utils;
+
+fn main() {
+    App::default()
+        .add_plugins(DefaultPlugins.set(WindowPlugin {
+            primary_window: Some(Window {
+                title: "SpriteColorLens".to_string(),
+                resolution: (1200., 600.).into(),
+                present_mode: bevy::window::PresentMode::Fifo, // vsync
+                ..default()
+            }),
+            ..default()
+        }))
+        .add_systems(Update, utils::close_on_esc)
+        .add_plugins(TweeningPlugin)
+        .add_systems(Startup, setup)
+        .run();
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2d::default());
+
+    let size = 80.;
+
+    let spacing = 1.25;
+    let screen_x = 450.;
+    let screen_y = 120.;
+    let mut x = -screen_x;
+    let mut y = screen_y;
+
+    for ease_function in &[
+        EaseFunction::QuadraticIn,
+        EaseFunction::QuadraticOut,
+        EaseFunction::QuadraticInOut,
+        EaseFunction::CubicIn,
+        EaseFunction::CubicOut,
+        EaseFunction::CubicInOut,
+        EaseFunction::QuarticIn,
+        EaseFunction::QuarticOut,
+        EaseFunction::QuarticInOut,
+        EaseFunction::QuinticIn,
+        EaseFunction::QuinticOut,
+        EaseFunction::QuinticInOut,
+        EaseFunction::SineIn,
+        EaseFunction::SineOut,
+        EaseFunction::SineInOut,
+        EaseFunction::CircularIn,
+        EaseFunction::CircularOut,
+        EaseFunction::CircularInOut,
+        EaseFunction::ExponentialIn,
+        EaseFunction::ExponentialOut,
+        EaseFunction::ExponentialInOut,
+        EaseFunction::ElasticIn,
+        EaseFunction::ElasticOut,
+        EaseFunction::ElasticInOut,
+        EaseFunction::BackIn,
+        EaseFunction::BackOut,
+        EaseFunction::BackInOut,
+        EaseFunction::BounceIn,
+        EaseFunction::BounceOut,
+        EaseFunction::BounceInOut,
+    ] {
+        let tween = Tween::new(
+            *ease_function,
+            std::time::Duration::from_secs(1),
+            SpriteColorLens {
+                start: RED.into(),
+                end: BLUE.into(),
+            },
+        )
+        .with_repeat_count(RepeatCount::Infinite)
+        .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
+
+        commands.spawn((
+            Transform::from_translation(Vec3::new(x, y, 0.)),
+            Sprite {
+                color: Color::BLACK,
+                custom_size: Some(Vec2::new(size, size)),
+                ..default()
+            },
+            // In this example we add the TweenAnim on the same Entity as the component being
+            // animated (Sprite). Because of that, the target is implicitly a component on this
+            // Entity, and we don't need to add an AnimTarget component.
+            TweenAnim::new(tween),
+        ));
+
+        y -= size * spacing;
+        if y < -screen_y {
+            x += size * spacing;
+            y = screen_y;
+        }
+    }
+}
diff --git a/examples/text_color.rs b/examples/text_color.rs
index 209797f..c99f61a 100644
--- a/examples/text_color.rs
+++ b/examples/text_color.rs
@@ -81,32 +81,33 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands
-            .spawn((
-                Text::new(*ease_name),
-                TextFont {
-                    font: font.clone(),
-                    font_size: 24.0,
-                    ..default()
-                },
-                TextColor(Color::WHITE),
-                Node {
-                    width: Val::Px(size_x),
-                    height: Val::Px(size_y),
-                    left: Val::Px(x),
-                    top: Val::Px(y),
-                    right: Val::Auto,
-                    bottom: Val::Auto,
-                    position_type: PositionType::Absolute,
-                    align_content: AlignContent::Center,
-                    align_items: AlignItems::Center,
-                    align_self: AlignSelf::Center,
-                    justify_content: JustifyContent::Center,
-                    ..default()
-                },
-            ))
-            // Automatically insert the animation via the entity command queue
-            .tween(tween);
+        commands.spawn((
+            Text::new(*ease_name),
+            TextFont {
+                font: font.clone(),
+                font_size: 24.0,
+                ..default()
+            },
+            TextColor(Color::WHITE),
+            Node {
+                width: Val::Px(size_x),
+                height: Val::Px(size_y),
+                left: Val::Px(x),
+                top: Val::Px(y),
+                right: Val::Auto,
+                bottom: Val::Auto,
+                position_type: PositionType::Absolute,
+                align_content: AlignContent::Center,
+                align_items: AlignItems::Center,
+                align_self: AlignSelf::Center,
+                justify_content: JustifyContent::Center,
+                ..default()
+            },
+            // In this example we add the TweenAnim on the same Entity as the component being
+            // animated (TextColor). Because of that, the target is implicitly a component on this
+            // Entity, and we don't need to add an AnimTarget component.
+            TweenAnim::new(tween),
+        ));
 
         y += delta_y;
         iy += 1;
diff --git a/examples/transform_rotation.rs b/examples/transform_rotation.rs
index cf1375b..2937320 100644
--- a/examples/transform_rotation.rs
+++ b/examples/transform_rotation.rs
@@ -103,14 +103,18 @@ fn setup(mut commands: Commands) {
                 Visibility::default(),
             ))
             .with_children(|parent| {
-                parent
-                    .spawn((Sprite {
+                parent.spawn((
+                    Sprite {
                         color: RED.into(),
                         custom_size: Some(Vec2::new(size, size * 0.5)),
                         ..default()
-                    },))
-                    // Automatically insert the animation via the entity command queue
-                    .tween(tween);
+                    },
+                    // In this example we add the TweenAnim on the same Entity as the component
+                    // being animated (Transform, automatically added because it's required by
+                    // Sprite). Because of that, the target is implicitly a component on this
+                    // Entity, and we don't need to add an AnimTarget component.
+                    TweenAnim::new(tween),
+                ));
             });
 
         y -= size * spacing;
diff --git a/examples/transform_translation.rs b/examples/transform_translation.rs
index 33204d2..f06245e 100644
--- a/examples/transform_translation.rs
+++ b/examples/transform_translation.rs
@@ -97,14 +97,18 @@ fn setup(mut commands: Commands) {
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands
-            .spawn((Sprite {
+        commands.spawn((
+            Sprite {
                 color: RED.into(),
                 custom_size: Some(Vec2::new(size, size)),
                 ..default()
-            },))
-            // Automatically insert the animation via the entity command queue
-            .tween(tween);
+            },
+            // In this example we add the TweenAnim on the same Entity as the component being
+            // animated (Transform, automatically added because it's required by Sprite). Because
+            // of that, the target is implicitly a component on this Entity, and we don't need to
+            // add an AnimTarget component.
+            TweenAnim::new(tween),
+        ));
 
         x += size * spacing;
     }
diff --git a/examples/ui_position.rs b/examples/ui_position.rs
index f98829b..3a844b2 100644
--- a/examples/ui_position.rs
+++ b/examples/ui_position.rs
@@ -106,26 +106,27 @@ fn setup(mut commands: Commands) {
         .with_repeat_count(RepeatCount::Infinite)
         .with_repeat_strategy(RepeatStrategy::MirroredRepeat);
 
-        commands
-            .spawn((
-                Node {
-                    width: Val::Px(size),
-                    height: Val::Px(size),
-                    left: Val::Px(x),
-                    top: Val::Px(10.),
-                    right: Val::Auto,
-                    bottom: Val::Auto,
-                    position_type: PositionType::Absolute,
-                    align_content: AlignContent::Center,
-                    align_items: AlignItems::Center,
-                    align_self: AlignSelf::Center,
-                    justify_content: JustifyContent::Center,
-                    ..default()
-                },
-                BackgroundColor(RED.into()),
-            ))
-            // Automatically insert the animation via the entity command queue
-            .tween(tween);
+        commands.spawn((
+            Node {
+                width: Val::Px(size),
+                height: Val::Px(size),
+                left: Val::Px(x),
+                top: Val::Px(10.),
+                right: Val::Auto,
+                bottom: Val::Auto,
+                position_type: PositionType::Absolute,
+                align_content: AlignContent::Center,
+                align_items: AlignItems::Center,
+                align_self: AlignSelf::Center,
+                justify_content: JustifyContent::Center,
+                ..default()
+            },
+            BackgroundColor(RED.into()),
+            // In this example we add the TweenAnim on the same Entity as the component being
+            // animated (Node). Because of that, the target is implicitly a component on this
+            // Entity, and we don't need to add an AnimTarget component.
+            TweenAnim::new(tween),
+        ));
 
         x += offset_x;
     }
diff --git a/src/lib.rs b/src/lib.rs
index cd69370..a058ca9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1831,6 +1831,8 @@ pub enum AnimTargetKind {
     Asset {
         /// The asset ID inside the [`Assets`] collection.
         asset_id: UntypedAssetId,
+        /// Type ID of the [`Assets`] collection itself.
+        assets_type_id: TypeId,
     },
 }
 
@@ -1876,6 +1878,7 @@ impl AnimTarget {
         Self {
             kind: AnimTargetKind::Asset {
                 asset_id: asset_id.into().untyped(),
+                assets_type_id: TypeId::of::<Assets<A>>(),
             },
             register_action: Some(Box::new(register_action)),
         }
@@ -2183,8 +2186,8 @@ impl TweenAnim {
                 AnimTargetKind::Resource => components
                     .get_resource_id(type_id)
                     .ok_or(TweeningError::ResourceNotRegistered(type_id))?,
-                AnimTargetKind::Asset { .. } => components
-                    .get_resource_id(type_id)
+                AnimTargetKind::Asset { assets_type_id, .. } => components
+                    .get_resource_id(*assets_type_id)
                     .ok_or(TweeningError::AssetNotRegistered(type_id))?,
             };
             Ok((component_id, target.kind))
@@ -2283,15 +2286,16 @@ impl TweenAnim {
                                         cycle_events.reborrow(),
                                         anim_events.reborrow(),
                                     ),
-                                    AnimTargetKind::Asset { asset_id } => resolver.resolve_asset(
-                                        world,
-                                        *component_id,
-                                        *asset_id,
-                                        *anim_entity,
-                                        delta_time,
-                                        cycle_events.reborrow(),
-                                        anim_events.reborrow(),
-                                    ),
+                                    AnimTargetKind::Asset { asset_id, .. } => resolver
+                                        .resolve_asset(
+                                            world,
+                                            *component_id,
+                                            *asset_id,
+                                            *anim_entity,
+                                            delta_time,
+                                            cycle_events.reborrow(),
+                                            anim_events.reborrow(),
+                                        ),
                                 };
 
                                 let retain = ret.map(|ret| ret.retain).unwrap_or(false);
@@ -2634,6 +2638,7 @@ impl TweenResolver {
 
                 let target = AnimTargetKind::Asset {
                     asset_id: asset_id.untyped(),
+                    assets_type_id: TypeId::of::<Assets<A>>(),
                 };
 
                 let (mut entities, commands) = world.entities_and_commands();

From e8e954c390feab09f9217646aec3ff9a8613ed36 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Mon, 11 Aug 2025 20:09:58 +0100
Subject: [PATCH 60/66] Fix docs

---
 src/lib.rs       | 318 +++++++++++++++++++----------------------------
 src/tweenable.rs |   1 +
 2 files changed, 130 insertions(+), 189 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index a058ca9..33c6dd5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -26,6 +26,9 @@
 //! Look at the documentation for:
 //! - [`Tween`] -- the description of a tweening animation and the explanation
 //!   of some core concepts
+//! - [`TweenAnim`] -- the component representing the runtime animation
+//! - [`AnimTarget`] -- the component defining the target that the animation
+//!   mutates
 //! - [`TweeningPlugin`] -- the plugin to add to your app
 //! - [`EntityCommandsTweeningExtensions`] -- the simplest way to spawn
 //!   animations
@@ -66,12 +69,40 @@
 //!     },
 //! );
 //!
-//! commands
-//!     // Spawn an entity to animate the position of.
-//!     .spawn(Transform::default())
-//!     // Create a tweenable animation targetting the current entity.
-//!     // This spawns a TweenAnim component.
-//!     .tween(tween);
+//! // Spawn an entity to animate the position of.
+//! commands.spawn((
+//!     Transform::default(),
+//!     // Create a tweenable animation targetting the current entity. Without AnimTarget,
+//!     // the target is implicitly a component on this same entity. The exact component
+//!     // type is derived from the type of the Lens used by the Tweenable itself.
+//!     TweenAnim::new(tween),
+//! ));
+//! # }
+//! ```
+//!
+//! If the target of the animation is not a component on the current entity,
+//! then an [`AnimTarget`] component is necessary to specify that target. Note
+//! that **[`AnimTarget`] is always mandatory for resource and asset
+//! animations**.
+//!
+//! ```
+//! # use bevy::prelude::*;
+//! # use bevy_tweening::{lens::*, *};
+//! # use std::time::Duration;
+//! # fn make_tween<R: Resource>() -> Tween { unimplemented!() }
+//! #[derive(Resource)]
+//! struct MyResource;
+//!
+//! # fn system(mut commands: Commands) {
+//! // Create a single animation (tween) to animate a resource.
+//! let tween = make_tween::<MyResource>();
+//!
+//! // Spawn an entity to own the resource animation.
+//! commands.spawn((
+//!     TweenAnim::new(tween),
+//!     // The AnimTarget is necessary here:
+//!     AnimTarget::resource::<MyResource>(),
+//! ));
 //! # }
 //! ```
 //!
@@ -97,54 +128,12 @@
 //! # }
 //! ```
 //!
-//! The [`tween()`] extension is convenient for fire-and-forget animations,
-//! because it implicitly targets the current entity. However, sometimes you
-//! want to remember the [`Entity`] owning the [`TweenAnim`], or insert a marker
-//! component on it, so that you can retrieve it later to control the animation
-//! at runtime. In that case, you can instead use the [`tween_component()`]
-//! extension:
-//!
-//! ```
-//! # use bevy::prelude::*;
-//! # use bevy_tweening::{lens::*, *};
-//! # use std::time::Duration;
-//! # fn system(mut commands: Commands) {
-//! // Marker component to identify the TweenAnim controller.
-//! #[derive(Component)]
-//! struct AnimController;
-//!
-//! // Create a single animation (tween) to move an entity.
-//! let tween = Tween::new(
-//!     // Use a quadratic easing on both endpoints.
-//!     EaseFunction::QuadraticInOut,
-//!     // It takes 1 second to go from start to end points.
-//!     Duration::from_secs(1),
-//!     // The lens gives access to the Transform component of the Entity,
-//!     // for the TweenAnimator to animate it. It also contains the start and
-//!     // end values respectively associated with the progress ratios 0. and 1.
-//!     TransformPositionLens {
-//!         start: Vec3::ZERO,
-//!         end: Vec3::new(1., 2., -4.),
-//!     },
-//! );
-//!
-//! // The Entity with the Transform being animated.
-//! // That entity contains a single Transform component.
-//! let target_entity = commands.spawn(Transform::default()).id();
-//!
-//! // The Entity with the TweenAnim controlling the animation.
-//! // That entity contains the (AnimController, TweenAnim) components.
-//! let anim_entity = commands
-//!     .spawn(AnimController)
-//!     .tween_component(target_entity, tween)
-//!     .id();
-//! # }
-//! ```
-//!
-//! See the [`TweeningExtensions`] extension trait for the various
-//! helpers provided for command-based animation, and the
-//! [`EntityCommandsTweeningExtensions`] for an extra layer of convenience for
-//! common animations like [`move_to()`].
+//! The [`move_to()`] extension is convenient helper for animations, which
+//! creates a [`Tween`] that animates the [`Transform::translation`]. It has the
+//! added benefit that the starting point is automatically read from the
+//! component itself; you only need to specify the end position. See the
+//! [`EntityCommandsTweeningExtensions`] extension trait defining helpers for
+//! other common animations.
 //!
 //! # Ready to animate
 //!
@@ -152,14 +141,9 @@
 //! particular system setup** aside from adding the [`TweeningPlugin`] to your
 //! [`App`]. In particular, per-component-type and per-asset-type systems are
 //! gone. Instead, the plugin adds a _single_ system executing during the
-//! [`Update`] schedule. Each [`TweenAnim`] acts as a controller for one
-//! animation, and mutates its target which can be any component or asset, even
-//! a custom one.
-//!
-//! If you animate resources or assets, please do read the documentation of the
-//! [`TweenResolver`] to ensure the resource or asset type is properly handled.
-//! Depending on your workflow, you may need to register those types with the
-//! resolver. With other workflows this is done automatically for you.
+//! [`Update`] schedule, which calls [`TweenAnim::step_all()`]. Each
+//! [`TweenAnim`] acts as a controller for one animation, and mutates its
+//! target.
 //!
 //! # Tweenables
 //!
@@ -224,15 +208,15 @@
 //! determines the target component, resource, or asset, to animate, via an
 //! [`AnimTarget`], and accesses the field(s) of that target using a [`Lens`].
 //!
-//! - Components are animated via the [`ComponentAnimTarget`], which identifies
-//!   a component instance on an entity via the [`Entity`] itself and the
-//!   [`ComponentId`] of the registered component type.
-//! - Resources are animated via the [`ResourceAnimTarget`], which identifies a
-//!   resource instance via the [`ComponentId`] of the registered resource type.
-//! - Assets are animated via the [`AssetAnimTarget`] which identifies an asset
-//!   via the type of its [`Assets`] collection (and so indirectly the type of
-//!   asset itself) and the [`AssetId`] referencing that asset inside that
-//!   collection.
+//! - Components are animated via the [`AnimTargetKind::Component`], which
+//!   identifies a component instance on an entity via the [`Entity`] itself. If
+//!   that target entity is the same as the one owning the [`TweenAnim`], then
+//!   the [`AnimTarget`] can be omitted, for convenience.
+//! - Resources are animated via the [`AnimTargetKind::Resource`].
+//! - Assets are animated via the [`AnimTargetKind::Asset`] which identifies an
+//!   asset via the type of its [`Assets`] collection (and so indirectly the
+//!   type of asset itself) and the [`AssetId`] referencing that asset inside
+//!   that collection.
 //!
 //! Because assets are typically shared, and the animation applies to the asset
 //! itself, all users of the asset see the animation. For example, animating the
@@ -241,40 +225,6 @@
 //! need to duplicate the asset and assign a unique copy to that mesh,
 //! then animate that copy alone.
 //!
-//! Although you generally should prefer using the various extensions on
-//! commands, like the [`tween()`] function on entity commands, under the hood
-//! the manual process of queuing a new animation involves spawning a
-//! [`TweenAnim`] component.
-//!
-//! ```no_run
-//! # use bevy::{prelude::*, ecs::component::Components};
-//! # use bevy_tweening::*;
-//! # fn make_tween() -> Tween { unimplemented!() }
-//! fn my_system(mut commands: Commands, components: &Components) -> Result<(), TweeningError> {
-//! # let entity = Entity::PLACEHOLDER;
-//!     let entity = commands.spawn(Transform::default()).id();
-//!     let target = ComponentAnimTarget::new::<Transform>(components, entity)?;
-//!     // Place the TweenAnim on the same entity as the target component:
-//!     let tween: Tween = make_tween();
-//!     commands
-//!         .entity(entity)
-//!         .insert(TweenAnim::new(target, tween));
-//!     // ---OR---
-//!     // Place it on its own entity
-//!     let tween: Tween = make_tween();
-//!     commands.spawn(TweenAnim::new(target, tween));
-//!     Ok(())
-//! }
-//! ```
-//!
-//! For resources and assets, you also must ensure a resolver is registered for
-//! that resource or asset type, through
-//! [`TweenResolver::register_resource_resolver_for()`] and
-//! [`TweenResolver::register_asset_resolver_for()`], respectively. Note that
-//! the [`tween_resource()`] and [`tween_asset()`] extensions take care of
-//! this for you, which is another reason to prefer using those rather than
-//! manually spawning a [`TweenAnim`] component.
-//!
 //! After that, you can use the [`TweenAnim`] component to control the animation
 //! playback:
 //!
@@ -290,9 +240,9 @@
 //!
 //! The [`AnimTarget`] references the target (component, resource, or asset)
 //! being animated. However, only a part of that target is generally animated.
-//! To that end, the [`TweenAnim`] accesses the field(s) to animate via a
-//! _lens_, a type that implements the [`Lens`] trait and allows mapping a
-//! target to the actual value(s) animated.
+//! To that end, the [`TweenAnim`] (or, more exactly, the [`Tweenable`] it uses)
+//! accesses the field(s) to animate via a _lens_, a type that implements the
+//! [`Lens`] trait and allows mapping a target to the actual value(s) animated.
 //!
 //! For example, the [`TransformPositionLens`] uses a [`Transform`] component as
 //! input, and animates its [`Transform::translation`] field only, leaving the
@@ -314,7 +264,8 @@
 //! provided for convenience and mainly as examples. 🍃 Bevy Tweening expects
 //! you to write your own lenses by implementing the [`Lens`] trait, which as
 //! you can see above is very simple. This allows animating virtually any field
-//! of any component or asset, whether shipped with Bevy or defined by the user.
+//! of any component, resource, or asset, whether shipped with Bevy or defined
+//! by the user.
 //!
 //! # Tweening vs. keyframed animation
 //!
@@ -336,10 +287,6 @@
 //! [`ColorMaterial`]: https://docs.rs/bevy/0.16.0/bevy/sprite/struct.ColorMaterial.html
 //! [`Transform`]: https://docs.rs/bevy/0.16.0/bevy/transform/components/struct.Transform.html
 //! [`TransformPositionLens`]: crate::lens::TransformPositionLens
-//! [`tween()`]: crate::TweeningExtensions::tween
-//! [`tween_component()`]: crate::TweeningExtensions::tween_component
-//! [`tween_resource()`]: crate::TweeningExtensions::tween_resource
-//! [`tween_asset()`]: crate::TweeningExtensions::tween_asset
 //! [`move_to()`]: crate::EntityCommandsTweeningExtensions::move_to
 
 use std::{
@@ -1328,21 +1275,22 @@ impl TweenCommand for RotateZByCommand {
 /// # fn my_system(mut commands: Commands) {
 /// commands.spawn(Transform::default())
 ///     // Consume the EntityCommands, and wrap it into an AnimatedEntityCommands,
-///     // which stores a MoveToCommand animation command.
+///     // which stores an animation command to move an entity.
 ///     .move_to(
 ///         Vec3::ONE,
 ///         Duration::from_millis(400)
 ///         EaseFunction::QuadraticIn,
 ///     )
-///     // Tweak the MoveToCommand to configure the repeat count of the Tween
+///     // Tweak the stored animation to set the repeat count of the Tween.
 ///     .repeat_count(2);
 /// # }
 /// ```
 ///
 /// The animation commands always stores the last animation inserted. When the
-/// commands is mutably dereferenced, it first flushes any pending (single)
-/// animation command by inserting it into the underlying [`EntityCommands`]
-/// queue.
+/// commands is mutably dereferenced, it first flushes the pending animation
+/// command, if any, by inserting it into the underlying [`EntityCommands`]
+/// queue. It also flushes the animation when dropped, to ensure the last
+/// animation is queued too.
 ///
 /// To move from an [`AnimatedEntityCommands`] to its underlying
 /// [`EntityCommands`], the former automatically dereferences to the latter.
@@ -1409,6 +1357,15 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
     }
 
     /// Configure the repeat parameters of this animation.
+    /// 
+    /// This is a shortcut for:
+    /// 
+    /// ```no_run
+    /// # impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
+    /// # fn xxx(&self) -> Self {
+    /// self.with_repeat_count(repeat_count).with_repeat_strategy(repeat_strategy)
+    /// # }}
+    /// ```
     #[inline]
     pub fn with_repeat(
         self,
@@ -1421,8 +1378,8 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
 
     /// Consume self and return the inner [`EntityCommands`].
     ///
-    /// The current animation is inserted into the commands queue before that
-    /// commands queue is returned.
+    /// The current animation is inserted into the commands queue, before that
+    /// wrapped commands queue is returned.
     pub fn into_inner(mut self) -> EntityCommands<'a> {
         self.flush();
         // Since we already flushed above, we don't need Drop. And trying to keep would
@@ -1797,8 +1754,8 @@ pub enum TweeningError {
         /// The actual type the asset ID references.
         actual: TypeId,
     },
-    /// Expected [`Tweenable::type_id()`] to return a value, but it returned
-    /// `None`.
+    /// Expected [`Tweenable::target_type_id()`] to return a value, but it
+    /// returned `None`.
     #[error("Expected a typed Tweenable.")]
     UntypedTweenable,
     /// Invalid [`Entity`].
@@ -1817,7 +1774,10 @@ pub enum TweeningError {
 
 type RegisterAction = dyn Fn(&Components, &mut TweenResolver) + Send + Sync + 'static;
 
-/// Enumeration of the types of animation target.
+/// Enumeration of the types of animation targets.
+///
+/// This type holds the minimum amount of data to reference ananimation target,
+/// aside from the actual type of the target.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum AnimTargetKind {
     /// Component animation target.
@@ -1836,12 +1796,13 @@ pub enum AnimTargetKind {
     },
 }
 
-/// Animation target.
+/// Component defining the target of an animation.
 ///
-/// References an object used as the target of a tweenable animation.
+/// References an object used as the target of the animation stored in the
+/// [`TweenAnim`] component on the same entity.
 #[derive(Component)]
 pub struct AnimTarget {
-    /// Target kind.
+    /// Target kind and additional data to identify it.
     pub kind: AnimTargetKind,
 
     /// Self-registering action for assets and resources.
@@ -1890,46 +1851,49 @@ impl AnimTarget {
             register_action(components, resolver);
         }
     }
-
-    /// Check if the target is an [`AnimTarget::Component`].
-    #[inline]
-    pub fn is_component(&self) -> bool {
-        matches!(self.kind, AnimTargetKind::Component { .. })
-    }
-
-    /// Check if the target is an [`AnimTarget::Resource`].
-    #[inline]
-    pub fn is_resource(&self) -> bool {
-        matches!(self.kind, AnimTargetKind::Resource)
-    }
-
-    /// Check if the target is an [`AnimTarget::Asset`].
-    #[inline]
-    pub fn is_asset(&self) -> bool {
-        matches!(self.kind, AnimTargetKind::Asset { .. })
-    }
 }
 
 /// Animation controller instance.
 ///
 /// The [`TweenAnim`] represents a single animation instance for a single
-/// target, component or asset. Each instance is independent, even if it mutates
-/// the same target as another instance. Spawning this component adds an active
-/// animation, and destroying it stops that animation. The component can also be
-/// used to control the animation playback at runtime, like the playback speed.
+/// target (component or resource or asset). Each instance is independent, even
+/// if it mutates the same target as another instance. Spawning this component
+/// adds an active animation, and destroying it stops that animation. The
+/// component can also be used to control the animation playback at runtime,
+/// like the playback speed.
 ///
-/// You can create this component yourself via [`new()`] and spawn it as a
-/// regular component, but doing so involves creating an [`AnimTarget`], which
-/// is now always convenient. Instead, it's often easier to use one of the
-/// extension functions provided by the [`TweeningExtensions`]
-/// trait, like [`tween()`]. Those extensions automatically create an approriate
-/// [`AnimTarget`] for you.
+/// The target is described by the [`AnimTarget`] component. If that component
+/// is absent, then the animation implicitly targets a component on the current
+/// Entity. The type of the component is derived from the type that the [`Lens`]
+/// animates.
 ///
 /// _If you're looking for the basic tweenable animation description, see
 /// [`Tween`] instead._
 ///
-/// [`new()`]: Self::new
-/// [`tween()`]: TweeningExtensions::tween
+/// # Example
+///
+/// ```
+/// # use bevy::prelude::*;
+/// # use bevy_tweening::*;
+/// # fn make_tweenable<T>() -> Tween { unimplemented!() }
+/// fn my_system(mut commands: Commands) {
+///     let tweenable = make_tweenable::<Transform>();
+///     let id1 = commands
+///         .spawn((
+///             Transform::default(),
+///             // Implicitly targets the current entity's Transform
+///             TweenAnim::new(tweenable),
+///         ))
+///         .id();
+///
+///     let tweenable2 = make_tweenable::<Transform>();
+///     commands.spawn((
+///         TweenAnim::new(tweenable2),
+///         // Explicitly targets the Transform component of entity 'id1'
+///         AnimTarget::component::<Transform>(id1),
+///     ));
+/// }
+/// ```
 #[derive(Component)]
 pub struct TweenAnim {
     /// The animation itself. Note that the tweenable is stateful, so can't be
@@ -1985,12 +1949,13 @@ impl TweenAnim {
     ///
     /// # Panics
     ///
-    /// Panics if the tweenable is "typeless", that is [`Tweenable::type_id()`]
-    /// returns `None`. Animations must target a concrete component or asset
-    /// type. This means in particular that you can't use a single [`Delay`]
-    /// alone. You can however use a [`Delay`] or other typeless tweenables
-    /// as part of a [`Sequence`], provided there's at least one other typed
-    /// tweenable in the sequence to make it typed too.
+    /// Panics if the tweenable is "typeless", that is
+    /// [`Tweenable::target_type_id()`] returns `None`. Animations must
+    /// target a concrete component or asset type. This means in particular
+    /// that you can't use a single [`Delay`] alone. You can however use a
+    /// [`Delay`] or other typeless tweenables as part of a [`Sequence`],
+    /// provided there's at least one other typed tweenable in the sequence
+    /// to make it typed too.
     #[inline]
     pub fn new(tweenable: impl IntoBoxedTweenable) -> Self {
         let tweenable = tweenable.into_boxed();
@@ -2534,17 +2499,6 @@ type AssetResolver = Box<
 /// type-erased closures allowing to resolve an animation target definition into
 /// a mutable pointer [`MutUntyped`] to that instance, to allow the animation
 /// engine to apply the animation on it.
-///
-/// For users, this resource is important if you don't use the convenience
-/// [`tween_resource()`] or [`tween_asset()`], but instead manually insert the
-/// [`TweenAnim`] component. In that case, you should make sure to call once the
-/// [`register_resource_resolver_for()`] or [`register_asset_resolver_for()`],
-/// respectively, to register such a resolver.
-///
-/// [`tween_resource()`]: crate::TweeningExtensions::tween_resource
-/// [`tween_asset()`]: crate::TweeningExtensions::tween_asset
-/// [`register_resource_resolver_for()`]: Self::register_resource_resolver_for
-/// [`register_asset_resolver_for()`]: Self::register_asset_resolver_for
 #[derive(Default, Resource)]
 pub struct TweenResolver {
     /// Resource resolver allowing to call `World::resource_scope()` to extract
@@ -2562,14 +2516,7 @@ pub struct TweenResolver {
 
 impl TweenResolver {
     /// Register a resolver for the given resource type.
-    ///
-    /// This must be called once per resource type for every resource type being
-    /// animated. Using [`tween_resource()`] automatically calls it
-    /// automatically, so if you're only using that utility then you don't need
-    /// to manually call this function.
-    ///
-    /// [`tween_resource()`]: crate::TweeningExtensions::tween_resource
-    pub fn register_resource_resolver_for<R: Resource>(&mut self, components: &Components) {
+    pub(crate) fn register_resource_resolver_for<R: Resource>(&mut self, components: &Components) {
         let resource_id = components.resource_id::<R>().unwrap();
         let resolver = |world: &mut World,
                         entity: Entity,
@@ -2610,14 +2557,7 @@ impl TweenResolver {
     }
 
     /// Register a resolver for the given asset type.
-    ///
-    /// This must be called once per asset type for every asset type being
-    /// animated. Using [`tween_asset()`] automatically calls it automatically,
-    /// so if you're only using that utility then you don't need to manually
-    /// call this function.
-    ///
-    /// [`tween_asset()`]: crate::TweeningExtensions::tween_asset
-    pub fn register_asset_resolver_for<A: Asset>(&mut self, components: &Components) {
+    pub(crate) fn register_asset_resolver_for<A: Asset>(&mut self, components: &Components) {
         let resource_id = components.resource_id::<Assets<A>>().unwrap();
         let resolver = |world: &mut World,
                         asset_id: UntypedAssetId,
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 8e56848..625ccad 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -123,6 +123,7 @@ pub struct CycleCompletedEvent {
     /// would otherwise exist as component.
     ///
     /// [`TweenAnim`]: crate::TweenAnim
+    /// [`AnimTarget`]: crate::AnimTarget
     pub target: AnimTargetKind,
 }
 

From 5a5ec38cbc46b269559923299db59aa3fc95053e Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Mon, 11 Aug 2025 21:02:20 +0100
Subject: [PATCH 61/66] WIP - trying to handle heterogenous Sequence via
 retargetting

---
 src/lib.rs       | 139 +++++++++++++++++++++--------------------------
 src/tweenable.rs |  68 +++++++++++++++++------
 2 files changed, 113 insertions(+), 94 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 33c6dd5..323ca6a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1357,13 +1357,14 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
     }
 
     /// Configure the repeat parameters of this animation.
-    /// 
+    ///
     /// This is a shortcut for:
-    /// 
+    ///
     /// ```no_run
     /// # impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
     /// # fn xxx(&self) -> Self {
-    /// self.with_repeat_count(repeat_count).with_repeat_strategy(repeat_strategy)
+    /// self.with_repeat_count(repeat_count)
+    ///     .with_repeat_strategy(repeat_strategy)
     /// # }}
     /// ```
     #[inline]
@@ -2084,10 +2085,10 @@ impl TweenAnim {
         let mut targets = Vec::with_capacity(anims.len());
         for entity in anims {
             if let Ok((entity, anim, maybe_target)) = q_anims.get(world, *entity) {
-                if let Ok((component_id, target)) =
+                if let Ok((target_type_id, component_id, target)) =
                     Self::resolve_target(world.components(), maybe_target, entity, anim.tweenable())
                 {
-                    targets.push((entity, component_id, target));
+                    targets.push((entity, target_type_id, component_id, target));
                 }
             }
         }
@@ -2121,7 +2122,9 @@ impl TweenAnim {
                         entity,
                         anim.tweenable(),
                     ) {
-                        Ok((component_id, target)) => Some((entity, component_id, target)),
+                        Ok((target_type_id, component_id, target)) => {
+                            Some((entity, target_type_id, component_id, target))
+                        }
                         Err(err) => {
                             println!("err: {:?}", err);
                             None
@@ -2138,7 +2141,7 @@ impl TweenAnim {
         maybe_target: Option<&AnimTarget>,
         self_entity: Entity,
         tweenable: &dyn Tweenable,
-    ) -> Result<(ComponentId, AnimTargetKind), TweeningError> {
+    ) -> Result<(TypeId, ComponentId, AnimTargetKind), TweeningError> {
         let type_id = tweenable
             .target_type_id()
             .ok_or(TweeningError::UntypedTweenable)?;
@@ -2155,11 +2158,12 @@ impl TweenAnim {
                     .get_resource_id(*assets_type_id)
                     .ok_or(TweeningError::AssetNotRegistered(type_id))?,
             };
-            Ok((component_id, target.kind))
+            Ok((type_id, component_id, target.kind))
         } else {
             // Target implicitly self; this can only be a component target
             if let Some(component_id) = components.get_id(type_id) {
                 Ok((
+                    type_id,
                     component_id,
                     AnimTargetKind::Component {
                         entity: self_entity,
@@ -2175,16 +2179,17 @@ impl TweenAnim {
     fn step_impl(
         world: &mut World,
         delta_time: Duration,
-        anims: &[(Entity, ComponentId, AnimTargetKind)],
+        anims: &[(Entity, TypeId, ComponentId, AnimTargetKind)],
     ) {
         let mut to_remove = Vec::with_capacity(anims.len());
+        let mut to_retarget = Vec::with_capacity(8);
         world.resource_scope(|world, resolver: Mut<TweenResolver>| {
             world.resource_scope(
                 |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
                     world.resource_scope(
                         |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
                             let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
-                            for (anim_entity, component_id, anim_target) in anims {
+                            for (anim_entity, target_type_id, component_id, anim_target) in anims {
                                 let ret = match anim_target {
                                     AnimTargetKind::Component {
                                         entity: comp_entity,
@@ -2214,6 +2219,7 @@ impl TweenAnim {
                                                 delta_time,
                                                 anim_target,
                                                 target,
+                                                target_type_id,
                                                 cycle_events.reborrow(),
                                                 anim_events.reborrow(),
                                             )
@@ -2238,6 +2244,7 @@ impl TweenAnim {
                                                 delta_time,
                                                 anim_target,
                                                 target,
+                                                target_type_id,
                                                 cycle_events.reborrow(),
                                                 anim_events.reborrow(),
                                             )
@@ -2245,6 +2252,7 @@ impl TweenAnim {
                                     }
                                     AnimTargetKind::Resource => resolver.resolve_resource(
                                         world,
+                                        target_type_id,
                                         *component_id,
                                         *anim_entity,
                                         delta_time,
@@ -2254,6 +2262,7 @@ impl TweenAnim {
                                     AnimTargetKind::Asset { asset_id, .. } => resolver
                                         .resolve_asset(
                                             world,
+                                            target_type_id,
                                             *component_id,
                                             *asset_id,
                                             *anim_entity,
@@ -2263,7 +2272,16 @@ impl TweenAnim {
                                         ),
                                 };
 
-                                let retain = ret.map(|ret| ret.retain).unwrap_or(false);
+                                let retain = match ret {
+                                    Ok(res) => {
+                                        if res.retarget {
+                                            assert!(res.retain);
+                                            to_retarget.push(??????);
+                                        }
+                                        res.retain
+                                    }
+                                    Err(_) => false,
+                                };
                                 if !retain {
                                     to_remove.push(*anim_entity);
                                 }
@@ -2288,11 +2306,11 @@ impl TweenAnim {
         delta_time: Duration,
         target_kind: &AnimTargetKind,
         mut mut_untyped: MutUntyped,
+        target_type_id: &TypeId,
         mut cycle_events: Mut<Events<CycleCompletedEvent>>,
         mut anim_events: Mut<Events<AnimCompletedEvent>>,
     ) -> Result<StepResult, TweeningError> {
         let mut completed_events = Vec::with_capacity(8);
-        let mut sent_commands = false;
 
         // Sanity checks on fields which can be freely modified by the user
         self.speed = self.speed.max(0.);
@@ -2301,7 +2319,7 @@ impl TweenAnim {
         if self.tween_state == TweenState::Completed {
             let ret = StepResult {
                 retain: !self.destroy_on_completion,
-                sent_commands: false,
+                retarget: false,
             };
             return Ok(ret);
         }
@@ -2310,7 +2328,7 @@ impl TweenAnim {
         if self.playback_state == PlaybackState::Paused || self.speed <= 0. {
             let ret = StepResult {
                 retain: true,
-                sent_commands: false,
+                retarget: false,
             };
             return Ok(ret);
         }
@@ -2327,10 +2345,11 @@ impl TweenAnim {
                 target: *target_kind,
             });
         };
-        let state = self.tweenable.step(
+        let (state, retarget) = self.tweenable.step(
             anim_entity,
             delta_time,
             mut_untyped.reborrow(),
+            target_type_id,
             &mut notify_completed,
         );
         self.tween_state = state;
@@ -2338,8 +2357,6 @@ impl TweenAnim {
         // Send tween completed events once we reclaimed mut access to world and can get
         // a Commands.
         if !completed_events.is_empty() {
-            sent_commands = true;
-
             for event in completed_events.drain(..) {
                 // Send buffered event
                 cycle_events.send(event);
@@ -2360,13 +2377,12 @@ impl TweenAnim {
             anim_events.send(event);
 
             // Trigger all entity-scoped observers
-            sent_commands = true;
             commands.trigger_targets(event, anim_entity);
         }
 
         let ret = StepResult {
             retain: state == TweenState::Active || !self.destroy_on_completion,
-            sent_commands,
+            retarget,
         };
         Ok(ret)
     }
@@ -2461,6 +2477,7 @@ type ResourceResolver = Box<
     dyn for<'w> Fn(
             &mut World,
             Entity,
+            &TypeId,
             Duration,
             Mut<Events<CycleCompletedEvent>>,
             Mut<Events<AnimCompletedEvent>>,
@@ -2475,6 +2492,7 @@ type AssetResolver = Box<
             &mut World,
             UntypedAssetId,
             Entity,
+            &TypeId,
             Duration,
             Mut<Events<CycleCompletedEvent>>,
             Mut<Events<AnimCompletedEvent>>,
@@ -2486,6 +2504,9 @@ type AssetResolver = Box<
 
 /// Resolver for resources and assets.
 ///
+/// _This resource is largely an implementation detail. You can safely ignore
+/// it._
+///
 /// Bevy doesn't provide a suitable untyped API to access resources and assets
 /// at runtime without knowing their compile-time type.
 /// - For resources, most of the API is in place, but unfortunately there's no
@@ -2520,6 +2541,7 @@ impl TweenResolver {
         let resource_id = components.resource_id::<R>().unwrap();
         let resolver = |world: &mut World,
                         entity: Entity,
+                        target_type_id: &TypeId,
                         delta_time: Duration,
                         mut cycle_events: Mut<Events<CycleCompletedEvent>>,
                         mut anim_events: Mut<Events<AnimCompletedEvent>>|
@@ -2546,6 +2568,7 @@ impl TweenResolver {
                     delta_time,
                     &target,
                     resource.into(),
+                    target_type_id,
                     cycle_events.reborrow(),
                     anim_events.reborrow(),
                 )
@@ -2562,6 +2585,7 @@ impl TweenResolver {
         let resolver = |world: &mut World,
                         asset_id: UntypedAssetId,
                         entity: Entity,
+                        target_type_id: &TypeId,
                         delta_time: Duration,
                         mut cycle_events: Mut<Events<CycleCompletedEvent>>,
                         mut anim_events: Mut<Events<AnimCompletedEvent>>|
@@ -2598,6 +2622,7 @@ impl TweenResolver {
                     delta_time,
                     &target,
                     asset.into(),
+                    target_type_id,
                     cycle_events.reborrow(),
                     anim_events.reborrow(),
                 )
@@ -2612,6 +2637,7 @@ impl TweenResolver {
     pub(crate) fn resolve_resource(
         &self,
         world: &mut World,
+        target_type_id: &TypeId,
         resource_id: ComponentId,
         entity: Entity,
         delta_time: Duration,
@@ -2622,13 +2648,21 @@ impl TweenResolver {
             println!("ERROR: resource not registered {:?}", resource_id);
             return Err(TweeningError::AssetResolverNotRegistered(resource_id));
         };
-        resolver(world, entity, delta_time, cycle_events, anim_events)
+        resolver(
+            world,
+            entity,
+            target_type_id,
+            delta_time,
+            cycle_events,
+            anim_events,
+        )
     }
 
     #[inline]
     pub(crate) fn resolve_asset(
         &self,
         world: &mut World,
+        target_type_id: &TypeId,
         resource_id: ComponentId,
         untyped_asset_id: UntypedAssetId,
         entity: Entity,
@@ -2644,6 +2678,7 @@ impl TweenResolver {
             world,
             untyped_asset_id,
             entity,
+            target_type_id,
             delta_time,
             cycle_events,
             anim_events,
@@ -2652,64 +2687,14 @@ impl TweenResolver {
 }
 
 pub(crate) struct StepResult {
+    /// Whether to retain the current [`TweenAnim`]? If `false`, the
+    /// [`TweenAnim`] is destroyed unless [`TweenAnim::destroy_on_completion`]
+    /// is `false`.
     pub retain: bool,
-    #[allow(unused)]
-    pub sent_commands: bool,
-}
-
-//     /// Retarget a queued animation.
-//     ///
-//     /// Attempt to change the target of a tweening animation already
-// enqueued,     /// and possibly already playing. This function performs a
-// number of checks     /// on the new target to ensure it's compatible with the
-// previous     /// target. In particular, the new target needs to have:
-//     /// - the same kind (component or asset);
-//     /// - the same type.
-//     ///
-//     /// # Returns
-//     ///
-//     /// On success, returns the previous target which has been replaced.
-//     ///
-//     /// [`add_component()`]: Self::add_component
-//     /// [`add_asset()`]: Self::add_asset
-//     /// [`set_target()`]: Self::set_target
-//     pub fn set_target(
-//         &mut self,
-//         id: Entity,
-//         target: AnimTarget,
-//     ) -> Result<AnimTarget, TweeningError> {
-//         let anim = self
-//             .anims
-//             .get_mut(id)
-//             .ok_or(TweeningError::InvalidTweenId(id))?;
-//         match (anim.target, target) {
-//             (AnimTarget::Component(old_component),
-// AnimTarget::Component(new_component)) => {                 if
-// old_component.component_id != new_component.component_id {
-// return Err(TweeningError::MismatchingComponentId(
-// old_component.component_id,
-// new_component.component_id,                     ));
-//                 }
-//             }
-//             (AnimTarget::Asset(old_asset), AnimTarget::Asset(new_asset)) => {
-//                 if old_asset.resource_id != new_asset.resource_id {
-//                     return Err(TweeningError::MismatchingAssetResourceId(
-//                         old_asset.resource_id,
-//                         new_asset.resource_id,
-//                     ));
-//                 }
-//             }
-//             _ => {
-//                 return Err(TweeningError::MismatchingTargetKind(
-//                     anim.target.is_component(),
-//                     target.is_component(),
-//                 ))
-//             }
-//         }
-//         let old_target = anim.target;
-//         anim.target = target;
-//         Ok(old_target)
-//     }
+    /// Whether to recompute the new animation target and step again. This is
+    /// used by sequences when the animation target changes type in a sequence.
+    pub retarget: bool,
+}
 
 /// Extension trait to interpolate between two colors.
 ///
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 625ccad..dd85304 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -503,8 +503,9 @@ pub trait Tweenable: Send + Sync {
         tween_id: Entity,
         delta: Duration,
         target: MutUntyped,
+        target_type_id: &TypeId,
         notify_cycle_completed: &mut dyn FnMut(),
-    ) -> TweenState;
+    ) -> (TweenState, bool);
 
     /// Rewind the animation to its starting state.
     ///
@@ -1025,10 +1026,13 @@ impl Tweenable for Tween {
         _tween_id: Entity,
         delta: Duration,
         target: MutUntyped,
+        target_type_id: &TypeId,
         notify_cycle_completed: &mut dyn FnMut(),
-    ) -> TweenState {
+    ) -> (TweenState, bool) {
+        debug_assert_eq!(self.type_id, *target_type_id);
+
         if self.clock.state(self.playback_direction) == TweenState::Completed {
-            return TweenState::Completed;
+            return (TweenState::Completed, false);
         }
 
         // Advance the animation clock
@@ -1049,7 +1053,7 @@ impl Tweenable for Tween {
             notify_cycle_completed();
         }
 
-        state
+        (state, false)
     }
 
     fn rewind(&mut self) {
@@ -1206,8 +1210,14 @@ impl Tweenable for Sequence {
         tween_id: Entity,
         mut delta: Duration,
         mut target: MutUntyped,
+        target_type_id: &TypeId,
         notify_completed: &mut dyn FnMut(),
-    ) -> TweenState {
+    ) -> (TweenState, bool) {
+        // Early out
+        if self.index >= self.tweens.len() {
+            return (TweenState::Completed, false);
+        }
+
         // Calculate the new elapsed time at the end of this tick
         self.elapsed = self.elapsed.saturating_add(delta);
         if let TotalDuration::Finite(total_duration) = self.total_duration {
@@ -1221,16 +1231,20 @@ impl Tweenable for Sequence {
 
             let prev_elapsed = tween.elapsed();
 
-            if tween.step(tween_id, delta, target.reborrow(), notify_completed)
-                == TweenState::Active
-            {
-                return TweenState::Active;
+            if let (TweenState::Active, retarget) = tween.step(
+                tween_id,
+                delta,
+                target.reborrow(),
+                target_type_id,
+                notify_completed,
+            ) {
+                return (TweenState::Active, retarget);
             }
 
             let TotalDuration::Finite(total_duration) = tween.total_duration() else {
                 // Note: Rust can't figure it out, but this can never happen, because infinite
                 // children will always return TweenState::Active. Just add this for safety.
-                return TweenState::Active;
+                return (TweenState::Active, false);
             };
 
             // Child tween has completed. So it was finite, and consumed all the time left
@@ -1238,9 +1252,21 @@ impl Tweenable for Sequence {
             let consumed_duration = total_duration.saturating_sub(prev_elapsed);
             delta -= consumed_duration;
             self.index += 1;
+
+            // If the target type changed, we need to ask the caller to retarget and step
+            // again.
+            if self.index < self.tweens.len() {
+                // If the tweenable it untyped, it's guaranteed to not access the target, so we
+                // can pass any target as argument.
+                if let Some(type_id) = self.tweens[self.index].target_type_id() {
+                    if type_id != *target_type_id {
+                        return (TweenState::Active, true);
+                    }
+                }
+            }
         }
 
-        TweenState::Completed
+        (TweenState::Completed, false)
     }
 
     fn rewind(&mut self) {
@@ -1338,8 +1364,9 @@ impl Tweenable for Delay {
         _tween_id: Entity,
         delta: Duration,
         _target: MutUntyped,
+        _target_type_id: &TypeId,
         _notify_completed: &mut dyn FnMut(),
-    ) -> TweenState {
+    ) -> (TweenState, bool) {
         self.timer.tick(delta);
 
         let state = self.state();
@@ -1364,7 +1391,7 @@ impl Tweenable for Delay {
         //     }
         // }
 
-        state
+        (state, false)
     }
 
     fn rewind(&mut self) {
@@ -1531,7 +1558,8 @@ mod tests {
         entity: Entity,
     ) -> TweenState {
         // Tick the given tween and apply its state to the given entity target
-        let state = world.resource_scope(
+        let target_type_id = TypeId::of::<Transform>();
+        let ret = world.resource_scope(
             |world: &mut World, mut events: Mut<Events<CycleCompletedEvent>>| {
                 let component_id = world.component_id::<Transform>().unwrap();
                 let entity_mut = &mut world.get_entity_mut([entity]).unwrap()[0];
@@ -1543,9 +1571,15 @@ mod tests {
                             target: world_target,
                         });
                     };
-                    tween.step(tween_id, duration, target.reborrow(), &mut notify_completed)
+                    tween.step(
+                        tween_id,
+                        duration,
+                        target.reborrow(),
+                        &target_type_id,
+                        &mut notify_completed,
+                    )
                 } else {
-                    TweenState::Completed
+                    (TweenState::Completed, false)
                 }
             },
         );
@@ -1556,7 +1590,7 @@ mod tests {
             events.update();
         }
 
-        state
+        ret.0
     }
 
     #[derive(Debug, Default, Clone, Copy, Component)]

From 17837a47a33f67afd9e4335f8bf71cf8f09ed7d0 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Tue, 26 Aug 2025 17:58:45 +0100
Subject: [PATCH 62/66] Panic on multi-target seq (unsupported)

---
 Cargo.toml       |   2 +-
 src/lib.rs       | 196 +++++++++++++++++++++++++++++++++++------------
 src/tweenable.rs |  14 +++-
 3 files changed, 159 insertions(+), 53 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 2c1b6dd..1d247d4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ bevy_text = ["bevy/bevy_text", "bevy/bevy_render", "bevy/bevy_sprite"]
 
 [dependencies]
 # Note: abuse 'bevy_color' to force 'bevy_math/curve' feature, which defines EaseFunction
-bevy = { version = "0.16", default-features = false, features = [ "bevy_color", "bevy_asset" ]}
+bevy = { version = "0.16", default-features = false, features = [ "bevy_color", "bevy_asset", "bevy_log" ]}
 thiserror = "2"
 
 [dev-dependencies]
diff --git a/src/lib.rs b/src/lib.rs
index 323ca6a..1e156aa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2085,10 +2085,16 @@ impl TweenAnim {
         let mut targets = Vec::with_capacity(anims.len());
         for entity in anims {
             if let Ok((entity, anim, maybe_target)) = q_anims.get(world, *entity) {
-                if let Ok((target_type_id, component_id, target)) =
+                if let Ok((target_type_id, component_id, target, is_retargetable)) =
                     Self::resolve_target(world.components(), maybe_target, entity, anim.tweenable())
                 {
-                    targets.push((entity, target_type_id, component_id, target));
+                    targets.push((
+                        entity,
+                        target_type_id,
+                        component_id,
+                        target,
+                        is_retargetable,
+                    ));
                 }
             }
         }
@@ -2122,9 +2128,13 @@ impl TweenAnim {
                         entity,
                         anim.tweenable(),
                     ) {
-                        Ok((target_type_id, component_id, target)) => {
-                            Some((entity, target_type_id, component_id, target))
-                        }
+                        Ok((target_type_id, component_id, target, is_retargetable)) => Some((
+                            entity,
+                            target_type_id,
+                            component_id,
+                            target,
+                            is_retargetable,
+                        )),
                         Err(err) => {
                             println!("err: {:?}", err);
                             None
@@ -2139,9 +2149,9 @@ impl TweenAnim {
     fn resolve_target(
         components: &Components,
         maybe_target: Option<&AnimTarget>,
-        self_entity: Entity,
+        anim_entity: Entity,
         tweenable: &dyn Tweenable,
-    ) -> Result<(TypeId, ComponentId, AnimTargetKind), TweeningError> {
+    ) -> Result<(TypeId, ComponentId, AnimTargetKind, bool), TweeningError> {
         let type_id = tweenable
             .target_type_id()
             .ok_or(TweeningError::UntypedTweenable)?;
@@ -2158,16 +2168,19 @@ impl TweenAnim {
                     .get_resource_id(*assets_type_id)
                     .ok_or(TweeningError::AssetNotRegistered(type_id))?,
             };
-            Ok((type_id, component_id, target.kind))
+            let is_retargetable = false; // explicit target
+            Ok((type_id, component_id, target.kind, is_retargetable))
         } else {
             // Target implicitly self; this can only be a component target
+            let is_retargetable = true;
             if let Some(component_id) = components.get_id(type_id) {
                 Ok((
                     type_id,
                     component_id,
                     AnimTargetKind::Component {
-                        entity: self_entity,
+                        entity: anim_entity,
                     },
+                    is_retargetable,
                 ))
             } else {
                 // We can't implicitly target an asset without its AssetId
@@ -2179,24 +2192,30 @@ impl TweenAnim {
     fn step_impl(
         world: &mut World,
         delta_time: Duration,
-        anims: &[(Entity, TypeId, ComponentId, AnimTargetKind)],
+        anims: &[(Entity, TypeId, ComponentId, AnimTargetKind, bool)],
     ) {
         let mut to_remove = Vec::with_capacity(anims.len());
-        let mut to_retarget = Vec::with_capacity(8);
         world.resource_scope(|world, resolver: Mut<TweenResolver>| {
             world.resource_scope(
                 |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
                     world.resource_scope(
                         |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
                             let anim_comp_id = world.component_id::<TweenAnim>().unwrap();
-                            for (anim_entity, target_type_id, component_id, anim_target) in anims {
-                                let ret = match anim_target {
+                            for (
+                                anim_entity,
+                                target_type_id,
+                                component_id,
+                                anim_target,
+                                is_retargetable,
+                            ) in anims
+                            {
+                                let retain = match anim_target {
                                     AnimTargetKind::Component {
                                         entity: comp_entity,
                                     } => {
                                         let (mut entities, commands) =
                                             world.entities_and_commands();
-                                        if *anim_entity == *comp_entity {
+                                        let ret = if *anim_entity == *comp_entity {
                                             // The TweenAnim animates another component on the same
                                             // entity
                                             let Ok([mut ent]) = entities.get_mut([*anim_entity])
@@ -2248,17 +2267,44 @@ impl TweenAnim {
                                                 cycle_events.reborrow(),
                                                 anim_events.reborrow(),
                                             )
-                                        }
+                                        };
+                                        let retain = match ret {
+                                            Ok(res) => {
+                                                if res.needs_retarget {
+                                                    assert!(res.retain);
+                                                    if *is_retargetable {
+                                                        //to_retarget.push(anim_entity);
+                                                        //true
+                                                        bevy::log::warn!("TODO: Multi-target tweenable sequence is not yet supported. Ensure the animation of the TweenAnim component on entity {:?} targets a single component type.", *anim_entity);
+                                                        false
+                                                    } else {
+                                                        bevy::log::warn!("Multi-target tweenable sequence cannot be used with an explicit single target. Remove the AnimTarget component from entity {:?}, or ensure all tweenables in the sequence target the same component.", *anim_entity);
+                                                        false
+                                                    }
+                                                } else {
+                                                    res.retain
+                                                }
+                                            }
+                                            Err(_) => false,
+                                        };
+                                        retain
                                     }
-                                    AnimTargetKind::Resource => resolver.resolve_resource(
-                                        world,
-                                        target_type_id,
-                                        *component_id,
-                                        *anim_entity,
-                                        delta_time,
-                                        cycle_events.reborrow(),
-                                        anim_events.reborrow(),
-                                    ),
+                                    AnimTargetKind::Resource => resolver
+                                        .resolve_resource(
+                                            world,
+                                            target_type_id,
+                                            *component_id,
+                                            *anim_entity,
+                                            delta_time,
+                                            cycle_events.reborrow(),
+                                            anim_events.reborrow(),
+                                        )
+                                        .unwrap_or_else(|err| {
+                                            bevy::log::error!(
+                                                "Deleting resource animation due to error: {err:?}"
+                                            );
+                                            false
+                                        }),
                                     AnimTargetKind::Asset { asset_id, .. } => resolver
                                         .resolve_asset(
                                             world,
@@ -2269,19 +2315,15 @@ impl TweenAnim {
                                             delta_time,
                                             cycle_events.reborrow(),
                                             anim_events.reborrow(),
-                                        ),
+                                        )
+                                        .unwrap_or_else(|err| {
+                                            bevy::log::error!(
+                                                "Deleting asset animation due to error: {err:?}"
+                                            );
+                                            false
+                                        }),
                                 };
 
-                                let retain = match ret {
-                                    Ok(res) => {
-                                        if res.retarget {
-                                            assert!(res.retain);
-                                            to_retarget.push(??????);
-                                        }
-                                        res.retain
-                                    }
-                                    Err(_) => false,
-                                };
                                 if !retain {
                                     to_remove.push(*anim_entity);
                                 }
@@ -2319,7 +2361,7 @@ impl TweenAnim {
         if self.tween_state == TweenState::Completed {
             let ret = StepResult {
                 retain: !self.destroy_on_completion,
-                retarget: false,
+                needs_retarget: false,
             };
             return Ok(ret);
         }
@@ -2328,7 +2370,7 @@ impl TweenAnim {
         if self.playback_state == PlaybackState::Paused || self.speed <= 0. {
             let ret = StepResult {
                 retain: true,
-                retarget: false,
+                needs_retarget: false,
             };
             return Ok(ret);
         }
@@ -2345,7 +2387,7 @@ impl TweenAnim {
                 target: *target_kind,
             });
         };
-        let (state, retarget) = self.tweenable.step(
+        let (state, needs_retarget) = self.tweenable.step(
             anim_entity,
             delta_time,
             mut_untyped.reborrow(),
@@ -2382,7 +2424,7 @@ impl TweenAnim {
 
         let ret = StepResult {
             retain: state == TweenState::Active || !self.destroy_on_completion,
-            retarget,
+            needs_retarget,
         };
         Ok(ret)
     }
@@ -2481,7 +2523,7 @@ type ResourceResolver = Box<
             Duration,
             Mut<Events<CycleCompletedEvent>>,
             Mut<Events<AnimCompletedEvent>>,
-        ) -> Result<StepResult, TweeningError>
+        ) -> Result<bool, TweeningError>
         + Send
         + Sync
         + 'static,
@@ -2496,7 +2538,7 @@ type AssetResolver = Box<
             Duration,
             Mut<Events<CycleCompletedEvent>>,
             Mut<Events<AnimCompletedEvent>>,
-        ) -> Result<StepResult, TweeningError>
+        ) -> Result<bool, TweeningError>
         + Send
         + Sync
         + 'static,
@@ -2545,7 +2587,7 @@ impl TweenResolver {
                         delta_time: Duration,
                         mut cycle_events: Mut<Events<CycleCompletedEvent>>,
                         mut anim_events: Mut<Events<AnimCompletedEvent>>|
-         -> Result<StepResult, TweeningError> {
+         -> Result<bool, TweeningError> {
             // First, remove the resource R from the world so we can access it mutably in
             // parallel of the TweenAnim
             world.resource_scope(|world, resource: Mut<R>| {
@@ -2562,7 +2604,7 @@ impl TweenResolver {
                 };
 
                 // Finally, step the TweenAnim and mutate the target
-                anim.step_self(
+                let ret = anim.step_self(
                     commands,
                     entity,
                     delta_time,
@@ -2571,7 +2613,11 @@ impl TweenResolver {
                     target_type_id,
                     cycle_events.reborrow(),
                     anim_events.reborrow(),
-                )
+                );
+                ret.map(|result| {
+                    assert!(!result.needs_retarget, "Cannot use a multi-target sequence of tweenable animations with a resource target.");
+                    result.retain
+                })
             })
         };
         self.resource_resolver
@@ -2589,7 +2635,7 @@ impl TweenResolver {
                         delta_time: Duration,
                         mut cycle_events: Mut<Events<CycleCompletedEvent>>,
                         mut anim_events: Mut<Events<AnimCompletedEvent>>|
-         -> Result<StepResult, TweeningError> {
+         -> Result<bool, TweeningError> {
             let asset_id = asset_id.typed::<A>();
             // First, remove the Assets<A> from the world so we can access it mutably in
             // parallel of the TweenAnim
@@ -2616,7 +2662,7 @@ impl TweenResolver {
                 };
 
                 // Finally, step the TweenAnim and mutate the target
-                anim.step_self(
+                let ret = anim.step_self(
                     commands,
                     entity,
                     delta_time,
@@ -2625,7 +2671,11 @@ impl TweenResolver {
                     target_type_id,
                     cycle_events.reborrow(),
                     anim_events.reborrow(),
-                )
+                );
+                ret.map(|result| {
+                    assert!(!result.needs_retarget, "Cannot use a multi-target sequence of tweenable animations with an asset target.");
+                    result.retain
+                })
             })
         };
         self.asset_resolver
@@ -2643,7 +2693,7 @@ impl TweenResolver {
         delta_time: Duration,
         cycle_events: Mut<Events<CycleCompletedEvent>>,
         anim_events: Mut<Events<AnimCompletedEvent>>,
-    ) -> Result<StepResult, TweeningError> {
+    ) -> Result<bool, TweeningError> {
         let Some(resolver) = self.resource_resolver.get(&resource_id) else {
             println!("ERROR: resource not registered {:?}", resource_id);
             return Err(TweeningError::AssetResolverNotRegistered(resource_id));
@@ -2669,7 +2719,7 @@ impl TweenResolver {
         delta_time: Duration,
         cycle_events: Mut<Events<CycleCompletedEvent>>,
         anim_events: Mut<Events<AnimCompletedEvent>>,
-    ) -> Result<StepResult, TweeningError> {
+    ) -> Result<bool, TweeningError> {
         let Some(resolver) = self.asset_resolver.get(&resource_id) else {
             println!("ERROR: asset not registered {:?}", resource_id);
             return Err(TweeningError::AssetResolverNotRegistered(resource_id));
@@ -2693,7 +2743,7 @@ pub(crate) struct StepResult {
     pub retain: bool,
     /// Whether to recompute the new animation target and step again. This is
     /// used by sequences when the animation target changes type in a sequence.
-    pub retarget: bool,
+    pub needs_retarget: bool,
 }
 
 /// Extension trait to interpolate between two colors.
@@ -2771,11 +2821,21 @@ mod tests {
         end: f32,
     }
 
+    struct DummyLens2 {
+        start: i32,
+        end: i32,
+    }
+
     #[derive(Debug, Default, Clone, Copy, Component)]
     struct DummyComponent {
         value: f32,
     }
 
+    #[derive(Debug, Default, Clone, Copy, Component)]
+    struct DummyComponent2 {
+        value: i32,
+    }
+
     #[derive(Debug, Default, Clone, Copy, Resource)]
     struct DummyResource {
         value: f32,
@@ -2792,6 +2852,12 @@ mod tests {
         }
     }
 
+    impl Lens<DummyComponent2> for DummyLens2 {
+        fn lerp(&mut self, mut target: Mut<DummyComponent2>, ratio: f32) {
+            target.value = ((self.start as f32) * (1. - ratio) + (self.end as f32) * ratio) as i32;
+        }
+    }
+
     #[test]
     fn dummy_lens_component() {
         let mut c = DummyComponent::default();
@@ -3218,6 +3284,36 @@ mod tests {
         assert!(env.component().value >= 2. && env.component().value <= 3.);
     }
 
+    // Currently multi-target sequences are not implemented. This _could_ work with
+    // implicit targets (so, multiple components on the same entity), but is a bit
+    // complex to implement with the current code. So leave that out for now, and
+    // test we assert if the user attempts it. The workaround is to create separate
+    // animations for each comopnent/target. Anyway multi-target sequence can't work
+    // with other target types, since they need an explicit TweenAnim, and we
+    // can't have more than one per entity.
+    #[test]
+    #[should_panic(
+        expected = "TODO: Cannot use tweenable animations with different targets inside the same Sequence. Create separate animations for each target."
+    )]
+    fn seq_multi_target() {
+        let tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        )
+        .then(Tween::new::<DummyComponent2, DummyLens2>(
+            EaseFunction::SmoothStep,
+            Duration::from_secs(1),
+            DummyLens2 { start: -5, end: 5 },
+        ));
+        let mut env = TestEnv::<DummyComponent>::new(tween);
+        let entity = env.entity;
+        env.world_mut()
+            .entity_mut(entity)
+            .insert(DummyComponent2 { value: -42 });
+        TweenAnim::step_one(&mut env.world, Duration::from_millis(1100), entity).unwrap();
+    }
+
     // #[test]
     // fn animator_set_target() {
     //     let tween = Tween::new::<DummyComponent, DummyLens>(
diff --git a/src/tweenable.rs b/src/tweenable.rs
index dd85304..703fcd0 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1282,12 +1282,22 @@ impl Tweenable for Sequence {
         // Loop over all children, because we want to skip all untyped ones (Delay).
         // Otherwise the animator will panic, because we can't create an untyped
         // animation.
+        // for tween in &self.tweens {
+        //     if let Some(type_id) = tween.target_type_id() {
+        //         return Some(type_id);
+        //     }
+        // }
+        //None
+
+        // TEMP - not supporting multi-target yet, so assert here so users know
+        let mut target_type_id = None;
         for tween in &self.tweens {
             if let Some(type_id) = tween.target_type_id() {
-                return Some(type_id);
+                assert!(target_type_id.is_none(), "TODO: Cannot use tweenable animations with different targets inside the same Sequence. Create separate animations for each target.");
+                target_type_id = Some(type_id);
             }
         }
-        None
+        target_type_id
     }
 }
 

From d789641dcf2d94f4a78ff2d83cca1c8c2e5a1914 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 30 Aug 2025 10:20:21 +0100
Subject: [PATCH 63/66] Fix uniform multi-target sequence

---
 examples/sequence.rs | 2 +-
 src/tweenable.rs     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/sequence.rs b/examples/sequence.rs
index 3129aef..1472567 100644
--- a/examples/sequence.rs
+++ b/examples/sequence.rs
@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use bevy::{color::palettes::css::*, ecs::component::Components, prelude::*};
+use bevy::{color::palettes::css::*, prelude::*};
 use bevy_tweening::{lens::*, *};
 
 mod utils;
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 703fcd0..1a7df59 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1293,7 +1293,7 @@ impl Tweenable for Sequence {
         let mut target_type_id = None;
         for tween in &self.tweens {
             if let Some(type_id) = tween.target_type_id() {
-                assert!(target_type_id.is_none(), "TODO: Cannot use tweenable animations with different targets inside the same Sequence. Create separate animations for each target.");
+                assert!(target_type_id.is_none() || target_type_id == Some(type_id), "TODO: Cannot use tweenable animations with different targets inside the same Sequence. Create separate animations for each target.");
                 target_type_id = Some(type_id);
             }
         }

From b0a196b2dde151768fe40d0b86a10b5b9a6f878a Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 30 Aug 2025 10:52:07 +0100
Subject: [PATCH 64/66] Minor clean-ups

---
 CHANGELOG.md     |  55 +++++++++++++++++++----
 run_examples.bat |   1 +
 run_examples.sh  |   1 +
 src/lib.rs       |   2 +-
 src/plugin.rs    |   2 +-
 src/tweenable.rs | 115 +++--------------------------------------------
 6 files changed, 57 insertions(+), 119 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2c08328..dfcc8f2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,14 +8,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 _This change introduces a major API redesign compared to v0.13.
 It removes the need for generics,
 and unifies all animations of all components and assets,
-executing them from a single exclusive system._
+executing them from a single exclusive system.
+See the [Migration Guide for v0.14](./docs/migration-guide-0.14.md) for details._
 
 ### Added
 
-- Added `TweenAnimator`, a resource acting as a container for all active animations.
 - Added `TweenAnim`, a representation of the runtime parameters of an active animation.
-- Added `AnimTarget`, an enum describing the target mutated by an animation.
-  Also added two structs `ComponentAnimTarget` and `AssetAnimTarget` as its enum variants.
+- Added `AnimTarget`, a component describing (via its `AnimTargetKind`) the target mutated by an animation.
+- Added some extension functions on `EntityCommands` to enable simplified create-and-spawn patterns:
+
+  ```rust
+  commands
+    // Spawn an entity to animate the position of
+    .spawn(Transform::default())
+    // Create-and-spawn a new Transform::translation animation
+    .move_to(
+        Vec3::new(1., 2., -4.),
+        Duration::from_secs(1),
+        EaseFunction::QuadraticInOut,
+    );
+  ```
+
+  See `EntityCommandsTweeningExtensions` for all the possible animations.
+
+- Added `AnimCompletedEvent`, raised when the entire tweenable animation completed.
+- Added `CycleCompletedEvent`, optionally raised when a single tweenable animation
+  cycle completed. Enable it with `Tween::with_cycle_completed_event()`.
 - Added `TotalDuration::from_cycles()` to simply creating an animation duration
   from a number of individual cycles and their duration.
 - Added `TotalDuration::is_finite()` helper to check an animation duration is finite.
@@ -31,10 +49,30 @@ executing them from a single exclusive system._
   of the current cycle the animation is at is mirrored.
   This always returns `false` unless `RepeatStrategy::MirroredRepeat` is used,
   and the animation contains more than 1 cycle.
+- Added a new example `follow` demonstrating how to achieve following-with-smoothing.
+  The example moves an entity to follow the mouse cursor on screen.
+- Added a new example `ambient_light` showing how to animate resources (here, `AmbientLight`).
+- Added new built-in lenses applying a rotation on top of the existing `Transform::rotation`:
+
+  - `TransformRotateAdditiveXLens`
+  - `TransformRotateAdditiveYLens`
+  - `TransformRotateAdditiveZLens`
+
+  Those are useful to create animations with infinitely-rotating objects.
 
 ### Changed
 
 - The `bevy_asset` feature was removed; `bevy_tweening` now depends on `bevy/bevy_asset` always.
+  You can just delete that feature from your `Cargo.toml` if you were adding it explicitly.
+- `Sequence` now accepts infinite duration child animations.
+  It's your responsibility to ensure the resulting sequence makes sense,
+  which generally means only using an infinite animation as the last item.
+- The following types lost their generic parameter `<T>`:
+  - `Tweenable`
+  - `Tween`
+  - `Sequence`
+  - `Delay`
+  They still implicitly depend on a target type, but this is not encoded in the Rust type anymore.
 - The `Lens<T>` trait now takes its target as `Mut<T>` instead of `&mut dyn Targetable<T>`.
 
   ```rust
@@ -44,11 +82,6 @@ executing them from a single exclusive system._
   The functioning is the same, but this removes one level of indirection.
   The use of `Mut<T>` should be familiar to most Bevy users.
 
-- The following types lost their generic parameter `<T>`:
-  - `Tweenable`
-  - `Tween`
-  - `Sequence`
-  - `Delay`
 - `Tweenable::duration()` was renamed to `Tweenable::cycle_duration()` for clarity.
 - `Tweenable::times_completed()` was renamed to `Tweenable::cycles_completed()` for clarity.
 - `Tweenable::tick()` was renamed to `Tweenable::step()`, to insist on the fact
@@ -65,12 +98,16 @@ executing them from a single exclusive system._
 
 ### Removed
 
+- Removed the `component_animator_system` and `asset_animator_system`.
+  Animations are now auto-played based on the presence of a `TweenAnim` component.
+  There's no need for you to manually register anything.
 - Removed `Tracks<T>`. Use multiple animations instead.
 - Removed `Targetable`, `ComponentTarget`, `AssetTarget`. Those were workarounds
   for the inability to use `Mut<T>` directly. In Bevy 0.16 they're not necessary.
 - Removed all references to "progress" in all APIs, in favor of `Duration`s.
 - Removed the `user_data` value from completed events.
 - Removed callback-based completion events. Use Bevy-style events or one-shot systems instead.
+  Observers are also supported.
 
 ## [0.13.0] - 2025-04-28
 
diff --git a/run_examples.bat b/run_examples.bat
index a264d2c..cefc6fa 100644
--- a/run_examples.bat
+++ b/run_examples.bat
@@ -6,6 +6,7 @@ cargo r --example transform_translation --no-default-features --features="bevy_s
 cargo r --example transform_rotation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
 cargo r --example ambient_light --no-default-features --features="bevy_ui bevy_text bevy/bevy_winit bevy/bevy_picking bevy/bevy_pbr bevy/hdr bevy/tonemapping_luts"
+cargo r --example follow --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
 REM bevy_sprite
 cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example colormaterial_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
diff --git a/run_examples.sh b/run_examples.sh
index e6df2e9..86d7dc4 100755
--- a/run_examples.sh
+++ b/run_examples.sh
@@ -5,6 +5,7 @@ cargo r --example transform_translation --no-default-features --features="bevy_s
 cargo r --example transform_rotation --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example sequence --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
 cargo r --example ambient_light --no-default-features --features="bevy_ui bevy_text bevy/bevy_winit bevy/bevy_picking bevy/bevy_pbr bevy/hdr bevy/tonemapping_luts"
+cargo r --example follow --no-default-features --features="bevy_sprite bevy_text bevy/bevy_winit bevy/bevy_picking"
 # bevy_sprite
 cargo r --example sprite_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
 cargo r --example colormaterial_color --no-default-features --features="bevy_sprite bevy/bevy_winit bevy/bevy_picking"
diff --git a/src/lib.rs b/src/lib.rs
index 1e156aa..9996186 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2383,7 +2383,7 @@ impl TweenAnim {
         // Step the tweenable animation
         let mut notify_completed = || {
             completed_events.push(CycleCompletedEvent {
-                id: anim_entity,
+                anim_entity,
                 target: *target_kind,
             });
         };
diff --git a/src/plugin.rs b/src/plugin.rs
index 8811ca5..d7b09b3 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 use crate::{AnimCompletedEvent, CycleCompletedEvent, TweenAnim, TweenResolver};
 
-/// Plugin to register tweening animation framework.
+/// Plugin to register the 🍃 Bevy Tweening animation framework.
 ///
 /// This plugin registers the common resources and events used by 🍃 Bevy
 /// Tweening as well as the core animation system which steps all pending
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 1a7df59..01c6443 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -108,13 +108,13 @@ pub enum TweenState {
 /// [`CycleCompletedEvent`] instead marks the end of a single cycle.
 #[derive(Copy, Clone, Event)]
 pub struct CycleCompletedEvent {
-    /// The ID of the tweenable animation which completed.
+    /// The entity owning the tweenable animation which completed.
     ///
-    /// This is the entity owning the top-level [`TweenAnim`] this tweenable is
-    /// part of.
+    /// This is the entity owning the [`TweenAnim`] component that the tweenable
+    /// which completed is part of.
     ///
     /// [`TweenAnim`]: crate::TweenAnim
-    pub id: Entity,
+    pub anim_entity: Entity,
     /// The target the tweenable which completed and the [`TweenAnim`] it's
     /// part of are mutating. Note that an actual [`AnimTarget`] component might
     /// not be spawned in the ECS world, if the target is a component on the
@@ -570,7 +570,6 @@ macro_rules! impl_boxed {
 
 impl_boxed!(Tween);
 impl_boxed!(Sequence);
-//impl_boxed!(Tracks);
 impl_boxed!(Delay);
 
 type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
@@ -1561,7 +1560,7 @@ mod tests {
 
     /// Manually tick a test tweenable targeting a component.
     fn manual_tick_component(
-        tween_id: Entity,
+        anim_entity: Entity,
         duration: Duration,
         tween: &mut dyn Tweenable,
         world: &mut World,
@@ -1577,12 +1576,12 @@ mod tests {
                     let world_target = AnimTargetKind::Component { entity };
                     let mut notify_completed = || {
                         events.send(CycleCompletedEvent {
-                            id: tween_id,
+                            anim_entity,
                             target: world_target,
                         });
                     };
                     tween.step(
-                        tween_id,
+                        anim_entity,
                         duration,
                         target.reborrow(),
                         &target_type_id,
@@ -2238,106 +2237,6 @@ mod tests {
         }
     }
 
-    // /// Test ticking parallel tracks of tweens.
-    // #[test]
-    // fn tracks_tick() {
-    //     let tween1 = Tween::new(
-    //         EaseMethod::default(),
-    //         Duration::from_millis(1000),
-    //         TransformPositionLens {
-    //             start: Vec3::ZERO,
-    //             end: Vec3::ONE,
-    //         },
-    //     );
-    //     let tween2 = Tween::new(
-    //         EaseMethod::default(),
-    //         Duration::from_millis(800), // shorter
-    //         TransformRotationLens {
-    //             start: Quat::IDENTITY,
-    //             end: Quat::from_rotation_x(90_f32.to_radians()),
-    //         },
-    //     );
-    //     let mut tracks = Tracks::new([tween1, tween2]);
-    //     assert_eq!(tracks.duration(), Duration::from_secs(1)); // max(1.,
-    // 0.8)
-
-    //     let (mut world, entity, _system_id) = make_test_env();
-
-    //     for i in 1..=6 {
-    //         let state = manual_tick_component(
-    //             Entity::PLACEHOLDER, // unused in this test
-    //             Duration::from_millis(200),
-    //             &mut tracks,
-    //             &mut world,
-    //             entity,
-    //         );
-    //         let transform = world.entity(entity).get::<Transform>().unwrap();
-    //         if i < 5 {
-    //             assert_eq!(state, TweenState::Active);
-    //             assert_eq!(tracks.cycles_completed(), 0);
-    //             let r = i as f32 * 0.2;
-    //             assert_approx_eq!(tracks.progress(), r);
-    //             let alpha_deg = 22.5 * i as f32;
-    //             assert!(transform.translation.abs_diff_eq(Vec3::splat(r),
-    // 1e-5));             assert!(transform
-    //                 .rotation
-    //
-    // .abs_diff_eq(Quat::from_rotation_x(alpha_deg.to_radians()), 1e-5));
-    //         } else {
-    //             assert_eq!(state, TweenState::Completed);
-    //             assert_eq!(tracks.cycles_completed(), 1);
-    //             assert_approx_eq!(tracks.progress(), 1.);
-    //             assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
-    //             assert!(transform
-    //                 .rotation
-    //                 .abs_diff_eq(Quat::from_rotation_x(90_f32.to_radians()),
-    // 1e-5));         }
-    //     }
-
-    //     tracks.rewind();
-    //     assert_eq!(tracks.cycles_completed(), 0);
-    //     assert_approx_eq!(tracks.progress(), 0.);
-
-    //     tracks.set_progress(0.9);
-    //     assert_approx_eq!(tracks.progress(), 0.9);
-    //     // tick to udpate state (set_progress() does not update state)
-    //     let state = manual_tick_component(
-    //         Entity::PLACEHOLDER, // unused in this test
-    //         Duration::ZERO,
-    //         &mut tracks,
-    //         &mut world,
-    //         entity,
-    //     );
-    //     assert_eq!(state, TweenState::Active);
-    //     assert_eq!(tracks.cycles_completed(), 0);
-
-    //     tracks.set_progress(3.2);
-    //     assert_approx_eq!(tracks.progress(), 1.);
-    //     // tick to udpate state (set_progress() does not update state)
-    //     let state = manual_tick_component(
-    //         Entity::PLACEHOLDER, // unused in this test
-    //         Duration::ZERO,
-    //         &mut tracks,
-    //         &mut world,
-    //         entity,
-    //     );
-    //     assert_eq!(state, TweenState::Completed);
-    //     assert_eq!(tracks.cycles_completed(), 1); // no looping
-
-    //     tracks.set_progress(-0.5);
-    //     assert_approx_eq!(tracks.progress(), 0.);
-    //     // tick to udpate state (set_progress() does not update state)
-    //     let state = manual_tick_component(
-    //         Entity::PLACEHOLDER, // unused in this test
-    //         Duration::ZERO,
-    //         &mut tracks,
-    //         &mut world,
-    //         entity,
-    //     );
-    //     assert_eq!(state, TweenState::Active);
-    //     assert_eq!(tracks.cycles_completed(), 0); // no looping
-    // }
-
     /// Delay::then()
     #[test]
     fn delay_then() {

From c5ccb8f026110976df3149e07932e7b6b68144a8 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Sat, 30 Aug 2025 16:56:03 +0100
Subject: [PATCH 65/66] Linter and doc fixes

---
 examples/follow.rs |  2 +-
 src/lib.rs         | 72 +++++++++++++++++++---------------------------
 src/test_utils.rs  |  4 +--
 src/tweenable.rs   | 43 +++++++++++++--------------
 4 files changed, 53 insertions(+), 68 deletions(-)

diff --git a/examples/follow.rs b/examples/follow.rs
index 3c7e277..fbcc2d6 100644
--- a/examples/follow.rs
+++ b/examples/follow.rs
@@ -80,7 +80,7 @@ fn setup(
         .spawn((
             Mesh2d(meshes.add(Rectangle::new(10., 10.))),
             MeshMaterial2d(materials.add(ColorMaterial {
-                color: PURPLE.into(),
+                color: WHITE.into(),
                 ..default()
             })),
             Follower,
diff --git a/src/lib.rs b/src/lib.rs
index 9996186..41664f5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1270,19 +1270,21 @@ impl TweenCommand for RotateZByCommand {
 /// entity commands queue. This deferred queuing allows fluent patterns like:
 ///
 /// ```
+/// # use std::time::Duration;
 /// # use bevy::prelude::*;
 /// # use bevy_tweening::*;
 /// # fn my_system(mut commands: Commands) {
-/// commands.spawn(Transform::default())
+/// commands
+///     .spawn(Transform::default())
 ///     // Consume the EntityCommands, and wrap it into an AnimatedEntityCommands,
 ///     // which stores an animation command to move an entity.
 ///     .move_to(
 ///         Vec3::ONE,
-///         Duration::from_millis(400)
+///         Duration::from_millis(400),
 ///         EaseFunction::QuadraticIn,
 ///     )
 ///     // Tweak the stored animation to set the repeat count of the Tween.
-///     .repeat_count(2);
+///     .with_repeat_count(2);
 /// # }
 /// ```
 ///
@@ -1299,13 +1301,15 @@ impl TweenCommand for RotateZByCommand {
 /// [`EntityCommands`] by value. In that case, you need to call [`reborrow()`]:
 ///
 /// ```
+/// # use std::time::Duration;
 /// # use bevy::prelude::*;
 /// # use bevy_tweening::*;
 /// # fn my_system(mut commands: Commands) {
-/// commands.spawn(Transform::default())
+/// commands
+///     .spawn(Transform::default())
 ///     .move_to(
 ///         Vec3::ONE,
-///         Duration::from_millis(400)
+///         Duration::from_millis(400),
 ///         EaseFunction::QuadraticIn,
 ///     )
 ///     // This call invokes std::ops::DerefMut, and returns a mutable ref
@@ -1317,7 +1321,7 @@ impl TweenCommand for RotateZByCommand {
 ///     // This call requires an `EntityCommands` (by value)
 ///     .scale_to(
 ///         Vec3::splat(1.1),
-///         Duration::from_millis(400)
+///         Duration::from_millis(400),
 ///         EaseFunction::Linear,
 ///     );
 /// # }
@@ -1351,7 +1355,7 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
     #[inline]
     pub fn with_repeat_strategy(mut self, repeat_strategy: RepeatStrategy) -> Self {
         if let Some(cmd) = self.cmd.as_mut() {
-            cmd.config_mut().repeat_strategy = repeat_strategy.into();
+            cmd.config_mut().repeat_strategy = repeat_strategy;
         }
         self
     }
@@ -1361,8 +1365,14 @@ impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
     /// This is a shortcut for:
     ///
     /// ```no_run
-    /// # impl<'a, C: TweenCommand> AnimatedEntityCommands<'a, C> {
-    /// # fn xxx(&self) -> Self {
+    /// # use bevy_tweening::*;
+    /// # struct AnimatedEntityCommands {}
+    /// # impl AnimatedEntityCommands {
+    /// # fn with_repeat_count(self, r: RepeatCount) -> Self { unimplemented!() }
+    /// # fn with_repeat_strategy(self, r: RepeatStrategy) -> Self { unimplemented!() }
+    /// # fn xxx(self) -> Self {
+    /// # let repeat_count = RepeatCount::Infinite;
+    /// # let repeat_strategy = RepeatStrategy::Repeat;
     /// self.with_repeat_count(repeat_count)
     ///     .with_repeat_strategy(repeat_strategy)
     /// # }}
@@ -1504,14 +1514,14 @@ impl<'a, C: TweenCommand> Deref for AnimatedEntityCommands<'a, C> {
     }
 }
 
-impl<'a, C: TweenCommand> DerefMut for AnimatedEntityCommands<'a, C> {
+impl<C: TweenCommand> DerefMut for AnimatedEntityCommands<'_, C> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.flush();
         &mut self.commands
     }
 }
 
-impl<'a, C: TweenCommand> Drop for AnimatedEntityCommands<'a, C> {
+impl<C: TweenCommand> Drop for AnimatedEntityCommands<'_, C> {
     fn drop(&mut self) {
         self.flush();
     }
@@ -1973,13 +1983,16 @@ impl TweenAnim {
         }
     }
 
-    ///
+    /// Configure the playback speed.
     pub fn with_speed(mut self, speed: f64) -> Self {
         self.speed = speed;
         self
     }
 
+    /// Enable or disable destroying this component on animation completion.
     ///
+    /// If enabled, the component is automatically removed from its `Entity`
+    /// when the animation completed.
     pub fn with_destroy_on_completed(mut self, destroy_on_completed: bool) -> Self {
         self.destroy_on_completion = destroy_on_completed;
         self
@@ -2268,7 +2281,7 @@ impl TweenAnim {
                                                 anim_events.reborrow(),
                                             )
                                         };
-                                        let retain = match ret {
+                                        match ret {
                                             Ok(res) => {
                                                 if res.needs_retarget {
                                                     assert!(res.retain);
@@ -2286,8 +2299,7 @@ impl TweenAnim {
                                                 }
                                             }
                                             Err(_) => false,
-                                        };
-                                        retain
+                                        }
                                     }
                                     AnimTargetKind::Resource => resolver
                                         .resolve_resource(
@@ -2341,6 +2353,7 @@ impl TweenAnim {
         world.flush();
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn step_self(
         &mut self,
         mut commands: Commands,
@@ -2683,6 +2696,7 @@ impl TweenResolver {
             .or_insert(Box::new(resolver));
     }
 
+    #[allow(clippy::too_many_arguments)]
     #[inline]
     pub(crate) fn resolve_resource(
         &self,
@@ -2708,6 +2722,7 @@ impl TweenResolver {
         )
     }
 
+    #[allow(clippy::too_many_arguments)]
     #[inline]
     pub(crate) fn resolve_asset(
         &self,
@@ -2780,33 +2795,6 @@ impl ColorLerper for Color {
     }
 }
 
-///
-pub trait TweeningTransform {
-    ///
-    fn move_to(
-        self,
-        end: Vec3,
-        duration: Duration,
-        ease_method: impl Into<EaseMethod>,
-    ) -> TweenAnim;
-}
-
-impl TweeningTransform for Transform {
-    fn move_to(
-        self,
-        end: Vec3,
-        duration: Duration,
-        ease_method: impl Into<EaseMethod>,
-    ) -> TweenAnim {
-        let lens = TransformPositionLens {
-            start: self.translation,
-            end,
-        };
-        let tween = Tween::new(ease_method.into(), duration, lens);
-        TweenAnim::new(tween)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::marker::PhantomData;
diff --git a/src/test_utils.rs b/src/test_utils.rs
index cec36e2..c1febd4 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -188,7 +188,7 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
     }
 
     /// Get the animation.
-    pub fn anim_mut(&mut self) -> Option<Mut<TweenAnim>> {
+    pub fn anim_mut(&mut self) -> Option<Mut<'_, TweenAnim>> {
         self.world.get_mut::<TweenAnim>(self.entity)
     }
 
@@ -198,7 +198,7 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
     }
 
     /// Get the component.
-    pub fn component_mut(&mut self) -> Mut<T> {
+    pub fn component_mut(&mut self) -> Mut<'_, T> {
         self.world.get_mut::<T>(self.entity).unwrap()
     }
 
diff --git a/src/tweenable.rs b/src/tweenable.rs
index 01c6443..75bc029 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -35,11 +35,11 @@ use crate::{AnimTargetKind, EaseMethod, Lens, PlaybackDirection, RepeatCount, Re
 /// #     fn total_duration(&self) -> TotalDuration  { unimplemented!() }
 /// #     fn set_elapsed(&mut self, elapsed: Duration)  { unimplemented!() }
 /// #     fn elapsed(&self) -> Duration  { unimplemented!() }
-/// #     fn step(&mut self, _tween_id: Entity, delta: Duration, target: MutUntyped, notify_completed: &mut dyn FnMut()) -> TweenState  { unimplemented!() }
+/// #     fn step(&mut self, tween_id: Entity, delta: Duration, target: MutUntyped, target_type_id: &TypeId, notify_cycle_completed: &mut dyn FnMut(),) -> (TweenState, bool)  { unimplemented!() }
 /// #     fn rewind(&mut self) { unimplemented!() }
 /// #     fn cycles_completed(&self) -> u32 { unimplemented!() }
 /// #     fn cycle_fraction(&self) -> f32 { unimplemented!() }
-/// #     fn type_id(&self) -> Option<TypeId> { unimplemented!() }
+/// #     fn target_type_id(&self) -> Option<TypeId> { unimplemented!() }
 /// # }
 ///
 /// Sequence::new([Box::new(MyTweenable) as BoxedTweenable]);
@@ -294,9 +294,9 @@ impl AnimClock {
                 // Always clamp
                 self.elapsed = self.elapsed.min(total_duration);
 
-                if direction.is_forward() && self.elapsed >= total_duration {
-                    TweenState::Completed
-                } else if direction.is_backward() && self.elapsed == Duration::ZERO {
+                if (direction.is_forward() && self.elapsed >= total_duration)
+                    || (direction.is_backward() && self.elapsed == Duration::ZERO)
+                {
                     TweenState::Completed
                 } else {
                     TweenState::Active
@@ -318,9 +318,9 @@ impl AnimClock {
     fn state(&self, playback_direction: PlaybackDirection) -> TweenState {
         match self.total_duration {
             TotalDuration::Finite(total_duration) => {
-                if playback_direction.is_forward() && self.elapsed >= total_duration {
-                    TweenState::Completed
-                } else if playback_direction.is_backward() && self.elapsed == Duration::ZERO {
+                if (playback_direction.is_forward() && self.elapsed >= total_duration)
+                    || (playback_direction.is_backward() && self.elapsed == Duration::ZERO)
+                {
                     TweenState::Completed
                 } else {
                     TweenState::Active
@@ -400,7 +400,7 @@ impl std::iter::Sum for TotalDuration {
         let Some(mut acc) = iter.next() else {
             return TotalDuration::Finite(Duration::ZERO);
         };
-        while let Some(td) = iter.next() {
+        for td in iter {
             acc = acc + td;
         }
         acc
@@ -580,17 +580,17 @@ type TargetAction = dyn FnMut(MutUntyped, f32) + Send + Sync + 'static;
 #[doc(hidden)]
 #[derive(Default, Clone, Copy)]
 pub struct TweenConfig {
-    ///
+    /// Ease method.
     pub ease_method: EaseMethod,
-    ///
+    /// Playback direction.
     pub playback_direction: PlaybackDirection,
-    ///
+    /// Send [`CycleCompletedEvent`]?
     pub send_cycle_completed_event: bool,
-    ///
+    /// Cycle duration.
     pub cycle_duration: Duration,
-    ///
+    /// Repeat count.
     pub repeat_count: RepeatCount,
-    ///
+    /// Repeat strategy.
     pub repeat_strategy: RepeatStrategy,
 }
 
@@ -868,9 +868,8 @@ impl Tween {
     /// fn my_system(mut reader: EventReader<CycleCompletedEvent>) {
     ///     for ev in reader.read() {
     ///         println!(
-    ///             "Tween animation {:?} raised CycleCompletedEvent for target entity {:?}!",
-    ///             ev.id,
-    ///             ev.target.as_component().unwrap().entity
+    ///             "Tween animation {:?} raised CycleCompletedEvent for target {:?}!",
+    ///             ev.anim_entity, ev.target
     ///         );
     ///     }
     /// }
@@ -1724,12 +1723,10 @@ mod tests {
                                     } else {
                                         (1000i32, TweenState::Completed)
                                     }
+                                } else if i < 5 {
+                                    (1000i32 - i * 200i32, TweenState::Active)
                                 } else {
-                                    if i < 5 {
-                                        (1000i32 - i * 200i32, TweenState::Active)
-                                    } else {
-                                        (0i32, TweenState::Completed)
-                                    }
+                                    (0i32, TweenState::Completed)
                                 };
                                 let just_completed = i == 5;
                                 (

From 070741d6007b00a08f3745ce7b3696cb1eed8297 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Wed, 3 Sep 2025 18:20:29 +0100
Subject: [PATCH 66/66] Fix auto-registration in `step_many()`

---
 src/lib.rs        | 645 ++++++++++++++++++++++++++++++++++++++++++----
 src/plugin.rs     |  10 +
 src/test_utils.rs |  28 +-
 3 files changed, 624 insertions(+), 59 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 41664f5..4683e12 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2094,23 +2094,37 @@ impl TweenAnim {
     ///
     /// [`step_all()`]: Self::step_all
     pub fn step_many(world: &mut World, delta_time: Duration, anims: &[Entity]) -> usize {
-        let mut q_anims = world.query::<(Entity, &TweenAnim, Option<&AnimTarget>)>();
-        let mut targets = Vec::with_capacity(anims.len());
-        for entity in anims {
-            if let Ok((entity, anim, maybe_target)) = q_anims.get(world, *entity) {
-                if let Ok((target_type_id, component_id, target, is_retargetable)) =
-                    Self::resolve_target(world.components(), maybe_target, entity, anim.tweenable())
-                {
-                    targets.push((
-                        entity,
-                        target_type_id,
-                        component_id,
-                        target,
-                        is_retargetable,
-                    ));
+        let mut targets = vec![];
+        world.resource_scope(|world, mut resolver: Mut<TweenResolver>| {
+            let mut q_anims = world.query::<(Entity, &TweenAnim, Option<&AnimTarget>)>();
+            targets.reserve(anims.len());
+            for entity in anims {
+                if let Ok((entity, anim, maybe_target)) = q_anims.get(world, *entity) {
+                    // Lazy registration with resolver if needed
+                    if let Some(anim_target) = maybe_target {
+                        anim_target.register(world.components(), &mut resolver);
+                    }
+
+                    // Actually step the tweenable and update the target
+                    if let Ok((target_type_id, component_id, target, is_retargetable)) =
+                        Self::resolve_target(
+                            world.components(),
+                            maybe_target,
+                            entity,
+                            anim.tweenable(),
+                        )
+                    {
+                        targets.push((
+                            entity,
+                            target_type_id,
+                            component_id,
+                            target,
+                            is_retargetable,
+                        ));
+                    }
                 }
             }
-        }
+        });
         Self::step_impl(world, delta_time, &targets[..]);
         targets.len()
     }
@@ -2132,9 +2146,12 @@ impl TweenAnim {
             q_anims
                 .iter(world)
                 .filter_map(|(entity, anim, maybe_target)| {
+                    // Lazy registration with resolver if needed
                     if let Some(anim_target) = maybe_target {
                         anim_target.register(world.components(), &mut resolver);
                     }
+
+                    // Actually step the tweenable and update the target
                     match Self::resolve_target(
                         world.components(),
                         maybe_target,
@@ -2149,7 +2166,11 @@ impl TweenAnim {
                             is_retargetable,
                         )),
                         Err(err) => {
-                            println!("err: {:?}", err);
+                            bevy::log::error!(
+                                "Error while stepping TweenAnim on entity {:?}: {:?}",
+                                entity,
+                                err
+                            );
                             None
                         }
                     }
@@ -2761,43 +2782,12 @@ pub(crate) struct StepResult {
     pub needs_retarget: bool,
 }
 
-/// Extension trait to interpolate between two colors.
-///
-/// This adds a [`Color::lerp()`] function which linearly interpolates the
-/// `LinearRgba` values component-wise, by converting the input color to
-/// [`LinearRgba`] space.
-///
-/// Note that this is a convenience helper with naive color interpolation. In
-/// general, to get more accurrate colors, you should create your own [`Lens`]
-/// and apply a better interpolation, for example based on luminosity. There's
-/// no "canonical" color interpolation, and the best answer varies depending on
-/// the context and the color space used. This utility does a reasonable job for
-/// simple cases where the color accuracy is less critical, like animating some
-/// colors in UI. You should probably not use it to animate in-game colors on
-/// _e.g._ materials, especially if you're using Bevy's PBR rendering engine.
-#[allow(dead_code)]
-#[cfg(any(feature = "bevy_sprite", feature = "bevy_ui", feature = "bevy_text"))]
-trait ColorLerper {
-    fn lerp(&self, target: &Self, ratio: f32) -> Self;
-}
-
-#[allow(dead_code)]
-#[cfg(any(feature = "bevy_sprite", feature = "bevy_ui", feature = "bevy_text"))]
-impl ColorLerper for Color {
-    fn lerp(&self, target: &Color, ratio: f32) -> Color {
-        let src = self.to_linear();
-        let dst = target.to_linear();
-        let r = src.red.lerp(dst.red, ratio);
-        let g = src.green.lerp(dst.green, ratio);
-        let b = src.blue.lerp(dst.blue, ratio);
-        let a = src.alpha.lerp(dst.alpha, ratio);
-        Color::linear_rgba(r, g, b, a)
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use std::marker::PhantomData;
+    use std::{
+        f32::consts::{FRAC_PI_2, TAU},
+        marker::PhantomData,
+    };
 
     use bevy::ecs::{change_detection::MaybeLocation, component::Tick};
 
@@ -2958,6 +2948,12 @@ mod tests {
             repeat.total_duration(cycle_duration),
             TotalDuration::Finite(duration)
         );
+
+        let repeat = RepeatCount::Infinite;
+        assert_eq!(
+            repeat.total_duration(cycle_duration),
+            TotalDuration::Infinite
+        );
     }
 
     #[test]
@@ -3296,7 +3292,7 @@ mod tests {
         ));
         let mut env = TestEnv::<DummyComponent>::new(tween);
         let entity = env.entity;
-        env.world_mut()
+        env.world
             .entity_mut(entity)
             .insert(DummyComponent2 { value: -42 });
         TweenAnim::step_one(&mut env.world, Duration::from_millis(1100), entity).unwrap();
@@ -3391,4 +3387,549 @@ mod tests {
     //         assert_eq!(nc, false);
     //     }
     // }
+
+    #[test]
+    fn anim_target_component() {
+        let mut env = TestEnv::<Transform>::empty();
+        let entity = env.world.spawn(Transform::default()).id();
+        let tween = Tween::new::<Transform, TransformPositionLens>(
+            EaseFunction::Linear,
+            Duration::from_secs(1),
+            TransformPositionLens {
+                start: Vec3::ZERO,
+                end: Vec3::ONE,
+            },
+        );
+        let target = AnimTarget::component::<Transform>(entity);
+        let anim_entity = env
+            .world
+            .spawn((
+                TweenAnim::new(tween)
+                    .with_speed(2.)
+                    .with_destroy_on_completed(true),
+                target,
+            ))
+            .id();
+
+        // Step
+        assert!(
+            TweenAnim::step_one(&mut env.world, Duration::from_millis(100), anim_entity).is_ok()
+        );
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.translation, Vec3::ONE * 0.2);
+
+        // Complete
+        assert_eq!(
+            TweenAnim::step_many(&mut env.world, Duration::from_millis(400), &[anim_entity]),
+            1
+        );
+
+        // Destroyed on completion
+        assert!(env.world.entity(anim_entity).get::<TweenAnim>().is_none());
+    }
+
+    #[test]
+    fn anim_target_resource() {
+        let mut env = TestEnv::<Transform>::empty();
+        env.world.init_resource::<DummyResource>();
+        let tween = Tween::new::<DummyResource, DummyLens>(
+            EaseFunction::Linear,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let target = AnimTarget::resource::<DummyResource>();
+        let anim_entity = env
+            .world
+            .spawn((
+                TweenAnim::new(tween)
+                    .with_speed(2.)
+                    .with_destroy_on_completed(true),
+                target,
+            ))
+            .id();
+
+        // Step
+        assert!(
+            TweenAnim::step_one(&mut env.world, Duration::from_millis(100), anim_entity).is_ok()
+        );
+        let res = env.world.resource::<DummyResource>();
+        assert_eq!(res.value, 0.2);
+
+        // Complete
+        assert_eq!(
+            TweenAnim::step_many(&mut env.world, Duration::from_millis(400), &[anim_entity]),
+            1
+        );
+
+        // Destroyed on completion
+        assert!(env.world.entity(anim_entity).get::<TweenAnim>().is_none());
+    }
+
+    #[test]
+    fn anim_target_asset() {
+        let mut env = TestEnv::<Transform>::empty();
+        let mut assets = Assets::<DummyAsset>::default();
+        let handle = assets.add(DummyAsset::default());
+        env.world.insert_resource(assets);
+        let tween = Tween::new::<DummyAsset, DummyLens>(
+            EaseFunction::Linear,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let target = AnimTarget::asset::<DummyAsset>(&handle);
+        let anim_entity = env
+            .world
+            .spawn((
+                TweenAnim::new(tween)
+                    .with_speed(2.)
+                    .with_destroy_on_completed(true),
+                target,
+            ))
+            .id();
+
+        // Step
+        assert!(
+            TweenAnim::step_one(&mut env.world, Duration::from_millis(100), anim_entity).is_ok()
+        );
+        let assets = env.world.resource::<Assets<DummyAsset>>();
+        let asset = assets.get(&handle).unwrap();
+        assert_eq!(asset.value, 0.2);
+
+        // Complete
+        assert_eq!(
+            TweenAnim::step_many(&mut env.world, Duration::from_millis(400), &[anim_entity]),
+            1
+        );
+
+        // Destroyed on completion
+        assert!(env.world.entity(anim_entity).get::<TweenAnim>().is_none());
+    }
+
+    #[test]
+    fn animated_entity_commands_common() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .move_to(Vec3::ONE, Duration::from_secs(1), EaseFunction::Linear)
+            .with_repeat_count(4)
+            .with_repeat_strategy(RepeatStrategy::MirroredRepeat)
+            .id();
+        let entity2 = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .move_to(Vec3::ONE, Duration::from_secs(1), EaseFunction::Linear)
+            .with_repeat(4, RepeatStrategy::MirroredRepeat)
+            .into_inner()
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(3300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.translation, Vec3::ONE * 0.7);
+        let tr = env.world.entity(entity2).get::<Transform>().unwrap();
+        assert_eq!(tr.translation, Vec3::ONE * 0.7);
+    }
+
+    #[test]
+    fn animated_entity_commands_move_to() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .move_to(Vec3::ONE, Duration::from_secs(1), EaseFunction::Linear)
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.translation, Vec3::ONE * 0.3);
+    }
+
+    #[test]
+    fn animated_entity_commands_move_from() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .move_from(Vec3::ONE, Duration::from_secs(1), EaseFunction::Linear)
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.translation, Vec3::ONE * 0.7);
+    }
+
+    #[test]
+    fn animated_entity_commands_scale_to() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .scale_to(Vec3::ONE * 2., Duration::from_secs(1), EaseFunction::Linear)
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.scale, Vec3::ONE * 1.3);
+    }
+
+    #[test]
+    fn animated_entity_commands_scale_from() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .scale_from(Vec3::ONE * 2., Duration::from_secs(1), EaseFunction::Linear)
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.scale, Vec3::ONE * 1.7);
+    }
+
+    #[test]
+    fn animated_entity_commands_rotate_x() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .rotate_x(Duration::from_secs(1))
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(1300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.rotation, Quat::from_rotation_x(TAU * 0.3));
+    }
+
+    #[test]
+    fn animated_entity_commands_rotate_y() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .rotate_y(Duration::from_secs(1))
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(1300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.rotation, Quat::from_rotation_y(TAU * 0.3));
+    }
+
+    #[test]
+    fn animated_entity_commands_rotate_z() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .rotate_z(Duration::from_secs(1))
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(1300));
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.rotation, Quat::from_rotation_z(TAU * 0.3));
+    }
+
+    #[test]
+    fn animated_entity_commands_rotate_x_by() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .rotate_x_by(FRAC_PI_2, Duration::from_secs(1), EaseFunction::Linear)
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(1300)); // 130%
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.rotation, Quat::from_rotation_x(FRAC_PI_2)); // 100%
+    }
+
+    #[test]
+    fn animated_entity_commands_rotate_y_by() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .rotate_y_by(FRAC_PI_2, Duration::from_secs(1), EaseFunction::Linear)
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(1300)); // 130%
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.rotation, Quat::from_rotation_y(FRAC_PI_2)); // 100%
+    }
+
+    #[test]
+    fn animated_entity_commands_rotate_z_by() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        let entity = env
+            .world
+            .commands()
+            .spawn(Transform::default())
+            .rotate_z_by(FRAC_PI_2, Duration::from_secs(1), EaseFunction::Linear)
+            .id();
+        env.world.flush();
+
+        env.step_all(Duration::from_millis(1300)); // 130%
+
+        let tr = env.world.entity(entity).get::<Transform>().unwrap();
+        assert_eq!(tr.rotation, Quat::from_rotation_z(FRAC_PI_2)); // 100%
+    }
+
+    #[test]
+    fn resolver_resource() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        // Register the resource and create a TweenAnim for it
+        env.world.init_resource::<DummyResource>();
+        let tween = Tween::new::<DummyResource, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let entity = env.world.commands().spawn(TweenAnim::new(tween)).id();
+
+        // Ensure all commands are applied before starting the test
+        env.world.flush();
+
+        let delta_time = Duration::from_millis(200);
+        let resource_id = env.world.resource_id::<DummyResource>().unwrap();
+
+        // Resource resolver not registered; fails
+        env.world
+            .resource_scope(|world, resolver: Mut<TweenResolver>| {
+                world.resource_scope(
+                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                        world.resource_scope(
+                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                                assert!(resolver
+                                    .resolve_resource(
+                                        world,
+                                        &TypeId::of::<DummyResource>(),
+                                        resource_id,
+                                        entity,
+                                        delta_time,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    )
+                                    .is_err());
+                            },
+                        );
+                    },
+                );
+            });
+
+        // Register the resource resolver
+        env.world
+            .resource_scope(|world, mut resolver: Mut<TweenResolver>| {
+                resolver.register_resource_resolver_for::<DummyResource>(world.components());
+            });
+
+        // Resource resolver registered; succeeds
+        env.world
+            .resource_scope(|world, resolver: Mut<TweenResolver>| {
+                world.resource_scope(
+                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                        world.resource_scope(
+                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                                assert!(resolver
+                                    .resolve_resource(
+                                        world,
+                                        &TypeId::of::<DummyResource>(),
+                                        resource_id,
+                                        entity,
+                                        delta_time,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    )
+                                    .unwrap());
+                            },
+                        );
+                    },
+                );
+            });
+    }
+
+    #[test]
+    fn resolver_asset() {
+        let dummy_tween = Tween::new::<DummyComponent, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut env = TestEnv::<DummyComponent>::new(dummy_tween);
+
+        // Register the asset and create a TweenAnim for it
+        let mut assets = Assets::<DummyAsset>::default();
+        let handle = assets.add(DummyAsset::default());
+        let untyped_asset_id = handle.id().untyped();
+        env.world.insert_resource(assets);
+        let tween = Tween::new::<DummyAsset, DummyLens>(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let entity = env.world.commands().spawn(TweenAnim::new(tween)).id();
+
+        // Ensure all commands are applied before starting the test
+        env.world.flush();
+
+        let delta_time = Duration::from_millis(200);
+        let resource_id = env.world.resource_id::<Assets<DummyAsset>>().unwrap();
+
+        // Asset resolver not registered; fails
+        env.world
+            .resource_scope(|world, resolver: Mut<TweenResolver>| {
+                world.resource_scope(
+                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                        world.resource_scope(
+                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                                assert!(resolver
+                                    .resolve_asset(
+                                        world,
+                                        &TypeId::of::<DummyAsset>(),
+                                        resource_id,
+                                        untyped_asset_id,
+                                        entity,
+                                        delta_time,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    )
+                                    .is_err());
+                            },
+                        );
+                    },
+                );
+            });
+
+        // Register the asset resolver
+        env.world
+            .resource_scope(|world, mut resolver: Mut<TweenResolver>| {
+                resolver.register_asset_resolver_for::<DummyAsset>(world.components());
+            });
+
+        // Asset resolver registered; succeeds
+        env.world
+            .resource_scope(|world, resolver: Mut<TweenResolver>| {
+                world.resource_scope(
+                    |world, mut cycle_events: Mut<Events<CycleCompletedEvent>>| {
+                        world.resource_scope(
+                            |world, mut anim_events: Mut<Events<AnimCompletedEvent>>| {
+                                assert!(resolver
+                                    .resolve_asset(
+                                        world,
+                                        &TypeId::of::<DummyAsset>(),
+                                        resource_id,
+                                        untyped_asset_id,
+                                        entity,
+                                        delta_time,
+                                        cycle_events.reborrow(),
+                                        anim_events.reborrow(),
+                                    )
+                                    .unwrap());
+                            },
+                        );
+                    },
+                );
+            });
+    }
 }
diff --git a/src/plugin.rs b/src/plugin.rs
index d7b09b3..418ac5c 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -61,8 +61,18 @@ mod tests {
         },
     };
 
+    use bevy::time::TimePlugin;
+
     use crate::{lens::TransformPositionLens, test_utils::TestEnv, *};
 
+    #[test]
+    fn app() {
+        let mut app = App::default();
+        app.add_plugins((TimePlugin, TweeningPlugin));
+        app.finish();
+        app.update();
+    }
+
     #[test]
     fn custom_target_entity() {
         let tween = Tween::new(
diff --git a/src/test_utils.rs b/src/test_utils.rs
index c1febd4..04edcea 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -150,15 +150,27 @@ impl<T: Component<Mutability = Mutable> + Default> TestEnv<T> {
             _phantom: PhantomData,
         }
     }
-}
 
-impl<T: Component<Mutability = Mutable>> TestEnv<T> {
-    /// Get the test world.
-    #[allow(unused)]
-    pub fn world_mut(&mut self) -> &mut World {
-        &mut self.world
+    pub fn empty() -> Self {
+        let mut world = World::new();
+        world.init_resource::<Time>();
+        world.init_resource::<Events<CycleCompletedEvent>>();
+        world.init_resource::<Events<AnimCompletedEvent>>();
+        world.init_resource::<TweenResolver>();
+
+        let mut system = IntoSystem::into_system(crate::plugin::animator_system);
+        system.initialize(&mut world);
+
+        Self {
+            world,
+            entity: Entity::PLACEHOLDER,
+            system: Box::new(system),
+            _phantom: PhantomData,
+        }
     }
+}
 
+impl<T: Component<Mutability = Mutable>> TestEnv<T> {
     /// Tick the test environment, updating the simulation time and executing
     /// the built-in system which calls [`TweenAnimator::step_all()`].
     pub fn step_all(&mut self, duration: Duration) {
@@ -170,7 +182,9 @@ impl<T: Component<Mutability = Mutable>> TestEnv<T> {
 
         // Reset world-related change detection
         self.world.clear_trackers();
-        assert!(!self.component_mut().is_changed());
+        if self.entity != Entity::PLACEHOLDER {
+            assert!(!self.component_mut().is_changed());
+        }
 
         // Tick system
         self.system.run((), &mut self.world);