Add Delta Tweens

You can now have multiple tweens affect the same entity without having to make complex calculations or have to pick one of them!
In practice, added:

Previous value now provided to each interpolator function (you don't have to use it)
An example that showcases two tweens affecting the same entity
A Delta variant to all basic interpolators

Author: Rabbival

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## v0.8.1 - 2025-07-14
+
+### Breaking Changes
+
+- `interpolate` functions now take an additional `previous_value` argument, which you can now use to make delta tweens.
+Still, you'd have to update everything that implements `Interpolator` to match the new signature.
+
+### Changes
+
+- Migrate to Bevy 0.16.1
+- You can now use `previous_value` to make tweens that apply delta instead of set values
+  (see `TranslationDelta` for example). This is useful when you want two ongoing tweens to affect the same entity.
+
 ## v0.8.0 - 2025-05-09
 
 ### Changes

Cargo.toml

@@ -18,7 +18,7 @@ resolver = "2"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies.bevy]
-version = "0.16.0"
+version = "0.16.1"
 default-features = false
 features = ["std"]
 
@@ -28,7 +28,7 @@ default-features = false
 features = ["curve"]
 
 [dependencies.bevy_time_runner]
-version = "0.4.0"
+version = "0.4.1"
 
 [dependencies.serde]
 version = "1"
@@ -45,7 +45,7 @@ optional = true
 
 [dev-dependencies]
 bevy-inspector-egui = "0.31.0"
-rand = "0.9.0"
+rand = "0.9.1"
 
 [dev-dependencies.bevy]
 version = "0.16.0"
@@ -165,3 +165,6 @@ required-features = [
     "bevy_lookup_curve",
 ]
 
+[[example]]
+name = "delta_tweens"
+path = "examples/demo/delta_tweens.rs"

examples/animation/banner_bounce.rs

