Dairy-Drift/src/scene.rs

use crate::model::Model;
use crate::camera::Camera;
use crate::camera::Camera_Movement;
use crate::shader::shader;
use std::sync::Arc;
use std::rc::Rc;
use glow::*;

use imgui_glow_renderer::AutoRenderer;
use imgui_sdl2_support::SdlPlatform;
use crate::debug;
pub mod objects;
use cgmath::{Matrix4, vec3, Point3, Deg, perspective};
use cgmath::prelude::*;

use sdl2::keyboard::Keycode;
use sdl2::event::Event;

const SCR_WIDTH: u32 = 1600;
const SCR_HEIGHT: u32 = 900;

const MODELS: [&str; 3]= ["resources/models/TestCarModel/CarW4.obj", "resources/models/TestCarModel/CarW1.obj",
"resources/models/TestCarModel/CarW0.obj"];

use crate::debug::Debug;

pub enum SceneEnum {
    Exit,
    Pause,
    Resume,
}


pub struct Scene {
    gl: Arc<glow::Context>,
    pub Car: objects::Player,
    camera: Camera,
    debug: Debug,
    shaders: Vec<Rc<shader>>,
    time: std::time::Instant,
    DebugMode: bool,
    input: objects::Input,
    plane: objects::plane
}

impl Scene{
    pub fn new(gl: Arc<glow::Context>) -> Scene
        {
            let Car = objects::Player::new(Arc::clone(&gl));

            let shader = Rc::new(shader::new("model", Arc::clone(&gl)));
            let planeShader = Rc::new(shader::new("plane", Arc::clone(&gl)));

            let time = std::time::Instant::now();

            let camera = Camera {
                Position: Point3::new(0.0, 0.40, 1.0),
                Pitch: -20.0,
                ..Camera::default()
            };
            let plane = objects::plane::new(Arc::clone(&gl));

            let debug = Debug::new(gl.clone());
            Scene{
                gl,
                Car,
                camera,
                debug,
                shaders: vec![shader, planeShader],
                time,
                DebugMode: false,
                input: objects::Input::default(),
                plane
            }
        }

    pub fn update(&mut self ,events_loop: &mut sdl2::EventPump, window: &sdl2::video::Window) -> SceneEnum
        {




            let mut ret = SceneEnum::Resume;

            unsafe {
            self.gl.enable(glow::DEPTH_TEST);
            self.gl.clear(glow::COLOR_BUFFER_BIT | glow::DEPTH_BUFFER_BIT);
            }


            self.camera.follow(self.Car.Transform.Position);
            self.plane.draw(&self.shaders[1], &self.camera);
            self.Car.update(&self.input);
            self.Car.Draw(&self.shaders[0], &self.camera);
            if self.DebugMode{
                self.handleDebug(events_loop, window, &mut ret)
                          }

            for event in events_loop.poll_iter() {
                if self.DebugMode {
                self.debug.handle(&event);
                }

                match event {
                    Event::Quit {..} |
                    Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
                        ret = SceneEnum::Exit;
                    },
                    Event::KeyDown {keycode: Some(Keycode::P), ..} => {
                    },
                    Event::KeyDown {keycode: Some(Keycode::Q), ..} => {
                        self.DebugMode = !self.DebugMode
                    },
                    Event::KeyDown {keycode: Some(Keycode::W), repeat: false, ..} => {
                        self.input.Accel = true;
                    },
                    Event::KeyUp {keycode: Some(Keycode::W), ..} => {
                        self.input.Accel = false;
                    },
                    Event::KeyDown {keycode: Some(Keycode::S), repeat: false, ..} => {
                        self.input.Decel = true;
                    },
                    Event::KeyUp {keycode: Some(Keycode::S), ..} => {
                        self.input.Decel = false;
                    },
                    Event::KeyDown {keycode: Some(Keycode::D), repeat: false, ..} => {
                        self.input.Right = true;
                    },
                    Event::KeyUp {keycode: Some(Keycode::D), ..} => {
                        self.input.Right = false;
                    },

                    Event::KeyDown {keycode: Some(Keycode::A), repeat: false, ..} => {
                        self.input.Left = true;
                    },
                    Event::KeyUp {keycode: Some(Keycode::A), ..} => {
                        self.input.Left = false;
                    },
                    Event::KeyDown {keycode: Some(Keycode::M), ..} => {
                        self.debug.addWindow(debug::OpenWindows::ModelInfo)
                    },
                        _ => {}
                    }

            }

                ret
        }

    fn handleDebug(&mut self, events_loop:&mut sdl2::EventPump, window: &sdl2::video::Window, ret: &mut SceneEnum)
    {
        let mut Callbacks = Vec::new();
        let windows = self.debug.windows.clone();
        for (id, window) in windows
        {
            match window {
                debug::OpenWindows::ModelInfo => Callbacks.push(debug::ModelInfo(&self.Car.Model)),
                debug::OpenWindows::MainMenu => Callbacks.push(debug::Callback::MainMenu),
                debug::OpenWindows::Object(a) => Callbacks.push(debug::ObjectInfo(&self.Car)),

            }
        }


        for command in self.debug.drawImgui(&events_loop, &window, Callbacks)
        {
            use crate::debug::dEvent;
            match command
            {
                dEvent::exit => *ret = SceneEnum::Exit,
                dEvent::loadModel(i) => self.Car.Model = Model::new(MODELS[i as usize], Arc::clone(&self.gl)),
                dEvent::addWindow(a) => self.debug.addWindow(a),
                dEvent::removeWindow(a) => self.debug.removeWindow(a),
                dEvent::setObj(p) =>
                {
                    self.Car.Transform.Position = p;
                }
                // TODO
                dEvent::getObj(_a) => ()
            }
        }

    }


}