started removal of bevy_ecs in favor of hecs

src/app.rs

@@ -1,18 +1,13 @@
-use bevy_ecs::world::World;
 use winit::{event::ElementState, keyboard::KeyCode};
 
-#[allow(unused_variables)]
-pub trait App {
-    fn config(&self) -> AppConfig;
-
-    fn start(&mut self, world: &mut World) {}
-    fn input(&mut self, world: &mut World, keycode: &KeyCode, key_state: &ElementState) {}
-    fn mouse_moved(&mut self, world: &mut World, delta: (f64, f64)) {}
-}
+use crate::EngineResources;
 
-#[derive(Debug)]
-pub struct AppConfig {
-    pub update_dt: f32,
-    pub cursor_locked: bool,
-    pub cursor_visible: bool,
+pub trait App {
+    fn start(&mut self, resources: &mut EngineResources);
+    fn mouse_moved(&mut self, resources: &mut EngineResources, delta: (f64, f64));
+    fn input(&mut self,
+        resources: &mut EngineResources,
+        keycode: &KeyCode,
+        key_state: &ElementState
+    );
 }

src/lib.rs

@@ -3,7 +3,6 @@ pub mod util;
 pub mod components;
 pub mod resources;
 pub mod screens;
-pub mod world_ext;
 pub mod pass_ext;
 pub mod device_ext;
 pub mod app;
@@ -12,6 +11,7 @@ pub use bevy_ecs;
 pub use egui;
 pub use egui_wgpu;
 pub use egui_winit;
+use resources::screen_server::GameState;
 pub use wgpu;
 
 use std::sync::Arc;
@@ -22,39 +22,129 @@ use bevy_ecs::world::Mut;
 use bevy_ecs::world::World;
 use resources::asset_server::AssetServer;
 use resources::egui_renderer::EguiRenderer;
-use resources::game_state::GameState;
 use resources::glyphon_renderer::GlyphonRenderer;
-use resources::render_server::RenderServer;
+use resources::render_server::RenderStorage;
 use resources::screen_server::ScreenServer;
 use render::texture::*;
 use render::instance_data::*;
 
 use resources::default_pipeline::DefaultPipeline;
 use resources::frame_context::FrameContext;
 use resources::render_context::RenderContext;
-use resources::input::InputRes;
-use resources::mouse::MouseRes;
+use resources::input::InputStorage;
 use wgpu::Features;
 use winit::application::ApplicationHandler;
 use winit::dpi::PhysicalSize;
 use winit::event_loop::ActiveEventLoop;
 use winit::event_loop::ControlFlow;
-use winit::window::CursorGrabMode;
 use winit::window::WindowAttributes;
 use winit::window::WindowId;
 use winit::{
     event::*, event_loop::EventLoop, keyboard::{KeyCode, PhysicalKey}, window::Window
 };
 
-use world_ext::WorldExt;
+pub struct EngineResources {
+    update_dt: f32,
+    input_storage: InputStorage,
+    asset_server: AssetServer,
+    render_storage: RenderStorage,
+    screen_server: ScreenServer,
+    glyphon_renderer: GlyphonRenderer,
+    egui_renderer: EguiRenderer,
+    default_pipeline: DefaultPipeline,
+    render_context: RenderContext,
+    world: World,
+}
+
+impl EngineResources {
+    pub async fn new(window: &Arc<Window>) -> Self {
+        let size = window.inner_size();
+
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+            backends: wgpu::Backends::PRIMARY,
+            ..Default::default()
+        });
+
+        let surface = instance.create_surface(window.clone())
+            .unwrap();
+
+        let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions {
+            power_preference: wgpu::PowerPreference::default(),
+            compatible_surface: Some(&surface),
+            force_fallback_adapter: false,
+        }).await.unwrap();
+
+        let (device, queue) = adapter.request_device(&wgpu::DeviceDescriptor {
+            required_features: Features::POLYGON_MODE_LINE | Features::MULTI_DRAW_INDIRECT | Features::INDIRECT_FIRST_INSTANCE,
+            required_limits: wgpu::Limits::default(),
+            memory_hints: wgpu::MemoryHints::Performance,
+            label: None,
+        }, None).await.unwrap();
+
+        let surface_caps = surface.get_capabilities(&adapter);
+        let surface_format = surface_caps.formats.iter()
+            .find(|f| f.is_srgb())
+            .copied()
+            .unwrap_or(surface_caps.formats[0]);
+
+        let config = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format: surface_format,
+            width: size.width,
+            height: size.height,
+            present_mode: surface_caps.present_modes[0],
+            alpha_mode: surface_caps.alpha_modes[0],
+            view_formats: vec![],
+            desired_maximum_frame_latency: 2,
+        };
+
+        surface.configure(&device, &config);
+
+        let depth_texture = Texture::depth_texture(&device, &config);
+
+        let input_storage = InputStorage::default();
+        let asset_server = AssetServer::default();
+        let render_storage = RenderStorage::default();
+        let screen_server = ScreenServer::default();
+        let world = World::default();
+
+        let glyphon_renderer = GlyphonRenderer::new(&device, &queue);
+        let egui_renderer = EguiRenderer::new(&device, window);
+        let default_pipeline = DefaultPipeline::new(&device, &config);
+        let render_context = RenderContext {
+            window: window.clone(),
+            config,
+            size,
+            device,
+            queue,
+            surface,
+            depth_texture,
+        };
+
+        let update_dt = 1.0/20.0;
+
+        Self {
+            update_dt,
+            world,
+            input_storage,
+            asset_server,
+            render_storage,
+            screen_server,
+            glyphon_renderer,
+            egui_renderer,
+            default_pipeline,
+            render_context,
+        }
+    }
+}
 
 pub struct Engine {
     window: Option<Arc<Window>>,
     delta_time: Instant,
     time_accumulator: f32,
+    resources: Option<EngineResources>,
 
     app: Box<dyn App>,
-    world: World,
 }
 
 impl ApplicationHandler for Engine {
@@ -87,19 +177,15 @@ impl ApplicationHandler for Engine {
                 },
                 ..
             } => {
-                let world = &mut self.world;
-                self.app.input(world, &keycode, &key_state);
+                let resources = self.resources.as_mut().unwrap();
+                self.app.input(resources, &keycode, &key_state);
             },
             _ => {}
         }
 
