1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Provides unified access to input devices across platforms.
//!
//! # Keyboard Inputs
//!
//! To check whether the current platform provides keyboard input, call:
//!
//! ```rust,ignore
//! // Returns true if a keyboard is attached
//! input.has_keyboard_attached();
//! ```
//!
//! Nothing bad will happen if you call the keyboard functions even if `has_keyboard_
//! attached` returns false. To check the current state of specific keys:
//!
//! ```rust,ignore
//! // Checks if a key is currently held down.
//! input.is_key_down(KeyboardButton::A);
//!
//! // Checks if a key has been pressed down during the last frame.
//! input.is_key_press(KeyboardButton::A);
//!
//! // Checks if a key has been released during the last frame.
//! input.is_key_repeat(KeyboardButton::A);
//! ```
//!
//! A list of all key codes can be found in the `KeyboardButton` enumeration. Notes
//! that the key code used here, are virtual keycode of physical keys, they don't
//! necessarily represent what's actually printed on the key cap.
//!
//! It's useful to get converted character input instead of raw key codes, to capture
//! entered text in last frame, you can call:
//!
//! ```rust,ignore
//! // Gets captured text during the last frame.
//! input.text();
//! ```
//!
//! # Mouse Inputs
//!
//! Similar to keyboard device, to find out whether the host platform provides mouse
//! input, call `has_mouse_attached`.
//!
//! To check the state of the mouse buttons, use the following functions:
//!
//! ```rust,ignore
//! // Checks if a mouse button is held down.
//! input.is_mouse_down(MouseButton::Left);
//!
//! // Checks if a mouse button has been pressed during last frame.
//! input.is_mouse_press(MouseButton::Left);
//!
//! // Checks if a mouse button has been released during last frame.
//! input.is_mouse_release(MouseButton::Left);
//! ```
//!
//! A list of all mouse buttons can be found in the `KeyboardButton` enumeration. To get
//! the current mouse position and the last frame's mouse movement in pixels:
//!
//! ```rust,ignore
//! // Gets the mouse position relative to the top-left hand corner of the window.
//! input.mouse_position();
//!
//! // Gets mouse movement in pixels since last frame.
//! input.mouse_movement();
//! ```
//!
//! To get mouse wheel information:
//!
//! ```rust,ignore
//! // Gets the scroll movement of mouse in pixels, usually provided by mouse wheel.
//! input.mouse_scroll();
//! ```
//!
//! Mouse positions and movement are reported in pixel coordinates which makes it
//! difficult to derive useful movement information out of it. It might changes in
//! the future versions (dividing by the framebuffer resolution is a simple but very
//! fuzzy workaround).
//!
//! We also recognize some simple input patterns, like:
//!
//! ```rust,ignore
//! // Checks if a mouse button has been clicked during last frame.
//! input.mouse_position();
//!
//! // Checks if a mouse button has been double clicked during last frame.
//! input.is_mouse_double_click();
//! ```
//!
//! # `TouchPad` Inputs
//!
//! The touch input functions provides access to basic touch- and multi-touch-input,
//! and is currently only implemented on mobile platforms and not for notebook
//! touchpads. You can get the touch informations by the finger index, which is
//! ordered by the first touch time.
//!
//! ```rust,ignore
//! // Checks if the `n`th finger is touched during last frame.
//! input.is_finger_touched(n);
//!
//! // Gets the position of the `n`th touched finger.
//! input.finger_position(n);
//! ```
//!
//! The touch support also addresses a few platform-agnostic gesture recognizers
//! based on low-level touch inputs.
//!
//! ```rust,ignore
//! // Gets the tap gesture.
//! match input.finger_tap() {
//!     // A tap geture is detected during last frame.
//!     GestureTap::Action { position } => { ... },
//!     GestureTap::None => { ... },
//! }
//!
//! // Gets the double tap gesture.
//! match input.finger_double_tap() {
//!     // A double tap geture is detected during last frame.
//!     GestureTap::Action { position } => { ... },
//!     GestureTap::None => { ... },
//! }
//!
//! // Gets the panning gesture.
//! match input.finger_pan() {
//!     GesturePan::Start { start_position } => { ... },
//!     GesturePan::Move { start_position, position, movement } => { ... },
//!     GesturePan::End { start_position, position } => {... },
//!     GestureTap::None => { ... },
//! }
//! ```
//!
//! # Others Inputs
//!
//! Somethings that nice to have, but not implemented right now:
//!
//! 1. Device sensor inputs;
//! 2. Game pad inputs;
//! 3. More touch gesture like `Pinching`.

pub mod keyboard;
pub mod mouse;
pub mod touchpad;

mod service;
pub use self::service::{InputSetup, InputSystem, InputSystemShared};

/// Maximum touches that would be tracked at sametime.
pub const MAX_TOUCHES: usize = 4;

pub mod prelude {
    pub use super::{InputSetup, InputSystem, InputSystemShared};
    pub use super::keyboard::KeyboardSetup;
    pub use super::mouse::MouseSetup;
    pub use super::touchpad::{GesturePan, GestureTap, TouchPadSetup};
}