From 63ea41556a2df79728f623cf3212c16f0f3f7910 Mon Sep 17 00:00:00 2001
From: Jerome Humbert <djeedai@gmail.com>
Date: Fri, 26 Apr 2024 20:24:01 +0100
Subject: [PATCH] Enable lenses to avoid change detection (#124)

Add the ability for all `Lens`es to avoid triggering change detection if
they don't make any actual change to their target (component or asset).

This change modifies the signature of `Lerp::lerp()` to take `&mut dyn
Targetable<T>` instead of `&mut T`. The `Targetable<T>` acts as a
`Mut<T>`, marking the target as changed only if actually dereferenced
mutably.

Note that we cannot use `Mut<T>` directly because we can't obtain a
`Mut<A: Asset>` without marking the asset as mutable; see
bevyengine/bevy#13104.

Fixes #91
---
 CHANGELOG.md     |  22 +++
 src/lens.rs      | 497 +++++++++++++++++++++++++++++++++++++++++------
 src/lib.rs       |  52 ++++-
 src/plugin.rs    | 158 ++++++++++++---
 src/tweenable.rs |  82 +++++++-
 5 files changed, 722 insertions(+), 89 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b875e0b..dd2d7a9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,28 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Changed
+
+- `Lens::lerp()` now takes a `&mut dyn Targetable<T>` instead of `&mut T`.
+  This ensures the lens can skip change detection if needed.
+  `Targetable<T>` conceptually acts like a `Mut<T>`, but allows encapsulating assets too.
+  There should be no other change than the function signature to upgrade custom lenses,
+  because `dyn Targetable<T>` now implements `Defer` and `DeferMut`, so can be used in place of `&mut T`.
+- `AssetTarget::new()` now takes a simple `Mut<Assets<T>>` instead of `ResMut<Assets<T>>`.
+
+### Fixed
+
+- Fixed change detection such that lenses which do not dereference their target
+  do not unconditionally mark that target (component or asset) as changed from the point of view of ECS. (#91)
+
+### Added
+
+- Added `Targetable::target(&self) -> &T`.
+- `dyn Targetable<T>` now implements `Defer` and `DeferMut`, so can be used in place of `&T` and `&mut T`.
+- Added `ComponentTarget::to_mut(&mut self) -> Mut<'_, T>` to "reborrow" the component target as a `Mut<T>`.
+
 ## [0.10.0] - 2024-02-27
 
 ### Changed
diff --git a/src/lens.rs b/src/lens.rs
index 0afd1fc..227d94e 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -37,6 +37,8 @@
 
 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
@@ -60,7 +62,7 @@ use bevy::prelude::*;
 /// struct MyStruct(f32);
 ///
 /// impl Lens<MyStruct> for MyLens {
-///   fn lerp(&mut self, target: &mut MyStruct, ratio: f32) {
+///   fn lerp(&mut self, target: &mut dyn Targetable<MyStruct>, ratio: f32) {
 ///     target.0 = self.start + (self.end - self.start) * ratio;
 ///   }
 /// }
@@ -71,7 +73,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 T, ratio: f32);
+    fn lerp(&mut self, target: &mut dyn Targetable<T>, ratio: f32);
 }
 
 /// A lens to manipulate the [`color`] field of a section of a [`Text`]
@@ -92,7 +94,7 @@ pub struct TextColorLens {
 
 #[cfg(feature = "bevy_text")]
 impl Lens<Text> for TextColorLens {
-    fn lerp(&mut self, target: &mut Text, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Text>, ratio: f32) {
         use crate::ColorLerper as _;
 
         // Note: Add<f32> for Color affects alpha, but not Mul<f32>. So use Vec4 for
@@ -118,7 +120,7 @@ pub struct TransformPositionLens {
 }
 
 impl Lens<Transform> for TransformPositionLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
         let value = self.start + (self.end - self.start) * ratio;
         target.translation = value;
     }
@@ -150,7 +152,7 @@ pub struct TransformRotationLens {
 }
 
 impl Lens<Transform> for TransformRotationLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
         target.rotation = self.start.slerp(self.end, ratio);
     }
 }
@@ -176,7 +178,7 @@ pub struct TransformRotateXLens {
 }
 
 impl Lens<Transform> for TransformRotateXLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_rotation_x(angle);
     }
