Use bevy_app instead

src/core/app/app.rs

@@ -1,56 +0,0 @@
-use std::error::Error;
-
-use bevy_ecs::world::World;
-
-pub enum AppExit {
-    Success,
-    Error(Box<dyn Error>),
-}
-
-pub type RunnerFn = Box<dyn FnOnce(App) -> AppExit>;
-
-#[derive(Debug, thiserror::Error)]
-pub enum AppError {
-    #[error("Runner is not set")]
-    RunnerNotSet,
-    #[error("Runner returned an error : {0}")]
-    RunnerError(Box<dyn Error>),
-}
-
-pub struct App {
-    world: World,
-    runner: Option<RunnerFn>,
-}
-
-impl Default for App {
-    fn default() -> Self {
-        Self {
-            world: World::new(),
-            runner: None,
-        }
-    }
-}
-
-impl App {
-    pub fn world_mut(&mut self) -> &mut World {
-        &mut self.world
-    }
-
-    pub fn world(&self) -> &World {
-        &self.world
-    }
-
-    pub fn run(mut self) -> Result<(), AppError> {
-        match self.runner.take() {
-            Some(runner) => match runner(self) {
-                AppExit::Success => Ok(()),
-                AppExit::Error(e) => Err(AppError::RunnerError(e)),
-            },
-            None => Err(AppError::RunnerNotSet),
-        }
-    }
-
-    pub fn set_runner(&mut self, runner: RunnerFn) {
-        self.runner = Some(runner);
-    }
-}

src/core/app/mod.rs

@@ -1,2 +0,0 @@
-mod app;
-pub use app::*;

src/core/mod.rs

@@ -1,4 +1,3 @@
-pub mod app;
 pub mod camera;
 pub mod render;
 pub mod vulkan;

src/core/vulkan/mod.rs

@@ -1,7 +1,7 @@
 use vulkan_context::VulkanContext;
 use window_render_context::WindowRenderContext;
 
-use super::app::App;
+use bevy_app::App;
 
 mod utils;
 mod vulkan_context;

src/core/vulkan/vulkan_context.rs

@@ -1,5 +1,6 @@
 use std::{any::Any, sync::Arc};
 
+use bevy_app::App;
 use bevy_ecs::system::Resource;
 use vulkano::{
     command_buffer::{
@@ -14,7 +15,7 @@ use vulkano::{
 };
 use winit::raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 
-use crate::core::{app::App, window::raw_handle::DisplayHandleWrapper};
+use crate::core::window::raw_handle::DisplayHandleWrapper;
 
 use super::utils;
 

src/core/vulkan/window_render_context.rs

@@ -1,3 +1,4 @@
+use bevy_app::App;
 use bevy_ecs::system::Resource;
 use std::sync::Arc;
 use vulkano::image::view::ImageView;
@@ -8,7 +9,6 @@ use vulkano::sync::{self, GpuFuture};
 use vulkano::{Validated, VulkanError};
 use winit::window::Window;
 
-use crate::core::app::App;
 use crate::core::window::raw_handle::WindowWrapper;
 
 use super::vulkan_context::VulkanContext;

src/core/window/mod.rs

@@ -1,10 +1,9 @@
+use bevy_app::{App, AppExit};
 use config::WindowConfig;
 use raw_handle::{DisplayHandleWrapper, EventLoopProxyWrapper};
 use state::WindowState;
 use winit::event_loop::EventLoop;
 
-use super::app::{App, AppExit};
-
 pub mod config;
 pub mod raw_handle;
 pub mod state;
@@ -43,6 +42,9 @@ fn runner(mut app: App, event_loop: EventLoop<()>) -> AppExit {
 
     match event_loop.run_app(&mut window_state) {
         Ok(_) => AppExit::Success,
-        Err(e) => AppExit::Error(Box::new(e)),
+        Err(e) => {
+            log::error!("Error running window state: {e}");
+            AppExit::error()
+        }
     }
 }

src/core/window/state.rs

@@ -1,13 +1,12 @@
 use std::sync::Arc;
 
+use bevy_app::App;
 use bevy_ecs::world::World;
 use winit::{
     application::ApplicationHandler, event::WindowEvent, event_loop::ActiveEventLoop,
     window::WindowId,
 };
 
-use crate::core::app::App;
-
 use super::{config::WindowConfig, raw_handle::WindowWrapper};
 
 pub struct WindowState {

src/game/mod.rs

@@ -1,5 +1,6 @@
+use bevy_app::App;
+
 use crate::core::{
-    app::App,
     vulkan::Vulkan,
     window::{Window, config::WindowConfig},
 };

src/main.rs

@@ -1,29 +1,40 @@
-use std::error::Error;
 use winit::event_loop::{ControlFlow, EventLoop};
 
+use bevy_app::{App, AppExit};
+
 pub mod core;
 pub mod game;
 pub mod old_app;
 
-fn main() -> Result<(), impl Error> {
+fn main() {
     env_logger::init();
 
-    run_new_app()
-    // run_old_app()
+    run_new_app();
+    // run_old_app();
 }
 
-fn run_new_app() -> Result<(), impl Error> {
-    let mut app = core::app::App::default();
+fn run_new_app() {
+    let mut app = App::default();
     game::init(&mut app);
-    app.run()
+    match app.run() {
+        AppExit::Success => {}
+        AppExit::Error(e) => {
+            log::error!("Error running new app: {e}");
+        }
+    }
 }
 
-fn run_old_app() -> Result<(), impl Error> {
+fn run_old_app() {
     let event_loop = EventLoop::new().unwrap();
     event_loop.set_control_flow(ControlFlow::Poll);
 
     let vulkan_context = old_app::vulkan_context::VulkanContext::from(&event_loop);
     let mut app = old_app::app::App::from(vulkan_context);
 
-    event_loop.run_app(&mut app)
+    match event_loop.run_app(&mut app) {
+        Ok(_) => {}
+        Err(e) => {
+            log::error!("Error running old app: {e}");
+        }
+    }
 }