parse input from file

src/input.rs

@@ -1,5 +1,10 @@
 use winit::{ScanCode, ModifiersState, MouseButton, ElementState};
 use std::collections::{HashMap};
+use std::fs;
+
+use toml;
+
+use serde_derive::{Serialize, Deserialize};
 
 pub struct VirtualButton {
     pub digital_inputs: Vec<DigitalInput>
@@ -15,9 +20,75 @@ pub struct InputState {
     pressed_digital: HashMap<DigitalInput, (bool, bool)>
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+struct InputConfig {
+    button: Vec<InputConfigButton>,
+    axis: Vec<InputConfigAxis>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct InputConfigButton {
+    name: String,
+    scancode: u32,
+    ctrl: Option<bool>
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct InputConfigAxis {
+    name: String,
+    scancode_positive: u32,
+    ctrl_positive: Option<bool>,
+    scancode_negative: u32,
+    ctrl_negative: Option<bool>
+}
+
+type InputHashmapEntry<'a> = (&'a DigitalInput, (bool, bool));
 impl InputState {
-    pub fn new() -> InputState {
-        InputState { virtual_buttons: HashMap::new(), virtual_axes: HashMap::new(), pressed_digital: HashMap::new() }
+    pub fn new(toml_path: &str) -> InputState {
+        let mut state = InputState { virtual_buttons: HashMap::new(), virtual_axes: HashMap::new(), pressed_digital: HashMap::new() };
+
+        let config: InputConfig = toml::from_slice(&fs::read(toml_path).expect("Failed to read input config!")).expect("Failed to parse input config!");
+
+        let buttons = config.button.iter().for_each(|bn| {
+            let modifiers = ModifiersState {
+                shift: false,
+                ctrl: bn.ctrl.is_some(),
+                alt: false,
+                logo: false
+            };
+            let input = DigitalInput::Keyboard(KeyboardInput { scancode: bn.scancode, modifiers });
+            if let Some(virtual_button) = state.virtual_buttons.get_mut(&bn.name) {
+                virtual_button.digital_inputs.push(input);
+            } else {
+                state.virtual_buttons.insert(bn.name.clone(), VirtualButton { digital_inputs: vec![input] });
+            }
+        });
+
+        let axes = config.axis.iter().for_each(|a| {
+            let modifiers_positive = ModifiersState {
+                shift: false,
+                ctrl: a.ctrl_positive.is_some(),
+                alt: false,
+                logo: false
+            };
+            let modifiers_negative = ModifiersState {
+                shift: false,
+                ctrl: a.ctrl_negative.is_some(),
+                alt: false,
+                logo: false
+            };
+            let axis = AxisInput::Digital(
+                DigitalInput::Keyboard(KeyboardInput { scancode: a.scancode_positive, modifiers: modifiers_positive }),
+                DigitalInput::Keyboard(KeyboardInput { scancode: a.scancode_negative, modifiers: modifiers_negative })
+            );
+            if let Some(virtual_axis) = state.virtual_axes.get_mut(&a.name) {
+                virtual_axis.analog_inputs.push(axis);
+            } else {
+                state.virtual_axes.insert(a.name.clone(), VirtualAxis { analog_inputs: vec![axis] });
+            }
+        });
+
+        return state;
     }
 
     pub fn button_down(self: &Self, button_code: &str) -> bool {
@@ -28,12 +99,51 @@ impl InputState {
         }
     }
 
-    pub fn button_just_pressed(self: &Self, input: VirtualButton) -> bool {
-        false
+    pub fn button_just_pressed(self: &Self, button_code: &str) -> bool {
+        if let Some(input) = self.virtual_buttons.get(button_code) {
+            self.pressed_digital.iter()
+                .filter(|(_, (pressed, _))| *pressed)
+                .any(|(registered_input, _)| input.digital_inputs.iter().any(|digital_input| digital_input == registered_input))
+        } else {
+            false
+        }
     }
 
-    pub fn button_just_released(self: &Self, input: VirtualButton) -> bool {
-        false
+    pub fn button_just_released(self: &Self, button_code: &str) -> bool {
+        if let Some(input) = self.virtual_buttons.get(button_code) {
+            self.pressed_digital.iter()
+                .filter(|(_, (_, released))| *released)
+                .any(|(registered_input, _)| input.digital_inputs.iter().any(|digital_input| digital_input == registered_input))
+        } else {
+            false
+        }
+    }
+
+    pub fn get_axis(self: &Self, axis_code: &str) -> f32 {
+        if let Some(axis) = self.virtual_axes.get(axis_code) {
+            axis.analog_inputs.iter().fold(0.0, |fold, item| {
+                let val = match item {
+                    AxisInput::Analog(_) => 0.0,
+                    AxisInput::Digital(positive_button, negative_button) => self.button_to_float(positive_button) - self.button_to_float(negative_button),
+                };
+                if f32::abs(val) > fold {
+                    val
+                } else {
+                    fold
+                }
+            })
+        } else {
+            assert!(false, format!("Axis {:?} not found!", axis_code));
+            0.0
+        }
+    }
+
+    fn button_to_float(self: &Self, input: &DigitalInput) -> f32 {
+        if self.pressed_digital.iter().any(|(registered_input, _)| input == registered_input) {
+            1.0
+        } else {
+            0.0
+        }
     }
 
     pub fn on_keyboard_event(self: &mut Self, state: ElementState, scancode: ScanCode, modifiers: ModifiersState) {
@@ -49,7 +159,7 @@ impl InputState {
         }
     }
 
-    pub fn finish_update(self: &mut Self) {
+    pub fn frame_end(self: &mut Self) {
         self.pressed_digital.iter_mut().for_each(|(_, (recent_press, _))| {
             if *recent_press { *recent_press = false }
         });
@@ -68,17 +178,6 @@ pub enum DigitalInput {
     Mouse(MouseInput)
 }
 
-impl DigitalInput {
-    pub fn simple_key(scancode: ScanCode) -> DigitalInput {
-        DigitalInput::Keyboard(KeyboardInput { scancode, modifiers: ModifiersState {
-            shift: false,
-            ctrl: false,
-            alt: false,
-            logo: false
-        } })
-    }
-}
-
 #[derive(Debug, Eq, PartialEq, Hash)]
 pub struct KeyboardInput {
     scancode: ScanCode,