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

better lighting

Browse Source
This commit is contained in:
Till
2020-06-28 22:11:43 +02:00
parent f868a8e45a
commit 002db530be
5 changed files with 57 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/gameobject.rs
View File

@@ -19,10 +19,20 @@ impl GameObject {
self.model_matrix.w.z = pos.2;
}
pub fn get_position(&self) -> Vector3<f32> {
pub fn _get_position(&self) -> Vector3<f32> {
vec3(self.model_matrix.w.x, self.model_matrix.w.y, self.model_matrix.w.z)
}
pub fn set_scale(&mut self, scale: (f32, f32, f32)) {
self.model_matrix.x.x = scale.0;
self.model_matrix.y.y = scale.1;
self.model_matrix.z.z = scale.2;
}
pub fn _get_scale(&mut self) -> Vector3<f32> {
vec3(self.model_matrix.x.x, self.model_matrix.y.y, self.model_matrix.z.z)
}
pub fn translate(&mut self, x: f32, y: f32, z: f32) {
self.model_matrix.w.x += x;
self.model_matrix.w.y += y;

29
src/main.rs
View File

@@ -53,8 +53,9 @@ impl Game for TestGame {
println!("{:.0} ms / {:.0} FPS", frame_time * 1000.0, 1.0 / frame_time);
}
let light_pos = vec3(f32::sin(time) * 10.0, f32::cos(time) * 10.0, 0.0);
self.game_objects[0].get_game_object(renderer).unwrap().set_position(light_pos.into());
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().set_position(light_pos.into());
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;
@@ -63,7 +64,6 @@ impl Game for TestGame {
0.0,
self.input.get_axis("move_forward") * 0.05));
// Move game objects
let view = Matrix4::from(self.cam_rotation) * Matrix4::from_translation(self.cam_position);
let mut proj = cgmath::perspective(
@@ -72,7 +72,6 @@ impl Game for TestGame {
0.1,
100.0
);
proj.y.y *= -1.0;
renderer.game_data.line_push_constants.view = view.into();
@@ -86,12 +85,14 @@ impl Game for TestGame {
projection: proj.into(),
time,
light_position: light_pos.into(),
camera_position: self.cam_position.into(),
_dummy0: [0; 12],
_dummy1: [0; 4],
}
}
}
fn matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f32> {
fn _matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f32> {
let v4 = Vector4::new(vector.x, vector.y, vector.z, 1.0);
let out = matrix * v4;
Vector3::new(out.x, out.y, out.z)
@@ -99,17 +100,20 @@ fn matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f3
impl TestGame {
fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
self.load_gltf(renderer, "models/box.gltf.glb");
self.load_gltf(renderer, "models/sphere.glb");
let cube_meshes = self.load_gltf(renderer, "models/box.gltf.glb");
let sphere_meshes = self.load_gltf(renderer, "models/sphere.glb");
let cube = self.add_game_object(renderer, 0, 0);
let cube = self.add_game_object(renderer, *cube_meshes.first().unwrap(), 0);
cube.get_game_object(renderer).unwrap().set_position((3.0, 4.0, 5.0));
let sphere = self.add_game_object(renderer, 1, 0);
let sphere = self.add_game_object(renderer, *sphere_meshes.first().unwrap(), 0);
sphere.get_game_object(renderer).unwrap().set_position((0.0, 0.0, 0.0));
let light_sphere = self.add_game_object(renderer, *sphere_meshes.first().unwrap(), 0);
light_sphere.get_game_object(renderer).unwrap().set_scale((0.1, 0.1, 0.1));
println!("Game loaded!");
}
fn load_gltf(&mut self, renderer: &mut VulkanRenderer, gltf_path: &str) {
fn load_gltf(&mut self, renderer: &mut VulkanRenderer, gltf_path: &str) -> Vec<MeshHandle> {
let mut mesh_handles = Vec::new();
let (meshes, textures) = mesh::load_mesh(gltf_path, self.log_config.mesh_load_info).unwrap();
for cpu_mesh in meshes.into_iter() {
let id = match cpu_mesh.texture_index {
@@ -117,9 +121,12 @@ impl TestGame {
None => 0,
};
self.texture_index_counter += 1;
self.meshes.push((renderer.upload_mesh(cpu_mesh), id));
let mesh_handle = renderer.upload_mesh(cpu_mesh);
self.meshes.push((mesh_handle, id));
mesh_handles.push(mesh_handle);
}
textures.iter().for_each(|tex| renderer.upload_texture(tex));
mesh_handles
}
fn add_game_object(&mut self, renderer: &mut VulkanRenderer, mesh: MeshHandle, texture_index: usize) -> &mut GameObjectHandle {

8
src/vulkan.rs
View File

@@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::SystemTime;
use cgmath::{Matrix4, SquareMatrix, vec3};
use cgmath::{Matrix4, SquareMatrix};
use image::{ImageBuffer, ImageFormat, Rgb, Rgba};
use image::buffer::ConvertBuffer;
use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer};
@@ -280,8 +280,10 @@ impl VulkanRenderer {
view: Matrix4::identity().into(),
projection: Matrix4::identity().into(),
time: 0.0,
light_position: vec3(0.0, 0.0, 0.0).into(),
light_position: [0.0, 0.0, 0.0],
camera_position: [0.0, 0.0, 0.0],
_dummy0: [0; 12],
_dummy1: [0; 4],
};
for _ in 0..swapchain.num_images() {
@@ -434,7 +436,7 @@ impl VulkanRenderer {
};
}
pub fn upload_mesh(self: &mut Self, mesh: CPUMesh) -> usize {
pub fn upload_mesh(self: &mut Self, mesh: CPUMesh) -> MeshHandle {
let vertex_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::vertex_buffer(), false, mesh.vertices.into_iter()).unwrap();
let index_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::index_buffer(), false, mesh.indices.into_iter()).unwrap();
self.game_data.meshes.push(Mesh { vertex_buffer, index_buffer });