Dairy-Drift/src/debug.rs

use imgui_glow_renderer::AutoRenderer;
use imgui_sdl2_support::SdlPlatform;
use std::collections::HashMap;
use sdl2::event::Event;
const MODELS: [&str; 3]= ["resources/models/TestCarModel/CarW4.obj", "resources/models/TestCarModel/CarW1.obj",
"resources/models/TestCarModel/CarW0.obj"];

mod info;


pub enum dEvent
    {
        loadModel(i32),
        setTest(f32, i32),
        addWindow(OpenWindows),
        removeWindow(OpenWindows),
        exit,
    }


pub enum Callback
    {
        ModelInfo(info::ModelI),
        TestWind(info::testI),
        MainMenu,
    }

#[derive(Clone, PartialEq)]
pub enum OpenWindows {
    ModelInfo,
    TestWind,
    MainMenu,
}

pub struct Debug {
    imgui: imgui::Context,
    renderer: AutoRenderer,
    platform: SdlPlatform,
    pub windows: HashMap<u16, OpenWindows>,
    next_id: u16,
    free_ids:Vec<u16>
}



impl Debug {
    pub fn new(gl: std::sync::Arc<glow::Context>) -> Debug
        {
            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),
                };

            let mut windows = HashMap::new();
            windows.insert(0,OpenWindows::MainMenu,);
            Debug {
                imgui,
                renderer,
                platform,
                windows,
                next_id: 1,
                free_ids: Vec::new(),
            }
        }

    pub fn handle(&mut self, event: &sdl2::event::Event)
        {
            self.platform.handle_event(&mut self.imgui, event);
        }

    pub fn drawImgui(&mut self, events_loop: &sdl2::EventPump, window: &sdl2::video::Window,
    callback: Vec<Callback>) -> Vec<dEvent>
        {
            self.platform.prepare_frame(&mut self.imgui, &window, &events_loop);
            let ui = self.imgui.new_frame();
            let mut ret = Vec::new();
            for call in callback
            {
                match call {
                    Callback::ModelInfo(a) =>
                        ret.append(&mut Debug::displayModel(ui, &a)),
                    Callback::TestWind(mut a) =>
                        ret.append(&mut Debug::displayTest(ui, &mut a)),
                    Callback::MainMenu =>
                        ret.append(&mut Debug::displayMain(ui)),
                }

            }



            let draw_data = self.imgui.render();

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

            ret
        }
    pub fn addWindow(&mut self, window: OpenWindows)
    {
        let mut found = false;
        for (hashId, windowType) in &self.windows
            {
                if *windowType == window
                    {
                        found = true;
                        break;
                    }
            }
        if (!found)
            {
        if (self.free_ids.is_empty())
            {
                self.windows.insert(self.next_id, window);
                self.next_id += 1;
            }
        else {
            self.windows.insert(self.free_ids.pop().unwrap(), window);
        }
            }
    }
    pub fn removeWindow(&mut self, window: OpenWindows)
        {
            println!("searching for a match...");
            let mut id = 0;
            for (hashId, windowType) in &self.windows
            {
                if *windowType == window {
                    id = *hashId;
                    break;
                }

            }
            if id !=0
            {
                self.windows.remove(&id);
                self.free_ids.push(id);
            }
        }

    fn displayTest(ui: &mut imgui::Ui, testI: &mut info::testI) -> Vec<dEvent>
    {
        let mut ret = Vec::new();
        let mut selectedModel = testI.selectedModel;
        let mut spinSpeed = testI.spinSpeed;
        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 spinSpeed);
              if ui
                  .button("Close") {
                      ret.push(dEvent::removeWindow(OpenWindows::TestWind));
                  }
              if ui.list_box("Select Model to Load", &mut selectedModel, &MODELS, 5) {
                  ret.push(dEvent::loadModel(selectedModel));
              }
          });
        ret.push(dEvent::setTest(spinSpeed, selectedModel
        ));
        ret
    }

    fn displayModel(ui: &mut imgui::Ui ,model: &info::ModelI) -> Vec<dEvent>
    {
        let mut ret = Vec::new();
        ui.window("Stats")
          .size([300.0, 500.0], imgui::Condition::Always)
          .build(|| {
              ui.text("Model Information");
              ui.text(format!("count meshes: {}", model.meshesCount));
              ui.separator();
              for i in 0..model.meshesCount
              {
                  ui.text(format!("Mesh Number {}", i));
                  ui.text(format!("count Vertices: {}", model.vertCount[i]));
                  ui.separator();
              }
              if ui.button("close") {
                  ret.push(dEvent::removeWindow(OpenWindows::ModelInfo))
              }
          });
        ret
    }

    fn displayMain(ui: &mut imgui::Ui) -> Vec<dEvent>
    {
        let mut ret = Vec::new();
        ui.window("Welcome to the main Menu")
          .size([500.0, 500.0], imgui::Condition::Always)
          .build(|| {
              ui.text("this is the main Debugger Menu, it's used to Debug the game");
              ui.text("although it isn't done yet");
              ui.separator();
              if ui.button("Open the Model Info") {
                  ret.push(dEvent::addWindow(OpenWindows::ModelInfo))
              }
              if ui.button("Open the Test Modifier"){
                  ret.push(dEvent::addWindow(OpenWindows::TestWind))
              }
              if ui.button("Quit") {
                  ret.push(dEvent::exit)
              }

          });
        ret
    }


   }



use crate::model;
pub fn ModelInfo(model: &model::Model) -> Callback
    {
        let mut vertCount = Vec::new();
        let meshesCount = model.meshes.len();
        for i in 0..model.meshes.len() {
            vertCount.push(model.meshes[i].vertices.len());
        }
        Callback::ModelInfo(info::ModelI {
            meshesCount,
            vertCount
        })
    }

pub fn TestWind(spinSpeed: f32, selectedModel: i32) -> Callback
    {
        Callback::TestWind(info::testI {
            spinSpeed,
            selectedModel,
        })
    }