wip egui

3 files changed, 559 insertions, 183 deletions

diff --git a/bindgen/rust/examples/glfw.rs b/bindgen/rust/examples/glfw.rs
new file mode 100644
index 0000000..ce0bc7c
--- /dev/null
+++ b/bindgen/rust/examples/glfw.rs
@@ -0,0 +1,225 @@
+use std::ffi::CString;
+use std::ptr::addr_of_mut;
+
+use celeritas::*;
+use egui_glfw as egui_backend;
+use egui_backend::egui::{vec2, Pos2, Rect};
+use egui_glfw::glfw::{Context, fail_on_errors};
+
+use egui_glfw::glfw;
+
+const SCREEN_WIDTH: u32 = 2000;
+const SCREEN_HEIGHT: u32 = 1800;
+
+fn main() {
+    unsafe {
+      let mut glfw = glfw::init(glfw::fail_on_errors!()).unwrap();
+      glfw.window_hint(glfw::WindowHint::ContextVersion(4, 1));
+      glfw.window_hint(glfw::WindowHint::OpenGlProfile(
+          glfw::OpenGlProfileHint::Core,
+      ));
+      glfw.window_hint(glfw::WindowHint::DoubleBuffer(true));
+      glfw.window_hint(glfw::WindowHint::Resizable(false));
+  
+      let (mut window, events) = glfw
+          .create_window(
+              SCREEN_WIDTH,
+              SCREEN_HEIGHT,
+              "Egui in GLFW!",
+              glfw::WindowMode::Windowed,
+          )
+          .expect("Failed to create GLFW window.");
+  
+      window.set_all_polling(true);
+      window.make_current();
+      // glfw.set_swap_interval(glfw::SwapInterval::None);
+      glfw.set_swap_interval(glfw::SwapInterval::Adaptive);
+
+      
+  
+      gl::load_with(|symbol| window.get_proc_address(symbol) as *const _);
+
+      let window_ptr = window.window_ptr();
+      unsafe { 
+        // Cast the window pointer to the expected type
+        let window_ptr = window_ptr as *mut celeritas::GLFWwindow;
+        Core_Bringup(window_ptr);
+    };
+  
+      let mut painter = egui_backend::Painter::new(&mut window);
+      let egui_ctx = egui::Context::default();
+      
+  
+      let (width, height) = window.get_framebuffer_size();
+      let native_pixels_per_point = window.get_content_scale().0;
+      let native_pixels_per_point = 1.0;
+      // egui_ctx.set_pixels_per_point(2.0);
+  
+      let mut egui_input_state = egui_backend::EguiInputState::new(egui::RawInput {
+          screen_rect: Some(Rect::from_min_size(
+              Pos2::new(0f32, 0f32),
+              vec2(width as f32, height as f32) / native_pixels_per_point,
+          )),
+          ..Default::default()
+      });
+  
+      egui_input_state.input.time = Some(0.01);
+      
+      // let triangle = triangle::Triangle::new();
+      let slider = &mut 0.0;
+
+      // C data
+      let camera_pos = Vec3 {
+                    x: 18.9,
+                    y: 10.6,
+                    z: 11.6,
+                };
+                let camera_front = Vec3 {
+                    x: -0.6,
+                    y: -0.2,
+                    z: -0.7,
+                };
+                let camera = Camera_Create(
+                    camera_pos,
+                    camera_front,
+                    Vec3 {
+                        x: 0.0,
+                        y: 1.0,
+                        z: 0.0,
+                    },
+                    45.0,
+                );
+                SetCamera(camera);
+        
+                let mut cube_geo = Geo_CreateCuboid(f32x3 {
+                    x: 2.0,
+                    y: 2.0,
+                    z: 2.0,
+                });
+                let mut crate_mesh = Mesh_Create(addr_of_mut!(cube_geo), false);
+                let albedo_map = TextureLoadFromFile(
+                    CString::new("assets/demo/crate/Wood_Crate_001_basecolor.jpg")
+                        .unwrap()
+                        .as_ptr() as *const i8,
+                );
+                let roughness_map = TextureLoadFromFile(
+                    CString::new("assets/demo/crate/Wood_Crate_001_roughness.jpg")
+                        .unwrap()
+                        .as_ptr() as *const i8,
+                );
+                let normal_map = TextureLoadFromFile(
+                    CString::new("assets/demo/crate/Wood_Crate_001_normal.jpg")
+                        .unwrap()
+                        .as_ptr() as *const i8,
+                );
+                let ao_map = TextureLoadFromFile(
+                    CString::new("assets/demo/crate/Wood_Crate_001_ambientOcclusion.jpg")
+                        .unwrap()
+                        .as_ptr() as *const i8,
+                );
+                let name: [i8; 64] = [0; 64];
+                let mut crate_mat = Material {
+                    name: name,
+                    kind: 0,
+                    param_albedo: Vec3 {
+                        x: 0.0,
+                        y: 0.0,
+                        z: 0.0,
+                    },
+                    param_metallic: 0.0,
+                    param_roughness: 0.0,
+                    param_ao: 0.0,
+                    pbr_albedo_map: albedo_map,
+                    pbr_normal_map: normal_map,
+                    metal_roughness_combined: true,
+                    pbr_metallic_map: TextureHandle { raw: 99999 },
+                    pbr_roughness_map: roughness_map,
+                    pbr_ao_map: ao_map,
+                };
+                let crate_renderent = RenderEnt {
+                    mesh: addr_of_mut!(crate_mesh),
+                    material: addr_of_mut!(crate_mat),
+                    affine: mat4_ident(),
+                    casts_shadows: true,
+                };
+                let mut render_ents: [RenderEnt; 1] = [crate_renderent];
+                let mut skybox = Skybox_Default();
+        
+  
+      // Main rendering loop
+      while !window.should_close() {
+          glfw.poll_events();
+  
+          egui_ctx.begin_frame(egui_input_state.input.take());
+  
+          unsafe {
+              gl::ClearColor(0.455, 0.302, 0.663, 1.0);
+              gl::Clear(gl::COLOR_BUFFER_BIT);
+              gl::Clear(gl::DEPTH_TEST);
+          }
+  
+          Frame_Begin();
+          gl::Enable(gl::DEPTH_TEST);
+          gl::Enable(gl::CULL_FACE);
+
+          Skybox_Draw(addr_of_mut!(skybox), camera);
+            Render_RenderEntities(
+                render_ents.as_mut_ptr(),
+                render_ents.len(),
+            );
+            
+            // Frame_End();
+
+          // triangle.draw();
+  
+            gl::Disable(gl::DEPTH_TEST);
+            gl::Disable(gl::CULL_FACE);
+
+          egui::Window::new("Egui with GLFW").show(&egui_ctx, |ui| {
+              ui.label("Celeritas in-game editor");
+              let btn_m = &mut ui.button("-");
+              let btn_p = &mut ui.button("+");
+  
+              ui.add(egui::Slider::new(slider, 0.0..=100.0).text("My value"));
+  
+              if btn_m.clicked() && *slider > 0.0 {
+                  *slider -= 1.0;
+              }
+  
+              if btn_p.clicked() && *slider < 100.0 {
+                  *slider += 1.0;
+              }
+          });
+  
+          let egui::FullOutput {
+              platform_output,
+              textures_delta,
+              shapes, .. } = egui_ctx.end_frame();
+  
+          //Handle cut, copy text from egui
+          if !platform_output.copied_text.is_empty() {
+              egui_backend::copy_to_clipboard(&mut egui_input_state, platform_output.copied_text);
+          }
+  
+          //Note: passing a bg_color to paint_jobs will clear any previously drawn stuff.
+          //Use this only if egui is being used for all drawing and you aren't mixing your own Open GL
+          //drawing calls with it.
+          //Since we are custom drawing an OpenGL Triangle we don't need egui to clear the background.
+  
+          let clipped_shapes = egui_ctx.tessellate(shapes, native_pixels_per_point);
+          painter.paint_and_update_textures(native_pixels_per_point, &clipped_shapes, &textures_delta);
+  
+          for (_, event) in glfw::flush_messages(&events) {
+              match event {
+                  glfw::WindowEvent::Close => window.set_should_close(true),
+                  _ => {
+                      egui_backend::handle_event(event, &mut egui_input_state);
+                  }
+              }
+          }
+          
+          window.swap_buffers();
+      }
+
+    }
+}
diff --git a/bindgen/rust/examples/gui_test.rs b/bindgen/rust/examples/gui_test.rs
index 891b698..ddd8b86 100644
--- a/bindgen/rust/examples/gui_test.rs
+++ b/bindgen/rust/examples/gui_test.rs
@@ -1,135 +1,283 @@
-#![windows_subsystem = "windows"] // to turn off console.
-
-use celeritas::{Frame_Begin, Frame_End};
-use egui::DragValue;
-use egui_overlay::EguiOverlay;
-use egui_render_three_d::ThreeDBackend;
-use egui_render_wgpu::WgpuBackend;
-
-fn main() {
-    // use tracing_subscriber::{fmt, prelude::*, EnvFilter};
-    // if RUST_LOG is not set, we will use the following filters
-    // tracing_subscriber::registry()
-    //     .with(fmt::layer())
-    //     .with(
-    //         EnvFilter::try_from_default_env()
-    //             .unwrap_or(EnvFilter::new("debug,wgpu=warn,naga=warn")),
-    //     )
-    //     .init();
-
-    celeritas::egui_utils::start(HelloWorld { frame: 0});
-}
-
-pub struct HelloWorld {
-    pub frame: u64,
-}
-impl EguiOverlay for HelloWorld {
-    fn gui_run(
-        &mut self,
-        egui_context: &egui::Context,
-        _default_gfx_backend: &mut ThreeDBackend,
-        glfw_backend: &mut egui_window_glfw_passthrough::GlfwBackend,
-    ) {
-      // unsafe {
-      //   Frame_Begin(); 
-      //   Frame_End();
-      // }
-
-        // just some controls to show how you can use glfw_backend
-        egui::Window::new("controls").show(egui_context, |ui| {
-            ui.set_width(300.0);
-            self.frame += 1;
-            ui.label(format!("current frame number: {}", self.frame));
-            // sometimes, you want to see the borders to understand where the overlay is.
-            let mut borders = glfw_backend.window.is_decorated();
-            if ui.checkbox(&mut borders, "window borders").changed() {
-                glfw_backend.window.set_decorated(borders);
-            }
-
-            ui.label(format!(
-                "pixels_per_virtual_unit: {}",
-                glfw_backend.physical_pixels_per_virtual_unit
-            ));
-            ui.label(format!("window scale: {}", glfw_backend.scale));
-            ui.label(format!("cursor pos x: {}", glfw_backend.cursor_pos[0]));
-            ui.label(format!("cursor pos y: {}", glfw_backend.cursor_pos[1]));
-
-            ui.label(format!(
-                "passthrough: {}",
-                glfw_backend.window.is_mouse_passthrough()
-            ));
-            // how to change size.
-            // WARNING: don't use drag value, because window size changing while dragging ui messes things up.
-            let mut size = glfw_backend.window_size_logical;
-            let mut changed = false;
-            ui.horizontal(|ui| {
-                ui.label("width: ");
-                ui.add_enabled(false, DragValue::new(&mut size[0]));
-                if ui.button("inc").clicked() {
-                    size[0] += 10.0;
-                    changed = true;
-                }
-                if ui.button("dec").clicked() {
-                    size[0] -= 10.0;
-                    changed = true;
-                }
-            });
-            ui.horizontal(|ui| {
-                ui.label("height: ");
-                ui.add_enabled(false, DragValue::new(&mut size[1]));
-                if ui.button("inc").clicked() {
-                    size[1] += 10.0;
-                    changed = true;
-                }
-                if ui.button("dec").clicked() {
-                    size[1] -= 10.0;
-                    changed = true;
-                }
-            });
-            if changed {
-                glfw_backend.set_window_size(size);
-            }
-            // how to change size.
-            // WARNING: don't use drag value, because window size changing while dragging ui messes things up.
-            let mut pos = glfw_backend.window_position;
-            let mut changed = false;
-            ui.horizontal(|ui| {
-                ui.label("x: ");
-                ui.add_enabled(false, DragValue::new(&mut pos[0]));
-                if ui.button("inc").clicked() {
-                    pos[0] += 10;
-                    changed = true;
-                }
-                if ui.button("dec").clicked() {
-                    pos[0] -= 10;
-                    changed = true;
-                }
-            });
-            ui.horizontal(|ui| {
-                ui.label("y: ");
-                ui.add_enabled(false, DragValue::new(&mut pos[1]));
-                if ui.button("inc").clicked() {
-                    pos[1] += 10;
-                    changed = true;
-                }
-                if ui.button("dec").clicked() {
-                    pos[1] -= 10;
-                    changed = true;
-                }
-            });
-            if changed {
-                glfw_backend.window.set_pos(pos[0], pos[1]);
-            }
-        });
-
-        // here you decide if you want to be passthrough or not.
-        if egui_context.wants_pointer_input() || egui_context.wants_keyboard_input() {
-            // we need input, so we need the window to be NOT passthrough
-            glfw_backend.set_passthrough(false);
-        } else {
-            // we don't care about input, so the window can be passthrough now
-            glfw_backend.set_passthrough(true)
-        }
-        egui_context.request_repaint();
-    }
-}
\ No newline at end of file
+// // #![windows_subsystem = "windows"] // to turn off console.
+
+// use std::ptr;
+// use std::{ffi::CString, ptr::addr_of_mut};
+
+// use celeritas::*;
+// use egui::DragValue;
+// use egui_overlay::{EguiOverlay, OverlayApp};
+// use egui_render_three_d::ThreeDBackend;
+// use egui_window_glfw_passthrough::glfw::Context;
+// use egui_window_glfw_passthrough::{GlfwBackend, GlfwConfig};
+
+// fn main() {
+//     // use tracing_subscriber::{fmt, prelude::*, EnvFilter};
+//     // if RUST_LOG is not set, we will use the following filters
+//     // tracing_subscriber::registry()
+//     //     .with(fmt::layer())
+//     //     .with(
+//     //         EnvFilter::try_from_default_env()
+//     //             .unwrap_or(EnvFilter::new("debug,wgpu=warn,naga=warn")),
+//     //     )
+//     //     .init();
+
+//     unsafe {
+//         // let p: *mut GLFWwindow = ptr::null_mut();
+//         // Core_Bringup(p);
+
+//         // let core = get_global_core();
+//         // let glfw_window_ptr = Core_GetGlfwWindowPtr(core);
+
+//         let mut glfw_backend = GlfwBackend::new(GlfwConfig {
+//             // this closure will be called before creating a window
+//             glfw_callback: Box::new(|gtx| {
+//                 // some defualt hints. it is empty atm, but in future we might add some convenience hints to it.
+//                 (egui_window_glfw_passthrough::GlfwConfig::default().glfw_callback)(gtx);
+//                 // scale the window size based on monitor scale. as 800x600 looks too small on a 4k screen, compared to a hd screen in absolute pixel sizes.
+//                 gtx.window_hint(
+//                     egui_window_glfw_passthrough::glfw::WindowHint::ScaleToMonitor(true),
+//                 );
+//             }),
+//             opengl_window: Some(true), // macos doesn't support opengl.
+//             transparent_window: Some(false),
+//             window_title: "Celeritas egui".into(),
+//             ..Default::default()
+//         });
+
+//         // always on top
+//         // glfw_backend.window.set_floating(true);
+//         // disable borders/titlebar
+//         // glfw_backend.window.set_decorated(false);
+
+//         let latest_size = glfw_backend.window.get_framebuffer_size();
+//         let latest_size = [latest_size.0 as _, latest_size.1 as _];
+
+//         let default_gfx_backend = {
+//             ThreeDBackend::new(
+//                 egui_render_three_d::ThreeDConfig {
+//                     ..Default::default()
+//                 },
+//                 |s| glfw_backend.get_proc_address(s),
+//                 latest_size,
+//             )
+//         };
+
+//         let glfw_window_ptr = glfw_backend.window.window_ptr();
+//         unsafe {
+//             // Cast the window pointer to the expected type
+//             let window_ptr = glfw_window_ptr as *mut crate::GLFWwindow;
+//             Core_Bringup(window_ptr);
+//         };
+
+//         // cam pos: 18.871811 10.658584 11.643305 cam frontL -0.644326 -0.209243 -0.735569
+//         let camera_pos = Vec3 {
+//             x: 18.9,
+//             y: 10.6,
+//             z: 11.6,
+//         };
+//         let camera_front = Vec3 {
+//             x: -0.6,
+//             y: -0.2,
+//             z: -0.7,
+//         };
+//         let camera = Camera_Create(
+//             camera_pos,
+//             camera_front,
+//             Vec3 {
+//                 x: 0.0,
+//                 y: 1.0,
+//                 z: 0.0,
+//             },
+//             45.0,
+//         );
+//         SetCamera(camera);
+
+//         let mut cube_geo = Geo_CreateCuboid(f32x3 {
+//             x: 2.0,
+//             y: 2.0,
+//             z: 2.0,
+//         });
+//         let mut crate_mesh = Mesh_Create(addr_of_mut!(cube_geo), false);
+//         let albedo_map = TextureLoadFromFile(
+//             CString::new("assets/demo/crate/Wood_Crate_001_basecolor.jpg")
+//                 .unwrap()
+//                 .as_ptr() as *const i8,
+//         );
+//         let roughness_map = TextureLoadFromFile(
+//             CString::new("assets/demo/crate/Wood_Crate_001_roughness.jpg")
+//                 .unwrap()
+//                 .as_ptr() as *const i8,
+//         );
+//         let normal_map = TextureLoadFromFile(
+//             CString::new("assets/demo/crate/Wood_Crate_001_normal.jpg")
+//                 .unwrap()
+//                 .as_ptr() as *const i8,
+//         );
+//         let ao_map = TextureLoadFromFile(
+//             CString::new("assets/demo/crate/Wood_Crate_001_ambientOcclusion.jpg")
+//                 .unwrap()
+//                 .as_ptr() as *const i8,
+//         );
+//         let name: [i8; 64] = [0; 64];
+//         let mut crate_mat = Material {
+//             name: name,
+//             kind: 0,
+//             param_albedo: Vec3 {
+//                 x: 0.0,
+//                 y: 0.0,
+//                 z: 0.0,
+//             },
+//             param_metallic: 0.0,
+//             param_roughness: 0.0,
+//             param_ao: 0.0,
+//             pbr_albedo_map: albedo_map,
+//             pbr_normal_map: normal_map,
+//             metal_roughness_combined: true,
+//             pbr_metallic_map: TextureHandle { raw: 99999 },
+//             pbr_roughness_map: roughness_map,
+//             pbr_ao_map: ao_map,
+//         };
+//         let crate_renderent = RenderEnt {
+//             mesh: addr_of_mut!(crate_mesh),
+//             material: addr_of_mut!(crate_mat),
+//             affine: mat4_ident(),
+//             casts_shadows: true,
+//         };
+//         let mut render_ents: [RenderEnt; 1] = [crate_renderent];
+
+//         let world_state = HelloWorld {
+//             frame: 0,
+//             render_entities: render_ents,
+//         };
+
+//         let overlap_app = OverlayApp {
+//             user_data: world_state,
+//             egui_context: Default::default(),
+//             default_gfx_backend,
+//             glfw_backend,
+//         };
+
+//         overlap_app.enter_event_loop();
+
+//         // celeritas::egui_utils::start(HelloWorld { frame: 0});
+//     }
+// }
+
+// pub struct HelloWorld {
+//     pub frame: u64,
+//     pub render_entities: [RenderEnt; 1],
+// }
+// impl EguiOverlay for HelloWorld {
+//     fn gui_run(
+//         &mut self,
+//         egui_context: &egui::Context,
+//         _default_gfx_backend: &mut ThreeDBackend,
+//         glfw_backend: &mut egui_window_glfw_passthrough::GlfwBackend,
+//     ) {
+//         unsafe {
+//             // Frame_Begin();
+//             // Render_RenderEntities(
+//             //     self.render_entities.as_mut_ptr(),
+//             //     self.render_entities.len(),
+//             // );
+//             // Frame_End();
+//         }
+
+//         // just some controls to show how you can use glfw_backend
+//         egui::Window::new("controls").show(egui_context, |ui| {
+//             ui.set_width(300.0);
+//             self.frame += 1;
+//             ui.label(format!("current frame number: {}", self.frame));
+//             // sometimes, you want to see the borders to understand where the overlay is.
+//             let mut borders = glfw_backend.window.is_decorated();
+//             if ui.checkbox(&mut borders, "window borders").changed() {
+//                 glfw_backend.window.set_decorated(borders);
+//             }
+
+//             ui.label(format!(
+//                 "pixels_per_virtual_unit: {}",
+//                 glfw_backend.physical_pixels_per_virtual_unit
+//             ));
+//             ui.label(format!("window scale: {}", glfw_backend.scale));
+//             ui.label(format!("cursor pos x: {}", glfw_backend.cursor_pos[0]));
+//             ui.label(format!("cursor pos y: {}", glfw_backend.cursor_pos[1]));
+
+//             ui.label(format!(
+//                 "passthrough: {}",
+//                 glfw_backend.window.is_mouse_passthrough()
+//             ));
+//             // how to change size.
+//             // WARNING: don't use drag value, because window size changing while dragging ui messes things up.
+//             let mut size = glfw_backend.window_size_logical;
+//             let mut changed = false;
+//             ui.horizontal(|ui| {
+//                 ui.label("width: ");
+//                 ui.add_enabled(false, DragValue::new(&mut size[0]));
+//                 if ui.button("inc").clicked() {
+//                     size[0] += 10.0;
+//                     changed = true;
+//                 }
+//                 if ui.button("dec").clicked() {
+//                     size[0] -= 10.0;
+//                     changed = true;
+//                 }
+//             });
+//             ui.horizontal(|ui| {
+//                 ui.label("height: ");
+//                 ui.add_enabled(false, DragValue::new(&mut size[1]));
+//                 if ui.button("inc").clicked() {
+//                     size[1] += 10.0;
+//                     changed = true;
+//                 }
+//                 if ui.button("dec").clicked() {
+//                     size[1] -= 10.0;
+//                     changed = true;
+//                 }
+//             });
+//             if changed {
+//                 glfw_backend.set_window_size(size);
+//             }
+//             // how to change size.
+//             // WARNING: don't use drag value, because window size changing while dragging ui messes things up.
+//             let mut pos = glfw_backend.window_position;
+//             let mut changed = false;
+//             ui.horizontal(|ui| {
+//                 ui.label("x: ");
+//                 ui.add_enabled(false, DragValue::new(&mut pos[0]));
+//                 if ui.button("inc").clicked() {
+//                     pos[0] += 10;
+//                     changed = true;
+//                 }
+//                 if ui.button("dec").clicked() {
+//                     pos[0] -= 10;
+//                     changed = true;
+//                 }
+//             });
+//             ui.horizontal(|ui| {
+//                 ui.label("y: ");
+//                 ui.add_enabled(false, DragValue::new(&mut pos[1]));
+//                 if ui.button("inc").clicked() {
+//                     pos[1] += 10;
+//                     changed = true;
+//                 }
+//                 if ui.button("dec").clicked() {
+//                     pos[1] -= 10;
+//                     changed = true;
+//                 }
+//             });
+//             if changed {
+//                 glfw_backend.window.set_pos(pos[0], pos[1]);
+//             }
+//         });
+
+//         // here you decide if you want to be passthrough or not.
+//         if egui_context.wants_pointer_input() || egui_context.wants_keyboard_input() {
+//             // we need input, so we need the window to be NOT passthrough
+//             glfw_backend.set_passthrough(false);
+//         } else {
+//             // we don't care about input, so the window can be passthrough now
+//             glfw_backend.set_passthrough(true)
+//         }
+//         egui_context.request_repaint();
+//     }
+// }
diff --git a/bindgen/rust/examples/main_loop.rs b/bindgen/rust/examples/main_loop.rs
index 6fce5cf..2b4919a 100644
--- a/bindgen/rust/examples/main_loop.rs
+++ b/bindgen/rust/examples/main_loop.rs
@@ -1,4 +1,7 @@
-use std::{ffi::{ CString}, ptr::{self, addr_of_mut}};
+use std::{
+    ffi::CString,
+    ptr::{self, addr_of_mut},
+};
 
 use celeritas::*;
 
