ready-paint 0.2.2

A simple ready-paint schema using wgpu and winit.
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
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

/// this file contain update logic and winit things to boot up a window before Gfx
use crate::NiceViewScene;
use ready_paint::{
    gfx::{Gfx, LimitFPS},
    Render, RenderEntry,
};
use std::{ops::Add, sync::Arc};
use winit::{application::ApplicationHandler, dpi::PhysicalSize, window::Window};
pub async fn run() {
    let event_loop = winit::event_loop::EventLoop::new().unwrap();
    event_loop.set_control_flow(winit::event_loop::ControlFlow::Poll);
    let mut app = App::default();
    let _ = event_loop.run_app(&mut app);
}

#[derive(Default)]
pub struct App {
    pub window: Option<Arc<Window>>,
    pub render: Render,
    pub first_resize: bool,
}

impl ApplicationHandler for App {
    fn about_to_wait(&mut self, _: &winit::event_loop::ActiveEventLoop) {
        if let RenderEntry::Ready(ref mut gfx) = self.render.entry {
            let now =ready_paint::time::now();
            #[cfg(not(target_arch = "wasm32"))]
            {
                let delta_time = now - gfx.last_update;
                let time = *gfx.time.lock().unwrap() + delta_time.as_secs_f32();
                if let LimitFPS::Limit(fps) = gfx.limit_fps {
                    let frame_duration = std::time::Duration::from_secs_f32(1.0 / fps as f32);
                    if delta_time < frame_duration {
                        spin_sleep::sleep(frame_duration - delta_time);
                    }
                    gfx.last_update = ready_paint::time::now();
                    *gfx.time.lock().unwrap() = time;
                    let real_delta = gfx.last_update - now;
                    gfx.delta_time = real_delta.as_secs_f32();
                    self.window.as_ref().unwrap().request_redraw();
                }
            }
            #[cfg(target_arch = "wasm32")]
            {
                let delta_time = now - gfx.last_update;
                let time = *gfx.time.lock().unwrap() + delta_time as f32;
                if let LimitFPS::Limit(fps) = gfx.limit_fps {
                    let frame_duration = std::time::Duration::from_secs_f32(1.0 / fps as f32);
                    if delta_time < frame_duration.as_secs_f32() {
                        #[cfg(not(target_arch = "wasm32"))]
                        spin_sleep::sleep(frame_duration - delta_time);
                        #[cfg(target_arch = "wasm32")]
                        wasm_bindgen_futures::spawn_local(async move {
                            wasm_timer::Delay::new(frame_duration).await.unwrap();
                        });
                    }
                    gfx.last_update = ready_paint::time::now();
                    *gfx.time.lock().unwrap() = time;
                    let real_delta = gfx.last_update - now;
                    gfx.delta_time = real_delta;
                    self.window.as_ref().unwrap().request_redraw();
                }
            }
        }
    }
    fn window_event(
        &mut self,
        event_loop: &winit::event_loop::ActiveEventLoop,
        _: winit::window::WindowId,
        event: winit::event::WindowEvent,
    ) {
        match event {
            winit::event::WindowEvent::Resized(size) => {
                println!("winit event: resized");
                let PhysicalSize { width, height } = size;
                match self.render.entry {
                    RenderEntry::Ready(ref mut gfx) => {
                        gfx.resize(width, height);
                        if self.first_resize {
                            self.first_resize = false;
                            return;
                        }
                        println!("resize ready");
                        self.render.ready();
                        self.window.as_ref().unwrap().request_redraw();
                    }
                    _ => {
                        println!("resize not ready");
                    }
                }
            }
            winit::event::WindowEvent::CloseRequested => {
                println!("The close button was pressed; stopping");
                event_loop.exit();
            }
            winit::event::WindowEvent::RedrawRequested => {
                if let RenderEntry::Ready(ref mut gfx) = self.render.entry {
                    if gfx.surface_config.is_some() {
                        self.render.paint();
                    }
                }
            }
            _ => (),
        }
    }
    fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
        if let RenderEntry::NotReady = self.render.entry {
            let window = event_loop
                .create_window(
                    winit::window::Window::default_attributes().with_title("nice_view".to_string()),
                )
                .unwrap();
            let main_owner_window = Arc::new(window);
            self.window = Some(main_owner_window.clone());
            let gfx = pollster::block_on(async move {
                println!("in async: Loading");
                let gfx = Gfx::new(main_owner_window.clone()).await;
                println!("in async: Ready");
                return gfx;
            });
            self.render.entry = RenderEntry::Ready(gfx);
            self.render.add_scene::<NiceViewScene>("check");
            self.first_resize = true;
        }
    }
}