looper 0.0.2

A fixed step loop
Documentation 
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

use std::thread;
use std::time;

pub struct Realtime {
    acc: time::Duration,
    curr: time::Instant,
    iter: RealtimeIter,
}

impl Realtime {
    pub fn new(fps: f32) -> Self {
        let step = time::Duration::new(0, (1.0 / fps * 1_000_000_000.0) as u32);

        Realtime {
            acc: time::Duration::new(0, 0),
            curr: time::Instant::now(),
            iter: RealtimeIter::new(step),
        }
    }

    pub fn acc(&mut self, acc: time::Duration) {
        self.acc = acc
    }

    pub fn tick(&mut self) -> RealtimeIter {
        let now = time::Instant::now();
        self.acc += now - self.curr;
        self.curr = now;
        self.iter.set(self.acc);
        self.iter.clone()
    }
}

#[derive(Clone)] // TODO remove
pub struct RealtimeIter {
    acc: time::Duration,
    step: time::Duration,
    update: bool,
}

impl RealtimeIter {
    pub fn new(step: time::Duration) -> Self {
        RealtimeIter {
            acc: time::Duration::new(0, 0),
            step: step,
            update: true,
        }
    }

    pub fn set(&mut self, acc: time::Duration) {
        self.acc = acc;
    }
}

impl Iterator for RealtimeIter {
    type Item = time::Duration;

    fn next(&mut self) -> Option<time::Duration> {
        while self.acc >= self.step {
            self.acc -= self.step;
            return Some(self.acc);
        }

        thread::sleep(self.step - self.acc);
        None
    }
}