OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <linux/input.h> | 5 #include "ui/events/ozone/gamepad/gamepad_mapping.h" |
6 #include <cstdint> | |
7 #include <map> | |
8 | 6 |
9 #include "base/macros.h" | 7 #include <memory> |
10 #include "ui/events/ozone/gamepad/gamepad_mapping.h" | 8 |
11 #include "ui/events/ozone/gamepad/webgamepad_constants.h" | 9 #include "base/memory/ptr_util.h" |
| 10 #include "ui/events/ozone/evdev/event_device_info.h" |
| 11 #include "ui/events/ozone/gamepad/generic_gamepad_mapping.h" |
| 12 #include "ui/events/ozone/gamepad/static_gamepad_mapping.h" |
12 | 13 |
13 namespace ui { | 14 namespace ui { |
14 | 15 |
15 // KeyMap maps evdev key code to web gamepad code. | 16 std::unique_ptr<GamepadMapper> GetGamepadMapper( |
16 struct KeyMapEntry { | 17 const EventDeviceInfo& devinfo) { |
17 uint16_t evdev_code; | 18 std::unique_ptr<GamepadMapper> result( |
18 uint16_t mapped_code; | 19 GetStaticGamepadMapper(devinfo.vendor_id(), devinfo.product_id())); |
19 }; | 20 if (!result) { |
20 | 21 return BuildGenericGamepadMapper(devinfo); |
21 // AbsMap maps evdev abs code to web gamepad (type, code). | |
22 struct AbsMapEntry { | |
23 uint16_t evdev_code; | |
24 GamepadEventType mapped_type; | |
25 uint16_t mapped_code; | |
26 }; | |
27 | |
28 using KeyMapType = const KeyMapEntry[]; | |
29 using AbsMapType = const AbsMapEntry[]; | |
30 | |
31 #define TO_BTN(code, mapped_code) \ | |
32 { code, GamepadEventType::BUTTON, mapped_code } | |
33 | |
34 #define TO_ABS(code, mapped_code) \ | |
35 { code, GamepadEventType::AXIS, mapped_code } | |
36 | |
37 #define DO_MAPPING \ | |
38 DoGamepadMapping(key_mapping, arraysize(key_mapping), abs_mapping, \ | |
39 arraysize(abs_mapping), type, code, mapped_type, \ | |
40 mapped_code) | |
41 | |
42 bool DoGamepadMapping(const KeyMapEntry* key_mapping, | |
43 size_t key_map_size, | |
44 const AbsMapEntry* abs_mapping, | |
45 size_t abs_map_size, | |
46 uint16_t type, | |
47 uint16_t code, | |
48 GamepadEventType* mapped_type, | |
49 uint16_t* mapped_code) { | |
50 if (type == EV_KEY) { | |
51 const KeyMapEntry* entry = nullptr; | |
52 for (size_t i = 0; i < key_map_size; i++) { | |
53 if (key_mapping[i].evdev_code == code) { | |
54 entry = key_mapping + i; | |
55 } | |
56 } | |
57 if (!entry) { | |
58 return false; | |
59 } | |
60 *mapped_type = GamepadEventType::BUTTON; | |
61 *mapped_code = entry->mapped_code; | |
62 return true; | |
63 } | 22 } |
64 | 23 return result; |
65 if (type == EV_ABS) { | |
66 const AbsMapEntry* entry = nullptr; | |
67 for (size_t i = 0; i < abs_map_size; i++) { | |
68 if (abs_mapping[i].evdev_code == code) { | |
69 entry = abs_mapping + i; | |
70 } | |
71 } | |
72 if (!entry) { | |
73 return false; | |
74 } | |
75 *mapped_type = entry->mapped_type; | |
76 *mapped_code = entry->mapped_code; | |
77 return true; | |
78 } | |
79 return false; | |
80 } | |
81 | |
82 // this mapper mapps gamepads compatible with xbox gamepad. | |
83 bool XInputStyleMapper(uint16_t type, | |
84 uint16_t code, | |
85 GamepadEventType* mapped_type, | |
86 uint16_t* mapped_code) { | |
87 static const KeyMapType key_mapping = { | |
88 {BTN_A, WG_BUTTON_A}, // btn_a = 304 / 0x130 | |
89 {BTN_B, WG_BUTTON_B}, // btn_b = 305 / 0x131 | |
90 {BTN_X, WG_BUTTON_X}, // btn_x = 307 / 0x133 | |
91 {BTN_Y, WG_BUTTON_Y}, // btn_y = 308 / 0x134 | |
92 {BTN_TL, WG_BUTTON_L1}, // btn_tl = 310 / 0x136 | |
93 {BTN_TR, WG_BUTTON_R1}, // btn_tr = 311 / 0x137 | |
94 {BTN_SELECT, WG_BUTTON_SELECT}, // btn_select = 314 / 0x13a | |
95 {BTN_START, WG_BUTTON_START}, // btn_start = 315 / 0x13b | |
96 {BTN_THUMBL, WG_BUTTON_THUMBL}, // btn_thumbl = 317 / 0x13d | |
97 {BTN_THUMBR, WG_BUTTON_THUMBR}, // btn_thumbr = 318 / 0x13e | |
98 {BTN_MODE, WG_BUTTON_MODE} // btn_mode = 316 / 0x13c | |
99 }; | |
100 | |
101 static const AbsMapType abs_mapping = { | |
102 TO_ABS(ABS_X, WG_ABS_X), // ABS_X = 0x00 | |
103 TO_ABS(ABS_Y, WG_ABS_Y), // ABS_Y = 0x01 | |
104 TO_ABS(ABS_RX, WG_ABS_RX), // ABS_RX = 0x03 | |
105 TO_ABS(ABS_RY, WG_ABS_RY), // ABS_RZ = 0x04 | |
106 TO_BTN(ABS_Z, WG_BUTTON_LT), // ABS_Z = 0x02 | |
107 TO_BTN(ABS_RZ, WG_BUTTON_RT), // ABS_RZ = 0x05 | |
108 TO_BTN(ABS_HAT0X, kHAT_X), // HAT0X = 0x10 | |
109 TO_BTN(ABS_HAT0Y, kHAT_Y) // HAT0Y = 0x11 | |
110 }; | |
111 return DO_MAPPING; | |
112 } | |
113 | |
114 bool PlaystationSixAxisMapper(uint16_t type, | |
115 uint16_t code, | |
116 GamepadEventType* mapped_type, | |
117 uint16_t* mapped_code) { | |
118 static const KeyMapType key_mapping = { | |
119 {0x12e, WG_BUTTON_A}, | |
120 {0x12d, WG_BUTTON_B}, | |
121 {BTN_DEAD, WG_BUTTON_X}, | |
122 {0x12c, WG_BUTTON_Y}, | |
123 {BTN_BASE5, WG_BUTTON_L1}, | |
124 {BTN_BASE6, WG_BUTTON_R1}, | |
125 {BTN_BASE3, WG_BUTTON_LT}, | |
126 {BTN_BASE4, WG_BUTTON_RT}, | |
127 {BTN_TRIGGER, WG_BUTTON_SELECT}, | |
128 {BTN_TOP, WG_BUTTON_START}, | |
129 {BTN_THUMB, WG_BUTTON_THUMBL}, | |
130 {BTN_THUMB2, WG_BUTTON_THUMBR}, | |
131 {BTN_TOP2, WG_BUTTON_DPAD_UP}, | |
132 {BTN_BASE, WG_BUTTON_DPAD_DOWN}, | |
133 {BTN_BASE2, WG_BUTTON_DPAD_LEFT}, | |
134 {BTN_PINKIE, WG_BUTTON_DPAD_RIGHT}, | |
135 {BTN_TRIGGER_HAPPY17, WG_BUTTON_MODE}, | |
136 }; | |
137 | |
138 static const AbsMapType abs_mapping = { | |
139 TO_ABS(ABS_X, WG_ABS_X), | |
140 TO_ABS(ABS_Y, WG_ABS_Y), | |
141 TO_ABS(ABS_Z, WG_ABS_RX), | |
142 TO_ABS(ABS_RZ, WG_ABS_RY), | |
143 TO_BTN(ABS_MT_TOUCH_MAJOR, WG_BUTTON_LT), | |
144 TO_BTN(ABS_MT_TOUCH_MINOR, WG_BUTTON_RT)}; | |
145 return DO_MAPPING; | |
146 } | |
147 | |
148 bool IBuffalocClassicMapper(uint16_t type, | |
149 uint16_t code, | |
150 GamepadEventType* mapped_type, | |
151 uint16_t* mapped_code) { | |
152 static const KeyMapType key_mapping = { | |
153 {BTN_TRIGGER, WG_BUTTON_A}, {BTN_THUMB, WG_BUTTON_B}, | |
154 {BTN_THUMB2, WG_BUTTON_X}, {BTN_TOP, WG_BUTTON_Y}, | |
155 {BTN_BASE, WG_BUTTON_L1}, {BTN_BASE2, WG_BUTTON_R1}, | |
156 {BTN_TOP2, WG_BUTTON_LT}, {BTN_PINKIE, WG_BUTTON_RT}}; | |
157 | |
158 static const AbsMapType abs_mapping = { | |
159 TO_BTN(ABS_X, kHAT_X), TO_BTN(ABS_Y, kHAT_Y), | |
160 }; | |
161 return DO_MAPPING; | |
162 } | |
163 | |
164 bool ClassicNESMapper(uint16_t type, | |
165 uint16_t code, | |
166 GamepadEventType* mapped_type, | |
167 uint16_t* mapped_code) { | |
168 static const KeyMapType key_mapping = { | |
169 {BTN_THUMB, WG_BUTTON_A}, {BTN_THUMB2, WG_BUTTON_B}, | |
170 {BTN_TRIGGER, WG_BUTTON_X}, {BTN_TOP, WG_BUTTON_Y}, | |
171 {BTN_TOP2, WG_BUTTON_L1}, {BTN_PINKIE, WG_BUTTON_R1}, | |
172 {BTN_BASE3, WG_BUTTON_SELECT}, {BTN_BASE4, WG_BUTTON_START}}; | |
173 | |
174 static const AbsMapType abs_mapping = { | |
175 TO_BTN(ABS_X, kHAT_X), TO_BTN(ABS_Y, kHAT_Y), | |
176 }; | |
177 return DO_MAPPING; | |
178 } | |
179 | |
180 bool SNesRetroMapper(uint16_t type, | |
181 uint16_t code, | |
182 GamepadEventType* mapped_type, | |
183 uint16_t* mapped_code) { | |
184 static const KeyMapType key_mapping = { | |
185 {BTN_C, WG_BUTTON_A}, {BTN_B, WG_BUTTON_B}, | |
186 {BTN_X, WG_BUTTON_X}, {BTN_A, WG_BUTTON_Y}, | |
187 {BTN_Y, WG_BUTTON_L1}, {BTN_Z, WG_BUTTON_R1}, | |
188 {BTN_TL2, WG_BUTTON_SELECT}, {BTN_TR2, WG_BUTTON_START}}; | |
189 | |
190 static const AbsMapType abs_mapping = { | |
191 TO_ABS(ABS_X, kHAT_X), TO_ABS(ABS_Y, kHAT_Y), | |
192 }; | |
193 return DO_MAPPING; | |
194 } | |
195 | |
196 bool ADT1Mapper(uint16_t type, | |
197 uint16_t code, | |
198 GamepadEventType* mapped_type, | |
199 uint16_t* mapped_code) { | |
200 static const KeyMapType key_mapping = { | |
201 {BTN_A, WG_BUTTON_A}, {BTN_B, WG_BUTTON_B}, | |
202 {BTN_X, WG_BUTTON_X}, {BTN_Y, WG_BUTTON_Y}, | |
203 {BTN_TL, WG_BUTTON_L1}, {BTN_TR, WG_BUTTON_R1}, | |
204 {BTN_THUMBL, WG_BUTTON_THUMBL}, {BTN_THUMBR, WG_BUTTON_THUMBR}, | |
205 {BTN_MODE, WG_BUTTON_START}, {KEY_BACK, WG_BUTTON_SELECT}, | |
206 {KEY_HOMEPAGE, WG_BUTTON_MODE}}; | |
207 | |
208 static const AbsMapType abs_mapping = { | |
209 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
210 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), | |
211 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), | |
212 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; | |
213 return DO_MAPPING; | |
214 } | |
215 | |
216 bool Vendor_1d79Product_0009Mapper(uint16_t type, | |
217 uint16_t code, | |
218 GamepadEventType* mapped_type, | |
219 uint16_t* mapped_code) { | |
220 static const KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A}, | |
221 {BTN_B, WG_BUTTON_B}, | |
222 {BTN_X, WG_BUTTON_X}, | |
223 {BTN_Y, WG_BUTTON_Y}, | |
224 {BTN_TL, WG_BUTTON_L1}, | |
225 {BTN_TR, WG_BUTTON_R1}, | |
226 {BTN_START, WG_BUTTON_START}, | |
227 {BTN_THUMBL, WG_BUTTON_THUMBL}, | |
228 {BTN_THUMBR, WG_BUTTON_THUMBR}, | |
229 {KEY_UP, WG_BUTTON_DPAD_UP}, | |
230 {KEY_DOWN, WG_BUTTON_DPAD_DOWN}, | |
231 {KEY_LEFT, WG_BUTTON_DPAD_LEFT}, | |
232 {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT}, | |
233 {KEY_BACK, WG_BUTTON_SELECT}, | |
234 {KEY_HOMEPAGE, WG_BUTTON_MODE}}; | |
235 | |
236 static const AbsMapType abs_mapping = { | |
237 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
238 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), | |
239 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), | |
240 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; | |
241 return DO_MAPPING; | |
242 } | |
243 | |
244 bool Vendor_046dProduct_b501Mapper(uint16_t type, | |
245 uint16_t code, | |
246 GamepadEventType* mapped_type, | |
247 uint16_t* mapped_code) { | |
248 static const KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A}, | |
249 {BTN_B, WG_BUTTON_B}, | |
250 {BTN_X, WG_BUTTON_X}, | |
251 {BTN_Y, WG_BUTTON_Y}, | |
252 {BTN_TL, WG_BUTTON_L1}, | |
253 {BTN_TR, WG_BUTTON_R1}, | |
254 {BTN_TL2, WG_BUTTON_LT}, | |
255 {BTN_TR2, WG_BUTTON_RT}, | |
256 {BTN_SELECT, WG_BUTTON_SELECT}, | |
257 {BTN_START, WG_BUTTON_START}, | |
258 {BTN_THUMBL, WG_BUTTON_THUMBL}, | |
259 {BTN_THUMBR, WG_BUTTON_THUMBR}, | |
260 {KEY_UP, WG_BUTTON_DPAD_UP}, | |
261 {KEY_DOWN, WG_BUTTON_DPAD_DOWN}, | |
262 {KEY_LEFT, WG_BUTTON_DPAD_LEFT}, | |
263 {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT}, | |
264 {BTN_MODE, WG_BUTTON_MODE}}; | |
265 | |
266 static const AbsMapType abs_mapping = { | |
267 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
268 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), | |
269 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), | |
270 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; | |
271 return DO_MAPPING; | |
272 } | |
273 | |
274 bool Vendor_046dProduct_c216Mapper(uint16_t type, | |
275 uint16_t code, | |
276 GamepadEventType* mapped_type, | |
277 uint16_t* mapped_code) { | |
278 static const KeyMapType key_mapping = { | |
279 {BTN_TRIGGER, WG_BUTTON_A}, {BTN_TOP, WG_BUTTON_B}, | |
280 {BTN_THUMB, WG_BUTTON_X}, {BTN_THUMB2, WG_BUTTON_Y}, | |
281 {BTN_TOP2, WG_BUTTON_L1}, {BTN_PINKIE, WG_BUTTON_R1}, | |
282 {BTN_BASE, WG_BUTTON_LT}, {BTN_BASE2, WG_BUTTON_RT}, | |
283 {BTN_BASE3, WG_BUTTON_SELECT}, {BTN_BASE4, WG_BUTTON_START}, | |
284 {BTN_BASE5, WG_BUTTON_THUMBL}, {BTN_BASE6, WG_BUTTON_THUMBR}}; | |
285 | |
286 static const AbsMapType abs_mapping = { | |
287 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
288 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), | |
289 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; | |
290 return DO_MAPPING; | |
291 } | |
292 | |
293 bool Vendor_046dProduct_c219Mapper(uint16_t type, | |
294 uint16_t code, | |
295 GamepadEventType* mapped_type, | |
296 uint16_t* mapped_code) { | |
297 static const KeyMapType key_mapping = { | |
298 {BTN_B, WG_BUTTON_A}, {BTN_C, WG_BUTTON_B}, | |
299 {BTN_A, WG_BUTTON_X}, {BTN_X, WG_BUTTON_Y}, | |
300 {BTN_Y, WG_BUTTON_L1}, {BTN_Z, WG_BUTTON_R1}, | |
301 {BTN_TL, WG_BUTTON_LT}, {BTN_TR, WG_BUTTON_RT}, | |
302 {BTN_TR2, WG_BUTTON_START}, {BTN_SELECT, WG_BUTTON_THUMBL}, | |
303 {BTN_START, WG_BUTTON_THUMBR}, {BTN_TL2, WG_BUTTON_SELECT}}; | |
304 | |
305 static const AbsMapType abs_mapping = { | |
306 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
307 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), | |
308 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; | |
309 return DO_MAPPING; | |
310 } | |
311 | |
312 bool Vendor_1038Product_1412Mapper(uint16_t type, | |
313 uint16_t code, | |
314 GamepadEventType* mapped_type, | |
315 uint16_t* mapped_code) { | |
316 static const KeyMapType key_mapping = { | |
317 {BTN_A, WG_BUTTON_A}, {BTN_B, WG_BUTTON_B}, | |
318 {BTN_X, WG_BUTTON_X}, {BTN_Y, WG_BUTTON_Y}, | |
319 {BTN_TL, WG_BUTTON_L1}, {BTN_TR, WG_BUTTON_R1}, | |
320 {BTN_MODE, WG_BUTTON_SELECT}, {BTN_START, WG_BUTTON_START}, | |
321 }; | |
322 | |
323 static const AbsMapType abs_mapping = { | |
324 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
325 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), | |
326 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; | |
327 return DO_MAPPING; | |
328 } | |
329 | |
330 bool Vendor_1689Product_fd00Mapper(uint16_t type, | |
331 uint16_t code, | |
332 GamepadEventType* mapped_type, | |
333 uint16_t* mapped_code) { | |
334 static const KeyMapType key_mapping = { | |
335 {BTN_A, WG_BUTTON_A}, | |
336 {BTN_B, WG_BUTTON_B}, | |
337 {BTN_X, WG_BUTTON_X}, | |
338 {BTN_Y, WG_BUTTON_Y}, | |
339 {BTN_TL, WG_BUTTON_L1}, | |
340 {BTN_TR, WG_BUTTON_R1}, | |
341 {BTN_START, WG_BUTTON_START}, | |
342 {BTN_THUMBL, WG_BUTTON_THUMBL}, | |
343 {BTN_THUMBR, WG_BUTTON_THUMBR}, | |
344 {BTN_TRIGGER_HAPPY3, WG_BUTTON_DPAD_UP}, | |
345 {BTN_TRIGGER_HAPPY4, WG_BUTTON_DPAD_DOWN}, | |
346 {BTN_TRIGGER_HAPPY1, WG_BUTTON_DPAD_LEFT}, | |
347 {BTN_TRIGGER_HAPPY2, WG_BUTTON_DPAD_RIGHT}, | |
348 {BTN_SELECT, WG_BUTTON_SELECT}, | |
349 {BTN_MODE, WG_BUTTON_MODE}}; | |
350 | |
351 static const AbsMapType abs_mapping = { | |
352 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
353 TO_ABS(ABS_RX, WG_ABS_RX), TO_ABS(ABS_RY, WG_ABS_RY), | |
354 TO_BTN(ABS_Z, WG_BUTTON_LT), TO_BTN(ABS_RZ, WG_BUTTON_RT)}; | |
355 return DO_MAPPING; | |
356 } | |
357 | |
358 bool GenericMapper(uint16_t type, | |
359 uint16_t code, | |
360 GamepadEventType* mapped_type, | |
361 uint16_t* mapped_code) { | |
362 static const KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A}, | |
363 {BTN_B, WG_BUTTON_B}, | |
364 {BTN_X, WG_BUTTON_X}, | |
365 {BTN_Y, WG_BUTTON_Y}, | |
366 {BTN_TL, WG_BUTTON_L1}, | |
367 {BTN_TR, WG_BUTTON_R1}, | |
368 {BTN_TL2, WG_BUTTON_LT}, | |
369 {BTN_TR2, WG_BUTTON_RT}, | |
370 {BTN_THUMBL, WG_BUTTON_THUMBL}, | |
371 {BTN_THUMBR, WG_BUTTON_THUMBR}, | |
372 {KEY_BACK, WG_BUTTON_SELECT}, | |
373 {KEY_HOMEPAGE, WG_BUTTON_MODE}, | |
374 {KEY_UP, WG_BUTTON_DPAD_UP}, | |
375 {KEY_DOWN, WG_BUTTON_DPAD_DOWN}, | |
376 {KEY_LEFT, WG_BUTTON_DPAD_LEFT}, | |
377 {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT}, | |
378 {BTN_SELECT, WG_BUTTON_SELECT}, | |
379 {BTN_START, WG_BUTTON_START}, | |
380 {BTN_MODE, WG_BUTTON_MODE}}; | |
381 | |
382 static const AbsMapType abs_mapping = { | |
383 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), | |
384 TO_ABS(ABS_RX, WG_ABS_RX), TO_ABS(ABS_RY, WG_ABS_RY), | |
385 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), | |
386 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), | |
387 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; | |
388 return DO_MAPPING; | |
389 } | |
390 | |
391 static const struct MappingData { | |
392 uint16_t vendor_id; | |
393 uint16_t product_id; | |
394 GamepadMapper mapper; | |
395 } AvailableMappings[] = { | |
396 // Xbox style gamepad. | |
397 {0x045e, 0x028e, XInputStyleMapper}, // Xbox 360 wired. | |
398 {0x045e, 0x028f, XInputStyleMapper}, // Xbox 360 wireless. | |
399 {0x045e, 0x02a1, XInputStyleMapper}, // Xbox 360 wireless. | |
400 {0x045e, 0x02d1, XInputStyleMapper}, // Xbox one wired. | |
401 {0x045e, 0x02dd, XInputStyleMapper}, // Xbox one wired (2015 fw). | |
402 {0x045e, 0x02e3, XInputStyleMapper}, // Xbox elite wired. | |
403 {0x045e, 0x02ea, XInputStyleMapper}, // Xbox one s (usb). | |
404 {0x045e, 0x0719, XInputStyleMapper}, // Xbox 360 wireless. | |
405 {0x046d, 0xc21d, XInputStyleMapper}, // Logitech f310. | |
406 {0x046d, 0xc21e, XInputStyleMapper}, // Logitech f510. | |
407 {0x046d, 0xc21f, XInputStyleMapper}, // Logitech f710. | |
408 {0x2378, 0x1008, XInputStyleMapper}, // Onlive controller (bluetooth). | |
409 {0x2378, 0x100a, XInputStyleMapper}, // Onlive controller (wired). | |
410 {0x1bad, 0xf016, XInputStyleMapper}, // Mad catz gamepad. | |
411 {0x1bad, 0xf023, XInputStyleMapper}, // Mad catz mlg gamepad for Xbox360. | |
412 {0x1bad, 0xf027, XInputStyleMapper}, // Mad catz fps pro. | |
413 {0x1bad, 0xf036, XInputStyleMapper}, // Mad catz generic Xbox controller. | |
414 {0x1689, 0xfd01, XInputStyleMapper}, // Razer Xbox 360 gamepad. | |
415 {0x1689, 0xfe00, XInputStyleMapper}, // Razer sabertooth elite. | |
416 // Sony gamepads. | |
417 {0x054c, 0x0268, PlaystationSixAxisMapper}, // Playstation 3. | |
418 // NES style gamepad. | |
419 {0x0583, 0x2060, IBuffalocClassicMapper}, // iBuffalo Classic. | |
420 {0x0079, 0x0011, ClassicNESMapper}, // Classic NES controller. | |
421 {0x12bd, 0xd015, SNesRetroMapper}, // Hitgaming SNES retro. | |
422 // Android gamepad. | |
423 {0x0b05, 0x4500, ADT1Mapper}, // Nexus player controller (asus gamepad). | |
424 {0x1532, 0x0900, ADT1Mapper}, // Razer serval. | |
425 {0x18d1, 0x2c40, ADT1Mapper}, // ADT-1 controller (odie). | |
426 // Other gamepads. | |
427 {0x1d79, 0x0009, | |
428 Vendor_1d79Product_0009Mapper}, // Nyko playpad / Playpad pro. | |
429 {0x046d, 0xb501, Vendor_046dProduct_b501Mapper}, // Logitech redhawk. | |
430 // Logitech dual action controller. | |
431 {0x046d, 0xc216, Vendor_046dProduct_c216Mapper}, | |
432 // Logitech cordless rumblepad2. | |
433 {0x046d, 0xc219, Vendor_046dProduct_c219Mapper}, | |
434 {0x1038, 0x1412, Vendor_1038Product_1412Mapper}, // Steelseries free. | |
435 // Razer onza tournment edition. | |
436 {0x1689, 0xfd00, Vendor_1689Product_fd00Mapper}}; | |
437 | |
438 GamepadMapper GetGamepadMapper(uint16_t vendor_id, uint16_t product_id) { | |
439 for (size_t i = 0; i < arraysize(AvailableMappings); i++) { | |
440 if (AvailableMappings[i].vendor_id == vendor_id && | |
441 AvailableMappings[i].product_id == product_id) { | |
442 return AvailableMappings[i].mapper; | |
443 } | |
444 } | |
445 return GenericMapper; | |
446 } | 24 } |
447 | 25 |
448 } // namespace ui | 26 } // namespace ui |
OLD | NEW |