mirror of
https://github.com/italicsjenga/winit-sonoma-fix.git
synced 2024-12-23 22:01:31 +11:00
ae7497e18f
The idea that redraw events are dispatched with a specific ordering that makes it possible to specifically report when we have finished dispatching redraw events isn't portable and the way in which we dispatched RedrawEventsCleared was inconsistent across backends. More generally speaking, there is no inherent relationship between redrawing and event loop iterations. An event loop may wake up at any frequency depending on what sources of input events are being listened to but redrawing is generally throttled and in some way synchronized with the display frequency. Similarly there's no inherent relationship between a single event loop iteration and the dispatching of any specific kind of "main" event. An event loop wakes up when there are events to read (e.g. input events or responses from a display server / compositor) and goes back to waiting when there's nothing else to read. There isn't really a special kind of "main" event that is dispatched in order with respect to other events. What we can do more portably is emit an event when the event loop is about to block and wait for new events. In practice this is very similar to how MainEventsCleared was implemented except it wasn't the very last event previously since redraw events could be dispatched afterwards. The main backend where we don't strictly know when we're going to wait for events is Web (since the real event loop is internal to the browser). For now we emulate AboutToWait on Web similar to how MainEventsCleared was dispatched. In practice most applications almost certainly shouldn't care about AboutToWait because the frequency of event loop iterations is essentially arbitrary and usually irrelevant.
127 lines
4.1 KiB
Rust
127 lines
4.1 KiB
Rust
#![allow(clippy::single_match)]
|
|
|
|
use std::thread;
|
|
#[cfg(not(wasm_platform))]
|
|
use std::time;
|
|
#[cfg(wasm_platform)]
|
|
use web_time as time;
|
|
|
|
use simple_logger::SimpleLogger;
|
|
use winit::{
|
|
event::{ElementState, Event, KeyEvent, WindowEvent},
|
|
event_loop::EventLoop,
|
|
keyboard::Key,
|
|
window::WindowBuilder,
|
|
};
|
|
|
|
#[path = "util/fill.rs"]
|
|
mod fill;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum Mode {
|
|
Wait,
|
|
WaitUntil,
|
|
Poll,
|
|
}
|
|
|
|
const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
|
|
const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);
|
|
|
|
fn main() -> Result<(), impl std::error::Error> {
|
|
SimpleLogger::new().init().unwrap();
|
|
|
|
println!("Press '1' to switch to Wait mode.");
|
|
println!("Press '2' to switch to WaitUntil mode.");
|
|
println!("Press '3' to switch to Poll mode.");
|
|
println!("Press 'R' to toggle request_redraw() calls.");
|
|
println!("Press 'Esc' to close the window.");
|
|
|
|
let event_loop = EventLoop::new();
|
|
let window = WindowBuilder::new()
|
|
.with_title("Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.")
|
|
.build(&event_loop)
|
|
.unwrap();
|
|
|
|
let mut mode = Mode::Wait;
|
|
let mut request_redraw = false;
|
|
let mut wait_cancelled = false;
|
|
let mut close_requested = false;
|
|
|
|
event_loop.run(move |event, _, control_flow| {
|
|
use winit::event::StartCause;
|
|
println!("{event:?}");
|
|
match event {
|
|
Event::NewEvents(start_cause) => {
|
|
wait_cancelled = match start_cause {
|
|
StartCause::WaitCancelled { .. } => mode == Mode::WaitUntil,
|
|
_ => false,
|
|
}
|
|
}
|
|
Event::WindowEvent { event, .. } => match event {
|
|
WindowEvent::CloseRequested => {
|
|
close_requested = true;
|
|
}
|
|
WindowEvent::KeyboardInput {
|
|
event:
|
|
KeyEvent {
|
|
logical_key: key,
|
|
state: ElementState::Pressed,
|
|
..
|
|
},
|
|
..
|
|
} => match key.as_ref() {
|
|
// WARNING: Consider using `key_without_modifers()` if available on your platform.
|
|
// See the `key_binding` example
|
|
Key::Character("1") => {
|
|
mode = Mode::Wait;
|
|
println!("\nmode: {mode:?}\n");
|
|
}
|
|
Key::Character("2") => {
|
|
mode = Mode::WaitUntil;
|
|
println!("\nmode: {mode:?}\n");
|
|
}
|
|
Key::Character("3") => {
|
|
mode = Mode::Poll;
|
|
println!("\nmode: {mode:?}\n");
|
|
}
|
|
Key::Character("r") => {
|
|
request_redraw = !request_redraw;
|
|
println!("\nrequest_redraw: {request_redraw}\n");
|
|
}
|
|
Key::Escape => {
|
|
close_requested = true;
|
|
}
|
|
_ => (),
|
|
},
|
|
_ => (),
|
|
},
|
|
Event::AboutToWait => {
|
|
if request_redraw && !wait_cancelled && !close_requested {
|
|
window.request_redraw();
|
|
}
|
|
|
|
match mode {
|
|
Mode::Wait => control_flow.set_wait(),
|
|
Mode::WaitUntil => {
|
|
if !wait_cancelled {
|
|
control_flow.set_wait_until(time::Instant::now() + WAIT_TIME);
|
|
}
|
|
}
|
|
Mode::Poll => {
|
|
thread::sleep(POLL_SLEEP_TIME);
|
|
control_flow.set_poll();
|
|
}
|
|
};
|
|
|
|
if close_requested {
|
|
control_flow.set_exit();
|
|
}
|
|
}
|
|
Event::RedrawRequested(_window_id) => {
|
|
fill::fill_window(&window);
|
|
}
|
|
_ => (),
|
|
}
|
|
})
|
|
}
|