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

yay cubes

Browse Source
This commit is contained in:
Till
2019-07-29 02:31:46 +02:00
parent ef1dab0115
commit 49285a71ce
3 changed files with 50 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
config/input.toml
View File

@@ -27,6 +27,11 @@ scan_code = 30
name = "d"
scan_code = 32
[[button]]
name = "test"
scan_code = 20
ctrl = true
[[axis]]
name = "move_forward"
positive_button = "w"

11
src/main.rs
View File

@@ -1,8 +1,8 @@
use winit::{Event};
use cgmath::{Matrix4, Rad, Vector3, Deg, Quaternion, Rotation3, One, Rotation};
use cgmath::{Matrix4, Rad, Vector3, Deg, Quaternion, Rotation3, One, Rotation, SquareMatrix};
mod vulkan;
use crate::vulkan::{GameData, Game, LinePoint};
use crate::vulkan::{GameData, Game, LinePoint, GameObject};
mod input;
use crate::input::{InputState};
@@ -40,6 +40,11 @@ impl Game for TestGame<'_> {
println!("{:.0} ms / {:.0} FPS", frame_time * 1000.0, 1.0 / frame_time);
}
if self.input.button_just_pressed("test") {
println!("test");
game_data.game_objects.push(GameObject { mesh_index: 0, model_matrix: Matrix4::identity() });
}
self.cam_rotation = self.cam_rotation * Quaternion::from_angle_z(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(
@@ -87,7 +92,7 @@ fn main() {
let line_count = 30;
vulkan::init(
"models/iski51.obj",
vec!["models/box.obj", "models/iski51.obj"],
(-line_count..=line_count)
.flat_map(|it| vec![
LinePoint { position: [it as f32, -line_count as f32, 0.] },

57
src/vulkan.rs
View File

@@ -35,7 +35,6 @@ use vs::ty::PushConstants;
use line_vs::ty::LinePushConstants;
use tobj::{load_obj};
use vulkano::pipeline::depth_stencil::DepthStencil;
const VALIDATION_LAYERS: &[&str] = &[
"VK_LAYER_LUNARG_standard_validation"
@@ -64,6 +63,16 @@ pub trait Game {
fn on_window_event(self: &mut Self, event: &Event);
}
pub struct Mesh {
vertex_buffer: Arc<CpuAccessibleBuffer<[Vertex]>>,
index_buffer: Arc<CpuAccessibleBuffer<[u32]>>,
}
pub struct GameObject {
pub mesh_index: usize,
pub model_matrix: Matrix4<f32>,
}
pub struct GameData {
pub start_time: SystemTime,
pub line_vertices: Vec<LinePoint>,
@@ -72,11 +81,11 @@ pub struct GameData {
pub recreate_pipeline: bool,
pub dimensions: [u32; 2],
pub shutdown: bool,
mesh_vertex_buffer: Option<Arc<CpuAccessibleBuffer<[Vertex]>>>,
mesh_index_buffer: Option<Arc<CpuAccessibleBuffer<[u32]>>>,
pub game_objects: Vec<GameObject>,
pub meshes: Vec<Mesh>,
}
pub fn init(mesh_path: &str, line_vertices: Vec<LinePoint>, game: &mut dyn Game) {
pub fn init(mesh_paths: Vec<&str>, line_vertices: Vec<LinePoint>, game: &mut dyn Game) {
let mut data = GameData {
push_constants: PushConstants {
time: 0.0,
@@ -95,8 +104,8 @@ pub fn init(mesh_path: &str, line_vertices: Vec<LinePoint>, game: &mut dyn Game)
shutdown: false,
line_vertices,
dimensions: [0, 0],
mesh_vertex_buffer: None,
mesh_index_buffer: None,
meshes: vec![],
game_objects: vec![],
};
if game.validation_layers_enabled() {
@@ -209,9 +218,8 @@ pub fn init(mesh_path: &str, line_vertices: Vec<LinePoint>, game: &mut dyn Game)
PresentMode::Fifo, true, None).unwrap()
};
let (mesh_vertices, mesh_indices) = load_mesh(mesh_path);
data.mesh_vertex_buffer = Some(CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::vertex_buffer(), mesh_vertices.into_iter()).unwrap());
data.mesh_index_buffer = Some(CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::index_buffer(), mesh_indices.into_iter()).unwrap());
mesh_paths.iter().for_each(|path| data.meshes.push(load_mesh(device.clone(), path)));
let line_vertex_buffer = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::vertex_buffer(), data.line_vertices.iter().cloned()).unwrap();
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
@@ -321,23 +329,29 @@ pub fn init(mesh_path: &str, line_vertices: Vec<LinePoint>, game: &mut dyn Game)
game.update(&mut data);
let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap()
let mut cbb = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap()
// Before we can draw, we have to *enter a render pass*. There are two methods to do
// this: `draw_inline` and `draw_secondary`. The latter is a bit more advanced and is
// not covered here.
.begin_render_pass(framebuffers[image_num].clone(), false, vec![[0.0, 0.0, 0.0, 1.0].into(), ClearValue::Depth(1.0)]).unwrap()
.begin_render_pass(framebuffers[image_num].clone(), false, vec![[0.0, 0.0, 0.0, 1.0].into(), ClearValue::Depth(1.0)]).unwrap();
// We are now inside the first subpass of the render pass. We add a draw command.
.draw_indexed(pipeline.clone(), &dynamic_state, data.mesh_vertex_buffer.clone().unwrap(), data.mesh_index_buffer.clone().unwrap(), (), data.push_constants.clone()).unwrap()
.draw(line_pipeline.clone(), &dynamic_state, line_vertex_buffer.clone(), (), data.line_push_constants.clone()).unwrap()
// We are now inside the first subpass of the render pass
for i in 0..data.game_objects.len() {
cbb = cbb.draw_indexed(pipeline.clone(), &dynamic_state,
data.meshes[data.game_objects[i].mesh_index].vertex_buffer.clone(),
data.meshes[data.game_objects[i].mesh_index].index_buffer.clone(),
(), data.push_constants.clone()).unwrap();
}
cbb = cbb.draw(line_pipeline.clone(), &dynamic_state, line_vertex_buffer.clone(), (), data.line_push_constants.clone()).unwrap()
// We leave the render pass by calling `draw_end`. Note that if we had multiple
// subpasses we could have called `next_inline` (or `next_secondary`) to jump to the
// next subpass.
.end_render_pass().unwrap()
.end_render_pass().unwrap();
// Finish building the command buffer by calling `build`.
.build().unwrap();
let command_buffer = cbb.build().unwrap();
let future = previous_frame_end.join(acquire_future)
.then_execute(queue.clone(), command_buffer).unwrap()
@@ -458,7 +472,7 @@ fn create_pipeline<T: RenderPassAbstract, V: vulkano::pipeline::vertex::Vertex>(
.vertex_shader(vertex_shader_entry.clone(), ())
.line_list()
.viewports_dynamic_scissors_irrelevant(1)
.depth_stencil(DepthStencil::simple_depth_test())
.depth_stencil_simple_depth()
.fragment_shader(fragment_shader_entry.clone(), ())
.render_pass(sub_pass.clone())
.build(device.clone())
@@ -470,6 +484,7 @@ fn create_pipeline<T: RenderPassAbstract, V: vulkano::pipeline::vertex::Vertex>(
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.depth_stencil_simple_depth()
.cull_mode_back()
.fragment_shader(fragment_shader_entry.clone(), ())
.render_pass(sub_pass.clone())
.build(device.clone())
@@ -508,7 +523,7 @@ fn read_shader(vert_path_relative: &str, frag_path_relative: &str) -> Option<(Co
}
}
fn load_mesh(mesh_path: &str) -> (Vec<Vertex>, Vec<u32>) {
fn load_mesh(device: Arc<Device>, mesh_path: &str) -> Mesh {
let mut vertices = Vec::new();
let mut indices = Vec::new();
@@ -543,5 +558,7 @@ fn load_mesh(mesh_path: &str) -> (Vec<Vertex>, Vec<u32>) {
}
}
(vertices, indices)
let vertex_buffer = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::vertex_buffer(), vertices.into_iter()).unwrap();
let index_buffer = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::index_buffer(), indices.into_iter()).unwrap();
Mesh { vertex_buffer, index_buffer }
}