mika/libnx
1
0
Fork 0
mirror of https://github.com/switchbrew/libnx.git synced 2025-08-06 16:19:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

Hid stylefix

Browse Source
This commit is contained in:
plutoo 2018-01-11 22:29:16 +01:00
parent 7482c849fe
commit fd4522423b
2 changed files with 134 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
nx/include/switch/services/hid.h
View File

@ -10,7 +10,7 @@ typedef enum
MOUSE_MIDDLE = BIT(2), MOUSE_MIDDLE = BIT(2),
MOUSE_FORWARD = BIT(3), MOUSE_FORWARD = BIT(3),
MOUSE_BACK = BIT(4), MOUSE_BACK = BIT(4),
} HIDMouseButton; } HidMouseButton;
typedef enum typedef enum
{ {
@ -25,7 +25,7 @@ typedef enum
KBD_MOD_CAPSLOCK = BIT(8), KBD_MOD_CAPSLOCK = BIT(8),
KBD_MOD_SCROLLLOCK = BIT(9), KBD_MOD_SCROLLLOCK = BIT(9),
KBD_MOD_NUMLOCK = BIT(10), KBD_MOD_NUMLOCK = BIT(10),
} HIDKeyboardModifier; } HidKeyboardModifier;
typedef enum typedef enum
{ {
@ -203,7 +203,7 @@ typedef enum
KBD_MEDIA_COFFEE = 0xf9, KBD_MEDIA_COFFEE = 0xf9,
KBD_MEDIA_REFRESH = 0xfa, KBD_MEDIA_REFRESH = 0xfa,
KBD_MEDIA_CALC = 0xfb KBD_MEDIA_CALC = 0xfb
} HIDKeyboardScancode; } HidKeyboardScancode;
typedef enum typedef enum
{ {
@ -212,23 +212,23 @@ typedef enum
TYPE_JOYCON_PAIR = BIT(2), TYPE_JOYCON_PAIR = BIT(2),
TYPE_JOYCON_LEFT = BIT(3), TYPE_JOYCON_LEFT = BIT(3),
TYPE_JOYCON_RIGHT = BIT(4), TYPE_JOYCON_RIGHT = BIT(4),
} HIDControllerType; } HidControllerType;
typedef enum typedef enum
{ {
LAYOUT_PROCONTROLLER = 0, // Pro Controller or HID gamepad LAYOUT_PROCONTROLLER = 0, // Pro Controller or Hid gamepad
LAYOUT_HANDHELD = 1, // Two Joy-Con docked to rails LAYOUT_HANDHELD = 1, // Two Joy-Con docked to rails
LAYOUT_SINGLE = 2, // Horizontal single Joy-Con or pair of Joy-Con, adjusted for orientation LAYOUT_SINGLE = 2, // Horizontal single Joy-Con or pair of Joy-Con, adjusted for orientation
LAYOUT_LEFT = 3, // Only raw left Joy-Con state, no orientation adjustment LAYOUT_LEFT = 3, // Only raw left Joy-Con state, no orientation adjustment
LAYOUT_RIGHT = 4, // Only raw right Joy-Con state, no orientation adjustment LAYOUT_RIGHT = 4, // Only raw right Joy-Con state, no orientation adjustment
LAYOUT_DEFAULT_DIGITAL = 5, // Same as next, but sticks have 8-direction values only LAYOUT_DEFAULT_DIGITAL = 5, // Same as next, but sticks have 8-direction values only
LAYOUT_DEFAULT = 6, // Safe default, single Joy-Con have buttons/sticks rotated for orientation LAYOUT_DEFAULT = 6, // Safe default, single Joy-Con have buttons/sticks rotated for orientation
} HIDControllerLayoutType; } HidControllerLayoutType;
typedef enum typedef enum
{ {
COLORS_NONEXISTENT = BIT(1), COLORS_NONEXISTENT = BIT(1),
} HIDControllerColorDescription; } HidControllerColorDescription;
typedef enum typedef enum
{ {
@ -273,13 +273,13 @@ typedef enum
KEY_DOWN = KEY_DDOWN | KEY_LSTICK_DOWN | KEY_RSTICK_DOWN, ///< D-Pad Down or Sticks Down KEY_DOWN = KEY_DDOWN | KEY_LSTICK_DOWN | KEY_RSTICK_DOWN, ///< D-Pad Down or Sticks Down
KEY_LEFT = KEY_DLEFT | KEY_LSTICK_LEFT | KEY_RSTICK_LEFT, ///< D-Pad Left or Sticks Left KEY_LEFT = KEY_DLEFT | KEY_LSTICK_LEFT | KEY_RSTICK_LEFT, ///< D-Pad Left or Sticks Left
KEY_RIGHT = KEY_DRIGHT | KEY_LSTICK_RIGHT | KEY_RSTICK_RIGHT, ///< D-Pad Right or Sticks Right KEY_RIGHT = KEY_DRIGHT | KEY_LSTICK_RIGHT | KEY_RSTICK_RIGHT, ///< D-Pad Right or Sticks Right
} HIDControllerKeys; } HidControllerKeys;
typedef enum typedef enum
{ {
CONTROLLER_STATE_CONNECTED = BIT(0), CONTROLLER_STATE_CONNECTED = BIT(0),
CONTROLLER_STATE_WIRED = BIT(1), CONTROLLER_STATE_WIRED = BIT(1),
} HIDControllerConnectionState; } HidControllerConnectionState;
typedef enum typedef enum
{ {
@ -293,7 +293,7 @@ typedef enum
CONTROLLER_PLAYER_8 = 7, CONTROLLER_PLAYER_8 = 7,
CONTROLLER_HANDHELD = 8, CONTROLLER_HANDHELD = 8,
CONTROLLER_UNKNOWN = 9, CONTROLLER_UNKNOWN = 9,
} HIDControllerID; } HidControllerID;
typedef struct touchPosition typedef struct touchPosition
{ {
@ -306,26 +306,26 @@ typedef struct touchPosition
// End enums and output structs // End enums and output structs
// Begin HIDTouchScreen // Begin HidTouchScreen
typedef struct HIDTouchScreenHeader typedef struct HidTouchScreenHeader
{ {
u64 timestampTicks; u64 timestampTicks;
u64 numEntries; u64 numEntries;
u64 latestEntry; u64 latestEntry;
u64 maxEntryIndex; u64 maxEntryIndex;
u64 timestamp; u64 timestamp;
} HIDTouchScreenHeader; } HidTouchScreenHeader;
static_assert(sizeof(HIDTouchScreenHeader) == 0x28, "HID touch screen header structure has incorrect size"); static_assert(sizeof(HidTouchScreenHeader) == 0x28, "Hid touch screen header structure has incorrect size");
typedef struct HIDTouchScreenEntryHeader typedef struct HidTouchScreenEntryHeader
{ {
u64 timestamp; u64 timestamp;
u64 numTouches; u64 numTouches;
} HIDTouchScreenEntryHeader; } HidTouchScreenEntryHeader;
static_assert(sizeof(HIDTouchScreenEntryHeader) == 0x10, "HID touch screen entry header structure has incorrect size"); static_assert(sizeof(HidTouchScreenEntryHeader) == 0x10, "Hid touch screen entry header structure has incorrect size");
typedef struct HIDTouchScreenEntryTouch typedef struct HidTouchScreenEntryTouch
{ {
u64 timestamp; u64 timestamp;
u32 padding; u32 padding;
@ -336,39 +336,39 @@ typedef struct HIDTouchScreenEntryTouch
u32 diameterY; u32 diameterY;
u32 angle; u32 angle;
u32 padding_2; u32 padding_2;
} HIDTouchScreenEntryTouch; } HidTouchScreenEntryTouch;
static_assert(sizeof(HIDTouchScreenEntryTouch) == 0x28, "HID touch screen touch structure has incorrect size"); static_assert(sizeof(HidTouchScreenEntryTouch) == 0x28, "Hid touch screen touch structure has incorrect size");
typedef struct HIDTouchScreenEntry typedef struct HidTouchScreenEntry
{ {
HIDTouchScreenEntryHeader header; HidTouchScreenEntryHeader header;
HIDTouchScreenEntryTouch touches[16]; HidTouchScreenEntryTouch touches[16];
u64 unk; u64 unk;
} HIDTouchScreenEntry; } HidTouchScreenEntry;
static_assert(sizeof(HIDTouchScreenEntry) == 0x298, "HID touch screen entry structure has incorrect size"); static_assert(sizeof(HidTouchScreenEntry) == 0x298, "Hid touch screen entry structure has incorrect size");
typedef struct HIDTouchScreen typedef struct HidTouchScreen
{ {
HIDTouchScreenHeader header; HidTouchScreenHeader header;
HIDTouchScreenEntry entries[17]; HidTouchScreenEntry entries[17];
u8 padding[0x3c0]; u8 padding[0x3c0];
} HIDTouchScreen; } HidTouchScreen;
static_assert(sizeof(HIDTouchScreen) == 0x3000, "HID touch screen structure has incorrect size"); static_assert(sizeof(HidTouchScreen) == 0x3000, "Hid touch screen structure has incorrect size");
// End HIDTouchScreen // End HidTouchScreen
// Begin HIDMouse // Begin HidMouse
typedef struct HIDMouseHeader typedef struct HidMouseHeader
{ {
u64 timestampTicks; u64 timestampTicks;
u64 numEntries; u64 numEntries;
u64 latestEntry; u64 latestEntry;
u64 maxEntryIndex; u64 maxEntryIndex;
} HIDMouseHeader; } HidMouseHeader;
static_assert(sizeof(HIDMouseHeader) == 0x20, "HID mouse header structure has incorrect size"); static_assert(sizeof(HidMouseHeader) == 0x20, "Hid mouse header structure has incorrect size");
typedef struct HIDMouseEntry typedef struct HidMouseEntry
{ {
u64 timestamp; u64 timestamp;
u64 timestamp_2; u64 timestamp_2;
@ -379,61 +379,61 @@ typedef struct HIDMouseEntry
u32 scrollVelocityX; u32 scrollVelocityX;
u32 scrollVelocityY; u32 scrollVelocityY;
u64 buttons; u64 buttons;
} HIDMouseEntry; } HidMouseEntry;
static_assert(sizeof(HIDMouseEntry) == 0x30, "HID mouse entry structure has incorrect size"); static_assert(sizeof(HidMouseEntry) == 0x30, "Hid mouse entry structure has incorrect size");
typedef struct HIDMouse typedef struct HidMouse
{ {
HIDMouseHeader header; HidMouseHeader header;
HIDMouseEntry entries[17]; HidMouseEntry entries[17];
u8 padding[0xB0]; u8 padding[0xB0];
} HIDMouse; } HidMouse;
static_assert(sizeof(HIDMouse) == 0x400, "HID mouse structure has incorrect size"); static_assert(sizeof(HidMouse) == 0x400, "Hid mouse structure has incorrect size");
// End HIDMouse // End HidMouse
// Begin HIDKeyboard // Begin HidKeyboard
typedef struct HIDKeyboardHeader typedef struct HidKeyboardHeader
{ {
u64 timestampTicks; u64 timestampTicks;
u64 numEntries; u64 numEntries;
u64 latestEntry; u64 latestEntry;
u64 maxEntryIndex; u64 maxEntryIndex;
} HIDKeyboardHeader; } HidKeyboardHeader;
static_assert(sizeof(HIDKeyboardHeader) == 0x20, "HID keyboard header structure has incorrect size"); static_assert(sizeof(HidKeyboardHeader) == 0x20, "Hid keyboard header structure has incorrect size");
typedef struct HIDKeyboardEntry typedef struct HidKeyboardEntry
{ {
u64 timestamp; u64 timestamp;
u64 timestamp_2; u64 timestamp_2;
u64 modifier; u64 modifier;
u32 keys[8]; u32 keys[8];
} HIDKeyboardEntry; } HidKeyboardEntry;
static_assert(sizeof(HIDKeyboardEntry) == 0x38, "HID keyboard entry structure has incorrect size"); static_assert(sizeof(HidKeyboardEntry) == 0x38, "Hid keyboard entry structure has incorrect size");
typedef struct HIDKeyboard typedef struct HidKeyboard
{ {
HIDKeyboardHeader header; HidKeyboardHeader header;
HIDKeyboardEntry entries[17]; HidKeyboardEntry entries[17];
u8 padding[0x28]; u8 padding[0x28];
} HIDKeyboard; } HidKeyboard;
static_assert(sizeof(HIDKeyboard) == 0x400, "HID keyboard structure has incorrect size"); static_assert(sizeof(HidKeyboard) == 0x400, "Hid keyboard structure has incorrect size");
// End HIDKeyboard // End HidKeyboard
// Begin HIDController // Begin HidController
typedef struct HIDControllerMAC typedef struct HidControllerMAC
{ {
u64 timestamp; u64 timestamp;
u8 mac[0x8]; u8 mac[0x8];
u64 unk; u64 unk;
u64 timestamp_2; u64 timestamp_2;
} HIDControllerMAC; } HidControllerMAC;
static_assert(sizeof(HIDControllerMAC) == 0x20, "HID controller MAC structure has incorrect size"); static_assert(sizeof(HidControllerMAC) == 0x20, "Hid controller MAC structure has incorrect size");
typedef struct HIDControllerHeader typedef struct HidControllerHeader
{ {
u32 type; u32 type;
u32 isHalf; u32 isHalf;
@ -445,19 +445,19 @@ typedef struct HIDControllerHeader
u32 leftColorButtons; u32 leftColorButtons;
u32 rightColorBody; u32 rightColorBody;
u32 rightColorbuttons; u32 rightColorbuttons;
} HIDControllerHeader; } HidControllerHeader;
static_assert(sizeof(HIDControllerHeader) == 0x28, "HID controller header structure has incorrect size"); static_assert(sizeof(HidControllerHeader) == 0x28, "Hid controller header structure has incorrect size");
typedef struct HIDControllerLayoutHeader typedef struct HidControllerLayoutHeader
{ {
u64 timestampTicks; u64 timestampTicks;
u64 numEntries; u64 numEntries;
u64 latestEntry; u64 latestEntry;
u64 maxEntryIndex; u64 maxEntryIndex;
} HIDControllerLayoutHeader; } HidControllerLayoutHeader;
static_assert(sizeof(HIDControllerLayoutHeader) == 0x20, "HID controller layout header structure has incorrect size"); static_assert(sizeof(HidControllerLayoutHeader) == 0x20, "Hid controller layout header structure has incorrect size");
typedef struct HIDControllerInputEntry typedef struct HidControllerInputEntry
{ {
u64 timestamp; u64 timestamp;
u64 timestamp_2; u64 timestamp_2;
@ -467,35 +467,35 @@ typedef struct HIDControllerInputEntry
u32 joystickRightX; u32 joystickRightX;
u32 joystickRightY; u32 joystickRightY;
u64 connectionState; u64 connectionState;
} HIDControllerInputEntry; } HidControllerInputEntry;
static_assert(sizeof(HIDControllerInputEntry) == 0x30, "HID controller input entry structure has incorrect size"); static_assert(sizeof(HidControllerInputEntry) == 0x30, "Hid controller input entry structure has incorrect size");
typedef struct HIDControllerLayout typedef struct HidControllerLayout
{ {
HIDControllerLayoutHeader header; HidControllerLayoutHeader header;
HIDControllerInputEntry entries[17]; HidControllerInputEntry entries[17];
} HIDControllerLayout; } HidControllerLayout;
static_assert(sizeof(HIDControllerLayout) == 0x350, "HID controller layout structure has incorrect size"); static_assert(sizeof(HidControllerLayout) == 0x350, "Hid controller layout structure has incorrect size");
typedef struct HIDController typedef struct HidController
{ {
HIDControllerHeader header; HidControllerHeader header;
HIDControllerLayout layouts[7]; HidControllerLayout layouts[7];
u8 unk_1[0x2A70]; u8 unk_1[0x2A70];
HIDControllerMAC macLeft; HidControllerMAC macLeft;
HIDControllerMAC macRight; HidControllerMAC macRight;
u8 unk_2[0xDF8]; u8 unk_2[0xDF8];
} HIDController; } HidController;
static_assert(sizeof(HIDController) == 0x5000, "HID controller structure has incorrect size"); static_assert(sizeof(HidController) == 0x5000, "Hid controller structure has incorrect size");
// End HIDController // End HidController
typedef struct HIDSharedMemory typedef struct HidSharedMemory
{ {
u8 header[0x400]; u8 header[0x400];
HIDTouchScreen touchscreen; HidTouchScreen touchscreen;
HIDMouse mouse; HidMouse mouse;
HIDKeyboard keyboard; HidKeyboard keyboard;
u8 unkSection1[0x400]; u8 unkSection1[0x400];
u8 unkSection2[0x400]; u8 unkSection2[0x400];
u8 unkSection3[0x400]; u8 unkSection3[0x400];
@ -505,10 +505,10 @@ typedef struct HIDSharedMemory
u8 unkSection7[0x200]; u8 unkSection7[0x200];
u8 unkSection8[0x800]; u8 unkSection8[0x800];
u8 controllerSerials[0x4000]; u8 controllerSerials[0x4000];
HIDController controllers[10]; HidController controllers[10];
u8 unkSection9[0x4600]; u8 unkSection9[0x4600];
} HIDSharedMemory; } HidSharedMemory;
static_assert(sizeof(HIDSharedMemory) == 0x40000, "HID Shared Memory structure has incorrect size"); static_assert(sizeof(HidSharedMemory) == 0x40000, "Hid Shared Memory structure has incorrect size");
Result hidInitialize(void); Result hidInitialize(void);
void hidExit(void); void hidExit(void);
@ -517,25 +517,25 @@ void hidReset(void);
Handle hidGetSessionService(void); Handle hidGetSessionService(void);
void* hidGetSharedmemAddr(void); void* hidGetSharedmemAddr(void);
void hidSetControllerLayout(HIDControllerID id, HIDControllerLayoutType layoutType); void hidSetControllerLayout(HidControllerID id, HidControllerLayoutType layoutType);
HIDControllerLayoutType hidGetControllerLayout(HIDControllerID id); HidControllerLayoutType hidGetControllerLayout(HidControllerID id);
void hidScanInput(void); void hidScanInput(void);
u64 hidKeysHeld(HIDControllerID id); u64 hidKeysHeld(HidControllerID id);
u64 hidKeysDown(HIDControllerID id); u64 hidKeysDown(HidControllerID id);
u64 hidKeysUp(HIDControllerID id); u64 hidKeysUp(HidControllerID id);
u64 hidMouseButtonsHeld(void); u64 hidMouseButtonsHeld(void);
u64 hidMouseButtonsDown(void); u64 hidMouseButtonsDown(void);
u64 hidMouseButtonsUp(void); u64 hidMouseButtonsUp(void);
bool hidKeyboardModifierHeld(HIDKeyboardModifier modifier); bool hidKeyboardModifierHeld(HidKeyboardModifier modifier);
bool hidKeyboardModifierDown(HIDKeyboardModifier modifier); bool hidKeyboardModifierDown(HidKeyboardModifier modifier);
bool hidKeyboardModifierUp(HIDKeyboardModifier modifier); bool hidKeyboardModifierUp(HidKeyboardModifier modifier);
bool hidKeyboardHeld(HIDKeyboardScancode key); bool hidKeyboardHeld(HidKeyboardScancode key);
bool hidKeyboardDown(HIDKeyboardScancode key); bool hidKeyboardDown(HidKeyboardScancode key);
bool hidKeyboardUp(HIDKeyboardScancode key); bool hidKeyboardUp(HidKeyboardScancode key);
u32 hidTouchCount(void); u32 hidTouchCount(void);
void hidTouchRead(touchPosition *pos, u32 point_id); void hidTouchRead(touchPosition *pos, u32 point_id);

66
nx/source/services/hid.c
View File

@ -5,17 +5,17 @@ static Handle g_hidServiceSession = INVALID_HANDLE;
static Handle g_hidIAppletResource = INVALID_HANDLE; static Handle g_hidIAppletResource = INVALID_HANDLE;
static SharedMemory g_hidSharedmem; static SharedMemory g_hidSharedmem;
static HIDTouchScreenEntry g_touchEntry; static HidTouchScreenEntry g_touchEntry;
static HIDMouseEntry g_mouseEntry; static HidMouseEntry g_mouseEntry;
static HIDKeyboardEntry g_keyboardEntry; static HidKeyboardEntry g_keyboardEntry;
static HIDControllerInputEntry g_controllerEntries[10]; static HidControllerInputEntry g_controllerEntries[10];
static u64 g_mouseOld, g_mouseHeld, g_mouseDown, g_mouseUp; static u64 g_mouseOld, g_mouseHeld, g_mouseDown, g_mouseUp;
static u64 g_keyboardModOld, g_keyboardModHeld, g_keyboardModDown, g_keyboardModUp; static u64 g_keyboardModOld, g_keyboardModHeld, g_keyboardModDown, g_keyboardModUp;
static u32 g_keyboardOld[8], g_keyboardHeld[8], g_keyboardDown[8], g_keyboardUp[8]; static u32 g_keyboardOld[8], g_keyboardHeld[8], g_keyboardDown[8], g_keyboardUp[8];
static u64 g_controllerOld[10], g_controllerHeld[10], g_controllerDown[10], g_controllerUp[10]; static u64 g_controllerOld[10], g_controllerHeld[10], g_controllerDown[10], g_controllerUp[10];
static HIDControllerLayoutType g_controllerLayout[10]; static HidControllerLayoutType g_controllerLayout[10];
static u64 g_touchTimestamp, g_mouseTimestamp, g_keyboardTimestamp, g_controllerTimestamps[10]; static u64 g_touchTimestamp, g_mouseTimestamp, g_keyboardTimestamp, g_controllerTimestamps[10];
static RwLock g_hidLock; static RwLock g_hidLock;
@ -92,9 +92,9 @@ void hidReset(void)
rwlockWriteLock(&g_hidLock); rwlockWriteLock(&g_hidLock);
// Reset internal state // Reset internal state
memset(&g_touchEntry, 0, sizeof(HIDTouchScreenEntry)); memset(&g_touchEntry, 0, sizeof(HidTouchScreenEntry));
memset(&g_mouseEntry, 0, sizeof(HIDMouseEntry)); memset(&g_mouseEntry, 0, sizeof(HidMouseEntry));
memset(&g_keyboardEntry, 0, sizeof(HIDKeyboardEntry)); memset(&g_keyboardEntry, 0, sizeof(HidKeyboardEntry));
memset(g_controllerEntries, 0, sizeof(g_controllerEntries)); memset(g_controllerEntries, 0, sizeof(g_controllerEntries));
g_mouseOld = g_mouseHeld = g_mouseDown = g_mouseUp = 0; g_mouseOld = g_mouseHeld = g_mouseDown = g_mouseUp = 0;
@ -122,15 +122,15 @@ void* hidGetSharedmemAddr(void) {
return shmemGetAddr(&g_hidSharedmem); return shmemGetAddr(&g_hidSharedmem);
} }
void hidSetControllerLayout(HIDControllerID id, HIDControllerLayoutType layoutType) { void hidSetControllerLayout(HidControllerID id, HidControllerLayoutType layoutType) {
rwlockWriteLock(&g_hidLock); rwlockWriteLock(&g_hidLock);
g_controllerLayout[id] = layoutType; g_controllerLayout[id] = layoutType;
rwlockWriteUnlock(&g_hidLock); rwlockWriteUnlock(&g_hidLock);
} }
HIDControllerLayoutType hidGetControllerLayout(HIDControllerID id) { HidControllerLayoutType hidGetControllerLayout(HidControllerID id) {
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
HIDControllerLayoutType tmp = g_controllerLayout[id]; HidControllerLayoutType tmp = g_controllerLayout[id];
rwlockReadUnlock(&g_hidLock); rwlockReadUnlock(&g_hidLock);
return tmp; return tmp;
@ -142,7 +142,7 @@ void hidScanInput(void) {
rwlockWriteLock(&g_hidLock); rwlockWriteLock(&g_hidLock);
HIDSharedMemory *sharedMem = (HIDSharedMemory*)hidGetSharedmemAddr(); HidSharedMemory *sharedMem = (HidSharedMemory*)hidGetSharedmemAddr();
g_mouseOld = g_mouseHeld; g_mouseOld = g_mouseHeld;
g_keyboardModOld = g_keyboardModHeld; g_keyboardModOld = g_keyboardModHeld;
@ -153,15 +153,15 @@ void hidScanInput(void) {
g_keyboardModHeld = 0; g_keyboardModHeld = 0;
memset(g_keyboardHeld, 0, sizeof(g_keyboardHeld)); memset(g_keyboardHeld, 0, sizeof(g_keyboardHeld));
memset(g_controllerHeld, 0, sizeof(g_controllerHeld)); memset(g_controllerHeld, 0, sizeof(g_controllerHeld));
memset(&g_touchEntry, 0, sizeof(HIDTouchScreenEntry)); memset(&g_touchEntry, 0, sizeof(HidTouchScreenEntry));
memset(&g_mouseEntry, 0, sizeof(HIDMouseEntry)); memset(&g_mouseEntry, 0, sizeof(HidMouseEntry));
memset(&g_keyboardEntry, 0, sizeof(HIDKeyboardEntry)); memset(&g_keyboardEntry, 0, sizeof(HidKeyboardEntry));
memset(g_controllerEntries, 0, sizeof(g_controllerEntries)); memset(g_controllerEntries, 0, sizeof(g_controllerEntries));
u64 latestTouchEntry = sharedMem->touchscreen.header.latestEntry; u64 latestTouchEntry = sharedMem->touchscreen.header.latestEntry;
HIDTouchScreenEntry *newTouchEntry = &sharedMem->touchscreen.entries[latestTouchEntry]; HidTouchScreenEntry *newTouchEntry = &sharedMem->touchscreen.entries[latestTouchEntry];
if ((s64)(newTouchEntry->header.timestamp - g_touchTimestamp) > 0) { if ((s64)(newTouchEntry->header.timestamp - g_touchTimestamp) > 0) {
memcpy(&g_touchEntry, newTouchEntry, sizeof(HIDTouchScreenEntry)); memcpy(&g_touchEntry, newTouchEntry, sizeof(HidTouchScreenEntry));
g_touchTimestamp = newTouchEntry->header.timestamp; g_touchTimestamp = newTouchEntry->header.timestamp;
if (hidTouchCount()) if (hidTouchCount())
@ -169,9 +169,9 @@ void hidScanInput(void) {
} }
u64 latestMouseEntry = sharedMem->mouse.header.latestEntry; u64 latestMouseEntry = sharedMem->mouse.header.latestEntry;
HIDMouseEntry *newMouseEntry = &sharedMem->mouse.entries[latestMouseEntry]; HidMouseEntry *newMouseEntry = &sharedMem->mouse.entries[latestMouseEntry];
if ((s64)(newMouseEntry->timestamp - g_mouseTimestamp) > 0) { if ((s64)(newMouseEntry->timestamp - g_mouseTimestamp) > 0) {
memcpy(&g_mouseEntry, newMouseEntry, sizeof(HIDMouseEntry)); memcpy(&g_mouseEntry, newMouseEntry, sizeof(HidMouseEntry));
g_mouseTimestamp = newMouseEntry->timestamp; g_mouseTimestamp = newMouseEntry->timestamp;
g_mouseHeld = g_mouseEntry.buttons; g_mouseHeld = g_mouseEntry.buttons;
@ -180,9 +180,9 @@ void hidScanInput(void) {
g_mouseUp = g_mouseOld & (~g_mouseHeld); g_mouseUp = g_mouseOld & (~g_mouseHeld);
u64 latestKeyboardEntry = sharedMem->keyboard.header.latestEntry; u64 latestKeyboardEntry = sharedMem->keyboard.header.latestEntry;
HIDKeyboardEntry *newKeyboardEntry = &sharedMem->keyboard.entries[latestKeyboardEntry]; HidKeyboardEntry *newKeyboardEntry = &sharedMem->keyboard.entries[latestKeyboardEntry];
if ((s64)(newKeyboardEntry->timestamp - g_keyboardTimestamp) > 0) { if ((s64)(newKeyboardEntry->timestamp - g_keyboardTimestamp) > 0) {
memcpy(&g_keyboardEntry, newKeyboardEntry, sizeof(HIDKeyboardEntry)); memcpy(&g_keyboardEntry, newKeyboardEntry, sizeof(HidKeyboardEntry));
g_keyboardTimestamp = newKeyboardEntry->timestamp; g_keyboardTimestamp = newKeyboardEntry->timestamp;
g_keyboardModHeld = g_keyboardEntry.modifier; g_keyboardModHeld = g_keyboardEntry.modifier;
@ -198,11 +198,11 @@ void hidScanInput(void) {
} }
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
HIDControllerLayout *currentLayout = &sharedMem->controllers[i].layouts[g_controllerLayout[i]]; HidControllerLayout *currentLayout = &sharedMem->controllers[i].layouts[g_controllerLayout[i]];
u64 latestControllerEntry = currentLayout->header.latestEntry; u64 latestControllerEntry = currentLayout->header.latestEntry;
HIDControllerInputEntry *newInputEntry = &currentLayout->entries[latestControllerEntry]; HidControllerInputEntry *newInputEntry = &currentLayout->entries[latestControllerEntry];
if ((s64)(newInputEntry->timestamp - g_controllerTimestamps[i]) > 0) { if ((s64)(newInputEntry->timestamp - g_controllerTimestamps[i]) > 0) {
memcpy(&g_controllerEntries[i], newInputEntry, sizeof(HIDControllerInputEntry)); memcpy(&g_controllerEntries[i], newInputEntry, sizeof(HidControllerInputEntry));
g_controllerTimestamps[i] = newInputEntry->timestamp; g_controllerTimestamps[i] = newInputEntry->timestamp;
g_controllerHeld[i] |= g_controllerEntries[i].buttons; g_controllerHeld[i] |= g_controllerEntries[i].buttons;
@ -215,7 +215,7 @@ void hidScanInput(void) {
rwlockWriteUnlock(&g_hidLock); rwlockWriteUnlock(&g_hidLock);
} }
u64 hidKeysHeld(HIDControllerID id) { u64 hidKeysHeld(HidControllerID id) {
if (id < 0 || id > 9) return 0; if (id < 0 || id > 9) return 0;
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
@ -225,7 +225,7 @@ u64 hidKeysHeld(HIDControllerID id) {
return tmp; return tmp;
} }
u64 hidKeysDown(HIDControllerID id) { u64 hidKeysDown(HidControllerID id) {
if (id < 0 || id > 9) return 0; if (id < 0 || id > 9) return 0;
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
@ -235,7 +235,7 @@ u64 hidKeysDown(HIDControllerID id) {
return tmp; return tmp;
} }
u64 hidKeysUp(HIDControllerID id) { u64 hidKeysUp(HidControllerID id) {
if (id < 0 || id > 9) return 0; if (id < 0 || id > 9) return 0;
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
@ -269,7 +269,7 @@ u64 hidMouseButtonsUp(void) {
return tmp; return tmp;
} }
bool hidKeyboardModifierHeld(HIDKeyboardModifier modifier) { bool hidKeyboardModifierHeld(HidKeyboardModifier modifier) {
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
bool tmp = g_keyboardModHeld & modifier; bool tmp = g_keyboardModHeld & modifier;
rwlockReadUnlock(&g_hidLock); rwlockReadUnlock(&g_hidLock);
@ -277,7 +277,7 @@ bool hidKeyboardModifierHeld(HIDKeyboardModifier modifier) {
return tmp; return tmp;
} }
bool hidKeyboardModifierDown(HIDKeyboardModifier modifier) { bool hidKeyboardModifierDown(HidKeyboardModifier modifier) {
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
bool tmp = g_keyboardModDown & modifier; bool tmp = g_keyboardModDown & modifier;
rwlockReadUnlock(&g_hidLock); rwlockReadUnlock(&g_hidLock);
@ -285,7 +285,7 @@ bool hidKeyboardModifierDown(HIDKeyboardModifier modifier) {
return tmp; return tmp;
} }
bool hidKeyboardModifierUp(HIDKeyboardModifier modifier) { bool hidKeyboardModifierUp(HidKeyboardModifier modifier) {
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
bool tmp = g_keyboardModUp & modifier; bool tmp = g_keyboardModUp & modifier;
rwlockReadUnlock(&g_hidLock); rwlockReadUnlock(&g_hidLock);
@ -293,7 +293,7 @@ bool hidKeyboardModifierUp(HIDKeyboardModifier modifier) {
return tmp; return tmp;
} }
bool hidKeyboardHeld(HIDKeyboardScancode key) { bool hidKeyboardHeld(HidKeyboardScancode key) {
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
u32 tmp = g_keyboardHeld[key / 32] & (1 << (key % 32)); u32 tmp = g_keyboardHeld[key / 32] & (1 << (key % 32));
rwlockReadUnlock(&g_hidLock); rwlockReadUnlock(&g_hidLock);
@ -301,7 +301,7 @@ bool hidKeyboardHeld(HIDKeyboardScancode key) {
return !!tmp; return !!tmp;
} }
bool hidKeyboardDown(HIDKeyboardScancode key) { bool hidKeyboardDown(HidKeyboardScancode key) {
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
u32 tmp = g_keyboardDown[key / 32] & (1 << (key % 32)); u32 tmp = g_keyboardDown[key / 32] & (1 << (key % 32));
rwlockReadUnlock(&g_hidLock); rwlockReadUnlock(&g_hidLock);
@ -309,7 +309,7 @@ bool hidKeyboardDown(HIDKeyboardScancode key) {
return !!tmp; return !!tmp;
} }
bool hidKeyboardUp(HIDKeyboardScancode key) { bool hidKeyboardUp(HidKeyboardScancode key) {
rwlockReadLock(&g_hidLock); rwlockReadLock(&g_hidLock);
u32 tmp = g_keyboardUp[key / 32] & (1 << (key % 32)); u32 tmp = g_keyboardUp[key / 32] & (1 << (key % 32));
rwlockReadUnlock(&g_hidLock); rwlockReadUnlock(&g_hidLock);