main_loop 0.3.3

main loop for real time applications
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

use std::ptr;
use std::cell::RefCell;
use std::os::raw::{c_int, c_void};

use super::super::{now, ControlFlow};

extern "C" {
    fn emscripten_set_main_loop(
        func: unsafe extern "C" fn(),
        fps: c_int,
        simulate_infinite_loop: c_int,
    );
    fn emscripten_resume_main_loop();
    fn emscripten_pause_main_loop();
}

thread_local!(
    static MAIN_LOOP_CALLBACK: RefCell<*mut c_void> = RefCell::new(ptr::null_mut());
    static MAIN_MS: RefCell<f64> = RefCell::new(0.0);
);

unsafe extern "C" fn callback_wrapper<F>()
where
    F: FnMut(f64),
{
    MAIN_LOOP_CALLBACK.with(|ref_cell| {
        let closure = *ref_cell.borrow_mut() as *mut F;
        let ms = now() - MAIN_MS.with(|ref_cell| *ref_cell.borrow());
        (*closure)(ms);
    });
}

#[inline]
fn set_callback_loop<F>(callback: F)
where
    F: FnMut(f64),
{
    MAIN_LOOP_CALLBACK.with(|ref_cell| {
        *ref_cell.borrow_mut() = &callback as *const _ as *mut c_void;
    });

    unsafe {
        emscripten_set_main_loop(callback_wrapper::<F>, 0, 1);
        emscripten_pause_main_loop();
    }
}

#[inline(always)]
fn pause_loop() {
    unsafe {
        emscripten_pause_main_loop();
    }
}

#[inline(always)]
pub fn set_target_fps(_: f64) {}

#[inline(always)]
pub fn target_fps() -> f64 {
    1000.0 / 60.0
}

#[inline]
pub fn run<F>(mut callback: F)
where
    F: FnMut(f64) -> ControlFlow,
{
    set_callback_loop(move |ms| match callback(ms) {
        ControlFlow::Break => pause_loop(),
        ControlFlow::Continue => (),
    });
    MAIN_MS.with(|ref_cell| {
        *ref_cell.borrow_mut() = now();
    });
    unsafe {
        emscripten_resume_main_loop();
    }
}