@@ -203,7 +205,7 @@ pub struct TransformRotateYLens {
 }
 
 impl Lens<Transform> for TransformRotateYLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_rotation_y(angle);
     }
@@ -230,7 +232,7 @@ pub struct TransformRotateZLens {
 }
 
 impl Lens<Transform> for TransformRotateZLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_rotation_z(angle);
     }
@@ -263,7 +265,7 @@ pub struct TransformRotateAxisLens {
 }
 
 impl Lens<Transform> for TransformRotateAxisLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
         let angle = (self.end - self.start).mul_add(ratio, self.start);
         target.rotation = Quat::from_axis_angle(self.axis, angle);
     }
@@ -282,7 +284,7 @@ pub struct TransformScaleLens {
 }
 
 impl Lens<Transform> for TransformScaleLens {
-    fn lerp(&mut self, target: &mut Transform, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Transform>, ratio: f32) {
         let value = self.start + (self.end - self.start) * ratio;
         target.scale = value;
     }
@@ -314,7 +316,7 @@ fn lerp_val(start: &Val, end: &Val, ratio: f32) -> Val {
 
 #[cfg(feature = "bevy_ui")]
 impl Lens<Style> for UiPositionLens {
-    fn lerp(&mut self, target: &mut Style, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Style>, 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);
@@ -334,7 +336,7 @@ pub struct UiBackgroundColorLens {
 
 #[cfg(feature = "bevy_ui")]
 impl Lens<BackgroundColor> for UiBackgroundColorLens {
-    fn lerp(&mut self, target: &mut BackgroundColor, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<BackgroundColor>, ratio: f32) {
         use crate::ColorLerper as _;
 
         let value = self.start.lerp(&self.end, ratio);
@@ -346,7 +348,7 @@ impl Lens<BackgroundColor> for UiBackgroundColorLens {
 ///
 /// [`color`]: https://docs.rs/bevy/0.12.0/bevy/sprite/struct.ColorMaterial.html#structfield.color
 /// [`ColorMaterial`]: https://docs.rs/bevy/0.12.0/bevy/sprite/struct.ColorMaterial.html
-#[cfg(feature = "bevy_sprite")]
+#[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct ColorMaterialColorLens {
     /// Start color.
@@ -355,9 +357,9 @@ pub struct ColorMaterialColorLens {
     pub end: Color,
 }
 
-#[cfg(feature = "bevy_sprite")]
+#[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
 impl Lens<ColorMaterial> for ColorMaterialColorLens {
-    fn lerp(&mut self, target: &mut ColorMaterial, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<ColorMaterial>, ratio: f32) {
         use crate::ColorLerper as _;
 
         // Note: Add<f32> for Color affects alpha, but not Mul<f32>. So use Vec4 for
@@ -382,7 +384,7 @@ pub struct SpriteColorLens {
 
 #[cfg(feature = "bevy_sprite")]
 impl Lens<Sprite> for SpriteColorLens {
-    fn lerp(&mut self, target: &mut Sprite, ratio: f32) {
+    fn lerp(&mut self, target: &mut dyn Targetable<Sprite>, ratio: f32) {
         use crate::ColorLerper as _;
 
         // Note: Add<f32> for Color affects alpha, but not Mul<f32>. So use Vec4 for
@@ -394,10 +396,16 @@ impl Lens<Sprite> for SpriteColorLens {
 
 #[cfg(test)]
 mod tests {
+    use bevy::ecs::component::Tick;
     use std::f32::consts::TAU;
 
     use super::*;
 
+    use crate::tweenable::ComponentTarget;
+
+    #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
+    use crate::tweenable::AssetTarget;
+
     #[cfg(feature = "bevy_text")]
     #[test]
     fn text_color() {
@@ -408,13 +416,49 @@ mod tests {
         };
         let mut text = Text::from_section("", default());
 
-        lens.lerp(&mut text, 0.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut text,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.);
+        }
         assert_eq!(text.sections[0].style.color, Color::RED);
 
-        lens.lerp(&mut text, 1.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut text,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 1.);
+        }
         assert_eq!(text.sections[0].style.color, Color::BLUE);
 
-        lens.lerp(&mut text, 0.3);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut text,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.3);
+        }
         assert_eq!(text.sections[0].style.color, Color::rgba(0.7, 0., 0.3, 1.0));
 
         let mut lens_section1 = TextColorLens {
@@ -423,7 +467,19 @@ mod tests {
             section: 1,
         };
 
-        lens_section1.lerp(&mut text, 1.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut text,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens_section1.lerp(&mut target, 1.);
+        }
         // Should not have changed because the lens targets section 1
         assert_eq!(text.sections[0].style.color, Color::rgba(0.7, 0., 0.3, 1.0));
 
@@ -432,7 +488,19 @@ mod tests {
             style: Default::default(),
         });
 
-        lens_section1.lerp(&mut text, 0.3);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut text,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens_section1.lerp(&mut target, 0.3);
+        }
         assert_eq!(text.sections[1].style.color, Color::rgba(0.7, 0., 0.3, 1.0));
     }
 
@@ -444,19 +512,55 @@ mod tests {
         };
         let mut transform = Transform::default();
 
-        lens.lerp(&mut transform, 0.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
         assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
 
-        lens.lerp(&mut transform, 1.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 1.);
+        }
         assert!(transform
             .translation
             .abs_diff_eq(Vec3::new(1., 2., -4.), 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
         assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
 
-        lens.lerp(&mut transform, 0.3);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.3);
+        }
         assert!(transform
             .translation
             .abs_diff_eq(Vec3::new(0.3, 0.6, -1.2), 1e-5));
@@ -472,19 +576,55 @@ mod tests {
         };
         let mut transform = Transform::default();
 
-        lens.lerp(&mut transform, 0.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
         assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
 
-        lens.lerp(&mut transform, 1.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 1.);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
             .rotation
             .abs_diff_eq(Quat::from_rotation_z(100_f32.to_radians()), 1e-5));
         assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
 
-        lens.lerp(&mut transform, 0.3);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.3);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
             .rotation
@@ -501,7 +641,19 @@ mod tests {
         let mut transform = Transform::default();
 
         for (index, ratio) in [0., 0.25, 0.5, 0.75, 1.].iter().enumerate() {
-            lens.lerp(&mut transform, *ratio);
+            {
+                let mut added = Tick::new(0);
+                let mut last_changed = Tick::new(0);
+                let mut target = ComponentTarget::new(Mut::new(
+                    &mut transform,
+                    &mut added,
+                    &mut last_changed,
+                    Tick::new(0),
+                    Tick::new(0),
+                ));
+
+                lens.lerp(&mut target, *ratio);
+            }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
                 // For odd-numbered turns, the opposite Quat is produced. This is equivalent in
@@ -516,7 +668,19 @@ mod tests {
             assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
         }
 
-        lens.lerp(&mut transform, 0.1);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.1);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
             .rotation
@@ -533,7 +697,19 @@ mod tests {
         let mut transform = Transform::default();
 
         for (index, ratio) in [0., 0.25, 0.5, 0.75, 1.].iter().enumerate() {
-            lens.lerp(&mut transform, *ratio);
+            {
+                let mut added = Tick::new(0);
+                let mut last_changed = Tick::new(0);
+                let mut target = ComponentTarget::new(Mut::new(
+                    &mut transform,
+                    &mut added,
+                    &mut last_changed,
+                    Tick::new(0),
+                    Tick::new(0),
+                ));
+
+                lens.lerp(&mut target, *ratio);
+            }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
                 // For odd-numbered turns, the opposite Quat is produced. This is equivalent in
@@ -548,7 +724,19 @@ mod tests {
             assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
         }
 
-        lens.lerp(&mut transform, 0.1);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.1);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
             .rotation
@@ -565,7 +753,19 @@ mod tests {
         let mut transform = Transform::default();
 
         for (index, ratio) in [0., 0.25, 0.5, 0.75, 1.].iter().enumerate() {
-            lens.lerp(&mut transform, *ratio);
+            {
+                let mut added = Tick::new(0);
+                let mut last_changed = Tick::new(0);
+                let mut target = ComponentTarget::new(Mut::new(
+                    &mut transform,
+                    &mut added,
+                    &mut last_changed,
+                    Tick::new(0),
+                    Tick::new(0),
+                ));
+
+                lens.lerp(&mut target, *ratio);
+            }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
                 // For odd-numbered turns, the opposite Quat is produced. This is equivalent in
@@ -580,7 +780,19 @@ mod tests {
             assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
         }
 
-        lens.lerp(&mut transform, 0.1);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.1);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
             .rotation
@@ -599,7 +811,19 @@ mod tests {
         let mut transform = Transform::default();
 
         for (index, ratio) in [0., 0.25, 0.5, 0.75, 1.].iter().enumerate() {
-            lens.lerp(&mut transform, *ratio);
+            {
+                let mut added = Tick::new(0);
+                let mut last_changed = Tick::new(0);
+                let mut target = ComponentTarget::new(Mut::new(
+                    &mut transform,
+                    &mut added,
+                    &mut last_changed,
+                    Tick::new(0),
+                    Tick::new(0),
+                ));
+
+                lens.lerp(&mut target, *ratio);
+            }
             assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
             if index == 1 || index == 3 {
                 // For odd-numbered turns, the opposite Quat is produced. This is equivalent in
@@ -614,7 +838,19 @@ mod tests {
             assert!(transform.scale.abs_diff_eq(Vec3::ONE, 1e-5));
         }
 
-        lens.lerp(&mut transform, 0.1);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.1);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform
             .rotation
@@ -630,17 +866,53 @@ mod tests {
         };
         let mut transform = Transform::default();
 
-        lens.lerp(&mut transform, 0.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
         assert!(transform.scale.abs_diff_eq(Vec3::ZERO, 1e-5));
 
-        lens.lerp(&mut transform, 1.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 1.);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
         assert!(transform.scale.abs_diff_eq(Vec3::new(1., 2., -4.), 1e-5));
 
-        lens.lerp(&mut transform, 0.3);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut transform,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.3);
+        }
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
         assert!(transform.rotation.abs_diff_eq(Quat::IDENTITY, 1e-5));
         assert!(transform.scale.abs_diff_eq(Vec3::new(0.3, 0.6, -1.2), 1e-5));
@@ -665,45 +937,124 @@ mod tests {
         };
         let mut style = Style::default();
 
-        lens.lerp(&mut style, 0.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut style,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.);
+        }
         assert_eq!(style.left, Val::Px(0.));
         assert_eq!(style.top, Val::Px(0.));
         assert_eq!(style.right, Val::Auto);
         assert_eq!(style.bottom, Val::Percent(25.));
 
-        lens.lerp(&mut style, 1.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut style,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 1.);
+        }
         assert_eq!(style.left, Val::Px(1.));
         assert_eq!(style.top, Val::Px(5.));
         assert_eq!(style.right, Val::Auto);
         assert_eq!(style.bottom, Val::Percent(45.));
 
-        lens.lerp(&mut style, 0.3);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut style,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.3);
+        }
         assert_eq!(style.left, Val::Px(0.3));
         assert_eq!(style.top, Val::Px(1.5));
         assert_eq!(style.right, Val::Auto);
         assert_eq!(style.bottom, Val::Percent(31.));
     }
 
-    #[cfg(feature = "bevy_sprite")]
+    #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset"))]
     #[test]
     fn colormaterial_color() {
         let mut lens = ColorMaterialColorLens {
             start: Color::RED,
             end: Color::BLUE,
         };
-        let mut mat = ColorMaterial {
+        let mut assets = Assets::default();
+        let handle = assets.add(ColorMaterial {
             color: Color::WHITE,
             texture: None,
-        };
-
-        lens.lerp(&mut mat, 0.);
-        assert_eq!(mat.color, Color::RED);
-
-        lens.lerp(&mut mat, 1.);
-        assert_eq!(mat.color, Color::BLUE);
+        });
 
-        lens.lerp(&mut mat, 0.3);
-        assert_eq!(mat.color, Color::rgba(0.7, 0., 0.3, 1.0));
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = AssetTarget::new(Mut::new(
+                &mut assets,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+            target.handle = handle.clone();
+
+            lens.lerp(&mut target, 0.);
+        }
+        assert_eq!(assets.get(handle.clone()).unwrap().color, Color::RED);
+
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = AssetTarget::new(Mut::new(
+                &mut assets,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+            target.handle = handle.clone();
+
+            lens.lerp(&mut target, 1.);
+        }
+        assert_eq!(assets.get(handle.clone()).unwrap().color, Color::BLUE);
+
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = AssetTarget::new(Mut::new(
+                &mut assets,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+            target.handle = handle.clone();
+
+            lens.lerp(&mut target, 0.3);
+        }
+        assert_eq!(
+            assets.get(handle).unwrap().color,
+            Color::rgba(0.7, 0., 0.3, 1.0)
+        );
     }
 
     #[cfg(feature = "bevy_sprite")]
@@ -718,13 +1069,49 @@ mod tests {
             ..default()
         };
 
-        lens.lerp(&mut sprite, 0.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut sprite,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.);
+        }
         assert_eq!(sprite.color, Color::RED);
 
-        lens.lerp(&mut sprite, 1.);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut sprite,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 1.);
+        }
         assert_eq!(sprite.color, Color::BLUE);
 
-        lens.lerp(&mut sprite, 0.3);
+        {
+            let mut added = Tick::new(0);
+            let mut last_changed = Tick::new(0);
+            let mut target = ComponentTarget::new(Mut::new(
+                &mut sprite,
+                &mut added,
+                &mut last_changed,
+                Tick::new(0),
+                Tick::new(0),
+            ));
+
+            lens.lerp(&mut target, 0.3);
+        }
         assert_eq!(sprite.color, Color::rgba(0.7, 0., 0.3, 1.0));
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 3b4f1c9..eb54668 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -540,11 +540,13 @@ impl<T: Asset> AssetAnimator<T> {
 /// 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);
@@ -557,6 +559,10 @@ impl ColorLerper for Color {
 
 #[cfg(test)]
 mod tests {
+    use bevy::ecs::component::Tick;
+
+    use self::tweenable::ComponentTarget;
+
     use super::*;
     use crate::test_utils::*;
 
@@ -565,7 +571,7 @@ mod tests {
         end: f32,
     }
 
-    #[derive(Debug, Default, Component)]
+    #[derive(Debug, Default, Clone, Copy, Component)]
     struct DummyComponent {
         value: f32,
     }
@@ -577,7 +583,7 @@ mod tests {
     }
 
     impl Lens<DummyComponent> for DummyLens {
-        fn lerp(&mut self, target: &mut DummyComponent, ratio: f32) {
+        fn lerp(&mut self, target: &mut dyn Targetable<DummyComponent>, ratio: f32) {
             target.value = self.start.lerp(self.end, ratio);
         }
     }
@@ -587,14 +593,29 @@ mod tests {
         let mut c = DummyComponent::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.] {
-            l.lerp(&mut c, r);
+            {
+                let mut added = Tick::new(0);
+                let mut last_changed = Tick::new(0);
+                let mut target = ComponentTarget::new(Mut::new(
+                    &mut c,
+                    &mut added,
+                    &mut last_changed,
+                    Tick::new(0),
+                    Tick::new(1),
+                ));
+
+                l.lerp(&mut target, r);
+
+                assert!(target.to_mut().is_changed());
+            }
+
             assert_approx_eq!(c.value, r);
         }
     }
 
     #[cfg(feature = "bevy_asset")]
     impl Lens<DummyAsset> for DummyLens {
-        fn lerp(&mut self, target: &mut DummyAsset, ratio: f32) {
+        fn lerp(&mut self, target: &mut dyn Targetable<DummyAsset>, ratio: f32) {
             target.value = self.start.lerp(self.end, ratio);
         }
     }
@@ -602,11 +623,28 @@ mod tests {
     #[cfg(feature = "bevy_asset")]
     #[test]
     fn dummy_lens_asset() {
-        let mut a = DummyAsset::default();
+        use self::tweenable::AssetTarget;
+
+        let mut assets = Assets::<DummyAsset>::default();
+        let handle = assets.add(DummyAsset::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.] {
-            l.lerp(&mut a, r);
-            assert_approx_eq!(a.value, r);
+            {
+                let mut added = Tick::new(0);
+                let mut last_changed = Tick::new(0);
+                let mut target = AssetTarget::new(Mut::new(
+                    &mut assets,
+                    &mut added,
+                    &mut last_changed,
+                    Tick::new(0),
+                    Tick::new(0),
+                ));
+                target.handle = handle.clone();
+
+                l.lerp(&mut target, r);
+            }
+            assert_approx_eq!(assets.get(handle.clone()).unwrap().value, r);
         }
     }
 
diff --git a/src/plugin.rs b/src/plugin.rs
index b8a0db8..46afce3 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -113,12 +113,12 @@ pub fn component_animator_system<T: Component>(
 #[cfg(feature = "bevy_asset")]
 pub fn asset_animator_system<T: Asset>(
     time: Res<Time>,
-    assets: ResMut<Assets<T>>,
+    mut assets: ResMut<Assets<T>>,
     mut query: Query<(Entity, &Handle<T>, &mut AssetAnimator<T>)>,
     events: ResMut<Events<TweenCompleted>>,
 ) {
     let mut events: Mut<Events<TweenCompleted>> = events.into();
-    let mut target = AssetTarget::new(assets);
+    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();
@@ -138,28 +138,44 @@ pub fn asset_animator_system<T: Asset>(
 
 #[cfg(test)]
 mod tests {
+    use std::{
+        marker::PhantomData,
+        ops::DerefMut,
+        sync::{
+            atomic::{AtomicBool, Ordering},
+            Arc,
+        },
+    };
+
     use crate::{lens::TransformPositionLens, *};
 
     /// A simple isolated test environment with a [`World`] and a single
     /// [`Entity`] in it.
-    struct TestEnv {
+    struct TestEnv<T: Component> {
         world: World,
         entity: Entity,
+        _phantom: PhantomData<T>,
     }
 
-    impl TestEnv {
+    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<T: Component>(animator: T) -> Self {
+        pub fn new(animator: Animator<T>) -> Self {
             let mut world = World::new();
             world.init_resource::<Events<TweenCompleted>>();
             world.init_resource::<Time>();
 
-            let entity = world.spawn((Transform::default(), animator)).id();
+            let entity = world.spawn((T::default(), animator)).id();
 
-            Self { world, entity }
+            Self {
+                world,
+                entity,
+                _phantom: PhantomData,
+            }
         }
+    }
 
+    impl<T: Component> TestEnv<T> {
         /// Get the test world.
         pub fn world_mut(&mut self) -> &mut World {
             &mut self.world
@@ -176,7 +192,7 @@ mod tests {
 
             // Reset world-related change detection
             self.world.clear_trackers();
-            assert!(!self.transform().is_changed());
+            assert!(!self.component_mut().is_changed());
 
             // Tick system
             system.run((), &mut self.world);
@@ -186,17 +202,14 @@ mod tests {
             events.update();
         }
 
-        /// Get the animator for the transform.
-        pub fn animator(&self) -> &Animator<Transform> {
-            self.world
-                .entity(self.entity)
-                .get::<Animator<Transform>>()
-                .unwrap()
+        /// Get the animator for the component.
+        pub fn animator(&self) -> &Animator<T> {
+            self.world.entity(self.entity).get::<Animator<T>>().unwrap()
         }
 
-        /// Get the transform component.
-        pub fn transform(&mut self) -> Mut<Transform> {
-            self.world.get_mut::<Transform>(self.entity).unwrap()
+        /// 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.
@@ -221,7 +234,7 @@ mod tests {
         let mut env = TestEnv::new(Animator::new(tween));
 
         // After being inserted, components are always considered changed
-        let transform = env.transform();
+        let transform = env.component_mut();
         assert!(transform.is_changed());
 
         // fn nit() {}
@@ -234,7 +247,7 @@ mod tests {
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
         assert_eq!(animator.tweenable().times_completed(), 0);
-        let transform = env.transform();
+        let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ZERO, 1e-5));
 
@@ -244,7 +257,7 @@ mod tests {
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
         assert_eq!(animator.tweenable().times_completed(), 0);
-        let transform = env.transform();
+        let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::splat(0.5), 1e-5));
 
@@ -254,7 +267,7 @@ mod tests {
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
         assert_eq!(animator.tweenable().times_completed(), 1);
-        let transform = env.transform();
+        let transform = env.component_mut();
         assert!(transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
 
@@ -264,8 +277,109 @@ mod tests {
         let animator = env.animator();
         assert_eq!(animator.state, AnimatorState::Playing);
         assert_eq!(animator.tweenable().times_completed(), 1);
-        let transform = env.transform();
+        let transform = env.component_mut();
         assert!(!transform.is_changed());
         assert!(transform.translation.abs_diff_eq(Vec3::ONE, 1e-5));
     }
+
+    #[derive(Debug, Default, Clone, Copy, Component)]
+    struct DummyComponent {
+        value: f32,
+    }
+
+    /// Test [`Lens`] which only access mutably the target component if `defer`
+    /// is `true`.
+    struct ConditionalDeferLens {
+        pub defer: Arc<AtomicBool>,
+    }
+
+    impl Lens<DummyComponent> for ConditionalDeferLens {
+        fn lerp(&mut self, target: &mut dyn Targetable<DummyComponent>, ratio: f32) {
+            if self.defer.load(Ordering::SeqCst) {
+                target.deref_mut().value += ratio;
+            }
+        }
+    }
+
+    #[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(Animator::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>);
+        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 673e1ff..2d98245 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1,4 +1,7 @@
-use std::{ops::DerefMut, time::Duration};
+use std::{
+    ops::{Deref, DerefMut},
+    time::Duration,
+};
 
 use bevy::prelude::*;
 
@@ -199,22 +202,50 @@ fn compute_total_duration(duration: Duration, count: RepeatCount) -> TotalDurati
 /// 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()
+    }
+}
+
 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<'a, T: Component> Targetable<T> for ComponentTarget<'a, T> {
+    fn target(&self) -> &T {
+        self.target.deref()
+    }
+
     fn target_mut(&mut self) -> &mut T {
         self.target.deref_mut()
     }
@@ -222,19 +253,23 @@ impl<'a, T: Component> Targetable<T> for ComponentTarget<'a, T> {
 
 #[cfg(feature = "bevy_asset")]
 pub struct AssetTarget<'a, T: Asset> {
-    assets: ResMut<'a, Assets<T>>,
+    assets: Mut<'a, Assets<T>>,
     pub handle: Handle<T>,
 }
 
 #[cfg(feature = "bevy_asset")]
 impl<'a, T: Asset> AssetTarget<'a, T> {
-    pub fn new(assets: ResMut<'a, Assets<T>>) -> Self {
+    /// 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`]: self::handle
     pub fn is_valid(&self) -> bool {
         self.assets.contains(&self.handle)
     }
@@ -242,6 +277,10 @@ impl<'a, T: Asset> AssetTarget<'a, T> {
 
 #[cfg(feature = "bevy_asset")]
 impl<'a, T: Asset> Targetable<T> for AssetTarget<'a, T> {
+    fn target(&self) -> &T {
+        self.assets.get(&self.handle).unwrap()
+    }
+
     fn target_mut(&mut self) -> &mut T {
         self.assets.get_mut(&self.handle).unwrap()
     }
@@ -677,7 +716,6 @@ impl<T> Tweenable<T> for Tween<T> {
             factor = 1. - factor;
         }
         let factor = self.ease_function.sample(factor);
-        let target = target.target_mut();
         self.lens.lerp(target, factor);
 
         // If completed at least once this frame, notify the user
@@ -1161,7 +1199,7 @@ impl<T> Tweenable<T> for Delay<T> {
 mod tests {
     use std::sync::{Arc, Mutex};
 
-    use bevy::ecs::system::SystemState;
+    use bevy::ecs::{component::Tick, system::SystemState};
 
     use super::*;
     use crate::{lens::*, test_utils::*};
@@ -1208,6 +1246,40 @@ mod tests {
         )
     }
 
+    #[derive(Debug, Default, Clone, Copy, Component)]
+    struct DummyComponent {
+        _value: f32,
+    }
+
+    #[test]
+    fn targetable_change_detect() {
+        let mut c = DummyComponent::default();
+        let mut added = Tick::new(0);
+        let mut last_changed = Tick::new(0);
+        let mut target = ComponentTarget::new(Mut::new(
+            &mut c,
+            &mut added,
+            &mut last_changed,
+            Tick::new(0),
+            Tick::new(1),
+        ));
+        let mut target = target.to_mut();
+
+        // No-op at start
+        assert!(!target.is_added());
+        assert!(!target.is_changed());
+
+        // Immutable deref doesn't trigger change detection
+        let _ = target.deref();
+        assert!(!target.is_added());
+        assert!(!target.is_changed());
+
+        // Mutable deref triggers change detection
+        let _ = target.deref_mut();
+        assert!(!target.is_added());
+        assert!(target.is_changed());
+    }
+
     #[test]
     fn anim_clock_precision() {
         let duration = Duration::from_millis(1);