1pub mod ease;
29mod shake;
30
31pub use ease::Ease;
32pub use shake::{Shake, ShakeConfig, ShakeError, ShakeSample};
33
34use glam::{Quat, Vec2, Vec3, Vec4};
35use std::time::Duration;
36
37pub trait Tweenable: Copy {
42 fn interpolate(from: Self, to: Self, t: f32) -> Self;
44}
45
46impl Tweenable for f32 {
47 fn interpolate(from: Self, to: Self, t: f32) -> Self {
48 from + (to - from) * t
49 }
50}
51impl Tweenable for Vec2 {
52 fn interpolate(from: Self, to: Self, t: f32) -> Self {
53 from.lerp(to, t)
54 }
55}
56impl Tweenable for Vec3 {
57 fn interpolate(from: Self, to: Self, t: f32) -> Self {
58 from.lerp(to, t)
59 }
60}
61impl Tweenable for Vec4 {
63 fn interpolate(from: Self, to: Self, t: f32) -> Self {
64 from.lerp(to, t)
65 }
66}
67impl Tweenable for Quat {
69 fn interpolate(from: Self, to: Self, t: f32) -> Self {
70 from.slerp(to, t)
71 }
72}
73impl Tweenable for [u8; 4] {
76 fn interpolate(from: Self, to: Self, t: f32) -> Self {
77 std::array::from_fn(|i| {
78 let (a, b) = (f32::from(from[i]), f32::from(to[i]));
79 (a + (b - a) * t).round().clamp(0.0, 255.0) as u8
80 })
81 }
82}
83
84#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
86pub struct TweenId(pub u32);
87
88#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
91pub struct TweenCompleted {
92 pub id: TweenId,
94}
95
96#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
98pub enum TweenMode {
99 #[default]
101 Once,
102 Loop,
104 PingPong,
106}
107
108#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
109enum Status {
110 Active,
111 Finished,
112 Cancelled,
113}
114
115pub trait Animate {
120 fn step(&mut self, dt: Duration) -> Option<Duration>;
123 fn rewind(&mut self);
125 fn skip_to_end(&mut self);
127 fn is_done(&self) -> bool;
129}
130
131macro_rules! controls {
133 () => {
134 pub fn advance(&mut self, dt: Duration) -> Option<TweenCompleted> {
137 self.step(dt).map(|_| TweenCompleted { id: self.id })
138 }
139 pub fn with_id(mut self, id: TweenId) -> Self {
141 self.id = id;
142 self
143 }
144 pub fn id(&self) -> TweenId {
146 self.id
147 }
148 pub fn pause(&mut self) {
150 self.paused = true;
151 }
152 pub fn resume(&mut self) {
154 self.paused = false;
155 }
156 pub fn is_paused(&self) -> bool {
158 self.paused
159 }
160 pub fn reset(&mut self) {
162 self.rewind();
163 }
164 pub fn cancel(&mut self) {
166 if self.status == Status::Active {
167 self.status = Status::Cancelled;
168 }
169 }
170 pub fn finish(&mut self) -> Option<TweenCompleted> {
173 if self.status != Status::Active {
174 return None;
175 }
176 self.skip_to_end();
177 Some(TweenCompleted { id: self.id })
178 }
179 pub fn is_finished(&self) -> bool {
181 self.status == Status::Finished
182 }
183 pub fn is_cancelled(&self) -> bool {
185 self.status == Status::Cancelled
186 }
187 };
188}
189
190fn from_nanos(nanos: u128) -> Duration {
191 Duration::new(
192 (nanos / 1_000_000_000) as u64,
193 (nanos % 1_000_000_000) as u32,
194 )
195}
196
197#[derive(Clone, Copy, Debug, PartialEq)]
205pub struct Tween<T> {
206 from: T,
207 to: T,
208 duration: Duration,
209 delay: Duration,
210 ease: Ease,
211 mode: TweenMode,
212 cycles: Option<u32>,
213 id: TweenId,
214 waited: Duration,
215 position: Duration,
216 completed: u32,
217 reversed: bool,
218 paused: bool,
219 status: Status,
220}
221
222impl<T: Tweenable> Tween<T> {
223 pub fn new(from: T, to: T, duration: Duration) -> Self {
226 Self {
227 from,
228 to,
229 duration,
230 delay: Duration::ZERO,
231 ease: Ease::Linear,
232 mode: TweenMode::Once,
233 cycles: None,
234 id: TweenId::default(),
235 waited: Duration::ZERO,
236 position: Duration::ZERO,
237 completed: 0,
238 reversed: false,
239 paused: false,
240 status: Status::Active,
241 }
242 }
243 pub fn with_delay(mut self, delay: Duration) -> Self {
246 let started = self.waited >= self.delay
247 && (!self.position.is_zero() || self.completed > 0 || self.status != Status::Active);
248 self.delay = delay;
249 if started {
250 self.waited = delay;
251 }
252 self
253 }
254 pub fn with_ease(mut self, ease: Ease) -> Self {
256 self.ease = ease;
257 self
258 }
259 pub fn with_mode(mut self, mode: TweenMode) -> Self {
262 assert!(
263 mode == TweenMode::Once || !self.duration.is_zero(),
264 "repeating tween duration must be nonzero"
265 );
266 self.mode = mode;
267 self.reversed &= mode == TweenMode::PingPong;
269 self
270 }
271 pub fn with_cycles(mut self, cycles: u32) -> Self {
275 assert!(cycles > 0, "tween cycle count must be positive");
276 self.cycles = Some(cycles);
277 self
278 }
279
280 pub fn from(&self) -> T {
282 self.from
283 }
284 pub fn to(&self) -> T {
286 self.to
287 }
288 pub fn duration(&self) -> Duration {
290 self.duration
291 }
292 pub fn delay(&self) -> Duration {
294 self.delay
295 }
296 pub fn ease(&self) -> Ease {
298 self.ease
299 }
300 pub fn mode(&self) -> TweenMode {
302 self.mode
303 }
304 pub fn completed_cycles(&self) -> u32 {
306 self.completed
307 }
308
309 pub fn progress(&self) -> f32 {
311 if self.duration.is_zero() {
312 return if self.status == Status::Finished {
313 1.0
314 } else {
315 0.0
316 };
317 }
318 (self.position.as_nanos() as f64 / self.duration.as_nanos() as f64) as f32
319 }
320
321 pub fn value(&self) -> T {
324 let t = self.progress();
325 let eased = self.ease.apply(if self.reversed { 1.0 - t } else { t });
326 if eased == 0.0 {
327 self.from
328 } else if eased == 1.0 {
329 self.to
330 } else {
331 T::interpolate(self.from, self.to, eased)
332 }
333 }
334
335 pub fn retarget(&mut self, to: T) {
339 self.from = self.value();
340 self.to = to;
341 self.rewind();
342 self.waited = self.delay;
343 }
344
345 controls!();
346}
347
348impl<T: Tweenable> Animate for Tween<T> {
349 fn step(&mut self, dt: Duration) -> Option<Duration> {
350 if self.paused || self.status != Status::Active {
351 return None;
352 }
353 let mut left = dt;
354 if self.waited < self.delay {
355 let wait = self.delay - self.waited;
356 if left < wait {
357 self.waited += left;
358 return None;
359 }
360 left -= wait;
361 self.waited = self.delay;
362 }
363 let period = self.duration.as_nanos();
365 let next = self.position.as_nanos() + left.as_nanos();
366 if self.mode == TweenMode::Once {
367 if next < period {
368 self.position = from_nanos(next);
369 return None;
370 }
371 self.skip_to_end();
372 return Some(from_nanos(next - period));
373 }
374 let crossed = next / period;
376 if let Some(cycles) = self.cycles {
377 let remaining = u128::from(cycles.saturating_sub(self.completed));
379 if crossed >= remaining {
380 self.skip_to_end();
381 return Some(from_nanos((next - remaining * period).min(left.as_nanos())));
382 }
383 }
384 self.completed = (u128::from(self.completed) + crossed).min(u128::from(u32::MAX)) as u32;
385 if self.mode == TweenMode::PingPong && crossed % 2 == 1 {
386 self.reversed = !self.reversed;
387 }
388 self.position = from_nanos(next % period);
389 None
390 }
391
392 fn rewind(&mut self) {
393 self.waited = Duration::ZERO;
394 self.position = Duration::ZERO;
395 self.completed = 0;
396 self.reversed = false;
397 self.status = Status::Active;
398 }
399
400 fn skip_to_end(&mut self) {
401 self.waited = self.delay;
402 self.position = self.duration;
403 (self.completed, self.reversed) = match (self.mode, self.cycles) {
404 (TweenMode::Once, _) => (1, false),
405 (mode, Some(cycles)) => (cycles, mode == TweenMode::PingPong && cycles % 2 == 0),
407 (_, None) => (self.completed.saturating_add(1), self.reversed),
409 };
410 self.status = Status::Finished;
411 }
412
413 fn is_done(&self) -> bool {
414 self.status != Status::Active
415 }
416}
417
418pub trait Tracks {
423 fn len(&self) -> usize;
425 fn is_empty(&self) -> bool {
427 self.len() == 0
428 }
429 fn track(&self, index: usize) -> &dyn Animate;
431 fn track_mut(&mut self, index: usize) -> &mut dyn Animate;
433}
434
435impl<A: Animate, const N: usize> Tracks for [A; N] {
436 fn len(&self) -> usize {
437 N
438 }
439 fn track(&self, index: usize) -> &dyn Animate {
440 &self[index]
441 }
442 fn track_mut(&mut self, index: usize) -> &mut dyn Animate {
443 &mut self[index]
444 }
445}
446
447impl<A: Animate> Tracks for Vec<A> {
448 fn len(&self) -> usize {
449 self.as_slice().len()
450 }
451 fn track(&self, index: usize) -> &dyn Animate {
452 &self[index]
453 }
454 fn track_mut(&mut self, index: usize) -> &mut dyn Animate {
455 &mut self[index]
456 }
457}
458
459macro_rules! tuple_tracks {
460 ($len:literal: $($name:ident $index:tt),+) => {
461 impl<$($name: Animate),+> Tracks for ($($name,)+) {
462 fn len(&self) -> usize {
463 $len
464 }
465 fn track(&self, index: usize) -> &dyn Animate {
466 match index {
467 $($index => &self.$index,)+
468 _ => panic!("track index {index} out of range for {} tracks", $len),
469 }
470 }
471 fn track_mut(&mut self, index: usize) -> &mut dyn Animate {
472 match index {
473 $($index => &mut self.$index,)+
474 _ => panic!("track index {index} out of range for {} tracks", $len),
475 }
476 }
477 }
478 };
479}
480tuple_tracks!(1: A 0);
481tuple_tracks!(2: A 0, B 1);
482tuple_tracks!(3: A 0, B 1, C 2);
483tuple_tracks!(4: A 0, B 1, C 2, D 3);
484tuple_tracks!(5: A 0, B 1, C 2, D 3, E 4);
485tuple_tracks!(6: A 0, B 1, C 2, D 3, E 4, F 5);
486tuple_tracks!(7: A 0, B 1, C 2, D 3, E 4, F 5, G 6);
487tuple_tracks!(8: A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
488
489#[derive(Clone, Debug)]
511pub struct Sequence<S> {
512 tracks: S,
513 current: usize,
514 id: TweenId,
515 paused: bool,
516 status: Status,
517}
518
519impl<S: Tracks> Sequence<S> {
520 pub fn new(tracks: S) -> Self {
522 Self {
523 tracks,
524 current: 0,
525 id: TweenId::default(),
526 paused: false,
527 status: Status::Active,
528 }
529 }
530 pub fn tracks(&self) -> &S {
532 &self.tracks
533 }
534 pub fn tracks_mut(&mut self) -> &mut S {
537 &mut self.tracks
538 }
539 pub fn current(&self) -> usize {
541 self.current
542 }
543
544 controls!();
545}
546
547impl<S: Tracks> Sequence<S> {
548 pub fn value<T: Tweenable>(&self) -> Option<T>
551 where
552 S: AsRef<[Tween<T>]>,
553 {
554 let tweens = self.tracks.as_ref();
555 tweens
556 .get(self.current.min(tweens.len().saturating_sub(1)))
557 .map(Tween::value)
558 }
559}
560
561impl<S: Tracks> Animate for Sequence<S> {
562 fn step(&mut self, dt: Duration) -> Option<Duration> {
563 if self.paused || self.status != Status::Active {
564 return None;
565 }
566 let mut left = dt;
567 while self.current < self.tracks.len() {
568 let track = self.tracks.track_mut(self.current);
569 if !track.is_done() {
570 left = track.step(left)?;
571 }
572 self.current += 1;
573 }
574 self.status = Status::Finished;
575 Some(left)
576 }
577
578 fn rewind(&mut self) {
579 for index in 0..self.tracks.len() {
580 self.tracks.track_mut(index).rewind();
581 }
582 self.current = 0;
583 self.status = Status::Active;
584 }
585
586 fn skip_to_end(&mut self) {
587 for index in 0..self.tracks.len() {
588 self.tracks.track_mut(index).skip_to_end();
589 }
590 self.current = self.tracks.len();
591 self.status = Status::Finished;
592 }
593
594 fn is_done(&self) -> bool {
595 self.status != Status::Active
596 }
597}
598
599#[derive(Clone, Debug)]
619pub struct Parallel<S> {
620 tracks: S,
621 id: TweenId,
622 paused: bool,
623 status: Status,
624}
625
626impl<S: Tracks> Parallel<S> {
627 pub fn new(tracks: S) -> Self {
629 Self {
630 tracks,
631 id: TweenId::default(),
632 paused: false,
633 status: Status::Active,
634 }
635 }
636 pub fn tracks(&self) -> &S {
638 &self.tracks
639 }
640 pub fn tracks_mut(&mut self) -> &mut S {
643 &mut self.tracks
644 }
645
646 controls!();
647}
648
649impl<S: Tracks> Animate for Parallel<S> {
650 fn step(&mut self, dt: Duration) -> Option<Duration> {
651 if self.paused || self.status != Status::Active {
652 return None;
653 }
654 let mut left = dt;
656 let mut done = true;
657 for index in 0..self.tracks.len() {
658 let track = self.tracks.track_mut(index);
659 if track.is_done() {
660 continue;
661 }
662 match track.step(dt) {
663 Some(rest) => left = left.min(rest),
664 None => done &= track.is_done(),
665 }
666 }
667 if !done {
668 return None;
669 }
670 self.status = Status::Finished;
671 Some(left)
672 }
673
674 fn rewind(&mut self) {
675 for index in 0..self.tracks.len() {
676 self.tracks.track_mut(index).rewind();
677 }
678 self.status = Status::Active;
679 }
680
681 fn skip_to_end(&mut self) {
682 for index in 0..self.tracks.len() {
683 self.tracks.track_mut(index).skip_to_end();
684 }
685 self.status = Status::Finished;
686 }
687
688 fn is_done(&self) -> bool {
689 self.status != Status::Active
690 }
691}
692
693#[cfg(test)]
694mod tests;