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
// Copyright 2016-2018 Mateusz Sieczko and other GilRs Developers
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
//! GilRs - Game Input Library for Rust
//! ===================================
//!
//! GilRs abstract platform specific APIs to provide unified interfaces for working with gamepads.
//!
//! Main features:
//!
//! - Unified gamepad layout—buttons and axes are represented by familiar names
//! - Support for SDL2 mappings including `SDL_GAMECONTROLLERCONFIG` environment
//! variable which Steam uses
//! - Hotplugging—GilRs will try to assign new IDs for new gamepads and reuse the same
//! ID for gamepads which reconnected
//! - Force feedback (rumble)
//! - Power information (is gamepad wired, current battery status)
//!
//! Example
//! -------
//!
//! ```rust
//! use gilrs::{Gilrs, Button, Event};
//!
//! let mut gilrs = Gilrs::new().unwrap();
//!
//! // Iterate over all connected gamepads
//! for (_id, gamepad) in gilrs.gamepads() {
//! println!("{} is {:?}", gamepad.name(), gamepad.power_info());
//! }
//!
//! let mut active_gamepad = None;
//!
//! loop {
//! // Examine new events
//! while let Some(Event { id, event, time, .. }) = gilrs.next_event() {
//! println!("{:?} New event from {}: {:?}", time, id, event);
//! active_gamepad = Some(id);
//! }
//!
//! // You can also use cached gamepad state
//! if let Some(gamepad) = active_gamepad.map(|id| gilrs.gamepad(id)) {
//! if gamepad.is_pressed(Button::South) {
//! println!("Button South is pressed (XBox - A, PS - X)");
//! }
//! }
//! # break;
//! }
//! ```
//!
//! Supported features
//! ------------------
//!
//! | | Input | Hotplugging | Force feedback |
//! |------------------|:-----:|:-----------:|:--------------:|
//! | Linux/BSD (evdev)| ✓ | ✓ | ✓ |
//! | Windows | ✓ | ✓ | ✓ |
//! | OS X | ✓ | ✓ | ✕ |
//! | Wasm | ✓ | ✓ | n/a |
//! | Android | ✕ | ✕ | ✕ |
//!
//! Controller layout
//! -----------------
//!
//! 
//! [original image by nicefrog](http://opengameart.org/content/generic-gamepad-template)
//!
//! Mappings
//! --------
//!
//! GilRs use SDL-compatible controller mappings to fix on Linux legacy drivers that doesn't follow
//! [Linux Gamepad API](https://www.kernel.org/doc/Documentation/input/gamepad.txt) and to provide
//! unified button layout for platforms that doesn't make any guarantees about it. The main source
//! is [SDL_GameControllerDB](https://github.com/gabomdq/SDL_GameControllerDB), but library also
//! support loading mappings from environment variable `SDL_GAMECONTROLLERCONFIG` (which Steam
//! use).
//!
//! Cargo features
//! --------------
//!
//! - `serde-serialize` - enable deriving of serde's `Serialize` and `Deserialize` for
//! various types.
//! - `wgi` - use Windows Gaming Input on Windows (enabled by default).
//! - `xinput` - use XInput on Windows.
//!
//! Platform specific notes
//! ======================
//!
//! Linux/BSD (evdev)
//! -----
//!
//! With evdev, GilRs read (and write, in case of force feedback) directly from appropriate
//! `/dev/input/event*` file. This mean that user have to have read and write access to this file.
//! On most distros it shouldn't be a problem, but if it is, you will have to create udev rule.
//! On FreeBSD generic HID gamepads use hgame(4) and special use Linux driver via `webcamd`.
//!
//! To build GilRs, you will need pkg-config and libudev .pc file. On some distributions this file
//! is packaged in separate archive (e.g., `libudev-dev` in Debian, `libudev-devd` in FreeBSD).
//!
//! Windows
//! -----
//!
//! Windows defaults to using Windows Gaming Input instead of XInput. If you need to use XInput you
//! can disable the `wgi` feature (it's enabled by default) and enable the `xinput` feature.
//!
//! Windows Gaming Input requires an in focus window to be associated with the process to receive
//! events. You can still switch back to using xInput by turning off default features and enabling
//! the xinput feature.
//!
//! Note: Some (Older?) devices may still report inputs without a window but this is not the case
//! for all devices so if you are writing a terminal based game, use the xinput feature instead.
//!
//! Wasm
//! -----
//!
//! Wasm implementation uses stdweb, or wasm-bindgen with the wasm-bindgen feature.
//! For stdweb, you will need [cargo-web](https://github.com/koute/cargo-web) to build gilrs for
//! wasm32-unknown-unknown. For wasm-bindgen, you will need the wasm-bindgen cli or a tool like
//! [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/).
//! Unlike other platforms, events are only generated when you call `Gilrs::next_event()`.
extern crate log;
pub use crateFilter;
pub use crate;
pub use crate;
pub use crateLinuxGamepadExt;
pub use crate;