From 35f3d0e4a8df829fed78b9ba755391cf8094b465 Mon Sep 17 00:00:00 2001 From: Asuro Date: Thu, 14 Oct 2021 07:30:12 +0200 Subject: [PATCH] input stuff --- src/game/mod.rs | 30 ++++++++++++++++++++---------- src/input.rs | 44 +++++++++++++++++++++++++++++++++++--------- src/vulkan/mesh.rs | 16 +++++++++------- src/vulkan/mod.rs | 33 ++++++++------------------------- 4 files changed, 72 insertions(+), 51 deletions(-) diff --git a/src/game/mod.rs b/src/game/mod.rs index daaad02..3a5a6b2 100644 --- a/src/game/mod.rs +++ b/src/game/mod.rs @@ -12,9 +12,9 @@ use player::Player; use crate::{config::LogConfig, vulkan}; use crate::input::InputState; -use crate::vulkan::{Game, MeshHandle, TextVertex, Texture, TextureHandle, Vertex, VulkanRenderer}; +use crate::vulkan::{Game, MeshHandle, TextVertex, TextureHandle, Vertex, VulkanRenderer}; use crate::vulkan::gameobject::{GameObject, GameObjectHandle, Updatable}; -use crate::vulkan::mesh::{self, CPUMesh, CPUVertex}; +use crate::vulkan::mesh::{self, CPUMesh, CPUVertexList}; use crate::vulkan::pipelines::vs::ty::ObjectUniformData; pub mod player; @@ -30,7 +30,8 @@ pub struct TestGame { pub last_time: f32, pub components: Vec>, pub paused: bool, - pub font: FontArc + pub font: FontArc, + pub test_str: String, } impl Game for TestGame { @@ -82,10 +83,17 @@ impl Game for TestGame { } if self.input.button_just_pressed("test") { - // self.paused = !self.paused; - self.text_objects[0].update_text("holy shit look at this", 200.0, renderer, &mut self.game_objects); + self.paused = !self.paused; } + for char in self.input.typed_characters.iter() { + match char { + '\u{8}' => { self.test_str.pop(); }, + c => { self.test_str.push(*c); }, + } + } + self.text_objects[0].update_text(&self.test_str, 30., renderer, &mut self.game_objects); + // Custom game object stuff let light_pos = vec3(2.0, 0.5, 2.0); if !self.paused { @@ -124,6 +132,7 @@ impl TestGame { components: vec![], paused: false, font: FontArc::try_from_slice(include_bytes!("../../models/FiraCode-Regular.ttf")).unwrap(), + test_str: String::new() } } @@ -255,17 +264,18 @@ pub fn update_text_quads(quads: Vec>, texture_index: usize, mesh let mut final_indices: Vec = vec![]; let mut index_offset = 0; - for quad in quads { - final_vertices.append(&mut quad.iter().map(|v| CPUVertex::VertexText(TextVertex { position: v.position, uv: [v.uv[0], v.uv[1]] })).collect()); + for mut quad in quads { + let len = quad.len(); + final_vertices.append(&mut quad); final_indices.append(&mut [0, 2, 3, 0, 3, 1].iter().map(|x| *x + index_offset).collect()); - index_offset += quad.len() as u32; + index_offset += len as u32; } if let Some(idx) = mesh_index { - renderer.update_mesh(idx, final_vertices, final_indices); + renderer.update_mesh(idx, CPUVertexList::VertexText(final_vertices), final_indices); None } else { let mesh = CPUMesh { - vertices: final_vertices, + vertices: CPUVertexList::VertexText(final_vertices), indices: final_indices, local_texture_index: Some(texture_index), local_normal_map_index: None, diff --git a/src/input.rs b/src/input.rs index ee7b724..a08483f 100644 --- a/src/input.rs +++ b/src/input.rs @@ -10,7 +10,7 @@ use gilrs; use gilrs::{EventType, Gilrs}; use serde_derive::{Deserialize, Serialize}; use toml; -use winit::event::{DeviceEvent, ElementState, Event, ModifiersState, MouseButton, MouseScrollDelta, ScanCode, Touch, TouchPhase, WindowEvent}; +use winit::event::{DeviceEvent, ElementState, Event, ModifiersState, MouseButton, MouseScrollDelta, ScanCode, Touch, TouchPhase, VirtualKeyCode, WindowEvent}; use crate::config::LogConfig; @@ -77,15 +77,16 @@ pub struct InputState { pub mouse_delta_x: f64, pub mouse_delta_y: f64, pub mouse_position: Vector2, + pub typed_characters: Vec, input_events: HashSet, - pressed_scan_codes: HashSet, - pressed_mouse_buttons: HashSet, + pub pressed_scan_codes: HashSet, + pub pressed_mouse_buttons: HashSet, pressed_touch_positions: HashMap>, analog_wheel_state: f32, config: InputConfigConfig, log_config: LogConfig, controller_input: Gilrs, - touch_inputs: Vec + touch_inputs: Vec, } #[derive(Debug, Eq, PartialEq, Hash, Clone)] @@ -115,7 +116,7 @@ impl InputState { input_events: HashSet::new(), pressed_scan_codes: HashSet::new(), pressed_mouse_buttons: HashSet::new(), pressed_touch_positions: HashMap::new(), touch_inputs: vec![], analog_wheel_state: 0.0, config: config.config, mouse_delta_x: 0.0, mouse_delta_y: 0.0, mouse_position: Vector2::zero(), log_config, - controller_input: Gilrs::new().unwrap() }; + controller_input: Gilrs::new().unwrap(), typed_characters: vec![] }; // Create virtual buttons from config config.button.iter().for_each(|bn| { @@ -130,7 +131,7 @@ impl InputState { // Keyboard buttons if let Some(scan_code) = bn.scan_code { - inputs.push(DigitalInput::Keyboard(KeyboardInput { scan_code, modifiers: modifiers.clone() })); + inputs.push(DigitalInput::Keyboard(KeyboardInput { scan_code, key_code: None, modifiers: modifiers.clone() })); } // Mouse buttons @@ -235,7 +236,7 @@ impl InputState { } } - self.on_keyboard_event(input.state, input.scancode, KeyboardModifierState::from_deprecated_state(&input.modifiers)); + self.on_keyboard_event(input.state, input.scancode, input.virtual_keycode, KeyboardModifierState::from_deprecated_state(&input.modifiers)); }, Event::WindowEvent { event: WindowEvent::MouseInput { device_id, state, button, modifiers }, .. } => { if self.log_config.input.buttons { @@ -277,6 +278,9 @@ impl InputState { } self.on_touch_event(touch); }, + Event::WindowEvent { event: WindowEvent::ReceivedCharacter(c), .. } => { + self.typed_characters.push(*c); + }, _ => {} } } @@ -300,6 +304,26 @@ impl InputState { } } + pub fn _scan_code_just_pressed(&self, scan_code: &ScanCode) -> bool { + self.input_events.iter().any(|ie| match ie { + DigitalInputEvent::Pressed(di) => match di { + DigitalInput::Keyboard(ki) => ki.scan_code == *scan_code, + _ => false, + }, + _ => false, + }) + } + + pub fn _scan_code_just_released(&self, scan_code: &ScanCode) -> bool { + self.input_events.iter().any(|ie| match ie { + DigitalInputEvent::Released(di) => match di { + DigitalInput::Keyboard(ki) => ki.scan_code == *scan_code, + _ => false, + }, + _ => false, + }) + } + pub fn button_just_pressed(self: &Self, button_code: &str) -> bool { match self.virtual_buttons.get(button_code) { Some(virtual_button) => { @@ -500,8 +524,8 @@ impl InputState { if input.digital_inputs.iter().any(|di| self.digital_input_pressed(di)) { 1.0 } else { 0.0 } } - pub fn on_keyboard_event(self: &mut Self, state: ElementState, scan_code: ScanCode, modifiers: KeyboardModifierState) { - let input = DigitalInput::Keyboard(KeyboardInput { scan_code, modifiers }); + pub fn on_keyboard_event(self: &mut Self, state: ElementState, scan_code: ScanCode, key_code: Option, modifiers: KeyboardModifierState) { + let input = DigitalInput::Keyboard(KeyboardInput { scan_code, key_code, modifiers }); match state { ElementState::Pressed => { if self.pressed_scan_codes.contains(&scan_code) { return; } @@ -604,6 +628,7 @@ impl InputState { self.mouse_delta_x = 0.0; self.mouse_delta_y = 0.0; self.input_events.clear(); + self.typed_characters.clear(); // Store final touch positions as base for next frame for touch_input in &mut self.touch_inputs { @@ -641,6 +666,7 @@ pub enum DigitalInput { #[derive(Debug, Eq, PartialEq, Hash, Clone)] pub struct KeyboardInput { scan_code: ScanCode, + key_code: Option, modifiers: KeyboardModifierState, } diff --git a/src/vulkan/mesh.rs b/src/vulkan/mesh.rs index 9317b0e..d4f9e8e 100644 --- a/src/vulkan/mesh.rs +++ b/src/vulkan/mesh.rs @@ -28,14 +28,14 @@ impl From for LoadError { } #[derive(Debug)] -pub enum CPUVertex { - Vertex3D(Vertex), - VertexText(TextVertex) +pub enum CPUVertexList { + Vertex3D(Vec), + VertexText(Vec) } #[derive(Debug)] pub struct CPUMesh { - pub vertices: Vec, + pub vertices: CPUVertexList, pub indices: Vec, pub local_texture_index: Option, pub local_normal_map_index: Option, @@ -88,16 +88,18 @@ pub fn load_mesh(mesh_path: &str, print_status: bool) -> Result<(Vec reader.read_tangents(), reader.read_joints(0), reader.read_weights(0)); - let vertices = vertices_result?.iter().map(|v| CPUVertex::Vertex3D(v.clone())).collect(); + + let verts = vertices_result?; + let vert_count = verts.len(); + let cpu_mesh = CPUMesh { - vertices, + vertices: CPUVertexList::Vertex3D(verts), indices: indices.into_u32().collect(), local_texture_index: texture_index, local_normal_map_index: normal_map_index, name: mesh.name().map(|n| n.to_owned()), }; if print_status { - let vert_count = cpu_mesh.vertices.len(); let index_count = cpu_mesh.indices.len(); total_vertices += vert_count; diff --git a/src/vulkan/mod.rs b/src/vulkan/mod.rs index d6bdeed..92a4548 100644 --- a/src/vulkan/mod.rs +++ b/src/vulkan/mod.rs @@ -31,7 +31,7 @@ use pipelines::vs; use crate::config::RenderConfig; use crate::vulkan::gameobject::GameObject; -use self::mesh::CPUVertex; +use self::mesh::{CPUVertexList}; pub mod pipelines; pub mod gameobject; @@ -428,22 +428,13 @@ impl VulkanRenderer { pub fn upload_mesh(self: &mut Self, mesh: CPUMesh, original_path: Option) -> usize { let index_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::index_buffer(), false, mesh.indices.into_iter()).unwrap(); - match mesh.vertices.get(0).unwrap() { - CPUVertex::Vertex3D(_) => { - let verts: Vec = mesh.vertices.into_iter().filter_map(|v| match v { - CPUVertex::Vertex3D(vert) => Some(vert), - CPUVertex::VertexText(_) => None - }).collect(); + match mesh.vertices { + CPUVertexList::Vertex3D(verts) => { let vertex_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::vertex_buffer(), false, verts.into_iter()).unwrap(); self.game_data.meshes.push(Mesh { vertex_buffer, index_buffer, original_path }); self.game_data.meshes.len() - 1 }, - CPUVertex::VertexText(_) => { - let verts: Vec = mesh.vertices.into_iter().filter_map(|v| match v { - CPUVertex::Vertex3D(_) => None, - CPUVertex::VertexText(vert) => Some(vert) - }).collect(); - + CPUVertexList::VertexText(verts) => { let vertex_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::vertex_buffer(), false, verts.into_iter()).unwrap(); self.game_data.meshes_text.push(Mesh { vertex_buffer, index_buffer, original_path }); self.game_data.meshes_text.len() - 1 @@ -451,24 +442,16 @@ impl VulkanRenderer { } } - pub fn update_mesh(self: &mut Self, mesh_index: usize, vertices: Vec, indices: Vec) { + pub fn update_mesh(self: &mut Self, mesh_index: usize, vertices: CPUVertexList, indices: Vec) { let index_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::index_buffer(), false, indices.into_iter()).unwrap(); - match vertices.get(0).unwrap() { - CPUVertex::Vertex3D(_) => { - let verts: Vec = vertices.into_iter().filter_map(|v| match v { - CPUVertex::Vertex3D(vert) => Some(vert), - CPUVertex::VertexText(_) => None - }).collect(); + match vertices { + CPUVertexList::Vertex3D(verts) => { let mesh = &mut self.game_data.meshes[mesh_index]; mesh.vertex_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::vertex_buffer(), false, verts.into_iter()).unwrap(); mesh.index_buffer = index_buffer; }, - CPUVertex::VertexText(_) => { - let verts: Vec = vertices.into_iter().filter_map(|v| match v { - CPUVertex::Vertex3D(_) => None, - CPUVertex::VertexText(vert) => Some(vert) - }).collect(); + CPUVertexList::VertexText(verts) => { let mesh = &mut self.game_data.meshes_text[mesh_index]; mesh.vertex_buffer = CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::vertex_buffer(), false, verts.into_iter()).unwrap(); mesh.index_buffer = index_buffer;