Merge #133

133:  Make key axis deltas continuous instead of discrete  r=vitvakatu a=alteous

Fixes unwanted 'jagged' input behaviour. This most notably affects the first person camera controls.

#### Behaviour before fix

Frame | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
-- | -- | -- | -- | -- | -- | -- | -- | -- | -- | --
Event | - | P | - | - | - | P | P | R | - | -
Move | N | Y | N | N | N | Y | Y | N | N | N

#### Behaviour after fix

Frame | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
-- | -- | -- | -- | -- | -- | -- | -- | -- | -- | --
Event | - | P | - | - | - | P | P | R | - | -
Move | N | Y | Y | Y | Y | Y | Y | N | N | N

Author: bors[bot]

src/controls/first_person.rs

@@ -339,9 +339,7 @@ impl FirstPerson {
         &mut self,
         input: &Input,
     ) {
-        let dtime = input.delta_time();
-        let dlook = dtime * self.look_speed;
-
+        let dlook = input.delta_time() * self.look_speed;
         let mouse = input.mouse_delta_raw();
 
         self.yaw += dlook * mouse.x;
@@ -360,7 +358,7 @@ impl FirstPerson {
         self.axes
             .vertical
             .map(|a| if let Some(diff) = input.timed(a) {
-                self.position.y += self.move_speed * diff * dtime;
+                self.position.y += self.move_speed * diff;
             });
 
         self.axes

src/input/mod.rs

@@ -261,23 +261,37 @@ impl Input {
         hit.hit(self)
     }
 
-    /// Returns `Option<delta>` value for specified axis, where `delta` is either `i8` for
-    /// [`axis::Key`](struct.Key.html) or `f32` for [`axis::Raw`](struct.Raw.html).
+    /// Returns the change ('delta') in input state since the last call to
+    /// [`Window::update`].
     ///
-    /// Delta value for [`axis::Key`](struct.Key.html) represents the amount of `positive` hits minus
-    /// amount of `negative` hits.
+    /// This value depends on the type of input device is given.
     ///
-    /// Delta value for [`axis::Raw`](struct.Raw.html) represents the sum of all
-    /// [raw movements](struct.Input.html#method.axes_movements) along specific axis.
+    /// [`axis::Key`]
+    ///
+    ///  * `None` when no updates to the axis are received.
+    ///  * `Some(1)` when only positive input to the axis is received.
+    ///  * `Some(-1)` when only negative input to the axis is received.
+    ///  * `Some(0)` when both positive and negative input to the axis is received.
+    ///
+    /// [`axis::Raw`]
+    ///
+    ///  * `None` when no updates to the axis are received and
+    ///  * `Some(x)` where `x` is the sum of positive and negative inputs otherwise.
+    ///
+    /// [`Window::update`]: window/struct.Window.html#method.update
+    /// [`axis::Key`]: input/axis/struct.Key.html
+    /// [`axis::Raw`]: input/axis/struct.Raw.html
     pub fn delta<D: Delta>(
         &self,
         delta: D,
     ) -> <D as Delta>::Output {
         delta.delta(self)
     }
 
-    /// The shortcut for [delta](struct.Input.html#method.delta) *
-    /// [delta_time](struct.Input.html#method.delta_time).
+    /// Shortcut for [`delta`] `*` [`delta_time`].
+    ///
+    /// [`delta`]: struct.Input.html#method.delta
+    /// [`delta_time`]: struct.Input.html#method.delta_time
     pub fn timed<D: Delta>(
         &self,
         delta: D,
@@ -323,23 +337,38 @@ impl Hit for Button {
         input: &Input,
     ) -> bool {
         match *self {
-            Button::Key(button) => input.state.keys_pressed.contains(&button),
-            Button::Mouse(button) => input.state.mouse_pressed.contains(&button),
+            Button::Key(button) => button.hit(input),
+            Button::Mouse(button) => button.hit(input),
         }
     }
 }
 
+impl Hit for Key {
+    fn hit(
+        &self,
+        input: &Input,
+    ) -> bool {
+        input.state.keys_pressed.contains(self)
+    }
+}
+
+impl Hit for MouseButton {
+    fn hit(
+        &self,
+        input: &Input,
+    ) -> bool {
+        input.state.mouse_pressed.contains(self)
+    }
+}
+
 impl Hit for axis::Key {
     fn hit(
         &self,
         input: &Input,
     ) -> bool {
-        input
-            .delta
-            .keys_hit
-            .iter()
-            .filter(|&&k| k == self.pos || k == self.neg)
-            .count() > 0
+        let pos_hit = input.state.keys_pressed.contains(&self.pos);
+        let neg_hit = input.state.keys_pressed.contains(&self.neg);
+        pos_hit || neg_hit
     }
 }
 
@@ -444,11 +473,11 @@ impl Delta for axis::Key {
         &self,
         input: &Input,
     ) -> Self::Output {
-        let (pos, neg) = self.hit_count(input);
-        if pos + neg == 0 {
-            None
-        } else {
-            Some(pos as i8 - neg as i8)
+        match (self.pos.hit(input), self.neg.hit(input)) {
+            (true, true) => Some(0),
+            (true, false) => Some(1),
+            (false, true) => Some(-1),
+            (false, false) => None,
         }
     }
 
@@ -457,7 +486,7 @@ impl Delta for axis::Key {
         input: &Input,
     ) -> Option<TimerDuration> {
         self.delta(input)
-            .map(|v| v as TimerDuration * input.delta_time())
+            .map(|delta| delta as TimerDuration * input.delta_time())
     }
 }