Bam! Camera movement, pure jank implementation but on the right track

src/main.rs

@@ -30,10 +30,10 @@ use winit::{
 use gilrs::Event as GilEvent;
 
 use crate::camera::{CameraController, Camera};
-use crate::components::{Collider, Color, Physics, Position};
+use crate::components::{Collider, Color, Physics, Position, LoopState};
 use crate::physics::PhysicsState;
 use crate::render::Renderer;
-use crate::owned_event::TrEventExtension;
+use crate::owned_event::{OwnedEventExtension, OwnedEvent};
 use gilrs::{Gamepad, Gilrs};
 use rapier3d::counters::Timer;
 
@@ -85,12 +85,10 @@ fn main() {
         (local_pool, spawner)
     };
 
-    // Schedule for the render systen
     let mut render_schedule = Schedule::builder()
         .add_system(render::render_test_system())
         .build();
 
-    // TODO schedule for the update system and others
     let mut update_schedule = Schedule::builder()
         .add_system(physics::update_camera_system())
         .add_system(physics::run_physics_system())
@@ -98,7 +96,11 @@ fn main() {
         // next system here, gamelogic update system?
         .build();
 
-    let event_loop = EventLoop::<TrEventExtension>::with_user_event();
+    let mut event_schedule = Schedule::builder()
+        .add_system(owned_event::event_dispatch_system())
+        .build();
+
+    let event_loop = EventLoop::<OwnedEventExtension>::with_user_event();
     let mut builder = winit::window::WindowBuilder::new();
     builder = builder.with_title("MVGE");
 
@@ -126,10 +128,15 @@ fn main() {
     resources.insert(physics_state);
     resources.insert(physics_pipeline);
 
-    resources.insert(CameraController::new(1.0, 1.0));
-    resources.insert(Instant::now());
+    resources.insert(LoopState {
+        delta_time: Default::default(),
+        start_time: Instant::now(),
+        step_size: 0.005,
+    });
 
 
+    resources.insert(Vec::<OwnedEvent<OwnedEventExtension>>::new());
+
     let event_loop_proxy = event_loop.create_proxy();
 
     std::thread::spawn(move || {
@@ -148,7 +155,7 @@ fn main() {
             while let Some(GilEvent { id, event, time }) = gilrs.next_event() {
                 println!("{:?} New event from {}: {:?}", time, id, event);
                 active_gamepad = Some(id);
-                event_loop_proxy.send_event(TrEventExtension::GamepadEvent {
+                event_loop_proxy.send_event(OwnedEventExtension::GamepadEvent {
                     gil_event: GilEvent { id, event, time }
                 }).ok();
             }
@@ -164,19 +171,15 @@ fn main() {
         }
     });
 
-
-
-    let step_size: f32 = 0.005;
     let mut elapsed_time: f32 = { // deltatime since last frame
-        let last_frame = resources.get::<Instant>().unwrap();
-        last_frame.elapsed()
+        let loop_state = resources.get::<LoopState>().unwrap();
+        loop_state.start_time.elapsed()
     }.as_secs_f32();
 
     let mut delta_time: f32 = 0.0;
     let mut accumulator_time: f32 = 0.0;
     let mut current_time: f32 = elapsed_time;
 
-
     event_loop.run(move |event, _, control_flow| {
         // Artificially slows the loop rate to 10 millis
         // This is called after redraw events cleared
@@ -184,12 +187,17 @@ fn main() {
         *control_flow = ControlFlow::Poll;
 
         match event {
+            event::Event::NewEvents(cause) => {
+                event_schedule.execute(&mut world, &mut resources);
+                resources.get_mut::<Vec<OwnedEvent<OwnedEventExtension>>>()
+                    .unwrap().clear();
+            }
             event::Event::MainEventsCleared => {
 
-                elapsed_time = { // deltatime since last frame
-                    let last_frame = resources.get::<Instant>().unwrap();
-                    last_frame.elapsed()
-                }.as_secs_f32();
+                let (step_size, elapsed_time) = { // deltatime since last frame
+                    let loop_state = resources.get::<LoopState>().unwrap();
+                    (loop_state.step_size, loop_state.start_time.elapsed().as_secs_f32())
+                };
                 delta_time = elapsed_time - current_time;
                 current_time = elapsed_time;
                 if delta_time > 0.02 {
@@ -197,35 +205,15 @@ fn main() {
                 }
                 accumulator_time += delta_time;
 
-
-                let dt = { // deltatime since last frame
-                    let last_frame = resources.get::<Instant>().unwrap();
-                    last_frame.elapsed()
-                };
-
-                update_schedule.execute(&mut world, &mut resources);
-
-                // ask for a redraw every 20 millis
-                if dt > Duration::from_millis(20) {
-
+                while ((accumulator_time - step_size) >= step_size) {
+                    accumulator_time -= step_size;
+                    // ==== DELTA TIME LOCKED ====
+                    update_schedule.execute(&mut world, &mut resources);
                 }
 
-                // update the world time here for next update
-                resources.insert(Instant::now());
-
+                // ==== FPS LOCKED ====
                 render_schedule.execute(&mut world, &mut resources);
             }
-            event::Event::DeviceEvent {
-                event: MouseMotion { delta },
-                ..
-            } => {
-                resources
-                    .get_mut::<Renderer>()
-                    .unwrap()
-                    .cam_look_delta((delta.0, delta.1));
-
-                //swap_chain = device.create_swap_chain(&surface, &sc_desc);
-            }
             // Resizing will queue a request_redraw
             event::Event::WindowEvent {
                 event: WindowEvent::Resized(size),
@@ -239,51 +227,37 @@ fn main() {
                     .get_mut::<Renderer>()
                     .unwrap()
                     .resize(width, height);
-
-                //swap_chain = device.create_swap_chain(&surface, &sc_desc);
             }
-            event::Event::WindowEvent { event, .. } => match event {
-                WindowEvent::KeyboardInput {
-                    input:
-                        event::KeyboardInput {
-                            virtual_keycode: Some(event::VirtualKeyCode::Escape),
-                            state: event::ElementState::Pressed,
-                            ..
-                        },
-                    ..
-                }
-                | WindowEvent::CloseRequested => {
-                    *control_flow = ControlFlow::Exit;
-                }
-                _ => {
-                    //renderer.update(event);
-                }
-            },
+            event::Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
+                *control_flow = ControlFlow::Exit
+            }
             event::Event::RedrawRequested(_) => {
                 // Call the render system
                 render_schedule.execute(&mut world, &mut resources);
             }
             _ => {}
         }
+
+        resources.get_mut::<Vec<OwnedEvent<OwnedEventExtension>>>()
+            .unwrap().push(event.into());
     });
 }
 
 pub fn entity_loading(world: &mut World, renderer: &mut Renderer) {
     let monkey_mesh = renderer.load_mesh_to_buffer("./resources/monkey.obj");
 
-
-
-    // let camera_ent: Entity = world.push((
-    //     Camera {
-    //         position: Point3 {
-    //             x: 5.0,
-    //             y: 5.0,
-    //             z: 5.0
-    //         },
-    //         yaw: Rad(45.0),
-    //         pitch: Rad(45.0)
-    //     }
-    // ));
+    let camera_ent: Entity = world.push((
+        Camera {
+            position: Point3 {
+                x: 5.0,
+                y: 5.0,
+                z: 5.0
+            },
+            yaw: Rad(0.0),
+            pitch: Rad(-75.0)
+        },
+        CameraController::new(1.0, 1.0),
+    ));
 
     let light_entity: Entity = world.push((
         cgmath::Point3 {