moved renderer to separate thread, add evenio and start structure, make it so you can add stuff

src/client/mod.rs

@@ -1,53 +1,65 @@
+mod app;
 mod camera;
+mod component;
 mod handle_input;
+mod init;
 mod input;
-mod render;
+pub mod render;
 mod rsc;
 mod state;
-mod window;
+mod system;
 
+pub use app::*;
+use component::RenderComponent;
+use evenio::world::World;
+use init::init_world;
+use render::{RenderMessage, RendererChannel};
 pub use state::*;
 
-use self::{input::Input, render::Renderer, rsc::FRAME_TIME, ClientState};
-use std::{
-    sync::Arc,
-    time::{Duration, Instant},
-};
-use winit::window::Window;
+use self::{input::Input, render::Renderer, ClientState};
+use std::{sync::Arc, thread::JoinHandle, time::Instant};
+use winit::{event::WindowEvent, window::Window};
 
-pub struct Client<'a> {
-    window: Option<Arc<Window>>,
-    renderer: Option<Renderer<'a>>,
-    frame_time: Duration,
+pub struct Client {
+    window: Arc<Window>,
     state: ClientState,
+    render_handle: Option<JoinHandle<()>>,
+    renderer: RendererChannel,
     exit: bool,
     input: Input,
-    target: Instant,
-    prev_frame: Instant,
     prev_update: Instant,
     grabbed_cursor: bool,
     keep_cursor: bool,
+    world: World,
 }
 
-impl Client<'_> {
-    pub fn new() -> Self {
+impl Client {
+    pub fn new(window: Arc<Window>) -> Self {
+        let mut world = World::new();
+
+        let (render_channel, render_handle) = Renderer::spawn(window.clone());
+        let e = world.spawn();
+        world.insert(e, RenderComponent(render_channel.clone()));
+        world.add_handler(system::voxel_grid::handle_create_grid);
+
+        init_world(&mut world);
+        let state = ClientState::new();
+        // render_channel.send(RenderMessage::ViewUpdate(state.camera)).expect("GRRRR");
+
         Self {
-            window: None,
-            renderer: None,
+            window,
             exit: false,
-            frame_time: FRAME_TIME,
-            state: ClientState::new(),
+            render_handle: Some(render_handle),
+            renderer: render_channel,
+            state,
             input: Input::new(),
-            prev_frame: Instant::now(),
             prev_update: Instant::now(),
-            target: Instant::now(),
             grabbed_cursor: false,
             keep_cursor: false,
+            world,
         }
     }
 
-    pub fn start(&mut self) {}
-
     pub fn update(&mut self) -> bool {
         let now = Instant::now();
         let dt = now - self.prev_update;
@@ -56,15 +68,32 @@ impl Client<'_> {
         self.handle_input(&dt);
         self.input.end();
 
-        if now >= self.target {
-            self.target += self.frame_time;
-            self.prev_frame = now;
-
-            let renderer = self.renderer.as_mut().unwrap();
-            renderer.update(&self.state);
-            renderer.draw();
+        if self.exit {
+            self.renderer.send(RenderMessage::Exit).expect("AAAA");
+            self.render_handle
+                .take()
+                .expect("uh oh")
+                .join()
+                .expect("bruh");
         }
-
         self.exit
     }
+
+    pub fn window_event(&mut self, event: WindowEvent) {
+        match event {
+            WindowEvent::CloseRequested => self.exit = true,
+            WindowEvent::Resized(size) => self
+                .renderer
+                .send(RenderMessage::Resize(size))
+                .expect("render broke"),
+            WindowEvent::RedrawRequested => self
+                .renderer
+                .send(RenderMessage::Draw)
+                .expect("render broke"),
+            WindowEvent::CursorLeft { .. } => {
+                self.input.clear();
+            }
+            _ => self.input.update_window(event),
+        }
+    }
 }