pub mod ease;
mod shake;
pub use ease::Ease;
pub use shake::{Shake, ShakeConfig, ShakeError, ShakeSample};
use glam::{Quat, Vec2, Vec3, Vec4};
use std::time::Duration;
pub trait Tweenable: Copy {
fn interpolate(from: Self, to: Self, t: f32) -> Self;
}
impl Tweenable for f32 {
fn interpolate(from: Self, to: Self, t: f32) -> Self {
from + (to - from) * t
}
}
impl Tweenable for Vec2 {
fn interpolate(from: Self, to: Self, t: f32) -> Self {
from.lerp(to, t)
}
}
impl Tweenable for Vec3 {
fn interpolate(from: Self, to: Self, t: f32) -> Self {
from.lerp(to, t)
}
}
impl Tweenable for Vec4 {
fn interpolate(from: Self, to: Self, t: f32) -> Self {
from.lerp(to, t)
}
}
impl Tweenable for Quat {
fn interpolate(from: Self, to: Self, t: f32) -> Self {
from.slerp(to, t)
}
}
impl Tweenable for [u8; 4] {
fn interpolate(from: Self, to: Self, t: f32) -> Self {
std::array::from_fn(|i| {
let (a, b) = (f32::from(from[i]), f32::from(to[i]));
(a + (b - a) * t).round().clamp(0.0, 255.0) as u8
})
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct TweenId(pub u32);
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct TweenCompleted {
pub id: TweenId,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum TweenMode {
#[default]
Once,
Loop,
PingPong,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Status {
Active,
Finished,
Cancelled,
}
pub trait Animate {
fn step(&mut self, dt: Duration) -> Option<Duration>;
fn rewind(&mut self);
fn skip_to_end(&mut self);
fn is_done(&self) -> bool;
}
macro_rules! controls {
() => {
pub fn advance(&mut self, dt: Duration) -> Option<TweenCompleted> {
self.step(dt).map(|_| TweenCompleted { id: self.id })
}
pub fn with_id(mut self, id: TweenId) -> Self {
self.id = id;
self
}
pub fn id(&self) -> TweenId {
self.id
}
pub fn pause(&mut self) {
self.paused = true;
}
pub fn resume(&mut self) {
self.paused = false;
}
pub fn is_paused(&self) -> bool {
self.paused
}
pub fn reset(&mut self) {
self.rewind();
}
pub fn cancel(&mut self) {
if self.status == Status::Active {
self.status = Status::Cancelled;
}
}
pub fn finish(&mut self) -> Option<TweenCompleted> {
if self.status != Status::Active {
return None;
}
self.skip_to_end();
Some(TweenCompleted { id: self.id })
}
pub fn is_finished(&self) -> bool {
self.status == Status::Finished
}
pub fn is_cancelled(&self) -> bool {
self.status == Status::Cancelled
}
};
}
fn from_nanos(nanos: u128) -> Duration {
Duration::new(
(nanos / 1_000_000_000) as u64,
(nanos % 1_000_000_000) as u32,
)
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Tween<T> {
from: T,
to: T,
duration: Duration,
delay: Duration,
ease: Ease,
mode: TweenMode,
cycles: Option<u32>,
id: TweenId,
waited: Duration,
position: Duration,
completed: u32,
reversed: bool,
paused: bool,
status: Status,
}
impl<T: Tweenable> Tween<T> {
pub fn new(from: T, to: T, duration: Duration) -> Self {
Self {
from,
to,
duration,
delay: Duration::ZERO,
ease: Ease::Linear,
mode: TweenMode::Once,
cycles: None,
id: TweenId::default(),
waited: Duration::ZERO,
position: Duration::ZERO,
completed: 0,
reversed: false,
paused: false,
status: Status::Active,
}
}
pub fn with_delay(mut self, delay: Duration) -> Self {
let started = self.waited >= self.delay
&& (!self.position.is_zero() || self.completed > 0 || self.status != Status::Active);
self.delay = delay;
if started {
self.waited = delay;
}
self
}
pub fn with_ease(mut self, ease: Ease) -> Self {
self.ease = ease;
self
}
pub fn with_mode(mut self, mode: TweenMode) -> Self {
assert!(
mode == TweenMode::Once || !self.duration.is_zero(),
"repeating tween duration must be nonzero"
);
self.mode = mode;
self.reversed &= mode == TweenMode::PingPong;
self
}
pub fn with_cycles(mut self, cycles: u32) -> Self {
assert!(cycles > 0, "tween cycle count must be positive");
self.cycles = Some(cycles);
self
}
pub fn from(&self) -> T {
self.from
}
pub fn to(&self) -> T {
self.to
}
pub fn duration(&self) -> Duration {
self.duration
}
pub fn delay(&self) -> Duration {
self.delay
}
pub fn ease(&self) -> Ease {
self.ease
}
pub fn mode(&self) -> TweenMode {
self.mode
}
pub fn completed_cycles(&self) -> u32 {
self.completed
}
pub fn progress(&self) -> f32 {
if self.duration.is_zero() {
return if self.status == Status::Finished {
1.0
} else {
0.0
};
}
(self.position.as_nanos() as f64 / self.duration.as_nanos() as f64) as f32
}
pub fn value(&self) -> T {
let t = self.progress();
let eased = self.ease.apply(if self.reversed { 1.0 - t } else { t });
if eased == 0.0 {
self.from
} else if eased == 1.0 {
self.to
} else {
T::interpolate(self.from, self.to, eased)
}
}
pub fn retarget(&mut self, to: T) {
self.from = self.value();
self.to = to;
self.rewind();
self.waited = self.delay;
}
controls!();
}
impl<T: Tweenable> Animate for Tween<T> {
fn step(&mut self, dt: Duration) -> Option<Duration> {
if self.paused || self.status != Status::Active {
return None;
}
let mut left = dt;
if self.waited < self.delay {
let wait = self.delay - self.waited;
if left < wait {
self.waited += left;
return None;
}
left -= wait;
self.waited = self.delay;
}
let period = self.duration.as_nanos();
let next = self.position.as_nanos() + left.as_nanos();
if self.mode == TweenMode::Once {
if next < period {
self.position = from_nanos(next);
return None;
}
self.skip_to_end();
return Some(from_nanos(next - period));
}
let crossed = next / period;
if let Some(cycles) = self.cycles {
let remaining = u128::from(cycles.saturating_sub(self.completed));
if crossed >= remaining {
self.skip_to_end();
return Some(from_nanos((next - remaining * period).min(left.as_nanos())));
}
}
self.completed = (u128::from(self.completed) + crossed).min(u128::from(u32::MAX)) as u32;
if self.mode == TweenMode::PingPong && crossed % 2 == 1 {
self.reversed = !self.reversed;
}
self.position = from_nanos(next % period);
None
}
fn rewind(&mut self) {
self.waited = Duration::ZERO;
self.position = Duration::ZERO;
self.completed = 0;
self.reversed = false;
self.status = Status::Active;
}
fn skip_to_end(&mut self) {
self.waited = self.delay;
self.position = self.duration;
(self.completed, self.reversed) = match (self.mode, self.cycles) {
(TweenMode::Once, _) => (1, false),
(mode, Some(cycles)) => (cycles, mode == TweenMode::PingPong && cycles % 2 == 0),
(_, None) => (self.completed.saturating_add(1), self.reversed),
};
self.status = Status::Finished;
}
fn is_done(&self) -> bool {
self.status != Status::Active
}
}
pub trait Tracks {
fn len(&self) -> usize;
fn is_empty(&self) -> bool {
self.len() == 0
}
fn track(&self, index: usize) -> &dyn Animate;
fn track_mut(&mut self, index: usize) -> &mut dyn Animate;
}
impl<A: Animate, const N: usize> Tracks for [A; N] {
fn len(&self) -> usize {
N
}
fn track(&self, index: usize) -> &dyn Animate {
&self[index]
}
fn track_mut(&mut self, index: usize) -> &mut dyn Animate {
&mut self[index]
}
}
impl<A: Animate> Tracks for Vec<A> {
fn len(&self) -> usize {
self.as_slice().len()
}
fn track(&self, index: usize) -> &dyn Animate {
&self[index]
}
fn track_mut(&mut self, index: usize) -> &mut dyn Animate {
&mut self[index]
}
}
macro_rules! tuple_tracks {
($len:literal: $($name:ident $index:tt),+) => {
impl<$($name: Animate),+> Tracks for ($($name,)+) {
fn len(&self) -> usize {
$len
}
fn track(&self, index: usize) -> &dyn Animate {
match index {
$($index => &self.$index,)+
_ => panic!("track index {index} out of range for {} tracks", $len),
}
}
fn track_mut(&mut self, index: usize) -> &mut dyn Animate {
match index {
$($index => &mut self.$index,)+
_ => panic!("track index {index} out of range for {} tracks", $len),
}
}
}
};
}
tuple_tracks!(1: A 0);
tuple_tracks!(2: A 0, B 1);
tuple_tracks!(3: A 0, B 1, C 2);
tuple_tracks!(4: A 0, B 1, C 2, D 3);
tuple_tracks!(5: A 0, B 1, C 2, D 3, E 4);
tuple_tracks!(6: A 0, B 1, C 2, D 3, E 4, F 5);
tuple_tracks!(7: A 0, B 1, C 2, D 3, E 4, F 5, G 6);
tuple_tracks!(8: A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
#[derive(Clone, Debug)]
pub struct Sequence<S> {
tracks: S,
current: usize,
id: TweenId,
paused: bool,
status: Status,
}
impl<S: Tracks> Sequence<S> {
pub fn new(tracks: S) -> Self {
Self {
tracks,
current: 0,
id: TweenId::default(),
paused: false,
status: Status::Active,
}
}
pub fn tracks(&self) -> &S {
&self.tracks
}
pub fn tracks_mut(&mut self) -> &mut S {
&mut self.tracks
}
pub fn current(&self) -> usize {
self.current
}
controls!();
}
impl<S: Tracks> Sequence<S> {
pub fn value<T: Tweenable>(&self) -> Option<T>
where
S: AsRef<[Tween<T>]>,
{
let tweens = self.tracks.as_ref();
tweens
.get(self.current.min(tweens.len().saturating_sub(1)))
.map(Tween::value)
}
}
impl<S: Tracks> Animate for Sequence<S> {
fn step(&mut self, dt: Duration) -> Option<Duration> {
if self.paused || self.status != Status::Active {
return None;
}
let mut left = dt;
while self.current < self.tracks.len() {
let track = self.tracks.track_mut(self.current);
if !track.is_done() {
left = track.step(left)?;
}
self.current += 1;
}
self.status = Status::Finished;
Some(left)
}
fn rewind(&mut self) {
for index in 0..self.tracks.len() {
self.tracks.track_mut(index).rewind();
}
self.current = 0;
self.status = Status::Active;
}
fn skip_to_end(&mut self) {
for index in 0..self.tracks.len() {
self.tracks.track_mut(index).skip_to_end();
}
self.current = self.tracks.len();
self.status = Status::Finished;
}
fn is_done(&self) -> bool {
self.status != Status::Active
}
}
#[derive(Clone, Debug)]
pub struct Parallel<S> {
tracks: S,
id: TweenId,
paused: bool,
status: Status,
}
impl<S: Tracks> Parallel<S> {
pub fn new(tracks: S) -> Self {
Self {
tracks,
id: TweenId::default(),
paused: false,
status: Status::Active,
}
}
pub fn tracks(&self) -> &S {
&self.tracks
}
pub fn tracks_mut(&mut self) -> &mut S {
&mut self.tracks
}
controls!();
}
impl<S: Tracks> Animate for Parallel<S> {
fn step(&mut self, dt: Duration) -> Option<Duration> {
if self.paused || self.status != Status::Active {
return None;
}
let mut left = dt;
let mut done = true;
for index in 0..self.tracks.len() {
let track = self.tracks.track_mut(index);
if track.is_done() {
continue;
}
match track.step(dt) {
Some(rest) => left = left.min(rest),
None => done &= track.is_done(),
}
}
if !done {
return None;
}
self.status = Status::Finished;
Some(left)
}
fn rewind(&mut self) {
for index in 0..self.tracks.len() {
self.tracks.track_mut(index).rewind();
}
self.status = Status::Active;
}
fn skip_to_end(&mut self) {
for index in 0..self.tracks.len() {
self.tracks.track_mut(index).skip_to_end();
}
self.status = Status::Finished;
}
fn is_done(&self) -> bool {
self.status != Status::Active
}
}
#[cfg(test)]
mod tests;