Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(22)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: ui/events/ozone/gamepad/gamepad_mapping.cc

Issue 2899893003: Add generic mapping for gamepad (Closed)
Patch Set: Created 3 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« ui/events/ozone/gamepad/gamepad_mapping.h ('K') | « ui/events/ozone/gamepad/gamepad_mapping.h ('k') | ui/events/ozone/gamepad/generic_gamepad_mapping.h » ('j') | ui/events/ozone/gamepad/generic_gamepad_mapping.h » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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 "ui/events/ozone/evdev/event_device_info.h"
10 #include "ui/events/ozone/gamepad/gamepad_mapping.h" 8 #include "ui/events/ozone/gamepad/generic_gamepad_mapping.h"
11 #include "ui/events/ozone/gamepad/webgamepad_constants.h" 9 #include "ui/events/ozone/gamepad/static_gamepad_mapping.h"
12 10
13 namespace ui { 11 namespace ui {
14 12
15 // KeyMap maps evdev key code to web gamepad code. 13 GamepadMapper* GetGamepadMapper(const EventDeviceInfo& devinfo) {
spang 2017/06/01 05:08:12 Should return std::unique_ptr<GamepadMapper>
jkwang 2017/06/02 22:03:51 Done.
16 struct KeyMapEntry { 14 GamepadMapper* result =
17 uint16_t evdev_code; 15 GetStaticGamepadMapper(devinfo.vendor_id(), devinfo.product_id());
18 uint16_t mapped_code; 16 if (!result) {
19 }; 17 result = new GenericGamepadMapping(devinfo);
spang 2017/06/01 05:08:12 Use base::MakeUnique here.
jkwang 2017/06/02 22:03:51 Done.
20
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 } 18 }
64 19 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 } 20 }
447 21
448 } // namespace ui 22 } // namespace ui
OLDNEW
« ui/events/ozone/gamepad/gamepad_mapping.h ('K') | « ui/events/ozone/gamepad/gamepad_mapping.h ('k') | ui/events/ozone/gamepad/generic_gamepad_mapping.h » ('j') | ui/events/ozone/gamepad/generic_gamepad_mapping.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698