hikari-animation 0.2.0

Animation hooks, easing functions and transition utilities for the Hikari design system
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Animation engine for managing multiple tweens

use std::cell::RefCell;
use std::rc::Rc;
use std::time::Duration;

use slotmap::SlotMap;

use super::{AnimationOptions, AnimationState, Tween, TweenId};

#[derive(Clone)]
pub struct AnimationEngine {
    pub tweens: Rc<RefCell<SlotMap<TweenId, Tween>>>,
}

impl Default for AnimationEngine {
    fn default() -> Self {
        Self::new()
    }
}

impl AnimationEngine {
    pub fn new() -> Self {
        Self {
            tweens: Rc::new(RefCell::new(SlotMap::with_key())),
        }
    }

    pub fn create_tween(&self, options: AnimationOptions) -> TweenId {
        let mut tweens = self.tweens.borrow_mut();
        let temp_tween = Tween::new_for_engine(options);
        tweens.insert(temp_tween)
    }

    pub fn get_tween(&self, id: TweenId) -> Option<Tween> {
        self.tweens.borrow().get(id).cloned()
    }

    pub fn with_tween_mut<F, R>(&self, id: TweenId, f: F) -> Option<R>
    where
        F: FnOnce(&mut Tween) -> R,
    {
        let mut tweens = self.tweens.borrow_mut();
        tweens.get_mut(id).map(f)
    }

    pub fn remove_tween(&self, id: TweenId) -> bool {
        let mut tweens = self.tweens.borrow_mut();
        tweens.remove(id).is_some()
    }

    pub fn play(&self, id: TweenId) {
        self.with_tween_mut(id, |tween| {
            tween.play();
        });
    }

    pub fn pause(&self, id: TweenId) {
        self.with_tween_mut(id, |tween| {
            tween.pause();
        });
    }

    pub fn reverse(&self, id: TweenId) {
        self.with_tween_mut(id, |tween| {
            tween.reverse();
        });
    }

    pub fn restart(&self, id: TweenId) {
        self.with_tween_mut(id, |tween| {
            tween.restart();
        });
    }

    pub fn seek(&self, id: TweenId, time: Duration) {
        self.with_tween_mut(id, |tween| {
            tween.seek(time);
        });
    }

    pub fn kill(&self, id: TweenId) {
        self.remove_tween(id);
    }

    pub fn kill_all(&self) {
        self.tweens.borrow_mut().clear();
    }

    pub fn is_active(&self, id: TweenId) -> bool {
        if let Some(tween) = self.get_tween(id) {
            tween.state() == AnimationState::Running
        } else {
            false
        }
    }

    pub fn get_all_active(&self) -> Vec<TweenId> {
        self.tweens
            .borrow()
            .iter()
            .filter(|(_, tween)| tween.state() == AnimationState::Running)
            .map(|(id, _)| id)
            .collect()
    }

    pub fn get_all_ids(&self) -> Vec<TweenId> {
        self.tweens.borrow().iter().map(|(id, _)| id).collect()
    }

    pub fn tween_state(&self, id: TweenId) -> Option<AnimationState> {
        self.tweens.borrow().get(id).map(|t| t.state())
    }

    pub fn seek_to_progress(&self, id: TweenId, progress: f64) {
        let progress = progress.clamp(0.0, 1.0);
        self.with_tween_mut(id, |tween| {
            let dur = tween.duration();
            tween.seek(Duration::from_secs_f64(dur.as_secs_f64() * progress));
        });
    }

    pub fn tick(&self, delta: Duration) {
        let tweens = self.tweens.borrow();
        let active_tweens: Vec<TweenId> = tweens
            .iter()
            .filter(|(_, tween)| tween.state() == AnimationState::Running)
            .map(|(id, _)| id)
            .collect();
        drop(tweens);

        for id in active_tweens {
            self.with_tween_mut(id, |tween| {
                tween.advance(delta);
            });
        }
    }
}