First-person movement

src/main.rs

@@ -1,28 +1,29 @@
-use cgmath::{Deg, Matrix4, One, Quaternion, Rad, Rotation, Rotation3, Vector3, vec3, Vector4};
+use crate::player::{Camera, Player};
+use cgmath::{Deg, Matrix4, Quaternion, Rotation, Rotation3, Vector3, vec3, Vector4};
 use winit::event::Event;
 
 use crate::config::LogConfig;
 use crate::input::InputState;
 use crate::vulkan::{Game, LinePoint, MeshHandle, VulkanRenderer};
 use crate::vulkan::vs::ty::ObjectUniformData;
-use crate::gameobject::{GameObject, GameObjectHandle, Component, TestComponent};
+use crate::gameobject::{GameObject, GameObjectHandle, Updatable};
 
 mod vulkan;
 mod input;
 mod config;
 mod mesh;
 mod gameobject;
+mod player;
 
 struct TestGame {
     input: InputState,
-    cam_position: Vector3<f32>,
-    cam_rotation: Quaternion<f32>,
+    player: Player,
     meshes: Vec<(MeshHandle, usize)>,
     game_objects: Vec<GameObjectHandle>,
     log_config: LogConfig,
     texture_index_counter: usize,
     last_time: f32,
-    components: Vec<Box<dyn Component>>,
+    components: Vec<Box<dyn Updatable>>,
 }
 
 impl Game for TestGame {
@@ -31,10 +32,12 @@ impl Game for TestGame {
     }
 
     fn update(self: &mut Self, renderer: &mut VulkanRenderer) -> ObjectUniformData {
+        // Input and timing
         self.input.frame_start();
         let time = (renderer.game_data.start_time.elapsed().unwrap().as_micros() as f64 / 1000000.0) as f32;
         let frame_time = time - self.last_time;
 
+        // Component update
         let input = &self.input;
         let components = &mut self.components;
         components.iter_mut().for_each(|component| {
@@ -58,38 +61,22 @@ impl Game for TestGame {
            println!("{:.0} ms / {:.0} FPS", frame_time * 1000.0, 1.0 / frame_time);
         }
 
+        // Custom game object stuff
         let light_pos = vec3(f32::sin(time) * 2.0 + 2.0, f32::cos(time) * 2.0 + 2.0, 2.0);
         self.game_objects[2].get_game_object(renderer).unwrap().position = light_pos;
 
-        self.cam_rotation = self.cam_rotation * Quaternion::from_angle_y(Deg(self.input.get_axis("look_horizontal") * 0.05));
-        self.cam_rotation = Quaternion::from_angle_x(Deg(self.input.get_axis("look_vertical") * 0.05)) * self.cam_rotation;
-        self.cam_position += self.cam_rotation.invert().rotate_vector(Vector3::new(
-            self.input.get_axis("move_sideways") * -0.05,
-            0.0,
-            self.input.get_axis("move_forward") * 0.05));
-
-        let view = Matrix4::from(self.cam_rotation) * Matrix4::from_translation(self.cam_position);
-
-        let mut proj = cgmath::perspective(
-            Rad::from(Deg(45.0)),
-            renderer.game_data.dimensions[0] as f32 / renderer.game_data.dimensions[1] as f32,
-            0.1,
-            100.0
-        );
-        proj.y.y *= -1.0;
-
-        renderer.game_data.line_push_constants.view = view.into();
-        renderer.game_data.line_push_constants.projection = proj.into();
+        self.player.update(frame_time, input, renderer);
 
+        // End frame
         self.last_time = time;
         self.input.frame_end();
 
         ObjectUniformData {
-            view: view.into(),
-            projection: proj.into(),
+            view: self.player.camera.view.into(),
+            projection: self.player.camera.proj.into(),
             time,
             light_position: light_pos.into(),
-            camera_position: self.cam_position.into(),
+            camera_position: self.player.camera.position.into(),
             _dummy0: [0; 12],
             _dummy1: [0; 4],
         }
@@ -104,15 +91,12 @@ fn _matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f
 
 impl TestGame {
     fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
-        let mut test_comp = TestComponent { game_objects: vec![] };
-
         let cube_meshes = self.load_gltf(renderer, "models/box.glb");
         let sphere_meshes = self.load_gltf(renderer, "models/sphere.glb");
         let plane_meshes = self.load_gltf(renderer, "models/plane.glb");
 
         let cube = self.add_game_object(renderer, *cube_meshes.first().unwrap(), 0);
         cube.get_game_object(renderer).unwrap().position = vec3(3.0, 4.0, 5.0);
-        test_comp.game_objects.push(cube.clone());
 
         let sphere = self.add_game_object(renderer, *sphere_meshes.first().unwrap(), 0);
         sphere.get_game_object(renderer).unwrap().position = vec3(0.0, 0.0, 0.0);
@@ -123,7 +107,6 @@ impl TestGame {
         let plane = self.add_game_object(renderer, *plane_meshes.first().unwrap(), 0);
         plane.get_game_object(renderer).unwrap().position = vec3(0.0, -1.0, 0.0);
 
-        self.components.push(Box::new(test_comp));
         println!("Game loaded!");
     }
 
@@ -157,8 +140,7 @@ fn main() {
 
     let mut game = TestGame {
         input: InputState::new("config/input.toml", log_config),
-        cam_rotation: Quaternion::one(),
-        cam_position: Vector3::new(0.0, 3.0, -10.0),
+        player: Player::new(),
         meshes: vec![],
         game_objects: vec![],
         log_config,