@@ -10,58 +13,64 @@ unsafe fn run_game() {
     let core = get_global_core();
     let glfw_window_ptr = Core_GetGlfwWindowPtr(core);
 
+    // cam pos: 18.871811 10.658584 11.643305 cam frontL -0.644326 -0.209243 -0.735569
     let camera_pos = Vec3 {
-        x: 0.0,
-        y: 2.0,
-        z: -3.0,
+        x: 18.9,
+        y: 10.6,
+        z: 11.6,
+    };
+    let camera_front = Vec3 {
+        x: -0.6,
+        y: -0.2,
+        z: -0.7,
     };
     let camera = Camera_Create(
         camera_pos,
-        vec3_normalise(vec3_negate(camera_pos)),
-        VEC3_Y,
+        camera_front,
+        Vec3 {
+            x: 0.0,
+            y: 1.0,
+            z: 0.0,
+        },
         45.0,
     );
     SetCamera(camera);
 
-    let whatever = Vec3 {
-        x: 1.0,
-        y: 1.0,
-        z: 1.0,
-    };
-    let sun = DirectionalLight {
-        direction: whatever,
-        ambient: whatever,
-        diffuse: whatever,
-        specular: whatever,
-    };
-    SetMainLight(sun);
-
-//     Geometry cube_geo = Geo_CreateCuboid(f32x3(2.0, 2.0, 2.0));
-//   Mesh crate_mesh = Mesh_Create(&cube_geo, false);  // dont free as we may use later
-//   TextureHandle albedo_map = TextureLoadFromFile("assets/demo/crate/Wood_Crate_001_basecolor.jpg");
-//   TextureHandle roughness_map =
-//       TextureLoadFromFile("assets/demo/crate/Wood_Crate_001_roughness.jpg");
-//   TextureHandle normal_map = TextureLoadFromFile("assets/demo/crate/Wood_Crate_001_normal.jpg");
-//   TextureHandle ao_map =
-//       TextureLoadFromFile("assets/demo/crate/Wood_Crate_001_ambientOcclusion.jpg");
-//   Material crate_mat = { .name = "Wood_Crate",
-//                          .kind = MAT_PBR,
-//                          .metal_roughness_combined = true,
-//                          .pbr_albedo_map = albedo_map,
-//                          .pbr_metallic_map = roughness_map,
-//                          .pbr_normal_map = normal_map,
-//                          .pbr_ao_map = ao_map };
-    let mut cube_geo = Geo_CreateCuboid(f32x3 { x: 2.0, y: 2.0, z: 2.0 });
+    let mut cube_geo = Geo_CreateCuboid(f32x3 {
+        x: 2.0,
+        y: 2.0,
+        z: 2.0,
+    });
     let mut crate_mesh = Mesh_Create(addr_of_mut!(cube_geo), false);
-    let albedo_map = TextureLoadFromFile(CString::new("assets/demo/crate/Wood_Crate_001_basecolor.jpg").unwrap().as_ptr() as *const i8);
-    let roughness_map = TextureLoadFromFile(CString::new("assets/demo/crate/Wood_Crate_001_roughness.jpg").unwrap().as_ptr() as *const i8);
-    let normal_map = TextureLoadFromFile(CString::new("assets/demo/crate/Wood_Crate_001_normal.jpg").unwrap().as_ptr() as *const i8);
-    let ao_map = TextureLoadFromFile(CString::new("assets/demo/crate/Wood_Crate_001_ambientOcclusion.jpg").unwrap().as_ptr() as *const i8);
+    let albedo_map = TextureLoadFromFile(
+        CString::new("assets/demo/crate/Wood_Crate_001_basecolor.jpg")
+            .unwrap()
+            .as_ptr() as *const i8,
+    );
+    let roughness_map = TextureLoadFromFile(
+        CString::new("assets/demo/crate/Wood_Crate_001_roughness.jpg")
+            .unwrap()
+            .as_ptr() as *const i8,
+    );
+    let normal_map = TextureLoadFromFile(
+        CString::new("assets/demo/crate/Wood_Crate_001_normal.jpg")
+            .unwrap()
+            .as_ptr() as *const i8,
+    );
+    let ao_map = TextureLoadFromFile(
+        CString::new("assets/demo/crate/Wood_Crate_001_ambientOcclusion.jpg")
+            .unwrap()
+            .as_ptr() as *const i8,
+    );
     let name: [i8; 64] = [0; 64];
     let mut crate_mat = Material {
         name: name,
         kind: 0,
-        param_albedo: VEC3_ZERO,
+        param_albedo: Vec3 {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+        },
         param_metallic: 0.0,
         param_roughness: 0.0,
         param_ao: 0.0,
@@ -70,7 +79,7 @@ unsafe fn run_game() {
         metal_roughness_combined: true,
         pbr_metallic_map: TextureHandle { raw: 99999 },
         pbr_roughness_map: roughness_map,
-        pbr_ao_map: ao_map
+        pbr_ao_map: ao_map,
     };
     let crate_renderent = RenderEnt {
         mesh: addr_of_mut!(crate_mesh),
@@ -78,14 +87,8 @@ unsafe fn run_game() {
         affine: mat4_ident(),
         casts_shadows: true,
     };
-    let mut render_entities: [RenderEnt; 1] = [crate_renderent]; 
-
-    // RenderEnt crate_renderable = {
-    //     .mesh = &crate_mesh, .material = &crate_mat, .affine = mat4_scale(3.0), .casts_shadows = true
-    //   };
+    let mut render_entities: [RenderEnt; 1] = [crate_renderent];
     
-    //   RenderEnt entities[] = { cube_r, crate_renderable };
-    //   size_t entity_count = 1;
 
     // main loop
     while !ShouldExit() {