refactor(app)!: add FrameContext (#29)

* refactor(app): replaced separate `gfx`, `input`, `timer` & `egui_ctx` arguments with a single `FrameContext`
* feat(app): expose window events in `FrameContext`
* docs: update examples to `FrameContext`

BREAKING CHANGE: App::run now receives a FrameContext instead of
separate arguments

Author: wick3dr0se

README.md

@@ -49,7 +49,7 @@ let mut position = Vec2::ZERO;
 
 App::new()
     .title("Egor Stateful Rectangle")
-    .run(move |gfx, input, timer| {
+    .run(move |FrameContext { gfx, input, timer, .. } | {
         let dx = input.key_held(KeyCode::ArrowRight) as i8
             - input.key_held(KeyCode::ArrowLeft) as i8;
         let dy =

crates/egor_glue/src/app.rs

@@ -10,15 +10,21 @@ use egor_app::{
 };
 use egor_render::Renderer;
 
-#[cfg(not(feature = "ui"))]
-type UpdateFn = dyn FnMut(&mut Graphics, &Input, &FrameTimer);
-#[cfg(feature = "ui")]
-type UpdateFn = dyn FnMut(&mut Graphics, &Input, &FrameTimer, &egui::Context);
+type UpdateFn = dyn FnMut(&mut FrameContext);
+
+pub struct FrameContext<'a> {
+    pub events: Vec<WindowEvent>,
+    pub gfx: Graphics<'a>,
+    pub input: &'a Input,
+    pub timer: &'a FrameTimer,
+    #[cfg(feature = "ui")]
+    pub egui_ctx: &'a egui::Context,
+}
 
 pub struct App {
+    events: Vec<WindowEvent>,
     update: Option<Box<UpdateFn>>,
     config: Option<AppConfig>,
-    on_quit: Option<Box<dyn FnMut()>>,
     vsync: bool,
     text_renderer: Option<TextRenderer>,
     #[cfg(feature = "ui")]
@@ -29,9 +35,9 @@ impl App {
     /// Create a new [`App`]
     pub fn new() -> Self {
         Self {
+            events: Vec::new(),
             update: None,
             config: Some(AppConfig::default()),
-            on_quit: None,
             vsync: true,
             text_renderer: None,
             #[cfg(feature = "ui")]
@@ -48,7 +54,7 @@ impl App {
     }
 
     /// Set window size (width, height in pixels)
-    pub fn screen_size(mut self, width: u32, height: u32) -> Self {
+    pub fn window_size(mut self, width: u32, height: u32) -> Self {
         if let Some(c) = self.config.as_mut() {
             c.width = width;
             c.height = height;
@@ -71,57 +77,30 @@ impl App {
     }
 
     /// Run the app with a per-frame update closure
-    #[cfg(not(feature = "ui"))]
-    pub fn run(
-        mut self,
-        #[allow(unused_mut)] mut update: impl FnMut(&mut Graphics, &Input, &FrameTimer) + 'static,
-    ) {
-        #[cfg(feature = "hot_reload")]
-        let update = {
-            dioxus_devtools::connect_subsecond();
-
-            move |g: &mut Graphics, i: &Input, t: &FrameTimer| {
-                dioxus_devtools::subsecond::call(|| update(g, i, t))
-            }
-        };
-        self.update = Some(Box::new(update));
-
-        let config = self.config.take().unwrap();
-        AppRunner::new(self, config).run();
-    }
-    #[cfg(feature = "ui")]
-    pub fn run(
-        mut self,
-        #[allow(unused_mut)] mut update: impl FnMut(&mut Graphics, &Input, &FrameTimer, &egui::Context)
-        + 'static,
-    ) {
+    pub fn run(mut self, #[allow(unused_mut)] mut update: impl FnMut(&mut FrameContext) + 'static) {
         #[cfg(feature = "hot_reload")]
         let update = {
             dioxus_devtools::connect_subsecond();
 
-            move |g: &mut Graphics, i: &Input, t: &FrameTimer, ui: &egui::Context| {
-                dioxus_devtools::subsecond::call(|| update(g, i, t, ui))
+            move |ctx: &mut FrameContext| {
+                dioxus_devtools::subsecond::call(|| update(ctx));
             }
         };
         self.update = Some(Box::new(update));
 
         let config = self.config.take().unwrap();
         AppRunner::new(self, config).run();
     }
-
-    /// Sets a closure to call when the app is quitting
-    pub fn on_quit(mut self, f: impl FnMut() + 'static) -> Self {
-        self.on_quit = Some(Box::new(f));
-        self
-    }
 }
 
 impl AppHandler<Renderer> for App {
-    fn on_window_event(&mut self, _window: &Window, _event: &WindowEvent) {
+    fn on_window_event(&mut self, _window: &Window, event: &WindowEvent) {
         #[cfg(feature = "ui")]
         if let Some(egui) = self.egui.as_mut() {
-            egui.handle_event(_window, _event);
+            egui.handle_event(_window, event);
         }
+
+        self.events.push(event.clone());
     }
 
     async fn with_resource(&mut self, window: Arc<Window>) -> Renderer {
@@ -167,17 +146,21 @@ impl AppHandler<Renderer> for App {
         let (device, queue) = (renderer.device().clone(), renderer.queue().clone());
 
         let text_renderer = self.text_renderer.as_mut().unwrap();
-        let mut graphics = Graphics::new(renderer, text_renderer);
 
-        #[cfg(not(feature = "ui"))]
-        update(&mut graphics, input, timer);
         #[cfg(feature = "ui")]
-        {
-            let egui_ctx = self.egui.as_mut().unwrap().begin_frame(_window);
-            update(&mut graphics, input, timer, egui_ctx);
-        }
+        let egui_ctx = self.egui.as_mut().unwrap().begin_frame(_window);
+        let mut ctx = FrameContext {
+            gfx: Graphics::new(renderer, text_renderer),
+            input,
+            timer,
+            #[cfg(feature = "ui")]
+            egui_ctx,
+            events: std::mem::take(&mut self.events),
+        };
+        update(&mut ctx);
+
+        let geometry = ctx.gfx.flush();
 
-        let geometry = graphics.flush();
         text_renderer.prepare(&device, &queue, width, height);
 
         {
@@ -210,10 +193,4 @@ impl AppHandler<Renderer> for App {
     fn resize(&mut self, width: u32, height: u32, renderer: &mut Renderer) {
         renderer.resize(width, height)
     }
-
-    fn on_quit(&mut self) {
-        if let Some(f) = &mut self.on_quit {
-            f();
-        }
-    }
 }

crates/egor_glue/src/text.rs

@@ -110,14 +110,6 @@ impl TextRenderer {
 /// and let it drop to submit the text for the current frame
 ///
 /// Text is queued immediately and rendered on the next frame
-///
-/// # Example
-/// ```no_run
-/// graphics.text("Hello world")
-///     .at((20.0, 40.0))
-///     .size(18.0)
-///     .color(Color::WHITE);
-/// ```
 pub struct TextBuilder<'a> {
     renderer: &'a mut TextRenderer,
     text: String,

demos/hot-reload-test/src/main.rs

@@ -1,15 +1,17 @@
 use egor::{
-    app::App,
+    app::{App, FrameContext},
     math::{Vec2, vec2},
     render::Color,
 };
 
 fn main() {
-    App::new().title("Hot Reload Demo").run(move |gfx, _, _| {
-        // Feel free to change this code and see hot-reload in action!
-        gfx.rect()
-            .at(vec2(0., 0.))
-            .size(Vec2::splat(100.0))
-            .color(Color::RED);
-    });
+    App::new()
+        .title("Hot Reload Demo")
+        .run(move |FrameContext { gfx, .. }| {
+            // Feel free to change this code and see hot-reload in action!
+            gfx.rect()
+                .at(vec2(0., 0.))
+                .size(Vec2::splat(100.0))
+                .color(Color::RED);
+        });
 }

demos/secs_particles/src/main.rs

@@ -1,5 +1,5 @@
 use egor::{
-    app::App,
+    app::{App, FrameContext},
     math::{Vec2, vec2},
     render::Color,
 };
@@ -35,11 +35,11 @@ fn main() {
 
     App::new()
         .title("Egor ECS Particles Demo")
-        .run(move |gfx, _, frame| {
+        .run(move |FrameContext { gfx, timer, .. }| {
             let screen_size = gfx.screen_size();
 
             world.query(|_, pos: &mut Position, vel: &Velocity| {
-                pos.vec += vel.vec * speed * frame.delta;
+                pos.vec += vel.vec * speed * timer.delta;
                 wraparound(&mut pos.vec, screen_size);
 
                 gfx.rect()

demos/shooter/src/main.rs

@@ -4,7 +4,7 @@ mod tilemap;
 use rand::Rng;
 
 use egor::{
-    app::{App, egui::Window},
+    app::{App, FrameContext, WindowEvent, egui::Window},
     input::{KeyCode, MouseButton},
     math::{Rect, Vec2, vec2},
     render::Color,
@@ -134,12 +134,27 @@ fn main() {
         game_over: false,
     };
 
-    App::new()
-        .title("Egor Shooter Demo")
-        .on_quit(|| {
-            println!("Quitting already? Don't be a sore loser");
-        })
-        .run(move |gfx, input, timer, ui| {
+    App::new().title("Egor Shooter Demo").run(
+        move |FrameContext {
+                  gfx,
+                  input,
+                  timer,
+                  egui_ctx,
+                  events,
+              }| {
+            for event in events {
+                match event {
+                    WindowEvent::CloseRequested => {
+                        println!("Quitting already? Don't be a sore loser");
+                        println!("Final Wave: {}", state.wave);
+                        println!("Killed {} zombies", state.kills);
+
+                        state.game_over = true;
+                    }
+                    _ => {}
+                }
+            }
+
             if timer.frame == 0 {
                 state.map.load_tileset(
                     gfx,
@@ -157,7 +172,6 @@ fn main() {
             }
 
             let screen_size = gfx.screen_size();
-            let screen_half = screen_size / 2.0;
 
             if state.game_over {
                 gfx.text("GAME OVER")
@@ -166,6 +180,7 @@ fn main() {
                 return;
             }
 
+            let screen_half = screen_size / 2.0;
             let position = state.player.rect.position - screen_half
                 + Into::<Vec2>::into(input.mouse_position());
 
@@ -278,13 +293,14 @@ fn main() {
                 );
             }
 
-            Window::new("Debug").show(ui, |ui| {
+            Window::new("Debug").show(egui_ctx, |ui| {
                 ui.label(format!("FPS: {}", timer.fps));
                 ui.label(format!("Wave: {}", state.wave));
                 ui.label(format!("Zombies killed: {}", state.kills));
                 ui.label(format!("HP: {:.0}", state.player.hp));
                 ui.label(format!("Fire rate: {:.1}/s", state.fire_rate));
                 ui.label(format!("Bullet Spread: {}", state.spread));
             });
-        });
+        },
+    );
 }

src/lib.rs

@@ -23,8 +23,8 @@
 //!
 //! ## Minimal Example: Draw a Rectangle
 //! ```no_run
-//! use egor::{app::App, render::Graphics};
-//! App::new().run(|gfx: &mut Graphics, _input, _timer| {
+//! use egor::{app::{App, FrameContext}, render::Graphics};
+//! App::new().run(|FrameContext { gfx, .. }| {
 //!     // start building a rectangle with some defaults
 //!     // draws automatically on `Drop` without an explicit `build()`
 //!     gfx.rect();
@@ -53,7 +53,8 @@
 //! - Optional backends can be enabled to override defaults or for cross-platform targeting
 
 pub mod app {
-    pub use egor_glue::app::App;
+    pub use egor_app::WindowEvent;
+    pub use egor_glue::app::{App, FrameContext};
     #[cfg(feature = "ui")]
     pub use egor_glue::ui::egui;
 }