Merge branch '9-engine-clean-too-early-during-shutdown' into 'dev'

Resolve "Engine clean too early during shutdown"

See merge request Steins7/iv!9

main.rs

@@ -32,17 +32,11 @@ fn setup_logger() -> Result<(), fern::InitError> {
     Ok(())
 }
 
-
-//pub fn draw_frame(hal : &mut HalState, local : &LocalState) -> Result<(), &'static str> {
-//
-//    hal.draw_clear_frame(local.color());
-//}
-
 pub fn main() -> Result<(), &'static str> {
 
     setup_logger().unwrap();
 
     run()?;
-    //print!("test");
+
     Ok(())
 }

src/controller.rs

@@ -78,6 +78,7 @@ where
                         },
                         Key::Close => {
                             info!("Shutting down IV !");
+
                             return;
                         }
                         _ => (),

src/io/winit_window.rs

@@ -46,7 +46,7 @@ impl Drop for WinitWindow {
             },
             _ => true,
         } {}
-        trace!("Dropped !");
+        trace!("Dropped window !");
     }
 }
 

src/lib.rs

@@ -92,129 +92,6 @@ pub fn run() -> Result<(), &'static str> {
     let mut controller = Controller::new(vec![subengine_pipeline]);
     controller.run();
 
-    //let engine_pipelines = vec![
-    //    EnginePipeline {
-    //        Inputs: vec![0,1],
-    //        Engines: vec![&color_engine],
-    //        Renderers: vec![(1,0)],
-    //    },
-    //    EnginePipeline {
-    //        Inputs: vec![3],
-    //        Engines: vec![&color_engine],
-    //        Renderers: vec![(1,1),(1,2),(1,3)],
-    //}];
-
-    //let controller = Controller::new(renderers, &windows, &windows, engine_pipelines);
-    //controller.run();
-
-    //Ok(())
-    //let local_state = LocalState::default();
-    
-//    let color = [0.5, 0.0, 0.0, 1.0];
-//    
-//    loop {
-//        for window in &mut windows {
-//            match renderer.draw_clear_frame(window, color) {
-//                Err(err) => println!("{}", err),
-//                _ => (),
-//    }}}
-//
     Ok(())
 }
 
-//    let (input_tx, input_rx) = mpsc::channel();
-//    let mut window_senders = HashMap::with_capacity(1);
-//    window_senders.insert(1, input_tx);
-//
-//    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};
-//
-//            let mut color = [0.0, 0.0, 0.0, 0.0];
-//
-//            loop 
-//
-//                //TODO manage errors
-//                for window in windows {
-//                    let _ = renderer.draw_clear_frame(&mut window, color);
-//                }
-//
-//                match cmd_rx.try_recv().unwrap_or(Command::NoCommand) {
-//                    Command::NoCommand => (),
-//                    Command::Stop => {
-//                        warn!("Stop render thread");
-//                        return;
-//                    },
-//                    Command::Color{r, g, b, a} => {
-//                        color = [r, g, b, a];
-//                    },
-//                }
-//            }
-//        });
-//
-//        loop {
-//            match input_rx.recv().unwrap() {
-//                 Input::Close => {
-//                     cmd_tx.send(Command::Stop).unwrap();
-//                     //TODO stop event_loop
-//                     warn!("wait for render thread");
-//                     render_thread.join().unwrap();
-//                     warn!("Stop control thread");
-//                     return;
-//                 },
-//                 Input::Mouse{x, y} => {
-//                    let pos = Command::Color{
-//                        r: (x/1280.0) as f32,
-//                        g: (y/720.0) as f32,
-//                        b: ((x/1280.0 + y/720.0)/2.0) as f32,
-//                        a: 1.0,
-//                    };
-//                    cmd_tx.send(pos).unwrap();
-//                 },
-//           }
-//        }
-//    })));
-//   
-//    windows[0].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(Input::Close).unwrap();
-//                    let handle = control_thread.replace(None).unwrap();
-//                    warn!("Wait for control thread");
-//                    handle.join().unwrap();
-//                    warn!("Stop input thread");
-//                    *control_flow = ControlFlow::Exit;
-//                },
-//                WindowEvent::CursorMoved{position, ..} => {
-//                    input_tx
-//                        .send(Input::Mouse{
-//                            x: position.x, 
-//                            y: position.y})
-//                        .unwrap();
-//                },
-//                _ => (),
-//            }
-//            _ => (),
-//        }
-//    });
-//}
-//
-//mod tests {                                                                                          
-//    #[test]                                                                                          
-//    fn it_works() {                                                                                  
-//        assert_eq!(2 + 2, 4);                                                                        
-//    }                                                                                                
-//}

src/renderer.rs

@@ -41,25 +41,26 @@ where
             device::Device,
         };
 
-        debug!("Dropping Pipelines...");
-        for pipeline in self.pipelines.drain(..) {
-            pipeline.drop(&mut self.gpu);
-        }
-
         debug!("Waiting for device to idle...");
         let _ = self.gpu
             .device()
             .wait_idle();
 
+        debug!("Dropping Pipelines...");
+        for pipeline in self.pipelines.drain(..) {
+            pipeline.drop(&mut self.gpu);
+        }
+
         info!("Dropping Renderer..."); 
         unsafe {
+            debug!("Dropping SwapSystems...");
             for mut swap_system in self.swap_systems.drain(..) {
                 self.instance.destroy_surface(swap_system.drop(&mut self.gpu));
             }
             ManuallyDrop::drop(&mut self.gpu);
             ManuallyDrop::drop(&mut self.instance);
         }
-        trace!("Renderer dropped !");
+        debug!("Renderer dropped !");
     }
 }
 

src/renderer/swap_system.rs

@@ -37,7 +37,7 @@ where
     pub fn drop(&mut self, gpu: &mut Gpu<B>) -> B::Surface {
         use gfx_hal::device::Device;
 
-        debug!("Dropping SwapSystem...");
+        trace!("Dropping frames...");
         for mut frame in self.frames.drain(..) {
             frame.drop(gpu);
         }

src/renderer/swap_system/frame.rs

@@ -32,7 +32,6 @@ where
             pool::CommandPool,
         };
 
-        trace!("Dropping Frame...");
         unsafe {
             if self.image_view.is_some() {
                 warn!("Dropping non-presented frame !");