Add Multiple variant to the Axis enum

amethyst_input/src/axis.rs

@@ -42,6 +42,8 @@ pub enum Axis {
         /// You almost always want this false.
         horizontal: bool,
     },
+    /// Represents multiple input alternatives. Allows to bind more than one input to a single axis.
+    Multiple(Vec<Axis>),
 }
 
 pub(super) enum Conflict {
@@ -52,6 +54,14 @@ pub(super) enum Conflict {
 }
 
 impl Axis {
+    pub(super) fn conflicts_with_button(&self, other: &Button) -> bool {
+        match self {
+            Axis::Emulated { pos, neg } => other == pos || other == neg,
+            Axis::Multiple(axes) => axes.iter().any(|a| a.conflicts_with_button(other)),
+            _ => false,
+        }
+    }
+
     pub(super) fn conflicts_with_axis(&self, other: &Axis) -> Option<Conflict> {
         match self {
             Axis::Emulated {
@@ -98,6 +108,15 @@ impl Axis {
                     }
                 }
             }
+            Axis::Multiple(axes) => {
+                if let Some(inner_conflict) = axes
+                    .iter()
+                    .map(|a| a.conflicts_with_axis(other))
+                    .find(|x| x.is_some())
+                {
+                    return inner_conflict;
+                }
+            }
         }
         None
     }

amethyst_input/src/bindings.rs

@@ -95,10 +95,16 @@ impl BindingTypes for StringBindings {
 ///             pos: Key(Up),
 ///             neg: Key(Down)
 ///         ),
-///         "leftright": Emulated(
-///             pos: Key(Right),
-///             neg: Key(Left)
-///         )
+///         "leftright": Multiple([ // Multiple bindings for one axis
+///             Emulated(
+///                 pos: Key(Right),
+///                 neg: Key(Left)
+///             ),
+///             Emulated(
+///                 pos: Key(D),
+///                 neg: Key(A)
+///             )
+///         ])
 ///     },
 ///     actions: {
 ///         "fire": [ [Mouse(Left)], [Key(X)] ], // Multiple bindings for one action
@@ -426,10 +432,8 @@ impl<T: BindingTypes> Bindings<T> {
         }
         if bind.len() == 1 {
             for (k, a) in self.axes.iter() {
-                if let Axis::Emulated { pos, neg } = a {
-                    if bind[0] == *pos || bind[0] == *neg {
-                        return Err(BindingError::ButtonBoundToAxis(k.clone(), a.clone()));
-                    }
+                if a.conflicts_with_button(&bind[0]) {
+                    return Err(BindingError::ButtonBoundToAxis(k.clone(), a.clone()));
                 }
             }
         }

amethyst_input/src/input_handler.rs

@@ -518,15 +518,10 @@ where
         }
     }
 
-    /// Returns the value of an axis by the id, if the id doesn't exist this returns None.
-    pub fn axis_value<A>(&self, id: &A) -> Option<f32>
-    where
-        T::Axis: Borrow<A>,
-        A: Hash + Eq + ?Sized,
-    {
-        self.bindings.axes.get(id).map(|a| match *a {
+    fn axis_value_impl(&self, a: &Axis) -> f32 {
+        match a {
             Axis::Emulated { pos, neg, .. } => {
-                match (self.button_is_down(pos), self.button_is_down(neg)) {
+                match (self.button_is_down(*pos), self.button_is_down(*neg)) {
                     (true, false) => 1.0,
                     (false, true) => -1.0,
                     _ => 0.0,
@@ -541,10 +536,10 @@ where
             } => self
                 .controller_axes
                 .iter()
-                .find(|&&(id, a, _)| id == controller_id && a == axis)
-                .map(|&(_, _, val)| if invert { -val } else { val })
+                .find(|&&(id, a, _)| id == *controller_id && a == *axis)
+                .map(|&(_, _, val)| if *invert { -val } else { val })
                 .map(|val| {
-                    let dead_zone = dead_zone as f32;
+                    let dead_zone = *dead_zone as f32;
                     if val < -dead_zone {
                         (val + dead_zone) / (1.0 - dead_zone)
                     } else if val > dead_zone {
@@ -569,7 +564,7 @@ where
 
                 let rel_delta = delta / radius;
 
-                if over_extendable {
+                if *over_extendable {
                     rel_delta
                 } else if rel_delta > 1. {
                     1.
@@ -579,8 +574,22 @@ where
                     rel_delta
                 }
             }
-            Axis::MouseWheel { horizontal } => self.mouse_wheel_value(horizontal),
-        })
+            Axis::MouseWheel { horizontal } => self.mouse_wheel_value(*horizontal),
+            Axis::Multiple(axes) => axes
+                .iter()
+                .map(|a| self.axis_value_impl(a))
+                .max_by(|x, y| x.abs().partial_cmp(&y.abs()).unwrap())
+                .unwrap_or(0.0),
+        }
+    }
+
+    /// Returns the value of an axis by the id, if the id doesn't exist this returns None.
+    pub fn axis_value<A>(&self, id: &A) -> Option<f32>
+    where
+        T::Axis: Borrow<A>,
+        A: Hash + Eq + ?Sized,
+    {
+        self.bindings.axes.get(id).map(|a| self.axis_value_impl(a))
     }
 
     /// Returns true if any of the actions bindings is down.