KallistiOS git master
Independent SDK for the Sega Dreamcast
Loading...
Searching...
No Matches
controller.h
Go to the documentation of this file.
1/* KallistiOS ##version##
2
3 dc/maple/controller.h
4 Copyright (C) 2000-2002 Jordan DeLong
5 Copyright (C) 2000-2002 Megan Potter
6 Copyright (C) 2023, 2025 Falco Girgis
7
8 Thanks to Marcus Comstedt for information on the controller.
9*/
10
11/** \file dc/maple/controller.h
12 \brief Definitions for using the controller device.
13 \ingroup controller
14
15 This file contains the definitions needed to access the Maple controller
16 device. Obviously, this corresponds to the MAPLE_FUNC_CONTROLLER function
17 code.
18
19 \author Jordan DeLong
20 \author Megan Potter
21 \author Falco Girgis
22*/
23
24#ifndef __DC_MAPLE_CONTROLLER_H
25#define __DC_MAPLE_CONTROLLER_H
26
27#include <sys/cdefs.h>
28__BEGIN_DECLS
29
30#include <stdint.h>
31
32/** \defgroup controller Controller
33 \brief Controller Maple Device API
34 \ingroup peripherals
35
36 This module contains the public API for the controller
37 maple driver.
38
39 A standard, first-party Dreamcast controller has
40 the following button configuration:
41
42 ___________
43 / | __ | \
44 L trigger ------| / | | | | \ |----- R trigger
45 _|__/ | |__| | \_|__
46 | _ \____/ |
47 Joystick ----|-/ \ (Y) |
48 | \_/ (X) (B)|
49 | _ (A) |
50 | _| |_ |
51 D-Pad ----|-|_ _| |
52 | |_| /\ |
53 \ /__\ /
54 \ _____|_______ /
55 \ / | \ /
56 \/ | \/
57 Start button
58
59 You can grab a pointer to a connected controller by
60 using the following:
61
62 maple_device_t *device = maple_enum_type(N, MAPLE_FUNC_CONTROLLER);
63
64 if(device) printf("Controller found!\n");
65 else printf("Controller not found!\n");
66
67 where N is the controller number. 0 would be the first
68 controller found, which may not necessarily be on port A.
69*/
70
71/** \defgroup controller_inputs Querying Inputs
72 \brief API used to query for input state
73 \ingroup controller
74
75 The following API is used to check for a controller's input state.
76
77 You can grab a controller's state structure, containing the state
78 of all of its inputs by using:
79
80 cont_state_t *state = (cont_state_t *)maple_dev_status(device);
81
82 Next you can check for the state of a particular button with:
83
84 if(state->a) // Check via bitfield
85 printf("Pressed A".);
86
87 or
88
89 if(state->buttons & CONT_A) // Check via applying bitmask
90 printf("Pressed A.")
91*/
92
93/** \defgroup controller_input_masks Inputs
94 \brief Collection of all status masks for checking input
95 \ingroup controller_inputs
96
97 A set of bitmasks representing each input source on a controller, used to
98 check its status.
99
100 @{
101*/
102#define CONT_C (1<<0) /**< \brief C button Mask. */
103#define CONT_B (1<<1) /**< \brief B button Mask. */
104#define CONT_A (1<<2) /**< \brief A button Mask. */
105#define CONT_START (1<<3) /**< \brief Start button Mask. */
106#define CONT_DPAD_UP (1<<4) /**< \brief Main Dpad Up button Mask. */
107#define CONT_DPAD_DOWN (1<<5) /**< \brief Main Dpad Down button Mask. */
108#define CONT_DPAD_LEFT (1<<6) /**< \brief Main Dpad Left button Mask. */
109#define CONT_DPAD_RIGHT (1<<7) /**< \brief Main Dpad right button Mask. */
110#define CONT_Z (1<<8) /**< \brief Z button Mask. */
111#define CONT_Y (1<<9) /**< \brief Y button Mask. */
112#define CONT_X (1<<10) /**< \brief X button Mask. */
113#define CONT_D (1<<11) /**< \brief D button Mask. */
114#define CONT_DPAD2_UP (1<<12) /**< \brief Secondary Dpad Up button Mask. */
115#define CONT_DPAD2_DOWN (1<<13) /**< \brief Secondary Dpad Down button Mask. */
116#define CONT_DPAD2_LEFT (1<<14) /**< \brief Secondary Dpad Left button Mask. */
117#define CONT_DPAD2_RIGHT (1<<15) /**< \brief Secondary Dpad Right button Mask. */
118/** @} */
119
120/** \brief Controller buttons for standard reset action
121 \ingroup controller_inputs
122
123 Convenience macro providing the standard button combination
124 used as a reset mechanism by most retail games.
125*/
126#define CONT_RESET_BUTTONS (CONT_A | CONT_B | CONT_X | CONT_Y | CONT_START)
127
128/** \brief Controller state structure.
129 \ingroup controller_inputs
130
131 This structure contains information about the status of the controller
132 device and can be fetched by casting the result of maple_dev_status() to
133 this structure.
134
135 A 1 bit in the buttons' bitfield indicates that a button is pressed, and the
136 joyx, joyy, joy2x, joy2 values are all 0 based (0 is centered).
137
138 \note
139 Whether a particular field or button is actually used by the controller
140 depends upon its capabilities. See \ref controller_query_caps.
141
142 \sa maple_dev_status
143*/
144typedef struct cont_state {
145 union {
146 /** \brief bit-packed controller button states
147 \sa controller_buttons
148 */
149 uint32_t buttons;
150 struct {
151 uint32_t c: 1; /**< \brief C button value. */
152 uint32_t b: 1; /**< \brief B button value. */
153 uint32_t a: 1; /**< \brief A button value. */
154 uint32_t start: 1; /**< \brief Start button value. */
155 uint32_t dpad_up: 1; /**< \brief Main Dpad Up button value. */
156 uint32_t dpad_down: 1; /**< \brief Main Dpad Down button value. */
157 uint32_t dpad_left: 1; /**< \brief Main Dpad Left button value. */
158 uint32_t dpad_right: 1; /**< \brief Main Dpad Right button value. */
159 uint32_t z: 1; /**< \brief Z button value. */
160 uint32_t y: 1; /**< \brief Y button value. */
161 uint32_t x: 1; /**< \brief X button value. */
162 uint32_t d: 1; /**< \brief D button value. */
163 uint32_t dpad2_up: 1; /**< \brief Secondary Dpad Up button value. */
164 uint32_t dpad2_down: 1; /**< \brief Secondary Dpad Down button value. */
165 uint32_t dpad2_left: 1; /**< \brief Secondary Dpad Left button value. */
166 uint32_t dpad2_right: 1; /**< \brief Secondary Dpad Right button value. */
167 uint32_t: 16;
168 };
169 };
170
171 int ltrig; /**< \brief Left trigger value (0-255). */
172 int rtrig; /**< \brief Right trigger value (0-255). */
173 int joyx; /**< \brief Main joystick x-axis value (-128 - 127). */
174 int joyy; /**< \brief Main joystick y-axis value. */
175 int joy2x; /**< \brief Secondary joystick x-axis value. */
176 int joy2y; /**< \brief Secondary joystick y-axis value. */
178
179/** \brief Controller automatic callback type.
180 \ingroup controller_inputs
181
182 Functions of this type can be set with cont_btn_callback() to respond
183 automatically to the specified set of buttons being pressed. This can be
184 used, for instance, to implement the standard A+B+X+Y+Start method of ending
185 the program running.
186
187 \param addr Maple BUS address to poll for the button mask
188 on, or 0 for all ports.
189 \param btns Mask of all buttons which should be pressed to
190 trigger the callback.
191
192 \sa cont_btn_callback
193*/
194typedef void (*cont_btn_callback_t)(uint8_t addr, uint32_t btns);
195
196/** \brief Set an automatic button press callback.
197 \ingroup controller_inputs
198
199 This function sets a callback function to be called when the specified
200 controller has the set of buttons given pressed.
201
202 \note
203 The callback gets invoked for the given maple port; however, providing
204 an address of '0' will cause it to be invoked for any port with a
205 device pressing the given buttons. Since you are passed back the address
206 of this device, You are free to implement your own filtering logic within
207 your callback. Any callback with addr==0 will be installed to the end of
208 the list of callbacks and will run after callbacks with the same btns but
209 a specified address.
210
211 \param addr The controller to listen on (or 0 for all ports).
212 This value can be obtained by using maple_addr().
213 \param btns The buttons bitmask to match.
214 \param cb The callback to call when the buttons are pressed.
215 Passing NULL will uninstall all callbacks on the
216 addr/btns combination.
217*/
218int cont_btn_callback(uint8_t addr, uint32_t btns, cont_btn_callback_t cb);
219
220/** \defgroup controller_query_caps Querying Capabilities
221 \brief API used to query for a controller's capabilities
222 \ingroup controller
223
224 The following API is used to query for the support of individual
225 or groups of capabilities by a particular device.
226*/
227
228/** \defgroup controller_caps Capabilities
229 \brief Bit masks used to identify controller capabilities
230 \ingroup controller_query_caps
231
232 These bits will be set in the function_data for the controller's deviceinfo
233 if the controller supports the corresponding button/axis capability.
234
235 \note
236 The ordering here is so that they match the order found in
237 \ref controller_input_masks.
238
239 @{
240*/
241#define CONT_CAPABILITY_C (1<<24) /**< \brief C button capability mask. */
242#define CONT_CAPABILITY_B (1<<25) /**< \brief B button capability mask. */
243#define CONT_CAPABILITY_A (1<<26) /**< \brief A button capability mask. */
244#define CONT_CAPABILITY_START (1<<27) /**< \brief Start button capability mask. */
245#define CONT_CAPABILITY_DPAD_UP (1<<28) /**< \brief First Dpad up capability mask. */
246#define CONT_CAPABILITY_DPAD_DOWN (1<<29) /**< \brief First Dpad down capability mask. */
247#define CONT_CAPABILITY_DPAD_LEFT (1<<30) /**< \brief First Dpad left capability mask. */
248#define CONT_CAPABILITY_DPAD_RIGHT (1<<31) /**< \brief First Dpad right capability mask. */
249#define CONT_CAPABILITY_Z (1<<16) /**< \brief Z button capability mask. */
250#define CONT_CAPABILITY_Y (1<<17) /**< \brief Y button capability mask. */
251#define CONT_CAPABILITY_X (1<<18) /**< \brief X button capability mask. */
252#define CONT_CAPABILITY_D (1<<19) /**< \brief D button capability mask. */
253#define CONT_CAPABILITY_DPAD2_UP (1<<20) /**< \brief Second Dpad up capability mask. */
254#define CONT_CAPABILITY_DPAD2_DOWN (1<<21) /**< \brief Second Dpad down capability mask. */
255#define CONT_CAPABILITY_DPAD2_LEFT (1<<22) /**< \brief Second Dpad left capability mask. */
256#define CONT_CAPABILITY_DPAD2_RIGHT (1<<23) /**< \brief Second Dpad right capability mask. */
257#define CONT_CAPABILITY_RTRIG (1<<8) /**< \brief Right trigger capability mask. */
258#define CONT_CAPABILITY_LTRIG (1<<9) /**< \brief Left trigger capability mask. */
259#define CONT_CAPABILITY_ANALOG_X (1<<10) /**< \brief First analog X axis capability mask. */
260#define CONT_CAPABILITY_ANALOG_Y (1<<11) /**< \brief First analog Y axis capability mask. */
261#define CONT_CAPABILITY_ANALOG2_X (1<<12) /**< \brief Second analog X axis capability mask. */
262#define CONT_CAPABILITY_ANALOG2_Y (1<<13) /**< \brief Second analog Y axis capability mask. */
263/** @} */
264
265/** \defgroup controller_caps_groups Capability Groups
266 \brief Bit masks representing common groups of capabilities
267 \ingroup controller_query_caps
268
269 These are a sets of capabilities providing a
270 convenient way to test for high-level features,
271 such as dual-analog sticks or extra buttons.
272
273 @{
274*/
275/** \brief Standard button (A, B, X, Y, Start) controller capabilities */
276#define CONT_CAPABILITIES_STANDARD_BUTTONS (CONT_CAPABILITY_A | \
277 CONT_CAPABILITY_B | \
278 CONT_CAPABILITY_X | \
279 CONT_CAPABILITY_Y | \
280 CONT_CAPABILITY_START)
281
282/** \brief Directional pad (up, down, left right) controller capabilities */
283#define CONT_CAPABILITIES_DPAD (CONT_CAPABILITY_DPAD_UP | \
284 CONT_CAPABILITY_DPAD_DOWN | \
285 CONT_CAPABILITY_DPAD_LEFT | \
286 CONT_CAPABILITY_DPAD_RIGHT)
287
288/** \brief Analog stick (X, Y axes) controller capabilities */
289#define CONT_CAPABILITIES_ANALOG (CONT_CAPABILITY_ANALOG_X | \
290 CONT_CAPABILITY_ANALOG_Y)
291
292/** \brief Trigger (L, R lever) controller capabilities */
293#define CONT_CAPABILITIES_TRIGGERS (CONT_CAPABILITY_LTRIG | \
294 CONT_CAPABILITY_RTRIG)
295
296/** \brief Extended button (C, Z) controller capabilities */
297#define CONT_CAPABILITIES_EXTENDED_BUTTONS (CONT_CAPABILITY_C | \
298 CONT_CAPABILITY_Z)
299
300/** \brief Secondary directional pad (up, down, left, right) controller capabilities */
301#define CONT_CAPABILITIES_SECONDARY_DPAD (CONT_CAPABILITY_DPAD2_UP | \
302 CONT_CAPABILITY_DPAD2_DOWN | \
303 CONT_CAPABILITY_DPAD2_LEFT | \
304 CONT_CAPABILITY_DPAD2_RIGHT)
305
306/** \brief Secondary analog stick (X, Y axes) controller capabilities */
307#define CONT_CAPABILITIES_SECONDARY_ANALOG (CONT_CAPABILITY_ANALOG2_X | \
308 CONT_CAPABILITY_ANALOG2_Y)
309
310/** \brief Both directional pads (up, down, left right) controller capabilities */
311#define CONT_CAPABILITIES_DUAL_DPAD (CONT_CAPABILITIES_DPAD | \
312 CONT_CAPABILITIES_SECONDARY_DPAD)
313
314/** \brief Both analog sticks (X, Y axes) controller capabilities */
315#define CONT_CAPABILITIES_DUAL_ANALOG (CONT_CAPABILITIES_ANALOG | \
316 CONT_CAPABILITIES_SECONDARY_ANALOG)
317
318/* Forward declaration */
319struct maple_device;
320
321/** \brief Check for controller capabilities
322 \ingroup controller_query_caps
323
324 Checks whether or not a controller implements the capabilities
325 associated with the given type.
326
327 \note
328 Controller capability reporting is an extremely generic mechanism,
329 such that many peripherals may implement the same capability in
330 completely different ways. For example, the Samba De Amigo maraca
331 controller will advertise itself as a dual-analog device, with each
332 maraca being an analog stick.
333
334 \param cont Pointer to a Maple device structure which
335 implements the CONTROLLER function.
336 \param capabilities Capability mask the controller is expected
337 to implement
338
339 \retval 1 The controller supports the given capabilities.
340 \retval 0 The controller doesn't support the given capabilities.
341 \retval -1 Invalid controller.
342
343 \sa cont_is_type
344*/
345int cont_has_capabilities(const struct maple_device *cont, uint32_t capabilities);
346/** @} */
347
348/** \defgroup controller_query_types Querying Types
349 \brief API for determining controller types
350 \ingroup controller
351
352 The following API is for detecting between different types
353 of standard controllers. These controllers are not identified
354 by specific model but are instead identified solely by capabilities,
355 so that homebrew software can remain generic and future-proof to later
356 homebrew controllers or exotic, untested 3rd party peripherals.
357
358 \warning
359 Usually you want to check if a controller <i>supports the
360 capabilities</i> of another controller, not whether it is has
361 the <i>exact</i> same capabilities of a controller. For example,
362 a controller that happens to come along supporting a dual analog
363 stick but is otherwise the same layout as a standard controller
364 would not match the standard controller type; however, it would
365 implement its capabilities. There exist 3rd party adapters for
366 connecting dual-analog PS2 controllers to DC which operate
367 like this today.
368
369 \note
370 If you really want to hard-code the detection of a certain
371 exact model or brand of controller, instead of basing your
372 detection upon capabilities, check for its product_name
373 or license within the maple_devinfo structure.
374
375 \sa cont_has_capabilities, maple_devinfo
376*/
377
378/** \defgroup controller_types Types
379 \brief Preconfigured capabilities for standard controllers
380 \ingroup controller_query_types
381
382 Aggregate capability mask containing all capabilities
383 which are implemented for a particular controller type.
384 For example, the standard controller type is simply a
385 combination of the following capabilities:
386 - Standard buttons
387 - Triggers
388 - Dpad
389 - Analog
390
391 \note
392 Because these are technically just capability masks,
393 a type may also be passed to cont_has_capabilities()
394 for detecting whether something has <i>at least</i>
395 the capabilities of a type.
396
397 @{
398*/
399/** \brief Standard controller type */
400#define CONT_TYPE_STANDARD_CONTROLLER (CONT_CAPABILITIES_STANDARD_BUTTONS | \
401 CONT_CAPABILITIES_TRIGGERS | \
402 CONT_CAPABILITIES_DPAD | \
403 CONT_CAPABILITIES_ANALOG)
404
405/** \brief Dual analog controller type */
406#define CONT_TYPE_DUAL_ANALOG_CONTROLLER (CONT_CAPABILITIES_STANDARD_BUTTONS | \
407 CONT_CAPABILITIES_TRIGGERS | \
408 CONT_CAPABILITIES_DPAD | \
409 CONT_CAPABILITIES_DUAL_ANALOG)
410
411/** \brief ASCII fighting pad controller type */
412#define CONT_TYPE_ASCII_PAD (CONT_CAPABILITIES_STANDARD_BUTTONS | \
413 CONT_CAPABILITIES_EXTENDED_BUTTONS | \
414 CONT_CAPABILITIES_DPAD)
415
416/** \brief Arcade stick controller type */
417#define CONT_TYPE_ARCADE_STICK (CONT_CAPABILITIES_STANDARD_BUTTONS | \
418 CONT_CAPABILITIES_EXTENDED_BUTTONS | \
419 CONT_CAPABILITIES_DPAD)
420
421/** \brief Twin stick joystick controller type */
422#define CONT_TYPE_TWIN_STICK (CONT_CAPABILITIES_STANDARD_BUTTONS | \
423 CONT_CAPABILITIES_EXTENDED_BUTTONS | \
424 CONT_CAPABILITY_D | \
425 CONT_CAPABILITIES_DUAL_DPAD)
426
427/** \brief ASCII Mission Stick controller type */
428#define CONT_TYPE_ASCII_MISSION_STICK (CONT_CAPABILITIES_STANDARD_BUTTONS | \
429 CONT_CAPABILITIES_DUAL_DPAD | \
430 CONT_CAPABILITIES_TRIGGERS | \
431 CONT_CAPABILITIES_ANALOG)
432
433/** \brief Racing wheel/controller type */
434#define CONT_TYPE_RACING_CONTROLLER (CONT_CAPABILITY_DPAD_UP | \
435 CONT_CAPABILITY_DPAD_DOWN | \
436 CONT_CAPABILITY_A | \
437 CONT_CAPABILITY_B | \
438 CONT_CAPABILITY_START | \
439 CONT_CAPABILITIES_TRIGGERS | \
440 CONT_CAPABILITY_ANALOG_X \
441 CONT_CAPABILITIES_SECONDARY_ANALOG)
442
443/** \brief Samba De Amigo maraca controller type */
444#define CONT_TYPE_MARACAS (CONT_CAPABILITY_A | \
445 CONT_CAPABILITY_B | \
446 CONT_CAPABILITY_D | \
447 CONT_CAPABILITY_START | \
448 CONT_CAPABILITIES_EXTENDED_BUTTONS | \
449 CONT_CAPABILITIES_DUAL_ANALOG)
450
451/** \brief Dance Dance Revolution mat controller type */
452#define CONT_TYPE_DANCE_MAT (CONT_CAPABILITY_A | \
453 CONT_CAPABILITY_B | \
454 CONT_CAPABILITY_START | \
455 CONT_CAPABILITIES_DPAD)
456
457/** \brief Fishing rod controller type */
458#define CONT_TYPE_FISHING_ROD (CONT_CAPABILITIES_STANDARD_BUTTONS | \
459 CONT_CAPABILITIES_DPAD | \
460 CONT_CAPABILITIES_TRIGGERS | \
461 CONT_CAPABILITIES_DUAL_ANALOG)
462
463/** \brief Pop'n'Music controller type */
464#define CONT_TYPE_POP_N_MUSIC (CONT_CAPABILITIES_STANDARD_BUTTONS | \
465 CONT_CAPABILITY_C | \
466 CONT_CAPABILITIES_DPAD)
467
468/** \brief Densha de Go! controller type */
469#define CONT_TYPE_DENSHA_DE_GO (CONT_CAPABILITIES_STANDARD_BUTTONS | \
470 CONT_CAPABILITIES_EXTENDED_BUTTONS | \
471 CONT_CAPABILITY_D | \
472 CONT_CAPABILITIES_DPAD)
473
474/** \brief Madcatz PantherDC "Flight Stick + Trackball" controller type */
475#define CONT_TYPE_PANTHERDC (CONT_CAPABILITIES_STANDARD_BUTTONS | \
476 CONT_CAPABILITIES_EXTENDED_BUTTONS | \
477 CONT_CAPABILITY_D | \
478 CONT_CAPABILITIES_TRIGGERS | \
479 CONT_CAPABILITIES_DPAD | \
480 CONT_CAPABILITIES_DUAL_ANALOG)
481/** @} */
482
483/** \brief Check for controller type
484 \ingroup controller_query_types
485
486 Checks whether or not a controller has the <i>exact</i>
487 capabilities associated with the given type.
488
489 \warning
490 Just because a controller has all of the same capabilities of a
491 type does not mean that it's that exact type. For example, the
492 ASCII Pad and Arcade Stick both implement the same capabilities,
493 although they are not the same controllers. They would be
494 indistinguishable here, by design, so that you are able to
495 generalize to a collection of 1st or 3rd party controllers
496 easily.
497
498 \param cont Pointer to a Maple device structure which
499 implements the CONTROLLER function.
500 \param type Type identifier or capability mask the
501 controller is expected to match
502
503 \retval 1 The controller matches the given type.
504 \retval 0 The controller doesn't match the given type.
505 \retval -1 Invalid controller.
506
507 \sa cont_has_capabilities
508*/
509int cont_is_type(const struct maple_device *cont, uint32_t type);
510
511/* \cond */
512/* Init / Shutdown */
513void cont_init(void);
514void cont_shutdown(void);
515/* \endcond */
516
517__END_DECLS
518
519#endif /* __DC_MAPLE_CONTROLLER_H */
520
int cont_btn_callback(uint8_t addr, uint32_t btns, cont_btn_callback_t cb)
Set an automatic button press callback.
void(* cont_btn_callback_t)(uint8_t addr, uint32_t btns)
Controller automatic callback type.
Definition controller.h:194
int cont_has_capabilities(const struct maple_device *cont, uint32_t capabilities)
Check for controller capabilities.
int cont_is_type(const struct maple_device *cont, uint32_t type)
Check for controller type.
Controller state structure.
Definition controller.h:144
int joy2y
Secondary joystick y-axis value.
Definition controller.h:176
uint32_t b
B button value.
Definition controller.h:152
uint32_t dpad_down
Main Dpad Down button value.
Definition controller.h:156
uint32_t z
Z button value.
Definition controller.h:159
uint32_t dpad2_down
Secondary Dpad Down button value.
Definition controller.h:164
uint32_t dpad2_up
Secondary Dpad Up button value.
Definition controller.h:163
int ltrig
Left trigger value (0-255).
Definition controller.h:171
uint32_t dpad2_left
Secondary Dpad Left button value.
Definition controller.h:165
uint32_t dpad2_right
Secondary Dpad Right button value.
Definition controller.h:166
uint32_t a
A button value.
Definition controller.h:153
uint32_t c
C button value.
Definition controller.h:151
uint32_t dpad_right
Main Dpad Right button value.
Definition controller.h:158
int joyx
Main joystick x-axis value (-128 - 127).
Definition controller.h:173
uint32_t buttons
bit-packed controller button states
Definition controller.h:149
int joy2x
Secondary joystick x-axis value.
Definition controller.h:175
uint32_t dpad_left
Main Dpad Left button value.
Definition controller.h:157
uint32_t y
Y button value.
Definition controller.h:160
int joyy
Main joystick y-axis value.
Definition controller.h:174
int rtrig
Right trigger value (0-255).
Definition controller.h:172
uint32_t x
X button value.
Definition controller.h:161
uint32_t d
D button value.
Definition controller.h:162
uint32_t start
Start button value.
Definition controller.h:154
uint32_t dpad_up
Main Dpad Up button value.
Definition controller.h:155