trying to eat the spaghetti (make it less)

playground/Cargo.toml

@@ -5,5 +5,3 @@ edition = "2024"
 
 [dependencies]
 moonhare_engine = { path = "../moonhare_engine" }
-moonhare_log = { path = "../moonhare_log" }
-glium = "0.36.0"

playground/src/main.rs

@@ -1,144 +1,6 @@
-use std::fs::read_to_string;
-
-use glium::{index::NoIndices, Frame, Program, VertexBuffer};
-use glium::{uniform, Surface};
-use moonhare_engine::{core::game::Game, game_plugin::GamePlugin, vertex::Vertex};
-use moonhare_log::{mh_debug, mh_error, mh_info, mh_trace, mh_warn};
-
-struct PlaygroundGame {
-    t: f32,
-    shape: Vec<Vertex>, 
-    vertex_buffer: Option<VertexBuffer<Vertex>>,
-    indices: Option<NoIndices>,
-    program: Option<Program>,
-}
-
-impl GamePlugin for PlaygroundGame {
-    fn init(&mut self) {
-        self.t = 0.0;
-    }
-    fn update(&mut self) { 
-        self.t += 0.02;
-        // use 't' as an offset -> smooth animation
-
-    }
-    fn render(&mut self, target: &mut Frame) {
-        
-        target.clear_color(
-            0.0, 
-            0.0, 
-            1.0, 
-            1.0
-        );
-        let x_offset = self.t.sin() * 0.5;
-                    
-        // Note: In OpenGL matrices are column-major
-        // Standard mathematical notation is row major:
-        //      1.0     0.0     0.0     x_offset
-        //      0.0     1.0     0.0     0.0
-        //      0.0     0.0     1.0     0.0
-        //      0.0     0.0     0.0     1.0
-        let uniforms = uniform! {
-            matrix: [
-                [1.0, 0.0, 0.0, 0.0],
-                [0.0, 1.0, 0.0, 0.0],
-                [0.0, 0.0, 1.0, 0.0],
-                [x_offset, 0.0, 0.0, 1.0f32],
-            ]
-        };    
-
-        target.draw(
-            self.vertex_buffer.as_ref().unwrap(), 
-            &self.indices.unwrap(), 
-            self.program.as_ref().unwrap(), 
-            &uniforms,
-            &Default::default()
-        ).unwrap();
-    }
-    fn cleanup(&mut self) {
-        
-    }
-    fn handle_events(&mut self) {
-        
-    }
-}
-
-
+use moonhare_engine::{event, log::{self}, window::{self, winit_window::WinitWindow}};
 
 fn main() {
-    let _ = moonhare_log::configere_logger();
-    mh_info("Blub");
-    mh_debug("blub");
-    mh_warn("blug");
-    mh_trace("trace");
-    mh_error("error");
-    println!("Blaa");
-/* 
-    let mut game = Game::new();
-    game.register_plugin(Box::new(PlaygroundGame{ t: 0.0, shape: Default::default(), vertex_buffer: None, indices: None, program: None }));
-    game.init();
-
-    let binding = Some(game.display.clone()).unwrap();
-    // todo: unwraps on none
-    let display = binding;
-
-    let shape = Vertex::define_shape(
-    Vertex { position: [-0.5, -0.5], color: [1.0, 0.0, 0.0] },
-    Vertex { position: [ 0.0,  0.5], color: [0.0, 1.0, 0.0] },
-    Vertex { position: [ 0.5, -0.5], color: [0.0, 0.0, 1.0] }
-    );
-
-
-    // "Upload" shape to the memory of the GPU (Vertex Buffer)
-    // Isn't strictly necessary but, makes tge drawing operation faster
-    
-    let vertex_buffer: VertexBuffer<Vertex> = VertexBuffer::new(&display, &shape).unwrap();
-
-        
-    // Complex shapes consist of hundreds/thousands of vertices -> need to have a list of vertices and tell OpenGL how to link these
-    // vertices together to obtain triangles.
-    // For only one triangle -> pass dummy marker to glium
-    // This line tells OpenGl that we don't use indices and instand want to draw a certain number of seperate triangles
-    let indices = glium::index::NoIndices(glium::index::PrimitiveType::TrianglesList);
-
-    // (Simplified) Render Pipeline:
-    // Vertex Shader -> Fragment (Pixel) Shader 
-    // uniform:
-    // value is set when we draw by passing its value to the draw function
-    // (easiest way is uniform! macro)
-    // Important to write matrix * vertex -> Matrix operations produce different results depending on the order
-    // out: defines a variable that is going to be passed along to the fragment shader
-
-    let vertex_shader_src = read_to_string("playground/src/shaders/vertex_shader.glsl").unwrap_or("vertex shader failed to unwrap".to_owned());
-    let fragment_shader_src = read_to_string("playground/src/shaders/fragment_shader.glsl").unwrap_or("fragment shader failed to unwrap".to_owned());
-
-    // send shader source code to glium
-    let program = match glium::Program::from_source(
-        &display, 
-        &vertex_shader_src, 
-        &fragment_shader_src, 
-        None
-    )  {
-        Ok(program) => program,
-        Err(err) => {
-            eprintln!("Shader compilation error: {:?}", err);
-            panic!("Failed to compile shaders")
-        }
-    };               
-
-
-    let pg_game = PlaygroundGame { 
-        t: 0.0,
-        shape: shape,
-        vertex_buffer: Some(vertex_buffer),
-        indices: Some(indices),
-        program: Some(program),
-    };
-
-    //let mut a = game.borrow_mut();
-    game.register_plugin(Box::new(pg_game));
-
-    game.run();
-
-*/
+    let _ = log::configere_logger();
+    log::info("test");
 }