Modules and stuff

src/game/player.rs

@@ -0,0 +1,115 @@
+use cgmath::{Deg, InnerSpace, Matrix4, One, Quaternion, Rad, Rotation, Rotation3, SquareMatrix, vec3, Vector3};
+
+use crate::game::player::PlayerMovementMode::{FirstPerson, Flying};
+
+use crate::input::InputState;
+use crate::MeshHandle;
+use crate::vulkan::{
+    gameobject::Updatable,
+    VulkanRenderer
+};
+
+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) {
+        // Camera stuff
+        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,
+    cube_mesh: Option<MeshHandle>
+}
+
+impl Player {
+    pub fn new() -> Player {
+        Player {
+            camera: Camera::new(),
+            movement_mode: FirstPerson,
+            movement_speed: 3.0,
+            look_sensitivity: 10.0,
+            height: -1.0,
+            cube_mesh: None
+        }
+    }
+}
+
+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;
+        }
+
+        // Spawn cube
+        if input.button_just_released("test") {
+            if self.cube_mesh.is_none() {
+                // self.cube_mesh = Some()
+            }
+        }
+
+        // Update
+        self.camera.update(renderer);
+    }
+}