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

use super::*;

mod empty;

pub use empty::*;

pub trait ProgressScreen: State {
    fn update_progress(&mut self, progress: f64) {
        #![allow(unused_variables)]
    }
}

impl ProgressScreen for EmptyState {}

pub struct LoadingScreen<T: 'static, L, G>
where
    L: ProgressScreen,
    G: State,
{
    future: Pin<Box<dyn Future<Output = T>>>,
    f: Option<Box<dyn FnOnce(T) -> G>>,
    state: L,
}

impl<T, L, G> LoadingScreen<T, L, G>
where
    L: ProgressScreen,
    G: State,
{
    pub fn new<F: FnOnce(T) -> G + 'static>(
        #[allow(unused_variables)] geng: &Rc<Geng>,
        state: L,
        future: impl Future<Output = T> + 'static,
        f: F,
    ) -> Self {
        LoadingScreen {
            future: future.boxed_local(),
            f: Some(Box::new(f)),
            state,
        }
    }
}

impl<T, L, G> State for LoadingScreen<T, L, G>
where
    L: ProgressScreen,
    G: State,
{
    fn update(&mut self, delta_time: f64) {
        self.state.update(delta_time);
        // TODO: state.update_progress(future.progress().unwrap());
    }
    fn draw(&mut self, framebuffer: &mut ugli::Framebuffer) {
        self.state.draw(framebuffer);
    }
    fn handle_event(&mut self, event: Event) {
        self.state.handle_event(event);
    }
    fn transition(&mut self) -> Option<Transition> {
        if self.f.is_some() {
            if let std::task::Poll::Ready(assets) =
                self.future
                    .as_mut()
                    .poll(&mut std::task::Context::from_waker(
                        futures::task::noop_waker_ref(),
                    ))
            {
                let state = (self.f.take().unwrap())(assets);
                return Some(Transition::Switch(Box::new(state)));
            }
        }
        None
    }
}