Implemented dirty input system

+ added render thread
+ added control thread
* tweaked event_loop

src/bin/main.rs

@@ -16,7 +16,7 @@ fn setup_logger() -> Result<(), fern::InitError> {
                 message
             ))
         })
-        .level(log::LevelFilter::Debug)
+        .level(log::LevelFilter::Warn)
         .chain(std::io::stdout())
         .chain(fern::log_file("output.log")?)
         .apply()?;

src/hal.rs

@@ -1,5 +1,5 @@
 #[allow(unused_imports)]
-use log::{debug,error, info, trace, warn};
+use log::{debug, error, info, trace, warn};
 
 use std::{
     mem::ManuallyDrop,

src/hal/render.rs

@@ -1,5 +1,5 @@
 #[allow(unused_imports)]
-use log::{debug,error, info, trace, warn};
+use log::{debug, error, info, trace, warn};
 
 use std::iter;
 

src/input.rs

@@ -17,12 +17,12 @@ impl Input {
     
     pub fn poll_events_loop(event_loop: &mut EventLoop<()>) -> Self {
         let mut input = Input::default();
-        event_loop.run(move |event, _, control_flow| {
+        event_loop.run(|event, _, control_flow| {
             *control_flow = ControlFlow::Wait;
 
             match event {
                 Event::WindowEvent{window_id: _, event} => match event {
-                    WindowEvent::CloseRequested => input.close_request = true,
+                    WindowEvent::CloseRequested => (),
                     _ => (),
                 }
                 _ => (),

src/lib.rs

@@ -5,33 +5,115 @@
 #[allow(unused_imports)]
 use log::{debug, error, info, trace, warn};
 
+use std::{
+    sync::mpsc,
+    thread,
+    collections::HashMap,
+    cell::RefCell,
+    time,
+};
+
 mod winit_state;
 use winit_state::WinitState;
 
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::ControlFlow,
+};
+
 mod hal;
 use hal::HalState;
 
-//mod input;
-//use input::Input;
-
 //mod local_state;
 //use local_state::LocalState;
 
+pub enum Command {
+    Draw,
+    Stop,
+}
+
+
 //--------------------------------------------------------------------------------------------------
 /* functions */
 
 /// The main function of the library
 pub fn run() -> Result<(), &'static str> {
     let winit_state = WinitState::default();
-
     let mut hal_state = HalState::new(&winit_state.window)?;
     //let local_state = LocalState::default();
 
-    loop {
+    let (input_tx, input_rx) = mpsc::channel();
-       //local_state.update();
+    let mut window_senders = HashMap::with_capacity(1);
-        let _ = hal_state.draw_clear_frame([0.0, 255.0, 0.0, 0.0])?;
+    window_senders.insert(1, input_tx);
-        //let input = Input::poll_events_loop(&mut winit_state.event_loop);
+
-    }
+    let control_thread = RefCell::new(Some(thread::spawn(move || {
+        #[allow(unused_imports)]
+        use log::{debug, error, info, trace, warn};
+
+        let (cmd_tx, cmd_rx) = mpsc::channel();
+        let render_thread = thread::spawn(move || {
+            #[allow(unused_imports)]
+            use log::{debug, error, info, trace, warn};
+
+
+
+            loop {
+                match cmd_rx.try_recv().unwrap_or(None) {
+                    None => (),
+                    Some(Command::Draw) =>  {
+                        //TODO manage errors
+                        let _ = hal_state.draw_clear_frame([0.0, 255.0, 0.0, 0.0]);
+                    },
+                    Some(Command::Stop) => {
+                        warn!("Stop render thread");
+                        return;
+                    },
+                };
+            }
+        });
+
+        loop {
+            match input_rx.try_recv().unwrap_or(false) {
+                 false => (),
+                 true => {
+                     cmd_tx.send(Some(Command::Stop)).unwrap();
+                     //TODO stop event_loop
+                     warn!("wait for render thread");
+                     render_thread.join().unwrap();
+                     warn!("Stop control thread");
+                     return;
+                 },
+            };
+
+            cmd_tx.send(Some(Command::Draw)).unwrap();
+            thread::sleep(time::Duration::from_millis(100));
+
+        }
+    })));
+   
+    winit_state.event_loop.run(move |event, _, control_flow| {
+        #[allow(unused_imports)]
+        use log::{debug, error, info, trace, warn};
+
+        *control_flow = ControlFlow::Wait;
+
+        //TODO manage errors
+        let input_tx = window_senders.get(&1).unwrap();
+        match event {
+            Event::WindowEvent{window_id: _, event} => match event {
+                WindowEvent::CloseRequested => {
+                    input_tx.send(true).unwrap();
+                    let handle = control_thread.replace(None).unwrap();
+                    warn!("Wait for control thread");
+                    handle.join().unwrap();
+                    warn!("Stop input thread");
+                    *control_flow = ControlFlow::Exit;
+                },
+                _ => (),
+            }
+            _ => (),
+        }
+    });
 }
 
 mod tests {