First-person movement

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+  </state>
+</component>

.idea/runConfigurations/release.xml

@@ -3,13 +3,12 @@
     <option name="channel" value="DEFAULT" />
     <option name="command" value="run --release" />
     <option name="allFeatures" value="false" />
-    <option name="nocapture" value="false" />
     <option name="emulateTerminal" value="false" />
     <option name="backtrace" value="FULL" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <envs />
     <method v="2">
-      <option name="RunConfigurationTask" enabled="true" run_configuration_name="D:\Code\rust-engine\build\quick-clean.ps1" run_configuration_type="PowerShellRunType" />
+      <option name="RunConfigurationTask" enabled="true" />
       <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
     </method>
   </configuration>

src/gameobject.rs

@@ -9,12 +9,13 @@ pub struct GameObject {
     pub position: Vector3<f32>,
     pub rotation: Quaternion<f32>,
     pub scale: Vector3<f32>,
+    pub children: Vec<GameObject>
 }
 
 impl GameObject {
     pub fn new(mesh: MeshHandle, texture_index: usize) -> GameObject {
         GameObject { mesh_index: mesh, texture_index, position: Vector3::new(0.0, 0.0, 0.0),
-            rotation: Quaternion::new(1.0, 0.0, 0.0, 0.0), scale: Vector3::new(1.0, 1.0, 1.0) }
+            rotation: Quaternion::new(1.0, 0.0, 0.0, 0.0), scale: Vector3::new(1.0, 1.0, 1.0), children: vec![] }
     }
 
     pub fn set_position(&mut self, x: f32, y: f32, z: f32) {
@@ -62,26 +63,6 @@ impl GameObjectHandle {
     }
 }
 
-pub trait Component {
+pub trait Updatable {
     fn update(&mut self, delta_time: f32, input: &InputState, renderer: &mut VulkanRenderer);
-    fn add_game_object(&mut self, handle: GameObjectHandle);
-}
-
-#[derive(Debug)]
-pub struct TestComponent {
-    pub game_objects: Vec<GameObjectHandle>
-}
-
-impl Component for TestComponent {
-    fn update(&mut self, delta_time: f32, input: &InputState, renderer: &mut VulkanRenderer) {
-        self.game_objects.iter_mut().for_each(|handle| {
-            if input.button_down("test") {
-                handle.get_game_object(renderer).unwrap().rotate(90.0 * delta_time, 90.0 * delta_time, 90.0 * delta_time);
-            }
-        });
-    }
-
-    fn add_game_object(&mut self, handle: GameObjectHandle) {
-        self.game_objects.push(handle);
-    }
 }

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>,
+    player: Player,
-    cam_rotation: Quaternion<f32>,
     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.player.update(frame_time, input, renderer);
-        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();
 
+        // End frame
         self.last_time = time;
         self.input.frame_end();
 
         ObjectUniformData {
-            view: view.into(),
+            view: self.player.camera.view.into(),
-            projection: proj.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(),
+        player: Player::new(),
-        cam_position: Vector3::new(0.0, 3.0, -10.0),
         meshes: vec![],
         game_objects: vec![],
         log_config,

src/player.rs

@@ -0,0 +1,103 @@
+use cgmath::{vec3, One, SquareMatrix, Deg, Rad, Quaternion, Vector3, Matrix4, Rotation, Rotation3, InnerSpace};
+use crate::{
+    VulkanRenderer,
+    GameObjectHandle,
+    input::InputState,
+    gameobject::Updatable
+};
+use crate::player::PlayerMovementMode::{FirstPerson, Flying};
+
+pub struct Camera {
+    pub fov_y: f32,
+    pub position: Vector3<f32>,
+    pub rotation: Quaternion<f32>,
+    pub view: Matrix4<f32>,
+    pub proj: Matrix4<f32>,
+}
+
+impl Camera {
+    pub fn new() -> Camera {
+        Camera {
+            fov_y: 45.0,
+            position: vec3(0.0, 0.0, 0.0),
+            rotation: Quaternion::one(),
+            view: Matrix4::identity(),
+            proj: Matrix4::identity(),
+        }
+    }
+
+    pub fn update(&mut self, renderer: &mut VulkanRenderer) {
+        self.view = Matrix4::from(self.rotation) * Matrix4::from_translation(self.position);
+
+        self.proj = cgmath::perspective(
+            Rad::from(Deg(self.fov_y)),
+            renderer.game_data.dimensions[0] as f32 / renderer.game_data.dimensions[1] as f32,
+            0.1,
+            100.0
+        );
+        self.proj.y.y *= -1.0;
+
+        renderer.game_data.line_push_constants.view = self.view.into();
+        renderer.game_data.line_push_constants.projection = self.proj.into();
+    }
+
+    pub fn transform_vector(&self, vec: Vector3<f32>) -> Vector3<f32> {
+        self.rotation.invert().rotate_vector(vec)
+    }
+}
+
+#[derive(PartialEq)]
+pub enum PlayerMovementMode {
+    FirstPerson,
+    Flying,
+}
+
+pub struct Player {
+    pub camera: Camera,
+    pub movement_mode: PlayerMovementMode,
+    pub movement_speed: f32,
+    pub look_sensitivity: f32,
+    pub height: f32,
+}
+
+impl Player {
+    pub fn new() -> Player {
+        Player {
+            camera: Camera::new(),
+            movement_mode: FirstPerson,
+            movement_speed: 3.0,
+            look_sensitivity: 10.0,
+            height: -1.0,
+        }
+    }
+}
+
+impl Updatable for Player {
+    fn update(&mut self, delta_time: f32, input: &InputState, renderer: &mut VulkanRenderer) {
+        // Rotation
+        self.camera.rotation = self.camera.rotation * Quaternion::from_angle_y(Deg(input.get_axis("look_horizontal") * delta_time * self.look_sensitivity));
+        self.camera.rotation = Quaternion::from_angle_x(Deg(input.get_axis("look_vertical") * delta_time * self.look_sensitivity)) * self.camera.rotation;
+
+        // Movement
+        if self.movement_mode == FirstPerson {
+
+            self.camera.position.y = self.height;
+
+            let mut forward_vector = self.camera.transform_vector(vec3(0.0, 0.0, 1.0));
+            forward_vector.y = 0.0;
+            forward_vector = forward_vector.normalize();
+            self.camera.position += forward_vector * delta_time * input.get_axis("move_forward") * self.movement_speed;
+
+            let right_vector = forward_vector.cross(vec3(0.0, 1.0, 0.0));
+            self.camera.position += right_vector * delta_time * input.get_axis("move_sideways") * self.movement_speed;
+        } else if self.movement_mode == Flying {
+            self.camera.position += self.camera.transform_vector(vec3(
+                input.get_axis("move_sideways") * -self.movement_speed,
+                0.0,
+                input.get_axis("move_forward") * self.movement_speed)) * delta_time;
+        }
+
+        // Update
+        self.camera.update(renderer);
+    }
+}