iv/src/controller.rs

#[allow(unused_imports)]
use log::{debug, error, info, trace, warn};

use crate::{
    io::{Input, Output},
    subengine::SubenginePipeline,
};

//--Controller Implementation-----------------------------------------------------------------------
pub struct Controller<'a, I, W, O>
where
    I: Input,
    W: raw_window_handle::HasRawWindowHandle,
    O: Output<W>,
{
    pipelines: Vec<SubenginePipeline<'a, I, W, O>>,
    mouse_pos: [f32; 2],
}

impl<I, W, O> Controller<'_, I, W, O> 
where
    I: Input,
    W: raw_window_handle::HasRawWindowHandle,
    O: Output<W>,
{

    pub fn new<'a, Ip>(pipelines: Ip) -> Controller<'a, I, W, O> 
    where
        I: 'a + Input,
        W: raw_window_handle::HasRawWindowHandle,
        O: 'a + Output<W>,
        Ip: IntoIterator<Item = SubenginePipeline<'a, I, W, O>>,
    {
        let pipelines_vec = pipelines
            .into_iter()
            .map(|pipeline| pipeline)
            .collect();

        Controller {
            pipelines: pipelines_vec,
            mouse_pos: [0.5, 0.5],
        }
    }

    pub fn run(&mut self) {
        use std::time::Duration;

        use crate::{
            subengine::subengine_controller::SubengineCommand,
            io::Key,
            utils::Triangle,
        };

        let mut input_keys: Vec<Key> = Vec::new(); 

        for pipeline in &mut self.pipelines {
            for input in &pipeline.inputs {
                match input.borrow().read(Duration::from_millis(1)) {
                    Ok(key) => input_keys.push(key),
                    Err(_err) => (),
                }
            }
            for input_key in &input_keys {
                match input_key {
                    Key::MouseMove{x,y} => self.mouse_pos = [
                        (x/1280.0 * 2.0 - 1.0) as f32,
                        (y/720.0 * 2.0 - 1.0) as f32,
                    ],
                    Key::Close => return,
                    _ => (),
                };
            }
            for subengines in &pipeline.subengines {
                for subengine in subengines {
                    subengine.exec(SubengineCommand::Run);
                }
                for subengine in subengines {
                    subengine.wait_for_exec(Duration::from_millis(1)).unwrap();
                }
            }
            
            let triangle = Triangle {
                points: [self.mouse_pos, [-0.5, 0.5], [-0.5, -0.5]],
            };

            debug!("Triangle : {:#?}", triangle);

            for (renderer, output) in &mut pipeline.renderers {
            //    match renderer.draw_clear_frame(output, self.color) {
            //        Err(err) => warn!("{}", err),
            //        _ => (),
            //    }
                match renderer.draw_triangle_frame(output, triangle) {
                    Err(err) => warn!("{}", err),
                    _ => (),
                };
            };
        };
    }
}
//These tests are disabled because of some stange issue with cargo not waiting for the drop 
//functions to execute before executing the next test or something like that...
#[cfg(test)]
#[allow(dead_code)]
mod tests {
    use super::*;

    use std::iter;

    use crate::{
        io::WinitWindow,
        renderer::Renderer,
        utils::Rect,
        subengine::{SubengineController, TestSubengine},
    };

    use gfx_backend_vulkan as vk_back;

    //#[test]
    fn test_new() {
        use std::cell::RefCell;

        //creating windows
        let window1 = RefCell::new(WinitWindow::new("IV", Rect {w: 1280, h: 720}).unwrap());
        let window2 = RefCell::new(WinitWindow::new("IV 2", Rect {w: 720, h: 480}).unwrap());

        //creating renderers
        let renderer1 = Renderer::<vk_back::Backend>::new(&mut iter::once(&window1)).unwrap();
        let renderer2 = Renderer::<vk_back::Backend>::new(&mut iter::once(&window2)).unwrap();

        //creating subengines
        let (test_subengine1, _test_rx1) = TestSubengine::new("run1");
        let test_controller1 = SubengineController::new(test_subengine1);
        let (test_subengine2, _test_rx2) = TestSubengine::new("run2");
        let test_controller2 = SubengineController::new(test_subengine2);

        //preparing data
        let inputs = vec![&window1, &window2];
        let subengines = vec![vec![test_controller1, test_controller2]];
        let renderers = vec![(renderer1, &window1), (renderer2, &window2)];

        //creating pipeline
        let subengine_pipeline = SubenginePipeline::new(inputs, subengines, renderers);

        //creating controller
        let _controller = Controller::new(vec![subengine_pipeline]);
    }

    //#[test]
    fn test_run() {
        use std::cell::RefCell;

        //creating windows
        let window1 = RefCell::new(WinitWindow::new("IV", Rect {w: 1280, h: 720}).unwrap());
        let window2 = RefCell::new(WinitWindow::new("IV 2", Rect {w: 720, h: 480}).unwrap());

        //creating renderers
        let renderer1 = Renderer::<vk_back::Backend>::new(&mut iter::once(&window1)).unwrap();
        let renderer2 = Renderer::<vk_back::Backend>::new(&mut iter::once(&window2)).unwrap();

        //creating subengines
        let (test_subengine1, _test_rx1) = TestSubengine::new("run1");
        let test_controller1 = SubengineController::new(test_subengine1);
        let (test_subengine2, _test_rx2) = TestSubengine::new("run2");
        let test_controller2 = SubengineController::new(test_subengine2);

        //preparing data
        let inputs = vec![&window1, &window2];
        let subengines = vec![vec![test_controller1, test_controller2]];
        let renderers = vec![(renderer1, &window1), (renderer2, &window2)];

        //creating pipeline
        let subengine_pipeline = SubenginePipeline::new(inputs, subengines, renderers);

        //running controller
        let mut controller = Controller::new(vec![subengine_pipeline]);
        for _i in 0..10 {
            controller.run();
        }
    }
}