-        let world = &mut self.world;
-        let window = world
-            .render_context()
-            .window
-            .clone();
-
-        world.egui_renderer_mut()
+        let window = self.window.as_mut().unwrap();
+        let resources = self.resources.as_mut().unwrap();
+        resources.egui_renderer
             .window_event(&window, &event);
     }
 
@@ -110,26 +196,18 @@ impl ApplicationHandler for Engine {
         event: DeviceEvent
     ) {
         if let DeviceEvent::MouseMotion { delta } = event {
-            let world = &mut self.world;
-            self.app.mouse_moved(world, delta);
+            let resources = self.resources.as_mut().unwrap();
+            self.app.mouse_moved(resources, delta);
         }
     }
 
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
         let window = event_loop.create_window(WindowAttributes::default()).unwrap();
         let window = Arc::new(window);
-        let config = &self.app.config();
+        let resources = pollster::block_on(EngineResources::new(&window));
 
-        if config.cursor_locked {
-            window.set_cursor_grab(CursorGrabMode::Locked)
-                .or_else(|_e| window.set_cursor_grab(CursorGrabMode::Confined))
-                .unwrap();
-        }
-
-        window.set_cursor_visible(config.cursor_visible);
-
-        pollster::block_on(self.init(&window));
         self.window = Some(window);
+        self.resources = Some(resources);
     }
 
     fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
