Dairy-Drift/src/scene.rs

use crate::model::Model;
use crate::camera::Camera;
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 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"];



/// XXX this is temporary, thus the name
pub struct tempData {
    pub projection: Matrix4<f32>,
    pub spinSpeed: f32,
    pub current_rad: f32,
    pub currentFrame: f32,
    pub deltaTime: f32,
    pub lastFrame: f32,
}



pub struct Scene {
    gl: Arc<glow::Context>,
    pub Car: Model,
    camera: Camera,
    imgui: imgui::Context,
    imgui_rend: AutoRenderer,
    imgui_plat: SdlPlatform,
    shaders: Vec<Rc<shader>>,
    time: std::time::Instant,
    tempData: tempData,
}

impl Scene{
    pub fn new(gl: Arc<glow::Context>) -> Scene
        {
            let Car = Model::new(MODELS[0], Arc::clone(&gl));

            let shader = Rc::new(shader::new("model", 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 tempData = tempData {
                projection: perspective(Deg(45.0), 1600.0/ 900.0, 0.1, 100.0),
                spinSpeed: 1.0,
                current_rad: 1.0,
                currentFrame: 0.0,
                deltaTime: 0.0,
                lastFrame: 0.0

            };

            let mut imgui = imgui::Context::create();

            imgui
                .fonts()
                .add_font(&[imgui::FontSource::DefaultFontData {config: None}]);

            let mut platform = SdlPlatform::init(&mut imgui);
            let mut renderer = match AutoRenderer::initialize(gl.clone(), &mut imgui)
                {
                    Ok(ret) => ret,
                    Err(s) => panic!("Failed to initialize Imgui Platform Renderer: {}", s),
                };

            Scene{
                gl,
                Car,
                camera,
                imgui,
                imgui_rend: renderer,
                imgui_plat: platform,
                shaders: vec![shader],
                time,
                tempData,
            }
        }

    pub fn update(&mut self ,events_loop: &mut sdl2::EventPump, window: &sdl2::video::Window)
        {
            self.tempData.currentFrame = self.time.elapsed().as_secs_f32();
            self.tempData.deltaTime = self.tempData.currentFrame - self.tempData.lastFrame;
            self.tempData.lastFrame = self.tempData.currentFrame;
            self.tempData.current_rad += self.tempData.spinSpeed/15.0;

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

                self.shaders[0].Use();
                self.tempData.projection = perspective(Deg(self.camera.Zoom), SCR_WIDTH as f32 /SCR_HEIGHT as f32, 0.1, 100.0);
                let view = self.camera.GetViewMatrix();
                self.shaders[0].setMat4("projection", &self.tempData.projection);
                self.shaders[0].setMat4("view", &view);

                let mut model: Matrix4<f32> = Matrix4::from_axis_angle(vec3(0.0, -1.0, 0.0).normalize(),
                cgmath::Rad(self.tempData.current_rad));

                model = model * Matrix4::from_scale(0.2);
                self.shaders[0].setMat4("model", &model);
            }
            self.Car.Draw(&self.shaders[0]);

            self.drawImgui(&events_loop, &window);

            let quit = false;
            for event in events_loop.poll_iter() {
                self.imgui_plat.handle_event(&mut self.imgui, &event);

            }
        }


    fn drawImgui(&mut self, events_loop: &sdl2::EventPump, window: &sdl2::video::Window)
        {
            self.imgui_plat.prepare_frame(&mut self.imgui, &window, &events_loop );
            let ui = self.imgui.new_frame();

            ui.window("POLY I WILL FUCKING")
                  .size([500.0, 100.0], imgui::Condition::FirstUseEver)
                  .build(|| {
                      ui.text("you serve no purpose in life");
                      ui.text("Your Purpose in life is to suck my dick");
                      ui.slider("The Spin Speed", 0.1, 10.0, &mut self.tempData.spinSpeed);
                  });

            ui.window("Stats")
              .size([300.0,500.0], imgui::Condition::Always)
              .build(|| {
                  ui.text("Model Information");
                  ui.separator();
                  ui.text(format!("count meshes: {}", self.Car.meshes.len()));
                  for i in 0..self.Car.meshes.len()
                  {
                      ui.text(format!("Mesh Number: {}",i ));
                      ui.text(format!("count vertices: {}", self.Car.meshes[i].vertices.len()));
                      ui.separator();
                  }
              });


            let draw_data = self.imgui.render();

            self.imgui_rend.render(draw_data).unwrap();

        }

}