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

Different textures per object

Browse Source
This commit is contained in:
Asuro
2020-10-25 04:01:47 +01:00
parent d6f2b5d385
commit c055ea19ed
6 changed files with 63 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/main.rs
View File

@@ -1,5 +1,6 @@
use crate::player::{Camera, Player};
use cgmath::{Deg, Matrix4, Quaternion, Rotation, Rotation3, Vector3, vec3, Vector4};
use crate::vulkan::TextureHandle;
use crate::player::{Player};
use cgmath::{Matrix4, Vector3, vec3, Vector4};
use winit::event::Event;
use crate::config::LogConfig;
@@ -18,13 +19,12 @@ mod player;
struct TestGame {
input: InputState,
player: Player,
meshes: Vec<(MeshHandle, usize)>,
meshes: Vec<(MeshHandle, TextureHandle)>,
game_objects: Vec<GameObjectHandle>,
log_config: LogConfig,
texture_index_counter: usize,
last_time: f32,
components: Vec<Box<dyn Updatable>>,
show_grid: bool,
}
impl TestGame {
@@ -38,7 +38,6 @@ impl TestGame {
texture_index_counter: 1,
last_time: 0.0,
components: vec![],
show_grid: false,
}
}
}
@@ -79,9 +78,7 @@ impl Game for TestGame {
}
// 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;
let light_pos = self.player.camera.position * -1.0;
self.player.update(frame_time, input, renderer);
// End frame
@@ -108,20 +105,13 @@ fn _matrix_vector_mul(matrix: &Matrix4<f32>, vector: &Vector3<f32>) -> Vector3<f
impl TestGame {
fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
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);
let cube = self.add_from_gltf(renderer, "models/box.glb");
cube.get_game_object(renderer).unwrap().position = vec3(3.0, 4.0, 5.0);
let sphere = self.add_game_object(renderer, *sphere_meshes.first().unwrap(), 0);
let sphere = self.add_from_gltf(renderer, "models/sphere.glb");
sphere.get_game_object(renderer).unwrap().position = vec3(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().scale = vec3(0.1, 0.1, 0.1);
let plane = self.add_game_object(renderer, *plane_meshes.first().unwrap(), 0);
let plane = self.add_from_gltf(renderer, "models/plane.glb");
plane.get_game_object(renderer).unwrap().position = vec3(0.0, -1.0, 0.0);
println!("Game loaded!");
@@ -129,23 +119,41 @@ impl TestGame {
fn load_gltf(&mut self, renderer: &mut VulkanRenderer, gltf_path: &str) -> Vec<MeshHandle> {
let mut mesh_handles = Vec::new();
// Load file
let (meshes, textures) = mesh::load_mesh(gltf_path, self.log_config.mesh_load_info).unwrap();
for cpu_mesh in meshes.into_iter() {
// Convert file texture id to game texture id
let id = match cpu_mesh.texture_index {
Some(tex_id) => tex_id + self.texture_index_counter,
Some(local_tex_id) => local_tex_id + self.texture_index_counter,
None => 0,
};
self.texture_index_counter += 1;
if cpu_mesh.texture_index.is_some() {
self.texture_index_counter += 1;
}
// Upload mesh
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));
// TODO: this assumes each texture is actually used in a mesh above
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 {
let obj = GameObject::new(mesh, texture_index);
fn add_from_gltf(&mut self, renderer: &mut VulkanRenderer, path: &str) -> &mut GameObjectHandle {
let meshes = self.load_gltf(renderer, path);
self.add_game_object(renderer, *meshes.first().unwrap())
}
fn add_game_object(&mut self, renderer: &mut VulkanRenderer, mesh: MeshHandle) -> &mut GameObjectHandle {
let (mesh_id, mesh_texture_id) = self.meshes[mesh];
let obj = GameObject::new(mesh_id, mesh_texture_id);
let obj_handle = renderer.add_game_object(obj);
self.game_objects.push(obj_handle);
self.game_objects.last_mut().unwrap()