@@ -139,110 +217,31 @@ impl ApplicationHandler for Engine {
 }
 
 impl Engine {
-    fn from_app(app: impl App + 'static) -> Self{
+    fn new(app: impl App + 'static) -> Self{
         let window = Option::default();
         let delta_time = Instant::now();
         let time_accumulator = f32::default();
-        let world = World::default();
         let app = Box::new(app);
+        let resources = Option::default();
 
         Self {
             window,
             delta_time,
             time_accumulator,
-            world,
             app,
+            resources,
         }
     }
 
-    async fn init(&mut self, window: &Arc<Window>) {
-        let size = window.inner_size();
-
-        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-            backends: wgpu::Backends::PRIMARY,
-            ..Default::default()
-        });
-
-        let surface = instance.create_surface(window.clone())
-            .unwrap();
-
-        let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions {
-            power_preference: wgpu::PowerPreference::default(),
-            compatible_surface: Some(&surface),
-            force_fallback_adapter: false,
-        }).await.unwrap();
-
-        let (device, queue) = adapter.request_device(&wgpu::DeviceDescriptor {
-            required_features: Features::POLYGON_MODE_LINE | Features::MULTI_DRAW_INDIRECT | Features::INDIRECT_FIRST_INSTANCE,
-            required_limits: wgpu::Limits::default(),
-            memory_hints: wgpu::MemoryHints::Performance,
-            label: None,
-        }, None).await.unwrap();
-
-        let surface_caps = surface.get_capabilities(&adapter);
-        let surface_format = surface_caps.formats.iter()
-            .find(|f| f.is_srgb())
-            .copied()
-            .unwrap_or(surface_caps.formats[0]);
-
-        let config = wgpu::SurfaceConfiguration {
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            format: surface_format,
-            width: size.width,
-            height: size.height,
-            present_mode: surface_caps.present_modes[0],
-            alpha_mode: surface_caps.alpha_modes[0],
-            view_formats: vec![],
-            desired_maximum_frame_latency: 2,
-        };
-
-        surface.configure(&device, &config);
-
-        let depth_texture = Texture::depth_texture(&device, &config, "depth_texture");
-
-        let world = &mut self.world;
-        world.init_resource::<InputRes>();
-        world.init_resource::<MouseRes>();
-        world.init_resource::<GameState>();
-        world.init_resource::<AssetServer>();
-        world.init_resource::<RenderServer>();
-        world.init_resource::<ScreenServer>();
-
-        let shader = device.create_shader_module(wgpu::include_wgsl!("shader.wgsl"));
-        let glyphon_renderer = GlyphonRenderer::new(&device, &queue);
-        let egui_renderer = EguiRenderer::new(&device, window);
-
-        world.insert_resource(egui_renderer);
-        world.insert_resource(glyphon_renderer);
-
-        world.insert_resource(
-            DefaultPipeline::new(&device,
-                &shader,
-                &config
-        ));
-
-        world.insert_resource(RenderContext {
-            window: window.clone(),
-            config,
-            size,
-            device,
-            queue,
-            surface,
-            depth_texture,
-        });
-
-        self.app.start(world);
-    }
-
     fn resize(&mut self, new_size: PhysicalSize<u32>) {
         if new_size.width > 0 && new_size.height > 0 {
-            let mut ctx = self.world
-                .render_context_mut();
+            let resources = self.resources.as_mut().unwrap();
+            let ctx = &mut resources.render_context;
 
             ctx.size = new_size;
             ctx.config.width = new_size.width;
             ctx.config.height = new_size.height;
-            ctx.depth_texture = Texture::depth_texture(&ctx.device, &ctx.config, "depth_texture");
+            ctx.depth_texture = Texture::depth_texture(&ctx.device, &ctx.config);
             ctx.surface.configure(&ctx.device, &ctx.config);
         }
     }
@@ -253,7 +252,8 @@ impl Engine {
             .as_secs_f32();
         self.delta_time = Instant::now();
 
-        let update_dt = self.app.config().update_dt;
+        let resources = self.resources.as_mut().unwrap();
+        let update_dt = resources.update_dt;
         while self.time_accumulator >= update_dt {
             self.update();
             self.time_accumulator -= update_dt;
@@ -263,14 +263,14 @@ impl Engine {
     }
 
     fn update(&mut self) {
-        self.world.resource_scope(|world: &mut World, mut screen_server: Mut<ScreenServer>| {
-            screen_server.update(world);
-        });
+        let resources = self.resources.as_mut().unwrap();
+        resources.screen_server
+            .update(&mut self.world);
     }
 
     fn draw(&mut self) {
-        let world = &mut self.world;
-        let render_ctx = world.render_context();
+        let render_ctx = &mut self.resources.render_context
+            .unwrap();
 
         let frame_ctx = FrameContext::new(render_ctx, None);
         world.insert_resource(frame_ctx);
@@ -313,6 +313,6 @@ pub fn run(app: impl App + 'static) {
     let event_loop = EventLoop::new().unwrap();
     event_loop.set_control_flow(ControlFlow::Poll);
 
-    let mut engine = Engine::from_app(app);
+    let mut engine = Engine::new(app);
     let _ = event_loop.run_app(&mut engine);
 }