asuro/rust-engine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First-person movement

Browse Source
This commit is contained in:
Asuro
2020-10-23 05:58:11 +02:00
parent c2f0dd53c1
commit 8b8bf64e55
5 changed files with 127 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/gameobject.rs
View File

@@ -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);
}
}

48
src/main.rs
View File

@@ -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,

103
src/player.rs Normal file
View File

@@ -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);
}
}