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
pub(crate) mod clocks;
mod handle;
mod time;
pub use handle::*;
pub use time::*;
use std::sync::{
atomic::{AtomicBool, AtomicU64, Ordering},
Arc,
};
use atomic_arena::Key;
use crate::{
tween::{Tween, Tweener},
ClockSpeed,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ClockId(pub(crate) Key);
pub(crate) struct ClockShared {
ticking: AtomicBool,
ticks: AtomicU64,
removed: AtomicBool,
}
impl ClockShared {
pub fn new() -> Self {
Self {
ticking: AtomicBool::new(false),
ticks: AtomicU64::new(0),
removed: AtomicBool::new(false),
}
}
pub fn ticking(&self) -> bool {
self.ticking.load(Ordering::SeqCst)
}
pub fn ticks(&self) -> u64 {
self.ticks.load(Ordering::SeqCst)
}
pub fn is_marked_for_removal(&self) -> bool {
self.removed.load(Ordering::SeqCst)
}
pub fn mark_for_removal(&self) {
self.removed.store(true, Ordering::SeqCst);
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
enum State {
NotStarted,
Started { ticks: u64, tick_timer: f64 },
}
pub(crate) struct Clock {
shared: Arc<ClockShared>,
ticking: bool,
speed: Tweener<ClockSpeed>,
state: State,
}
impl Clock {
pub(crate) fn new(speed: ClockSpeed) -> Self {
Self {
shared: Arc::new(ClockShared::new()),
ticking: false,
speed: Tweener::new(speed),
state: State::NotStarted,
}
}
pub(crate) fn shared(&self) -> Arc<ClockShared> {
self.shared.clone()
}
pub(crate) fn set_speed(&mut self, speed: ClockSpeed, tween: Tween) {
self.speed.set(speed, tween);
}
pub(crate) fn start(&mut self) {
self.ticking = true;
self.shared.ticking.store(true, Ordering::SeqCst);
}
pub(crate) fn pause(&mut self) {
self.ticking = false;
self.shared.ticking.store(false, Ordering::SeqCst);
}
pub(crate) fn stop(&mut self) {
self.pause();
self.state = State::NotStarted;
self.shared.ticks.store(0, Ordering::SeqCst);
}
pub(crate) fn update(&mut self, dt: f64) -> Option<u64> {
self.speed.update(dt);
if !self.ticking {
return None;
}
let mut new_tick_count = None;
if self.state == State::NotStarted {
self.state = State::Started {
ticks: 0,
tick_timer: 1.0,
};
new_tick_count = Some(0);
}
if let State::Started { ticks, tick_timer } = &mut self.state {
*tick_timer -= self.speed.value().as_ticks_per_second() * dt;
while *tick_timer <= 0.0 {
*tick_timer += 1.0;
*ticks += 1;
new_tick_count = Some(*ticks);
}
} else {
panic!("clock state should be Started by now");
}
if let Some(new_tick_count) = new_tick_count {
self.shared.ticks.store(new_tick_count, Ordering::SeqCst);
}
new_tick_count
}
pub(crate) fn on_clock_tick(&mut self, time: ClockTime) {
self.speed.on_clock_tick(time);
}
}
