diff --git a/src/lens.rs b/src/lens.rs
index dbac914f2da74d256603dcc11807bff039dcb9e2..8a8eec8f1e79985e9cae5e299984253918aad0d7 100644
--- a/src/lens.rs
+++ b/src/lens.rs
@@ -607,6 +607,44 @@ mod tests {
assert!(transform.scale.abs_diff_eq(Vec3::new(0.3, 0.6, -1.2), 1e-5));
}
+ #[cfg(feature = "bevy_ui")]
+ #[test]
+ fn ui_position() {
+ let mut lens = UiPositionLens {
+ start: UiRect {
+ left: Val::Px(0.),
+ top: Val::Px(0.),
+ right: Val::Auto,
+ bottom: Val::Percent(25.),
+ },
+ end: UiRect {
+ left: Val::Px(1.),
+ top: Val::Px(5.),
+ right: Val::Auto,
+ bottom: Val::Percent(45.),
+ },
+ };
+ let mut style = Style::default();
+
+ lens.lerp(&mut style, 0.);
+ assert_eq!(style.position.left, Val::Px(0.));
+ assert_eq!(style.position.top, Val::Px(0.));
+ assert_eq!(style.position.right, Val::Auto);
+ assert_eq!(style.position.bottom, Val::Percent(25.));
+
+ lens.lerp(&mut style, 1.);
+ assert_eq!(style.position.left, Val::Px(1.));
+ assert_eq!(style.position.top, Val::Px(5.));
+ assert_eq!(style.position.right, Val::Auto);
+ assert_eq!(style.position.bottom, Val::Percent(45.));
+
+ lens.lerp(&mut style, 0.3);
+ assert_eq!(style.position.left, Val::Px(0.3));
+ assert_eq!(style.position.top, Val::Px(1.5));
+ assert_eq!(style.position.right, Val::Auto);
+ assert_eq!(style.position.bottom, Val::Percent(31.));
+ }
+
#[cfg(feature = "bevy_sprite")]
#[test]
fn colormaterial_color() {
diff --git a/src/lib.rs b/src/lib.rs
index 211050a01988ff82ce54ace69de68c0333cc8d6e..8be9eb234a34eba9881af8793d6040818d49aff2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -487,13 +487,13 @@ mod tests {
end: f32,
}
- #[derive(Debug, Component)]
+ #[derive(Debug, Default, Component)]
struct DummyComponent {
value: f32,
}
#[cfg(feature = "bevy_asset")]
- #[derive(Debug, Reflect, TypeUuid)]
+ #[derive(Debug, Default, Reflect, TypeUuid)]
#[uuid = "a33abc11-264e-4bbb-82e8-b87226bb4383"]
struct DummyAsset {
value: f32,
@@ -505,6 +505,16 @@ mod tests {
}
}
+ #[test]
+ fn dummy_lens_component() {
+ 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);
+ assert!(abs_diff_eq(c.value, r, 1e-5));
+ }
+ }
+
#[cfg(feature = "bevy_asset")]
impl Lens<DummyAsset> for DummyLens {
fn lerp(&mut self, target: &mut DummyAsset, ratio: f32) {
@@ -512,6 +522,17 @@ mod tests {
}
}
+ #[cfg(feature = "bevy_asset")]
+ #[test]
+ fn dummy_lens_asset() {
+ let mut a = 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!(abs_diff_eq(a.value, r, 1e-5));
+ }
+ }
+
#[test]
fn repeat_count() {
let count = RepeatCount::default();
@@ -659,6 +680,25 @@ mod tests {
assert!(abs_diff_eq(animator.speed(), 3.5, 1e-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]
fn asset_animator_new() {
@@ -758,4 +798,24 @@ mod tests {
let animator = AssetAnimator::new(Handle::<DummyAsset>::default(), tween).with_speed(3.5);
assert!(abs_diff_eq(animator.speed(), 3.5, 1e-5));
}
+
+ #[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(Handle::<DummyAsset>::default(), 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/tweenable.rs b/src/tweenable.rs
index c8213945d9c8629a20bc670e247ea418b1dfdcd8..5402dd24397974a53bf97e90ae47ef2a0b7dbf82 100644
--- a/src/tweenable.rs
+++ b/src/tweenable.rs
@@ -1359,6 +1359,22 @@ mod tests {
assert_eq!(seq.times_completed(), 0);
}
+ /// Sequence::from_single()
+ #[test]
+ fn seq_from_single() {
+ let tween = Tween::new(
+ EaseMethod::Linear,
+ Duration::from_secs(1),
+ TransformPositionLens {
+ start: Vec3::ZERO,
+ end: Vec3::ONE,
+ },
+ );
+ let seq = Sequence::from_single(tween);
+
+ assert_eq!(seq.duration(), Duration::from_secs(1));
+ }
+
/// Test ticking parallel tracks of tweens.
#[test]
fn tracks_tick() {
@@ -1455,10 +1471,22 @@ mod tests {
assert_eq!(tracks.times_completed(), 0); // no looping
}
+ /// Delay::then()
+ #[test]
+ fn delay_then() {
+ let seq: Sequence<Transform> =
+ 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));
+ }
+ }
+
/// Test ticking a delay.
#[test]
fn delay_tick() {
- let duration = Duration::from_secs_f32(1.0);
+ let duration = Duration::from_secs(1);
let mut delay = Delay::new(duration);
{
let tweenable: &dyn Tweenable<Transform> = &delay;
@@ -1474,7 +1502,7 @@ mod tests {
for i in 1..=6 {
let state = delay.tick(
- Duration::from_secs_f32(0.2),
+ Duration::from_millis(200),
&mut transform,
entity,
&mut event_writer,
@@ -1483,14 +1511,31 @@ mod tests {
let tweenable: &dyn Tweenable<Transform> = &delay;
if i < 5 {
assert_eq!(state, TweenState::Active);
+ assert_eq!(tweenable.times_completed(), 0);
let r = i as f32 * 0.2;
assert!((tweenable.progress() - r).abs() < 1e-5);
} else {
assert_eq!(state, TweenState::Completed);
+ assert_eq!(tweenable.times_completed(), 1);
assert!((tweenable.progress() - 1.).abs() < 1e-5);
}
}
}
+
+ let tweenable: &mut dyn Tweenable<Transform> = &mut delay;
+
+ tweenable.rewind();
+ assert_eq!(tweenable.times_completed(), 0);
+ assert!(abs_diff_eq(tweenable.progress(), 0., 1e-5));
+ let state = tweenable.tick(Duration::ZERO, &mut transform, entity, &mut event_writer);
+ assert_eq!(state, TweenState::Active);
+
+ tweenable.set_progress(0.3);
+ assert_eq!(tweenable.times_completed(), 0);
+ assert!(abs_diff_eq(tweenable.progress(), 0.3, 1e-5));
+ tweenable.set_progress(1.);
+ assert_eq!(tweenable.times_completed(), 1);
+ assert!(abs_diff_eq(tweenable.progress(), 1., 1e-5));
}
#[test]