Add resource to control winit runner

Author: B-head

crates/bevy_winit/src/lib.rs

@@ -13,6 +13,7 @@ mod system;
 #[cfg(target_arch = "wasm32")]
 mod web_resize;
 mod winit_config;
+mod winit_handler;
 mod winit_windows;
 
 use bevy_a11y::AccessibilityRequested;
@@ -22,6 +23,7 @@ use bevy_tasks::tick_global_task_pools_on_main_thread;
 use system::{changed_window, create_window, despawn_window, CachedWindow};
 
 pub use winit_config::*;
+pub use winit_handler::*;
 pub use winit_windows::*;
 
 use bevy_app::{App, AppExit, Last, Plugin};
@@ -75,7 +77,7 @@ pub struct WinitPlugin;
 
 impl Plugin for WinitPlugin {
     fn build(&self, app: &mut App) {
-        let mut event_loop_builder = EventLoopBuilder::<()>::with_user_event();
+        let mut event_loop_builder = EventLoopBuilder::<HandleEvent>::with_user_event();
 
         #[cfg(target_os = "android")]
         {
@@ -113,7 +115,7 @@ impl Plugin for WinitPlugin {
         #[cfg(not(target_arch = "wasm32"))]
         let mut create_window_system_state: SystemState<(
             Commands,
-            NonSendMut<EventLoop<()>>,
+            NonSendMut<EventLoop<HandleEvent>>,
             Query<(Entity, &mut Window)>,
             EventWriter<WindowCreated>,
             NonSendMut<WinitWindows>,
@@ -125,7 +127,7 @@ impl Plugin for WinitPlugin {
         #[cfg(target_arch = "wasm32")]
         let mut create_window_system_state: SystemState<(
             Commands,
-            NonSendMut<EventLoop<()>>,
+            NonSendMut<EventLoop<HandleEvent>>,
             Query<(Entity, &mut Window)>,
             EventWriter<WindowCreated>,
             NonSendMut<WinitWindows>,
@@ -185,9 +187,10 @@ impl Plugin for WinitPlugin {
     }
 }
 
-fn run<F>(event_loop: EventLoop<()>, event_handler: F) -> !
+fn run<F>(event_loop: EventLoop<HandleEvent>, event_handler: F) -> !
 where
-    F: 'static + FnMut(Event<'_, ()>, &EventLoopWindowTarget<()>, &mut ControlFlow),
+    F: 'static
+        + FnMut(Event<'_, HandleEvent>, &EventLoopWindowTarget<HandleEvent>, &mut ControlFlow),
 {
     event_loop.run(event_handler)
 }
@@ -204,9 +207,9 @@ where
     target_os = "netbsd",
     target_os = "openbsd"
 ))]
-fn run_return<F>(event_loop: &mut EventLoop<()>, event_handler: F)
+fn run_return<F>(event_loop: &mut EventLoop<HandleEvent>, event_handler: F)
 where
-    F: FnMut(Event<'_, ()>, &EventLoopWindowTarget<()>, &mut ControlFlow),
+    F: FnMut(Event<'_, HandleEvent>, &EventLoopWindowTarget<HandleEvent>, &mut ControlFlow),
 {
     use winit::platform::run_return::EventLoopExtRunReturn;
     event_loop.run_return(event_handler);
@@ -221,9 +224,9 @@ where
     target_os = "netbsd",
     target_os = "openbsd"
 )))]
-fn run_return<F>(_event_loop: &mut EventLoop<()>, _event_handler: F)
+fn run_return<F>(_event_loop: &mut EventLoop<HandleEvent>, _event_handler: F)
 where
-    F: FnMut(Event<'_, ()>, &EventLoopWindowTarget<()>, &mut ControlFlow),
+    F: FnMut(Event<'_, HandleEvent>, &EventLoopWindowTarget<HandleEvent>, &mut ControlFlow),
 {
     panic!("Run return is not supported on this platform!")
 }
@@ -304,10 +307,9 @@ pub fn winit_runner(mut app: App) {
     // We remove this so that we have ownership over it.
     let mut event_loop = app
         .world
-        .remove_non_send_resource::<EventLoop<()>>()
+        .remove_non_send_resource::<EventLoop<HandleEvent>>()
         .unwrap();
-    app.world
-        .insert_non_send_resource(event_loop.create_proxy());
+    app.world.insert_resource(WinitHandler::new(&event_loop));
 
     let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
     let mut redraw_event_reader = ManualEventReader::<RequestRedraw>::default();
@@ -364,8 +366,8 @@ pub fn winit_runner(mut app: App) {
     let mut next_frame = Instant::now();
     let mut frame_semaphore = 0u8;
 
-    let event_handler = move |event: Event<()>,
-                              event_loop: &EventLoopWindowTarget<()>,
+    let event_handler = move |event: Event<HandleEvent>,
+                              event_loop: &EventLoopWindowTarget<HandleEvent>,
                               control_flow: &mut ControlFlow| {
         #[cfg(feature = "trace")]
         let _span = bevy_utils::tracing::info_span!("winit event_handler").entered();
@@ -670,6 +672,44 @@ pub fn winit_runner(mut app: App) {
                     delta: Vec2::new(x as f32, y as f32),
                 });
             }
+            Event::UserEvent(event) => match event {
+                HandleEvent::Run(rate_multiplier) => {
+                    tick_mode = if let TickMode::Periodic { next_tick, .. } = tick_mode {
+                        TickMode::Periodic {
+                            next_tick,
+                            rate_multiplier,
+                        }
+                    } else {
+                        TickMode::Periodic {
+                            next_tick: Instant::now(),
+                            rate_multiplier,
+                        }
+                    };
+                }
+                HandleEvent::RunFullThrottle => {
+                    tick_mode = TickMode::Continuous;
+                }
+                HandleEvent::Pause => {
+                    tick_mode = TickMode::Manual { request_steps: 0 };
+                }
+                HandleEvent::Step(additional_steps) => {
+                    tick_mode = if let TickMode::Manual { request_steps } = tick_mode {
+                        TickMode::Manual {
+                            request_steps: request_steps + additional_steps,
+                        }
+                    } else {
+                        TickMode::Manual {
+                            request_steps: additional_steps,
+                        }
+                    };
+                }
+                HandleEvent::Redraw => {
+                    request_redraw = true;
+                }
+                HandleEvent::Exit(code) => {
+                    *control_flow = ControlFlow::ExitWithCode(code);
+                }
+            },
             Event::Suspended => {
                 app_active = false;
                 #[cfg(target_os = "android")]

crates/bevy_winit/src/system.rs

@@ -32,9 +32,9 @@ use crate::{
 ///
 /// This will default any necessary components if they are not already added.
 #[allow(clippy::too_many_arguments)]
-pub(crate) fn create_window<'a>(
+pub(crate) fn create_window<'a, T: 'static>(
     mut commands: Commands,
-    event_loop: &EventLoopWindowTarget<()>,
+    event_loop: &EventLoopWindowTarget<T>,
     created_windows: impl Iterator<Item = (Entity, Mut<'a, Window>)>,
     mut event_writer: EventWriter<WindowCreated>,
     mut winit_windows: NonSendMut<WinitWindows>,

crates/bevy_winit/src/winit_handler.rs

@@ -0,0 +1,98 @@
+use bevy_ecs::system::Resource;
+use bevy_utils::{synccell::SyncCell, tracing::warn};
+use winit::event_loop::{EventLoop, EventLoopProxy};
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum HandleEvent {
+    Run(f64),
+    RunFullThrottle,
+    Pause,
+    Step(u64),
+    Redraw,
+    Exit(i32),
+}
+
+/// Controls the operation of the winit runner.
+#[derive(Resource)]
+pub struct WinitHandler {
+    proxy: SyncCell<EventLoopProxy<HandleEvent>>,
+    is_running: bool,
+}
+
+impl WinitHandler {
+    pub(crate) fn new(event_loop: &EventLoop<HandleEvent>) -> Self {
+        Self {
+            proxy: SyncCell::new(event_loop.create_proxy()),
+            is_running: false,
+        }
+    }
+
+    /// Whether the ticks are automatically run or not.
+    pub fn is_running(&self) -> bool {
+        self.is_running
+    }
+
+    /// Run game ticks in sync with real time.
+    pub fn run(&mut self) {
+        self.run_at(1.);
+    }
+
+    /// Run game ticks in sync with real time with a specified speed.
+    pub fn run_at(&mut self, rate_multiplier: f64) {
+        self.is_running = true;
+        if let Err(e) = self
+            .proxy
+            .get()
+            .send_event(HandleEvent::Run(rate_multiplier))
+        {
+            warn!(%e);
+        }
+    }
+
+    /// Run game ticks as fast as possible.
+    pub fn run_full_throttle(&mut self) {
+        self.is_running = true;
+        if let Err(e) = self.proxy.get().send_event(HandleEvent::RunFullThrottle) {
+            warn!(%e);
+        }
+    }
+
+    /// Stop automatic running of game ticks.
+    pub fn pause(&mut self) {
+        self.is_running = false;
+        if let Err(e) = self.proxy.get().send_event(HandleEvent::Pause) {
+            warn!(%e);
+        }
+    }
+
+    /// Run a game tick only once.
+    pub fn step(&mut self) {
+        self.step_at(1);
+    }
+
+    /// Run game ticks a specified number of times.
+    pub fn step_at(&mut self, request_steps: u64) {
+        self.is_running = false;
+        if let Err(e) = self
+            .proxy
+            .get()
+            .send_event(HandleEvent::Step(request_steps))
+        {
+            warn!(%e);
+        }
+    }
+
+    /// Requests frame redraw.
+    pub fn redraw(&mut self) {
+        if let Err(e) = self.proxy.get().send_event(HandleEvent::Redraw) {
+            warn!(%e);
+        }
+    }
+
+    /// Exit the application.
+    pub fn exit(&mut self, code: i32) {
+        if let Err(e) = self.proxy.get().send_event(HandleEvent::Exit(code)) {
+            warn!(%e);
+        }
+    }
+}

crates/bevy_winit/src/winit_windows.rs

@@ -39,9 +39,9 @@ pub struct WinitWindows {
 
 impl WinitWindows {
     /// Creates a `winit` window and associates it with our entity.
-    pub fn create_window(
+    pub fn create_window<T: 'static>(
         &mut self,
-        event_loop: &winit::event_loop::EventLoopWindowTarget<()>,
+        event_loop: &winit::event_loop::EventLoopWindowTarget<T>,
         entity: Entity,
         window: &Window,
         adapters: &mut AccessKitAdapters,