@@ -362,7 +362,7 @@ fn animation(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 type InterpolateSpriteAlpha = Box<dyn Interpolator<Item = Sprite>>;
 fn sprite_alpha(start: f32, end: f32) -> InterpolateSpriteAlpha {
-    Box::new(interpolate::closure(move |sprite: &mut Sprite, value| {
+    Box::new(interpolate::closure(move |sprite: &mut Sprite, value, _| {
         sprite.color = sprite.color.with_alpha(start.lerp(end, value));
     }))
 }

examples/demo/delta_tweens.rs

@@ -0,0 +1,65 @@
+use std::time::Duration;
+use bevy::{
+    prelude::*,
+};
+use bevy_tween::{
+    combinator::*, prelude::*,
+    tween::AnimationTarget,
+};
+
+fn secs(secs: f32) -> Duration {
+    Duration::from_secs_f32(secs)
+}
+
+fn main() {
+    App::new()
+        .add_plugins((DefaultPlugins, DefaultTweenPlugins))
+        .add_systems(Startup, (
+            setup,
+            spawn_circle_with_tweens
+        ))
+        .run();
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2d);
+}
+
+fn spawn_circle_with_tweens(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+) {
+    let circle_filled_image = asset_server.load("circle_filled.png");
+    let circle_transform = Transform::from_xyz(400., -200., 0.);
+    let vertical_delta = Vec3::new(0.0, 400.0, 0.0);
+    let horizontal_delta = Vec3::new(-800.0, 0.0, 0.0);
+    let float_duration = secs(4.0);
+    let circle = AnimationTarget.into_target();
+    let mut circle_transform_state = circle.transform_state(circle_transform);
+
+    let mut circle_commands = commands
+        .spawn((
+            Sprite {
+                image: circle_filled_image,
+                ..default()
+            },
+            circle_transform,
+            AnimationTarget,
+        ));
+
+    circle_commands.animation()
+        .repeat(Repeat::Infinitely)
+        .repeat_style(RepeatStyle::PingPong)
+        .insert(parallel((
+            tween(
+                float_duration,
+                EaseKind::BounceIn,
+                circle_transform_state.translation_delta_by(horizontal_delta),
+            ),
+            tween(
+                float_duration,
+                EaseKind::SineInOut,
+                circle_transform_state.translation_delta_by(vertical_delta),
+            )
+        )));
+}

examples/demo/follow.rs

@@ -96,7 +96,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                 .insert_tween_here(
                     Duration::from_secs(2),
                     EaseKind::CubicInOut,
-                    jeb.with_closure(|transform: &mut Transform, value| {
+                    jeb.with_closure(|transform: &mut Transform, value, _| {
                         let start = 0.;
                         let end = TAU;
                         transform.rotation =

examples/demo/hold.rs

@@ -27,7 +27,7 @@ mod interpolate {
     impl Interpolator for EffectIntensity {
         type Item = super::EffectIntensitiy;
 
-        fn interpolate(&self, item: &mut Self::Item, value: f32) {
+        fn interpolate(&self, item: &mut Self::Item, value: f32, _previous_value: f32) {
             item.0 = self.start.lerp(self.end, value)
         }
     }

examples/demo/sprite_sheet.rs

@@ -25,7 +25,7 @@ mod interpolate {
     impl Interpolator for AtlasIndex {
         type Item = Sprite;
 
-        fn interpolate(&self, item: &mut Self::Item, value: f32) {
+        fn interpolate(&self, item: &mut Self::Item, value: f32, _previous_value: f32) {
             let Some(texture_atlas) = &mut item.texture_atlas else {
                 return;
             };

examples/interpolator.rs

@@ -34,7 +34,7 @@ mod interpolate {
     impl Interpolator for CircleRadius {
         type Item = Circle;
 
-        fn interpolate(&self, item: &mut Self::Item, value: f32) {
+        fn interpolate(&self, item: &mut Self::Item, value: f32, _previous_value: f32) {
             item.radius = self.start.lerp(self.end, value);
         }
     }
@@ -51,7 +51,7 @@ mod interpolate {
     impl Interpolator for CircleHue {
         type Item = Circle;
 
-        fn interpolate(&self, item: &mut Self::Item, value: f32) {
+        fn interpolate(&self, item: &mut Self::Item, value: f32, _previous_value: f32) {
             item.hue = self.start.lerp(self.end, value);
         }
     }
@@ -99,7 +99,7 @@ fn setup(mut commands: Commands) {
             Duration::from_secs(2),
             EaseKind::Linear,
             // Requires [`component_dyn_tween_system`]
-            circle.with_closure(|circle: &mut Circle, value| {
+            circle.with_closure(|circle: &mut Circle, value, _| {
                 circle.spikiness = (2.).lerp(4., value);
             }),
         ),

src/combinator/state.rs

@@ -170,4 +170,19 @@ impl TransformTargetState {
     pub fn scale_by(&mut self, by: Vec3) -> ComponentTween<Scale> {
         self.scale_with(scale_by(by))
     }
+
+    /// Create delta [`ComponentTween`] of transform's translation tweening by provided input
+    pub fn translation_delta_by(&mut self, by: Vec3) -> ComponentTween<TranslationDelta> {
+        self.translation_with(translation_delta_by(by))
+    }
+
+    /// Create delta [`ComponentTween`] of transform's rotation tweening by provided input
+    pub fn rotation_delta_by(&mut self, by: Quat) -> ComponentTween<RotationDelta> {
+        self.rotation_with(rotation_delta_by(by))
+    }
+    
+    /// Create delta [`ComponentTween`] of scale's rotation tweening by provided input
+    pub fn scale_delta_by(&mut self, by: Vec3) -> ComponentTween<ScaleDelta> {
+        self.scale_with(scale_delta_by(by))
+    }
 }

src/interpolate.rs

@@ -11,6 +11,7 @@
 //! - [`AngleZ`]
 //! - [`SpriteColor`]
 //! - [`ColorMaterial`]
+//! - All their delta variants (such as [`TranslationDelta`])
 //!
 //! # Your own [`Interpolator`]
 //!
@@ -45,7 +46,7 @@
 //!     type Item = Foo;
 //!
 //!     // Then we define how we want to interpolate `Foo`
-//!     fn interpolate(&self, item: &mut Self::Item, value: f32) {
+//!     fn interpolate(&self, item: &mut Self::Item, value: f32, _previous_value: f32) {
 //!         // Usually if the type already have the `.lerp` function provided
 //!         // by the `FloatExt` trait then we can use just that
 //!         item.0 = self.start.lerp(self.end, value);
@@ -90,13 +91,13 @@ use bevy::prelude::*;
 /// Alias for an `Interpolator` as a boxed trait object.
 pub type BoxedInterpolator<Item> = Box<dyn Interpolator<Item = Item>>;
 
-type InterpolatorClosure<I> = Box<dyn Fn(&mut I, f32) + Send + Sync + 'static>;
+type InterpolatorClosure<I> = Box<dyn Fn(&mut I, f32, f32) + Send + Sync + 'static>;
 
 /// Create boxed closure in order to be used with dynamic [`Interpolator`]
 pub fn closure<I, F>(f: F) -> InterpolatorClosure<I>
 where
     I: 'static,
-    F: Fn(&mut I, f32) + Send + Sync + 'static,
+    F: Fn(&mut I, f32, f32) + Send + Sync + 'static,
 {
     Box::new(f)
 }
@@ -115,7 +116,7 @@ pub trait Interpolator: Send + Sync + 'static {
     /// The value should be already sampled from an [`Interpolation`]
     ///
     /// [`Interpolation`]: crate::interpolation::Interpolation
-    fn interpolate(&self, item: &mut Self::Item, value: f32);
+    fn interpolate(&self, item: &mut Self::Item, value: f32, previous_value: f32);
 }
 
 // /// Reflect [`Interpolator`] trait
@@ -197,7 +198,7 @@ pub trait Interpolator: Send + Sync + 'static {
 
 /// Default interpolators
 ///
-/// Register type and systems for the following interpolators:
+/// Register type and systems for the following interpolators and their delta interpolators:
 /// - [`Translation`]
 /// - [`Rotation`]
 /// - [`Scale`]
@@ -217,29 +218,47 @@ impl Plugin for DefaultInterpolatorsPlugin {
             tween::component_tween_system::<Rotation>(),
             tween::component_tween_system::<Scale>(),
             tween::component_tween_system::<AngleZ>(),
+            tween::component_tween_system::<TranslationDelta>(),
+            tween::component_tween_system::<RotationDelta>(),
+            tween::component_tween_system::<ScaleDelta>(),
+            tween::component_tween_system::<AngleZDelta>()
         ))
         .register_type::<tween::ComponentTween<Translation>>()
         .register_type::<tween::ComponentTween<Rotation>>()
         .register_type::<tween::ComponentTween<Scale>>()
-        .register_type::<tween::ComponentTween<AngleZ>>();
+        .register_type::<tween::ComponentTween<AngleZ>>()
+        .register_type::<tween::ComponentTween<TranslationDelta>>()
+        .register_type::<tween::ComponentTween<RotationDelta>>()
+        .register_type::<tween::ComponentTween<ScaleDelta>>()
+        .register_type::<tween::ComponentTween<AngleZDelta>>();
 
         #[cfg(feature = "bevy_sprite")]
-        app.add_tween_systems(tween::component_tween_system::<SpriteColor>())
-            .register_type::<tween::ComponentTween<SpriteColor>>();
+        app.add_tween_systems((
+            tween::component_tween_system::<SpriteColor>(),
+            tween::component_tween_system::<SpriteColorDelta>(),
+        ))
+            .register_type::<tween::ComponentTween<SpriteColor>>()
+            .register_type::<tween::ComponentTween<SpriteColorDelta>>();
 
         #[cfg(feature = "bevy_ui")]
         app.add_tween_systems((
             tween::component_tween_system::<ui::BackgroundColor>(),
             tween::component_tween_system::<ui::BorderColor>(),
+            tween::component_tween_system::<BackgroundColorDelta>(),
+            tween::component_tween_system::<BorderColorDelta>(),
         ))
-        .register_type::<tween::ComponentTween<ui::BackgroundColor>>()
-        .register_type::<tween::ComponentTween<ui::BorderColor>>();
+            .register_type::<tween::ComponentTween<ui::BackgroundColor>>()
+            .register_type::<tween::ComponentTween<ui::BorderColor>>()
+            .register_type::<tween::ComponentTween<BackgroundColorDelta>>()
+            .register_type::<tween::ComponentTween<BorderColorDelta>>();
 
         #[cfg(all(feature = "bevy_sprite", feature = "bevy_asset",))]
-        app.add_tween_systems(
+        app.add_tween_systems((
             tween::asset_tween_system::<sprite::ColorMaterial>(),
-        )
-        .register_type::<tween::AssetTween<sprite::ColorMaterial>>();
+            tween::asset_tween_system::<ColorMaterialDelta>(),
+        ))
+            .register_type::<tween::AssetTween<sprite::ColorMaterial>>()
+            .register_type::<tween::ComponentTween<ColorMaterialDelta>>();
     }
 }