/** * @file hid.h * @brief Human input device (hid) service IPC wrapper. * @author shinyquagsire23 * @author yellows8 * @copyright libnx Authors */ #pragma once #include "../types.h" #include "../kernel/event.h" #include "../services/btdrv_types.h" #include "../sf/service.h" // Begin enums and output structs /// HidDebugPadButton typedef enum { HidDebugPadButton_A = BIT(0), ///< A button HidDebugPadButton_B = BIT(1), ///< B button HidDebugPadButton_X = BIT(2), ///< X button HidDebugPadButton_Y = BIT(3), ///< Y button HidDebugPadButton_L = BIT(4), ///< L button HidDebugPadButton_R = BIT(5), ///< R button HidDebugPadButton_ZL = BIT(6), ///< ZL button HidDebugPadButton_ZR = BIT(7), ///< ZR button HidDebugPadButton_Start = BIT(8), ///< Start button HidDebugPadButton_Select = BIT(9), ///< Select button HidDebugPadButton_Left = BIT(10), ///< D-Pad Left button HidDebugPadButton_Up = BIT(11), ///< D-Pad Up button HidDebugPadButton_Right = BIT(12), ///< D-Pad Right button HidDebugPadButton_Down = BIT(13), ///< D-Pad Down button } HidDebugPadButton; /// HidTouchScreenModeForNx typedef enum { HidTouchScreenModeForNx_UseSystemSetting = 0, ///< UseSystemSetting HidTouchScreenModeForNx_Finger = 1, ///< Finger HidTouchScreenModeForNx_Heat2 = 2, ///< Heat2 } HidTouchScreenModeForNx; /// HidMouseButton typedef enum { HidMouseButton_Left = BIT(0), HidMouseButton_Right = BIT(1), HidMouseButton_Middle = BIT(2), HidMouseButton_Forward = BIT(3), HidMouseButton_Back = BIT(4), } HidMouseButton; /// HidKeyboardKey typedef enum { HidKeyboardKey_A = 4, HidKeyboardKey_B = 5, HidKeyboardKey_C = 6, HidKeyboardKey_D = 7, HidKeyboardKey_E = 8, HidKeyboardKey_F = 9, HidKeyboardKey_G = 10, HidKeyboardKey_H = 11, HidKeyboardKey_I = 12, HidKeyboardKey_J = 13, HidKeyboardKey_K = 14, HidKeyboardKey_L = 15, HidKeyboardKey_M = 16, HidKeyboardKey_N = 17, HidKeyboardKey_O = 18, HidKeyboardKey_P = 19, HidKeyboardKey_Q = 20, HidKeyboardKey_R = 21, HidKeyboardKey_S = 22, HidKeyboardKey_T = 23, HidKeyboardKey_U = 24, HidKeyboardKey_V = 25, HidKeyboardKey_W = 26, HidKeyboardKey_X = 27, HidKeyboardKey_Y = 28, HidKeyboardKey_Z = 29, HidKeyboardKey_D1 = 30, HidKeyboardKey_D2 = 31, HidKeyboardKey_D3 = 32, HidKeyboardKey_D4 = 33, HidKeyboardKey_D5 = 34, HidKeyboardKey_D6 = 35, HidKeyboardKey_D7 = 36, HidKeyboardKey_D8 = 37, HidKeyboardKey_D9 = 38, HidKeyboardKey_D0 = 39, HidKeyboardKey_Return = 40, HidKeyboardKey_Escape = 41, HidKeyboardKey_Backspace = 42, HidKeyboardKey_Tab = 43, HidKeyboardKey_Space = 44, HidKeyboardKey_Minus = 45, HidKeyboardKey_Plus = 46, HidKeyboardKey_OpenBracket = 47, HidKeyboardKey_CloseBracket = 48, HidKeyboardKey_Pipe = 49, HidKeyboardKey_Tilde = 50, HidKeyboardKey_Semicolon = 51, HidKeyboardKey_Quote = 52, HidKeyboardKey_Backquote = 53, HidKeyboardKey_Comma = 54, HidKeyboardKey_Period = 55, HidKeyboardKey_Slash = 56, HidKeyboardKey_CapsLock = 57, HidKeyboardKey_F1 = 58, HidKeyboardKey_F2 = 59, HidKeyboardKey_F3 = 60, HidKeyboardKey_F4 = 61, HidKeyboardKey_F5 = 62, HidKeyboardKey_F6 = 63, HidKeyboardKey_F7 = 64, HidKeyboardKey_F8 = 65, HidKeyboardKey_F9 = 66, HidKeyboardKey_F10 = 67, HidKeyboardKey_F11 = 68, HidKeyboardKey_F12 = 69, HidKeyboardKey_PrintScreen = 70, HidKeyboardKey_ScrollLock = 71, HidKeyboardKey_Pause = 72, HidKeyboardKey_Insert = 73, HidKeyboardKey_Home = 74, HidKeyboardKey_PageUp = 75, HidKeyboardKey_Delete = 76, HidKeyboardKey_End = 77, HidKeyboardKey_PageDown = 78, HidKeyboardKey_RightArrow = 79, HidKeyboardKey_LeftArrow = 80, HidKeyboardKey_DownArrow = 81, HidKeyboardKey_UpArrow = 82, HidKeyboardKey_NumLock = 83, HidKeyboardKey_NumPadDivide = 84, HidKeyboardKey_NumPadMultiply = 85, HidKeyboardKey_NumPadSubtract = 86, HidKeyboardKey_NumPadAdd = 87, HidKeyboardKey_NumPadEnter = 88, HidKeyboardKey_NumPad1 = 89, HidKeyboardKey_NumPad2 = 90, HidKeyboardKey_NumPad3 = 91, HidKeyboardKey_NumPad4 = 92, HidKeyboardKey_NumPad5 = 93, HidKeyboardKey_NumPad6 = 94, HidKeyboardKey_NumPad7 = 95, HidKeyboardKey_NumPad8 = 96, HidKeyboardKey_NumPad9 = 97, HidKeyboardKey_NumPad0 = 98, HidKeyboardKey_NumPadDot = 99, HidKeyboardKey_Backslash = 100, HidKeyboardKey_Application = 101, HidKeyboardKey_Power = 102, HidKeyboardKey_NumPadEquals = 103, HidKeyboardKey_F13 = 104, HidKeyboardKey_F14 = 105, HidKeyboardKey_F15 = 106, HidKeyboardKey_F16 = 107, HidKeyboardKey_F17 = 108, HidKeyboardKey_F18 = 109, HidKeyboardKey_F19 = 110, HidKeyboardKey_F20 = 111, HidKeyboardKey_F21 = 112, HidKeyboardKey_F22 = 113, HidKeyboardKey_F23 = 114, HidKeyboardKey_F24 = 115, HidKeyboardKey_NumPadComma = 133, HidKeyboardKey_Ro = 135, HidKeyboardKey_KatakanaHiragana = 136, HidKeyboardKey_Yen = 137, HidKeyboardKey_Henkan = 138, HidKeyboardKey_Muhenkan = 139, HidKeyboardKey_NumPadCommaPc98 = 140, HidKeyboardKey_HangulEnglish = 144, HidKeyboardKey_Hanja = 145, HidKeyboardKey_Katakana = 146, HidKeyboardKey_Hiragana = 147, HidKeyboardKey_ZenkakuHankaku = 148, HidKeyboardKey_LeftControl = 224, HidKeyboardKey_LeftShift = 225, HidKeyboardKey_LeftAlt = 226, HidKeyboardKey_LeftGui = 227, HidKeyboardKey_RightControl = 228, HidKeyboardKey_RightShift = 229, HidKeyboardKey_RightAlt = 230, HidKeyboardKey_RightGui = 231, } HidKeyboardKey; /// HidKeyboardModifier typedef enum { HidKeyboardModifier_Control = BIT(0), HidKeyboardModifier_Shift = BIT(1), HidKeyboardModifier_LeftAlt = BIT(2), HidKeyboardModifier_RightAlt = BIT(3), HidKeyboardModifier_Gui = BIT(4), HidKeyboardModifier_CapsLock = BIT(8), HidKeyboardModifier_ScrollLock = BIT(9), HidKeyboardModifier_NumLock = BIT(10), HidKeyboardModifier_Katakana = BIT(11), HidKeyboardModifier_Hiragana = BIT(12), } HidKeyboardModifier; /// KeyboardLockKeyEvent typedef enum { HidKeyboardLockKeyEvent_NumLockOn = BIT(0), ///< NumLockOn HidKeyboardLockKeyEvent_NumLockOff = BIT(1), ///< NumLockOff HidKeyboardLockKeyEvent_NumLockToggle = BIT(2), ///< NumLockToggle HidKeyboardLockKeyEvent_CapsLockOn = BIT(3), ///< CapsLockOn HidKeyboardLockKeyEvent_CapsLockOff = BIT(4), ///< CapsLockOff HidKeyboardLockKeyEvent_CapsLockToggle = BIT(5), ///< CapsLockToggle HidKeyboardLockKeyEvent_ScrollLockOn = BIT(6), ///< ScrollLockOn HidKeyboardLockKeyEvent_ScrollLockOff = BIT(7), ///< ScrollLockOff HidKeyboardLockKeyEvent_ScrollLockToggle = BIT(8), ///< ScrollLockToggle } HidKeyboardLockKeyEvent; /// HID controller IDs typedef enum { HidNpadIdType_No1 = 0, ///< Player 1 controller HidNpadIdType_No2 = 1, ///< Player 2 controller HidNpadIdType_No3 = 2, ///< Player 3 controller HidNpadIdType_No4 = 3, ///< Player 4 controller HidNpadIdType_No5 = 4, ///< Player 5 controller HidNpadIdType_No6 = 5, ///< Player 6 controller HidNpadIdType_No7 = 6, ///< Player 7 controller HidNpadIdType_No8 = 7, ///< Player 8 controller HidNpadIdType_Other = 0x10, ///< Other controller HidNpadIdType_Handheld = 0x20, ///< Handheld mode controls } HidNpadIdType; /// HID controller styles typedef enum { HidNpadStyleTag_NpadFullKey = BIT(0), ///< Pro Controller HidNpadStyleTag_NpadHandheld = BIT(1), ///< Joy-Con controller in handheld mode HidNpadStyleTag_NpadJoyDual = BIT(2), ///< Joy-Con controller in dual mode HidNpadStyleTag_NpadJoyLeft = BIT(3), ///< Joy-Con left controller in single mode HidNpadStyleTag_NpadJoyRight = BIT(4), ///< Joy-Con right controller in single mode HidNpadStyleTag_NpadGc = BIT(5), ///< GameCube controller HidNpadStyleTag_NpadPalma = BIT(6), ///< Poké Ball Plus controller HidNpadStyleTag_NpadLark = BIT(7), ///< NES/Famicom controller HidNpadStyleTag_NpadHandheldLark = BIT(8), ///< NES/Famicom controller in handheld mode HidNpadStyleTag_NpadLucia = BIT(9), ///< SNES controller HidNpadStyleTag_NpadLagon = BIT(10), ///< N64 controller HidNpadStyleTag_NpadLager = BIT(11), ///< Sega Genesis controller HidNpadStyleTag_NpadSystemExt = BIT(29), ///< Generic external controller HidNpadStyleTag_NpadSystem = BIT(30), ///< Generic controller HidNpadStyleSet_NpadFullCtrl = HidNpadStyleTag_NpadFullKey | HidNpadStyleTag_NpadHandheld | HidNpadStyleTag_NpadJoyDual, ///< Style set comprising Npad styles containing the full set of controls {FullKey, Handheld, JoyDual} HidNpadStyleSet_NpadStandard = HidNpadStyleSet_NpadFullCtrl | HidNpadStyleTag_NpadJoyLeft | HidNpadStyleTag_NpadJoyRight, ///< Style set comprising all standard Npad styles {FullKey, Handheld, JoyDual, JoyLeft, JoyRight} } HidNpadStyleTag; /// HidColorAttribute typedef enum { HidColorAttribute_Ok = 0, ///< Ok HidColorAttribute_ReadError = 1, ///< ReadError HidColorAttribute_NoController = 2, ///< NoController } HidColorAttribute; /// HidNpadButton typedef enum { HidNpadButton_A = BITL(0), ///< A button / Right face button HidNpadButton_B = BITL(1), ///< B button / Down face button HidNpadButton_X = BITL(2), ///< X button / Up face button HidNpadButton_Y = BITL(3), ///< Y button / Left face button HidNpadButton_StickL = BITL(4), ///< Left Stick button HidNpadButton_StickR = BITL(5), ///< Right Stick button HidNpadButton_L = BITL(6), ///< L button HidNpadButton_R = BITL(7), ///< R button HidNpadButton_ZL = BITL(8), ///< ZL button HidNpadButton_ZR = BITL(9), ///< ZR button HidNpadButton_Plus = BITL(10), ///< Plus button HidNpadButton_Minus = BITL(11), ///< Minus button HidNpadButton_Left = BITL(12), ///< D-Pad Left button HidNpadButton_Up = BITL(13), ///< D-Pad Up button HidNpadButton_Right = BITL(14), ///< D-Pad Right button HidNpadButton_Down = BITL(15), ///< D-Pad Down button HidNpadButton_StickLLeft = BITL(16), ///< Left Stick pseudo-button when moved Left HidNpadButton_StickLUp = BITL(17), ///< Left Stick pseudo-button when moved Up HidNpadButton_StickLRight = BITL(18), ///< Left Stick pseudo-button when moved Right HidNpadButton_StickLDown = BITL(19), ///< Left Stick pseudo-button when moved Down HidNpadButton_StickRLeft = BITL(20), ///< Right Stick pseudo-button when moved Left HidNpadButton_StickRUp = BITL(21), ///< Right Stick pseudo-button when moved Up HidNpadButton_StickRRight = BITL(22), ///< Right Stick pseudo-button when moved Right HidNpadButton_StickRDown = BITL(23), ///< Right Stick pseudo-button when moved Left HidNpadButton_LeftSL = BITL(24), ///< SL button on Left Joy-Con HidNpadButton_LeftSR = BITL(25), ///< SR button on Left Joy-Con HidNpadButton_RightSL = BITL(26), ///< SL button on Right Joy-Con HidNpadButton_RightSR = BITL(27), ///< SR button on Right Joy-Con HidNpadButton_Palma = BITL(28), ///< Top button on Poké Ball Plus (Palma) controller HidNpadButton_Verification = BITL(29), ///< Verification HidNpadButton_HandheldLeftB = BITL(30), ///< B button on Left NES/HVC controller in Handheld mode HidNpadButton_LagonCLeft = BITL(31), ///< Left C button in N64 controller HidNpadButton_LagonCUp = BITL(32), ///< Up C button in N64 controller HidNpadButton_LagonCRight = BITL(33), ///< Right C button in N64 controller HidNpadButton_LagonCDown = BITL(34), ///< Down C button in N64 controller HidNpadButton_AnyLeft = HidNpadButton_Left | HidNpadButton_StickLLeft | HidNpadButton_StickRLeft, ///< Bitmask containing all buttons that are considered Left (D-Pad, Sticks) HidNpadButton_AnyUp = HidNpadButton_Up | HidNpadButton_StickLUp | HidNpadButton_StickRUp, ///< Bitmask containing all buttons that are considered Up (D-Pad, Sticks) HidNpadButton_AnyRight = HidNpadButton_Right | HidNpadButton_StickLRight | HidNpadButton_StickRRight, ///< Bitmask containing all buttons that are considered Right (D-Pad, Sticks) HidNpadButton_AnyDown = HidNpadButton_Down | HidNpadButton_StickLDown | HidNpadButton_StickRDown, ///< Bitmask containing all buttons that are considered Down (D-Pad, Sticks) HidNpadButton_AnySL = HidNpadButton_LeftSL | HidNpadButton_RightSL, ///< Bitmask containing SL buttons on both Joy-Cons (Left/Right) HidNpadButton_AnySR = HidNpadButton_LeftSR | HidNpadButton_RightSR, ///< Bitmask containing SR buttons on both Joy-Cons (Left/Right) } HidNpadButton; /// HidDebugPadAttribute typedef enum { HidDebugPadAttribute_IsConnected = BIT(0), ///< IsConnected } HidDebugPadAttribute; /// HidTouchAttribute typedef enum { HidTouchAttribute_Start = BIT(0), ///< Start HidTouchAttribute_End = BIT(1), ///< End } HidTouchAttribute; /// HidMouseAttribute typedef enum { HidMouseAttribute_Transferable = BIT(0), ///< Transferable HidMouseAttribute_IsConnected = BIT(1), ///< IsConnected } HidMouseAttribute; /// HidNpadAttribute typedef enum { HidNpadAttribute_IsConnected = BIT(0), ///< IsConnected HidNpadAttribute_IsWired = BIT(1), ///< IsWired HidNpadAttribute_IsLeftConnected = BIT(2), ///< IsLeftConnected HidNpadAttribute_IsLeftWired = BIT(3), ///< IsLeftWired HidNpadAttribute_IsRightConnected = BIT(4), ///< IsRightConnected HidNpadAttribute_IsRightWired = BIT(5), ///< IsRightWired } HidNpadAttribute; /// HidSixAxisSensorAttribute typedef enum { HidSixAxisSensorAttribute_IsConnected = BIT(0), ///< IsConnected HidSixAxisSensorAttribute_IsInterpolated = BIT(1), ///< IsInterpolated } HidSixAxisSensorAttribute; /// HidGestureAttribute typedef enum { HidGestureAttribute_IsNewTouch = BIT(4), ///< IsNewTouch HidGestureAttribute_IsDoubleTap = BIT(8), ///< IsDoubleTap } HidGestureAttribute; /// HidGestureDirection typedef enum { HidGestureDirection_None = 0, ///< None HidGestureDirection_Left = 1, ///< Left HidGestureDirection_Up = 2, ///< Up HidGestureDirection_Right = 3, ///< Right HidGestureDirection_Down = 4, ///< Down } HidGestureDirection; /// HidGestureType typedef enum { HidGestureType_Idle = 0, ///< Idle HidGestureType_Complete = 1, ///< Complete HidGestureType_Cancel = 2, ///< Cancel HidGestureType_Touch = 3, ///< Touch HidGestureType_Press = 4, ///< Press HidGestureType_Tap = 5, ///< Tap HidGestureType_Pan = 6, ///< Pan HidGestureType_Swipe = 7, ///< Swipe HidGestureType_Pinch = 8, ///< Pinch HidGestureType_Rotate = 9, ///< Rotate } HidGestureType; /// GyroscopeZeroDriftMode typedef enum { HidGyroscopeZeroDriftMode_Loose = 0, ///< Loose HidGyroscopeZeroDriftMode_Standard = 1, ///< Standard HidGyroscopeZeroDriftMode_Tight = 2, ///< Tight } HidGyroscopeZeroDriftMode; /// NpadJoyHoldType typedef enum { HidNpadJoyHoldType_Vertical = 0, ///< Default / Joy-Con held vertically. HidNpadJoyHoldType_Horizontal = 1, ///< Joy-Con held horizontally. } HidNpadJoyHoldType; /// NpadJoyDeviceType typedef enum { HidNpadJoyDeviceType_Left = 0, ///< Left HidNpadJoyDeviceType_Right = 1, ///< Right } HidNpadJoyDeviceType; /// This controls how many Joy-Cons must be attached for handheld-mode to be activated. typedef enum { HidNpadHandheldActivationMode_Dual = 0, ///< Dual (2 Joy-Cons) HidNpadHandheldActivationMode_Single = 1, ///< Single (1 Joy-Con) HidNpadHandheldActivationMode_None = 2, ///< None (0 Joy-Cons) } HidNpadHandheldActivationMode; /// NpadJoyAssignmentMode typedef enum { HidNpadJoyAssignmentMode_Dual = 0, ///< Dual (Set by \ref hidSetNpadJoyAssignmentModeDual) HidNpadJoyAssignmentMode_Single = 1, ///< Single (Set by hidSetNpadJoyAssignmentModeSingle*()) } HidNpadJoyAssignmentMode; /// NpadCommunicationMode typedef enum { HidNpadCommunicationMode_5ms = 0, ///< 5ms HidNpadCommunicationMode_10ms = 1, ///< 10ms HidNpadCommunicationMode_15ms = 2, ///< 15ms HidNpadCommunicationMode_Default = 3, ///< Default } HidNpadCommunicationMode; /// DeviceType (system) typedef enum { HidDeviceTypeBits_FullKey = BIT(0), ///< Pro Controller and Gc controller. HidDeviceTypeBits_DebugPad = BIT(1), ///< DebugPad HidDeviceTypeBits_HandheldLeft = BIT(2), ///< Joy-Con/Famicom/NES left controller in handheld mode. HidDeviceTypeBits_HandheldRight = BIT(3), ///< Joy-Con/Famicom/NES right controller in handheld mode. HidDeviceTypeBits_JoyLeft = BIT(4), ///< Joy-Con left controller. HidDeviceTypeBits_JoyRight = BIT(5), ///< Joy-Con right controller. HidDeviceTypeBits_Palma = BIT(6), ///< Poké Ball Plus controller. HidDeviceTypeBits_LarkHvcLeft = BIT(7), ///< Famicom left controller. HidDeviceTypeBits_LarkHvcRight = BIT(8), ///< Famicom right controller (with microphone). HidDeviceTypeBits_LarkNesLeft = BIT(9), ///< NES left controller. HidDeviceTypeBits_LarkNesRight = BIT(10), ///< NES right controller. HidDeviceTypeBits_HandheldLarkHvcLeft = BIT(11), ///< Famicom left controller in handheld mode. HidDeviceTypeBits_HandheldLarkHvcRight = BIT(12), ///< Famicom right controller (with microphone) in handheld mode. HidDeviceTypeBits_HandheldLarkNesLeft = BIT(13), ///< NES left controller in handheld mode. HidDeviceTypeBits_HandheldLarkNesRight = BIT(14), ///< NES right controller in handheld mode. HidDeviceTypeBits_Lucia = BIT(15), ///< SNES controller HidDeviceTypeBits_Lagon = BIT(16), ///< N64 controller HidDeviceTypeBits_Lager = BIT(17), ///< Sega Genesis controller HidDeviceTypeBits_System = BIT(31), ///< Generic controller. } HidDeviceTypeBits; /// Internal DeviceType for [9.0.0+]. Converted to/from the pre-9.0.0 version of this by the hiddbg funcs. typedef enum { HidDeviceType_JoyRight1 = 1, ///< ::HidDeviceTypeBits_JoyRight HidDeviceType_JoyLeft2 = 2, ///< ::HidDeviceTypeBits_JoyLeft HidDeviceType_FullKey3 = 3, ///< ::HidDeviceTypeBits_FullKey HidDeviceType_JoyLeft4 = 4, ///< ::HidDeviceTypeBits_JoyLeft HidDeviceType_JoyRight5 = 5, ///< ::HidDeviceTypeBits_JoyRight HidDeviceType_FullKey6 = 6, ///< ::HidDeviceTypeBits_FullKey HidDeviceType_LarkHvcLeft = 7, ///< ::HidDeviceTypeBits_LarkHvcLeft, ::HidDeviceTypeBits_HandheldLarkHvcLeft HidDeviceType_LarkHvcRight = 8, ///< ::HidDeviceTypeBits_LarkHvcRight, ::HidDeviceTypeBits_HandheldLarkHvcRight HidDeviceType_LarkNesLeft = 9, ///< ::HidDeviceTypeBits_LarkNesLeft, ::HidDeviceTypeBits_HandheldLarkNesLeft HidDeviceType_LarkNesRight = 10, ///< ::HidDeviceTypeBits_LarkNesRight, ::HidDeviceTypeBits_HandheldLarkNesRight HidDeviceType_Lucia = 11, ///< ::HidDeviceTypeBits_Lucia HidDeviceType_Palma = 12, ///< [9.0.0+] ::HidDeviceTypeBits_Palma HidDeviceType_FullKey13 = 13, ///< ::HidDeviceTypeBits_FullKey HidDeviceType_FullKey15 = 15, ///< ::HidDeviceTypeBits_FullKey HidDeviceType_DebugPad = 17, ///< ::HidDeviceTypeBits_DebugPad HidDeviceType_System19 = 19, ///< ::HidDeviceTypeBits_System with \ref HidNpadStyleTag |= ::HidNpadStyleTag_NpadFullKey. HidDeviceType_System20 = 20, ///< ::HidDeviceTypeBits_System with \ref HidNpadStyleTag |= ::HidNpadStyleTag_NpadJoyDual. HidDeviceType_System21 = 21, ///< ::HidDeviceTypeBits_System with \ref HidNpadStyleTag |= ::HidNpadStyleTag_NpadJoyDual. HidDeviceType_Lagon = 22, ///< ::HidDeviceTypeBits_Lagon HidDeviceType_Lager = 28, ///< ::HidDeviceTypeBits_Lager } HidDeviceType; /// AppletFooterUiType (system) typedef enum { HidAppletFooterUiType_None = 0, ///< None HidAppletFooterUiType_HandheldNone = 1, ///< HandheldNone HidAppletFooterUiType_HandheldJoyConLeftOnly = 2, ///< HandheldJoyConLeftOnly HidAppletFooterUiType_HandheldJoyConRightOnly = 3, ///< HandheldJoyConRightOnly HidAppletFooterUiType_HandheldJoyConLeftJoyConRight = 4, ///< HandheldJoyConLeftJoyConRight HidAppletFooterUiType_JoyDual = 5, ///< JoyDual HidAppletFooterUiType_JoyDualLeftOnly = 6, ///< JoyDualLeftOnly HidAppletFooterUiType_JoyDualRightOnly = 7, ///< JoyDualRightOnly HidAppletFooterUiType_JoyLeftHorizontal = 8, ///< JoyLeftHorizontal HidAppletFooterUiType_JoyLeftVertical = 9, ///< JoyLeftVertical HidAppletFooterUiType_JoyRightHorizontal = 10, ///< JoyRightHorizontal HidAppletFooterUiType_JoyRightVertical = 11, ///< JoyRightVertical HidAppletFooterUiType_SwitchProController = 12, ///< SwitchProController HidAppletFooterUiType_CompatibleProController = 13, ///< CompatibleProController HidAppletFooterUiType_CompatibleJoyCon = 14, ///< CompatibleJoyCon HidAppletFooterUiType_LarkHvc1 = 15, ///< LarkHvc1 HidAppletFooterUiType_LarkHvc2 = 16, ///< LarkHvc2 HidAppletFooterUiType_LarkNesLeft = 17, ///< LarkNesLeft HidAppletFooterUiType_LarkNesRight = 18, ///< LarkNesRight HidAppletFooterUiType_Lucia = 19, ///< Lucia HidAppletFooterUiType_Verification = 20, ///< Verification HidAppletFooterUiType_Lagon = 21, ///< [13.0.0+] Lagon } HidAppletFooterUiType; /// NpadInterfaceType (system) typedef enum { HidNpadInterfaceType_Bluetooth = 1, ///< Bluetooth. HidNpadInterfaceType_Rail = 2, ///< Rail. HidNpadInterfaceType_USB = 3, ///< USB. HidNpadInterfaceType_Unknown4 = 4, ///< Unknown. } HidNpadInterfaceType; /// XcdInterfaceType typedef enum { XcdInterfaceType_Bluetooth = BIT(0), XcdInterfaceType_Uart = BIT(1), XcdInterfaceType_Usb = BIT(2), XcdInterfaceType_FieldSet = BIT(7), } XcdInterfaceType; /// NpadLarkType typedef enum { HidNpadLarkType_Invalid = 0, ///< Invalid HidNpadLarkType_H1 = 1, ///< H1 HidNpadLarkType_H2 = 2, ///< H2 HidNpadLarkType_NL = 3, ///< NL HidNpadLarkType_NR = 4, ///< NR } HidNpadLarkType; /// NpadLuciaType typedef enum { HidNpadLuciaType_Invalid = 0, ///< Invalid HidNpadLuciaType_J = 1, ///< J HidNpadLuciaType_E = 2, ///< E HidNpadLuciaType_U = 3, ///< U } HidNpadLuciaType; /// NpadLagerType typedef enum { HidNpadLagerType_Invalid = 0, ///< Invalid HidNpadLagerType_J = 1, ///< J HidNpadLagerType_E = 2, ///< E HidNpadLagerType_U = 3, ///< U } HidNpadLagerType; /// Type values for HidVibrationDeviceInfo::type. typedef enum { HidVibrationDeviceType_Unknown = 0, ///< Unknown HidVibrationDeviceType_LinearResonantActuator = 1, ///< LinearResonantActuator HidVibrationDeviceType_GcErm = 2, ///< GcErm (::HidNpadStyleTag_NpadGc) } HidVibrationDeviceType; /// VibrationDevicePosition typedef enum { HidVibrationDevicePosition_None = 0, ///< None HidVibrationDevicePosition_Left = 1, ///< Left HidVibrationDevicePosition_Right = 2, ///< Right } HidVibrationDevicePosition; /// VibrationGcErmCommand typedef enum { HidVibrationGcErmCommand_Stop = 0, ///< Stops the vibration with a decay phase. HidVibrationGcErmCommand_Start = 1, ///< Starts the vibration. HidVibrationGcErmCommand_StopHard = 2, ///< Stops the vibration immediately, with no decay phase. } HidVibrationGcErmCommand; /// PalmaOperationType typedef enum { HidPalmaOperationType_PlayActivity = 0, ///< PlayActivity HidPalmaOperationType_SetFrModeType = 1, ///< SetFrModeType HidPalmaOperationType_ReadStep = 2, ///< ReadStep HidPalmaOperationType_EnableStep = 3, ///< EnableStep HidPalmaOperationType_ResetStep = 4, ///< ResetStep HidPalmaOperationType_ReadApplicationSection = 5, ///< ReadApplicationSection HidPalmaOperationType_WriteApplicationSection = 6, ///< WriteApplicationSection HidPalmaOperationType_ReadUniqueCode = 7, ///< ReadUniqueCode HidPalmaOperationType_SetUniqueCodeInvalid = 8, ///< SetUniqueCodeInvalid HidPalmaOperationType_WriteActivityEntry = 9, ///< WriteActivityEntry HidPalmaOperationType_WriteRgbLedPatternEntry = 10, ///< WriteRgbLedPatternEntry HidPalmaOperationType_WriteWaveEntry = 11, ///< WriteWaveEntry HidPalmaOperationType_ReadDataBaseIdentificationVersion = 12, ///< ReadDataBaseIdentificationVersion HidPalmaOperationType_WriteDataBaseIdentificationVersion = 13, ///< WriteDataBaseIdentificationVersion HidPalmaOperationType_SuspendFeature = 14, ///< SuspendFeature HidPalmaOperationType_ReadPlayLog = 15, ///< [5.1.0+] ReadPlayLog HidPalmaOperationType_ResetPlayLog = 16, ///< [5.1.0+] ResetPlayLog } HidPalmaOperationType; /// PalmaFrModeType typedef enum { HidPalmaFrModeType_Off = 0, ///< Off HidPalmaFrModeType_B01 = 1, ///< B01 HidPalmaFrModeType_B02 = 2, ///< B02 HidPalmaFrModeType_B03 = 3, ///< B03 HidPalmaFrModeType_Downloaded = 4, ///< Downloaded } HidPalmaFrModeType; /// PalmaWaveSet typedef enum { HidPalmaWaveSet_Small = 0, ///< Small HidPalmaWaveSet_Medium = 1, ///< Medium HidPalmaWaveSet_Large = 2, ///< Large } HidPalmaWaveSet; /// PalmaFeature typedef enum { HidPalmaFeature_FrMode = BIT(0), ///< FrMode HidPalmaFeature_RumbleFeedback = BIT(1), ///< RumbleFeedback HidPalmaFeature_Step = BIT(2), ///< Step HidPalmaFeature_MuteSwitch = BIT(3), ///< MuteSwitch } HidPalmaFeature; /// HidAnalogStickState typedef struct HidAnalogStickState { s32 x; ///< X s32 y; ///< Y } HidAnalogStickState; /// HidVector typedef struct HidVector { float x; float y; float z; } HidVector; /// HidDirectionState typedef struct HidDirectionState { float direction[3][3]; ///< 3x3 matrix } HidDirectionState; #define JOYSTICK_MAX (0x7FFF) #define JOYSTICK_MIN (-0x7FFF) // End enums and output structs /// HidCommonLifoHeader typedef struct HidCommonLifoHeader { u64 unused; ///< Unused u64 buffer_count; ///< BufferCount u64 tail; ///< Tail u64 count; ///< Count } HidCommonLifoHeader; // Begin HidDebugPad /// HidDebugPadState typedef struct HidDebugPadState { u64 sampling_number; ///< SamplingNumber u32 attributes; ///< Bitfield of \ref HidDebugPadAttribute. u32 buttons; ///< Bitfield of \ref HidDebugPadButton. HidAnalogStickState analog_stick_r; ///< AnalogStickR HidAnalogStickState analog_stick_l; ///< AnalogStickL } HidDebugPadState; /// HidDebugPadStateAtomicStorage typedef struct HidDebugPadStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidDebugPadState state; ///< \ref HidDebugPadState } HidDebugPadStateAtomicStorage; /// HidDebugPadLifo typedef struct HidDebugPadLifo { HidCommonLifoHeader header; ///< \ref HidCommonLifoHeader HidDebugPadStateAtomicStorage storage[17]; ///< \ref HidDebugPadStateAtomicStorage } HidDebugPadLifo; /// HidDebugPadSharedMemoryFormat typedef struct HidDebugPadSharedMemoryFormat { HidDebugPadLifo lifo; u8 padding[0x138]; } HidDebugPadSharedMemoryFormat; // End HidDebugPad // Begin HidTouchScreen /// HidTouchState typedef struct HidTouchState { u64 delta_time; ///< DeltaTime u32 attributes; ///< Bitfield of \ref HidTouchAttribute. u32 finger_id; ///< FingerId u32 x; ///< X u32 y; ///< Y u32 diameter_x; ///< DiameterX u32 diameter_y; ///< DiameterY u32 rotation_angle; ///< RotationAngle u32 reserved; ///< Reserved } HidTouchState; /// HidTouchScreenState typedef struct HidTouchScreenState { u64 sampling_number; ///< SamplingNumber s32 count; ///< Number of entries in the touches array. u32 reserved; ///< Reserved HidTouchState touches[16]; ///< Array of \ref HidTouchState, with the above count. } HidTouchScreenState; /// HidTouchScreenStateAtomicStorage typedef struct HidTouchScreenStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidTouchScreenState state; ///< \ref HidTouchScreenState } HidTouchScreenStateAtomicStorage; /// HidTouchScreenLifo typedef struct HidTouchScreenLifo { HidCommonLifoHeader header; ///< \ref HidCommonLifoHeader HidTouchScreenStateAtomicStorage storage[17]; ///< \ref HidTouchScreenStateAtomicStorage } HidTouchScreenLifo; /// HidTouchScreenSharedMemoryFormat typedef struct HidTouchScreenSharedMemoryFormat { HidTouchScreenLifo lifo; u8 padding[0x3c8]; } HidTouchScreenSharedMemoryFormat; /// HidTouchScreenConfigurationForNx typedef struct { u8 mode; ///< \ref HidTouchScreenModeForNx u8 reserved[0xF]; ///< Reserved } HidTouchScreenConfigurationForNx; // End HidTouchScreen // Begin HidMouse /// HidMouseState typedef struct HidMouseState { u64 sampling_number; ///< SamplingNumber s32 x; ///< X s32 y; ///< Y s32 delta_x; ///< DeltaX s32 delta_y; ///< DeltaY s32 wheel_delta_x; ///< WheelDeltaX s32 wheel_delta_y; ///< WheelDeltaY u32 buttons; ///< Bitfield of \ref HidMouseButton. u32 attributes; ///< Bitfield of \ref HidMouseAttribute. } HidMouseState; /// HidMouseStateAtomicStorage typedef struct HidMouseStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidMouseState state; } HidMouseStateAtomicStorage; /// HidMouseLifo typedef struct HidMouseLifo { HidCommonLifoHeader header; HidMouseStateAtomicStorage storage[17]; } HidMouseLifo; /// HidMouseSharedMemoryFormat typedef struct HidMouseSharedMemoryFormat { HidMouseLifo lifo; u8 padding[0xB0]; } HidMouseSharedMemoryFormat; // End HidMouse // Begin HidKeyboard /// HidKeyboardState typedef struct HidKeyboardState { u64 sampling_number; ///< SamplingNumber u64 modifiers; ///< Bitfield of \ref HidKeyboardModifier. u64 keys[4]; } HidKeyboardState; /// HidKeyboardStateAtomicStorage typedef struct HidKeyboardStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidKeyboardState state; } HidKeyboardStateAtomicStorage; /// HidKeyboardLifo typedef struct HidKeyboardLifo { HidCommonLifoHeader header; HidKeyboardStateAtomicStorage storage[17]; } HidKeyboardLifo; /// HidKeyboardSharedMemoryFormat typedef struct HidKeyboardSharedMemoryFormat { HidKeyboardLifo lifo; u8 padding[0x28]; } HidKeyboardSharedMemoryFormat; // End HidKeyboard // Begin HidBasicXpad /// HidBasicXpadState typedef struct { u64 sampling_number; u32 attributes; u32 buttons; u64 analog_stick_left; u64 analog_stick_right; } HidBasicXpadState; /// HidBasicXpadStateAtomicStorage typedef struct { u64 sampling_number; HidBasicXpadState state; } HidBasicXpadStateAtomicStorage; /// HidBasicXpadLifo typedef struct { HidCommonLifoHeader header; HidBasicXpadStateAtomicStorage storage[17]; } HidBasicXpadLifo; /// HidBasicXpadSharedMemoryEntry typedef struct { HidBasicXpadLifo lifo; u8 padding[0x138]; } HidBasicXpadSharedMemoryEntry; /// HidBasicXpadSharedMemoryFormat typedef struct { HidBasicXpadSharedMemoryEntry entries[4]; } HidBasicXpadSharedMemoryFormat; // End HidBasicXpad // Begin HidDigitizer /// HidDigitizerState typedef struct { u64 sampling_number; u32 unk_0x8; u32 unk_0xC; u32 attributes; u32 buttons; u32 unk_0x18; u32 unk_0x1C; u32 unk_0x20; u32 unk_0x24; u32 unk_0x28; u32 unk_0x2C; u32 unk_0x30; u32 unk_0x34; u32 unk_0x38; u32 unk_0x3C; u32 unk_0x40; u32 unk_0x44; u32 unk_0x48; u32 unk_0x4C; u32 unk_0x50; u32 unk_0x54; } HidDigitizerState; /// HidDigitizerStateAtomicStorage typedef struct { u64 sampling_number; HidDigitizerState state; } HidDigitizerStateAtomicStorage; /// HidDigitizerLifo typedef struct { HidCommonLifoHeader header; HidDigitizerStateAtomicStorage storage[17]; } HidDigitizerLifo; /// HidDigitizerSharedMemoryFormat typedef struct { HidDigitizerLifo lifo; u8 padding[0x980]; } HidDigitizerSharedMemoryFormat; // End HidDigitizer // Begin HidHomeButton /// HidHomeButtonState typedef struct { u64 sampling_number; u64 buttons; } HidHomeButtonState; /// HidHomeButtonStateAtomicStorage typedef struct { u64 sampling_number; HidHomeButtonState state; } HidHomeButtonStateAtomicStorage; /// HidHomeButtonLifo typedef struct { HidCommonLifoHeader header; HidHomeButtonStateAtomicStorage storage[17]; } HidHomeButtonLifo; /// HidHomeButtonSharedMemoryFormat typedef struct { HidHomeButtonLifo lifo; u8 padding[0x48]; } HidHomeButtonSharedMemoryFormat; // End HidHomeButton // Begin HidSleepButton /// HidSleepButtonState typedef struct { u64 sampling_number; u64 buttons; } HidSleepButtonState; /// HidSleepButtonStateAtomicStorage typedef struct { u64 sampling_number; HidSleepButtonState state; } HidSleepButtonStateAtomicStorage; /// HidSleepButtonLifo typedef struct { HidCommonLifoHeader header; HidSleepButtonStateAtomicStorage storage[17]; } HidSleepButtonLifo; /// HidSleepButtonSharedMemoryFormat typedef struct { HidSleepButtonLifo lifo; u8 padding[0x48]; } HidSleepButtonSharedMemoryFormat; // End HidSleepButton // Begin HidCaptureButton /// HidCaptureButtonState typedef struct { u64 sampling_number; u64 buttons; } HidCaptureButtonState; /// HidCaptureButtonStateAtomicStorage typedef struct { u64 sampling_number; HidCaptureButtonState state; } HidCaptureButtonStateAtomicStorage; /// HidCaptureButtonLifo typedef struct { HidCommonLifoHeader header; HidCaptureButtonStateAtomicStorage storage[17]; } HidCaptureButtonLifo; /// HidCaptureButtonSharedMemoryFormat typedef struct { HidCaptureButtonLifo lifo; u8 padding[0x48]; } HidCaptureButtonSharedMemoryFormat; // End HidCaptureButton // Begin HidInputDetector /// HidInputDetectorState typedef struct { u64 input_source_state; u64 sampling_number; } HidInputDetectorState; /// HidInputDetectorStateAtomicStorage typedef struct { u64 sampling_number; HidInputDetectorState state; } HidInputDetectorStateAtomicStorage; /// HidInputDetectorLifo typedef struct { HidCommonLifoHeader header; HidInputDetectorStateAtomicStorage storage[2]; } HidInputDetectorLifo; /// HidInputDetectorSharedMemoryEntry typedef struct { HidInputDetectorLifo lifo; u8 padding[0x30]; } HidInputDetectorSharedMemoryEntry; /// HidInputDetectorSharedMemoryFormat typedef struct { HidInputDetectorSharedMemoryEntry entries[16]; } HidInputDetectorSharedMemoryFormat; // End HidInputDetector // Begin HidUniquePad /// HidUniquePadConfigMutex typedef struct { u8 unk_0x0[0x20]; } HidUniquePadConfigMutex; /// HidSixAxisSensorUserCalibrationState typedef struct { u32 flags; u8 reserved[4]; u64 stage; u64 sampling_number; } HidSixAxisSensorUserCalibrationState; /// HidSixAxisSensorUserCalibrationStateAtomicStorage typedef struct { u64 sampling_number; HidSixAxisSensorUserCalibrationState calib_state; } HidSixAxisSensorUserCalibrationStateAtomicStorage; /// HidSixAxisSensorUserCalibrationStateLifo typedef struct { HidCommonLifoHeader header; HidSixAxisSensorUserCalibrationStateAtomicStorage storage[2]; } HidSixAxisSensorUserCalibrationStateLifo; /// HidAnalogStickCalibrationStateImpl typedef struct { u64 state; u64 flags; u64 stage; u64 sampling_number; } HidAnalogStickCalibrationStateImpl; /// HidAnalogStickCalibrationStateImplAtomicStorage typedef struct { u64 sampling_number; HidAnalogStickCalibrationStateImpl calib_state; } HidAnalogStickCalibrationStateImplAtomicStorage; /// HidAnalogStickCalibrationStateImplLifo typedef struct { HidCommonLifoHeader header; HidAnalogStickCalibrationStateImplAtomicStorage storage[2]; } HidAnalogStickCalibrationStateImplLifo; /// HidUniquePadConfig typedef struct { u32 type; u32 interface; u8 serial_number[0x10]; u32 controller_number; bool is_active; u8 reserved[3]; u64 sampling_number; } HidUniquePadConfig; /// HidUniquePadConfigAtomicStorage typedef struct { u64 sampling_number; HidUniquePadConfig config; } HidUniquePadConfigAtomicStorage; /// HidUniquePadConfigLifo typedef struct { HidCommonLifoHeader header; HidUniquePadConfigAtomicStorage storage[2]; } HidUniquePadConfigLifo; /// HidUniquePadLifo typedef struct { HidUniquePadConfigLifo config_lifo; HidAnalogStickCalibrationStateImplLifo analog_stick_calib_lifo[2]; HidSixAxisSensorUserCalibrationStateLifo sixaxis_calib_lifo; HidUniquePadConfigMutex mutex; } HidUniquePadLifo; /// HidUniquePadSharedMemoryEntry typedef struct { HidUniquePadLifo lifo; u8 padding[0x220]; } HidUniquePadSharedMemoryEntry; /// HidUniquePadSharedMemoryFormat typedef struct { HidUniquePadSharedMemoryEntry entries[16]; } HidUniquePadSharedMemoryFormat; // End HidUniquePad // Begin HidNpad /// Npad colors. /// Color fields are zero when not set. typedef struct HidNpadControllerColor { u32 main; ///< RGBA Body Color u32 sub; ///< RGBA Buttons Color } HidNpadControllerColor; /// HidNpadFullKeyColorState typedef struct HidNpadFullKeyColorState { u32 attribute; ///< \ref HidColorAttribute HidNpadControllerColor full_key; ///< \ref HidNpadControllerColor FullKey } HidNpadFullKeyColorState; /// HidNpadJoyColorState typedef struct HidNpadJoyColorState { u32 attribute; ///< \ref HidColorAttribute HidNpadControllerColor left; ///< \ref HidNpadControllerColor Left HidNpadControllerColor right; ///< \ref HidNpadControllerColor Right } HidNpadJoyColorState; /// HidNpadCommonState typedef struct HidNpadCommonState { u64 sampling_number; ///< SamplingNumber u64 buttons; ///< Bitfield of \ref HidNpadButton. HidAnalogStickState analog_stick_l; ///< AnalogStickL HidAnalogStickState analog_stick_r; ///< AnalogStickR u32 attributes; ///< Bitfield of \ref HidNpadAttribute. u32 reserved; ///< Reserved } HidNpadCommonState; typedef HidNpadCommonState HidNpadFullKeyState; ///< State for ::HidNpadStyleTag_NpadFullKey. typedef HidNpadCommonState HidNpadHandheldState; ///< State for ::HidNpadStyleTag_NpadHandheld. typedef HidNpadCommonState HidNpadJoyDualState; ///< State for ::HidNpadStyleTag_NpadJoyDual. typedef HidNpadCommonState HidNpadJoyLeftState; ///< State for ::HidNpadStyleTag_NpadJoyLeft. typedef HidNpadCommonState HidNpadJoyRightState; ///< State for ::HidNpadStyleTag_NpadJoyRight. /// State for ::HidNpadStyleTag_NpadGc. Loaded from the same lifo as \ref HidNpadFullKeyState, with the additional trigger_l/trigger_r loaded from elsewhere. typedef struct HidNpadGcState { u64 sampling_number; ///< SamplingNumber u64 buttons; ///< Bitfield of \ref HidNpadButton. HidAnalogStickState analog_stick_l; ///< AnalogStickL HidAnalogStickState analog_stick_r; ///< AnalogStickR u32 attributes; ///< Bitfield of \ref HidNpadAttribute. u32 trigger_l; ///< L analog trigger. Valid range: 0x0-0x7FFF. u32 trigger_r; ///< R analog trigger. Valid range: 0x0-0x7FFF. u32 pad; } HidNpadGcState; typedef HidNpadCommonState HidNpadPalmaState; ///< State for ::HidNpadStyleTag_NpadPalma. /// State for ::HidNpadStyleTag_NpadLark. The base state is loaded from the same lifo as \ref HidNpadFullKeyState. typedef struct HidNpadLarkState { u64 sampling_number; ///< SamplingNumber u64 buttons; ///< Bitfield of \ref HidNpadButton. HidAnalogStickState analog_stick_l; ///< This is always zero. HidAnalogStickState analog_stick_r; ///< This is always zero. u32 attributes; ///< Bitfield of \ref HidNpadAttribute. HidNpadLarkType lark_type_l_and_main; ///< \ref HidNpadLarkType LarkTypeLAndMain } HidNpadLarkState; /// State for ::HidNpadStyleTag_NpadHandheldLark. The base state is loaded from the same lifo as \ref HidNpadHandheldState. typedef struct HidNpadHandheldLarkState { u64 sampling_number; ///< SamplingNumber u64 buttons; ///< Bitfield of \ref HidNpadButton. HidAnalogStickState analog_stick_l; ///< AnalogStickL HidAnalogStickState analog_stick_r; ///< AnalogStickR u32 attributes; ///< Bitfield of \ref HidNpadAttribute. HidNpadLarkType lark_type_l_and_main; ///< \ref HidNpadLarkType LarkTypeLAndMain HidNpadLarkType lark_type_r; ///< \ref HidNpadLarkType LarkTypeR u32 pad; } HidNpadHandheldLarkState; /// State for ::HidNpadStyleTag_NpadLucia. The base state is loaded from the same lifo as \ref HidNpadFullKeyState. typedef struct HidNpadLuciaState { u64 sampling_number; ///< SamplingNumber u64 buttons; ///< Bitfield of \ref HidNpadButton. HidAnalogStickState analog_stick_l; ///< This is always zero. HidAnalogStickState analog_stick_r; ///< This is always zero. u32 attributes; ///< Bitfield of \ref HidNpadAttribute. HidNpadLuciaType lucia_type; ///< \ref HidNpadLuciaType } HidNpadLuciaState; typedef HidNpadCommonState HidNpadLagerState; ///< State for ::HidNpadStyleTag_NpadLager. Analog-sticks state are always zero. typedef HidNpadCommonState HidNpadSystemExtState; ///< State for ::HidNpadStyleTag_NpadSystemExt. typedef HidNpadCommonState HidNpadSystemState; ///< State for ::HidNpadStyleTag_NpadSystem. Analog-sticks state are always zero. Only the following button bits are available: HidNpadButton_A, HidNpadButton_B, HidNpadButton_X, HidNpadButton_Y, HidNpadButton_Left, HidNpadButton_Up, HidNpadButton_Right, HidNpadButton_Down, HidNpadButton_L, HidNpadButton_R. /// HidNpadCommonStateAtomicStorage typedef struct HidNpadCommonStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidNpadCommonState state; } HidNpadCommonStateAtomicStorage; /// HidNpadCommonLifo typedef struct HidNpadCommonLifo { HidCommonLifoHeader header; HidNpadCommonStateAtomicStorage storage[17]; } HidNpadCommonLifo; /// HidNpadGcTriggerState typedef struct HidNpadGcTriggerState { u64 sampling_number; ///< SamplingNumber u32 trigger_l; u32 trigger_r; } HidNpadGcTriggerState; /// HidNpadGcTriggerStateAtomicStorage typedef struct HidNpadGcTriggerStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidNpadGcTriggerState state; } HidNpadGcTriggerStateAtomicStorage; /// HidNpadGcTriggerLifo typedef struct HidNpadGcTriggerLifo { HidCommonLifoHeader header; HidNpadGcTriggerStateAtomicStorage storage[17]; } HidNpadGcTriggerLifo; /// HidSixAxisSensorState typedef struct HidSixAxisSensorState { u64 delta_time; ///< DeltaTime u64 sampling_number; ///< SamplingNumber HidVector acceleration; ///< Acceleration HidVector angular_velocity; ///< AngularVelocity HidVector angle; ///< Angle HidDirectionState direction; ///< Direction u32 attributes; ///< Bitfield of \ref HidSixAxisSensorAttribute. u32 reserved; ///< Reserved } HidSixAxisSensorState; /// HidSixAxisSensorStateAtomicStorage typedef struct HidSixAxisSensorStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidSixAxisSensorState state; } HidSixAxisSensorStateAtomicStorage; /// HidNpadSixAxisSensorLifo typedef struct HidNpadSixAxisSensorLifo { HidCommonLifoHeader header; HidSixAxisSensorStateAtomicStorage storage[17]; } HidNpadSixAxisSensorLifo; /// NpadSystemProperties typedef struct { u64 is_charging : 3; ///< Use \ref hidGetNpadPowerInfoSingle / \ref hidGetNpadPowerInfoSplit instead of accessing this directly. u64 is_powered : 3; ///< Use \ref hidGetNpadPowerInfoSingle / \ref hidGetNpadPowerInfoSplit instead of accessing this directly. u64 bit6 : 1; ///< Unused u64 bit7 : 1; ///< Unused u64 bit8 : 1; ///< Unused u64 is_unsupported_button_pressed_on_npad_system : 1; ///< IsUnsupportedButtonPressedOnNpadSystem u64 is_unsupported_button_pressed_on_npad_system_ext : 1; ///< IsUnsupportedButtonPressedOnNpadSystemExt u64 is_abxy_button_oriented : 1; ///< IsAbxyButtonOriented u64 is_sl_sr_button_oriented : 1; ///< IsSlSrButtonOriented u64 is_plus_available : 1; ///< [4.0.0+] IsPlusAvailable u64 is_minus_available : 1; ///< [4.0.0+] IsMinusAvailable u64 is_directional_buttons_available : 1; ///< [8.0.0+] IsDirectionalButtonsAvailable u64 unused : 48; ///< Unused } HidNpadSystemProperties; /// NpadSystemButtonProperties typedef struct { u32 is_unintended_home_button_input_protection_enabled : 1; ///< IsUnintendedHomeButtonInputProtectionEnabled } HidNpadSystemButtonProperties; /// HidPowerInfo (system) typedef struct { bool is_powered; ///< IsPowered bool is_charging; ///< IsCharging u8 reserved[6]; ///< Reserved u32 battery_level; ///< BatteryLevel, always 0-4. } HidPowerInfo; /// XcdDeviceHandle typedef struct XcdDeviceHandle { u64 handle; } XcdDeviceHandle; /// HidNfcXcdDeviceHandleStateImpl typedef struct HidNfcXcdDeviceHandleStateImpl { XcdDeviceHandle handle; u8 is_available; u8 is_activated; u8 reserved[6]; u64 sampling_number; ///< SamplingNumber } HidNfcXcdDeviceHandleStateImpl; /// HidNfcXcdDeviceHandleStateImplAtomicStorage typedef struct HidNfcXcdDeviceHandleStateImplAtomicStorage { u64 sampling_number; ///< SamplingNumber HidNfcXcdDeviceHandleStateImpl state; ///< \ref HidNfcXcdDeviceHandleStateImpl } HidNfcXcdDeviceHandleStateImplAtomicStorage; /// HidNfcXcdDeviceHandleState typedef struct HidNfcXcdDeviceHandleState { HidCommonLifoHeader header; HidNfcXcdDeviceHandleStateImplAtomicStorage storage[2]; } HidNfcXcdDeviceHandleState; /// HidNpadInternalState typedef struct HidNpadInternalState { u32 style_set; ///< Bitfield of \ref HidNpadStyleTag. u32 joy_assignment_mode; ///< \ref HidNpadJoyAssignmentMode HidNpadFullKeyColorState full_key_color; ///< \ref HidNpadFullKeyColorState HidNpadJoyColorState joy_color; ///< \ref HidNpadJoyColorState HidNpadCommonLifo full_key_lifo; ///< FullKeyLifo HidNpadCommonLifo handheld_lifo; ///< HandheldLifo HidNpadCommonLifo joy_dual_lifo; ///< JoyDualLifo HidNpadCommonLifo joy_left_lifo; ///< JoyLeftLifo HidNpadCommonLifo joy_right_lifo; ///< JoyRightLifo HidNpadCommonLifo palma_lifo; ///< PalmaLifo HidNpadCommonLifo system_ext_lifo; ///< SystemExtLifo HidNpadSixAxisSensorLifo full_key_six_axis_sensor_lifo; ///< FullKeySixAxisSensorLifo HidNpadSixAxisSensorLifo handheld_six_axis_sensor_lifo; ///< HandheldSixAxisSensorLifo HidNpadSixAxisSensorLifo joy_dual_left_six_axis_sensor_lifo; ///< JoyDualLeftSixAxisSensorLifo HidNpadSixAxisSensorLifo joy_dual_right_six_axis_sensor_lifo; ///< JoyDualRightSixAxisSensorLifo HidNpadSixAxisSensorLifo joy_left_six_axis_sensor_lifo; ///< JoyLeftSixAxisSensorLifo HidNpadSixAxisSensorLifo joy_right_six_axis_sensor_lifo; ///< JoyRightSixAxisSensorLifo u32 device_type; ///< Bitfield of \ref HidDeviceTypeBits. u32 reserved; ///< Reserved HidNpadSystemProperties system_properties; HidNpadSystemButtonProperties system_button_properties; u32 battery_level[3]; union { struct { // [1.0.0-3.0.2] HidNfcXcdDeviceHandleState nfc_xcd_device_handle; }; struct { u32 applet_footer_ui_attribute; ///< Bitfield of AppletFooterUiAttribute. u8 applet_footer_ui_type; ///< \ref HidAppletFooterUiType u8 reserved_x41AD[0x5B]; }; }; u8 reserved_x4208[0x20]; ///< Mutex on pre-10.0.0. HidNpadGcTriggerLifo gc_trigger_lifo; u32 lark_type_l_and_main; ///< \ref HidNpadLarkType u32 lark_type_r; ///< \ref HidNpadLarkType u32 lucia_type; ///< \ref HidNpadLuciaType u32 lager_type; ///< \ref HidNpadLagerType } HidNpadInternalState; /// HidNpadSharedMemoryEntry typedef struct HidNpadSharedMemoryEntry { HidNpadInternalState internal_state; u8 pad[0xC10]; } HidNpadSharedMemoryEntry; /// HidNpadSharedMemoryFormat typedef struct HidNpadSharedMemoryFormat { HidNpadSharedMemoryEntry entries[10]; } HidNpadSharedMemoryFormat; // End HidNpad // Begin HidGesture /// HidGesturePoint typedef struct HidGesturePoint { u32 x; ///< X u32 y; ///< Y } HidGesturePoint; /// HidGestureState typedef struct HidGestureState { u64 sampling_number; ///< SamplingNumber u64 context_number; ///< ContextNumber u32 type; ///< \ref HidGestureType u32 direction; ///< \ref HidGestureDirection u32 x; ///< X u32 y; ///< Y s32 delta_x; ///< DeltaX s32 delta_y; ///< DeltaY float velocity_x; ///< VelocityX float velocity_y; ///< VelocityY u32 attributes; ///< Bitfield of \ref HidGestureAttribute. float scale; ///< Scale float rotation_angle; ///< RotationAngle s32 point_count; ///< Number of entries in the points array. HidGesturePoint points[4]; ///< Array of \ref HidGesturePoint with the above count. } HidGestureState; /// HidGestureDummyStateAtomicStorage typedef struct HidGestureDummyStateAtomicStorage { u64 sampling_number; ///< SamplingNumber HidGestureState state; } HidGestureDummyStateAtomicStorage; /// HidGestureLifo typedef struct HidGestureLifo { HidCommonLifoHeader header; HidGestureDummyStateAtomicStorage storage[17]; } HidGestureLifo; /// HidGestureSharedMemoryFormat typedef struct HidGestureSharedMemoryFormat { HidGestureLifo lifo; u8 pad[0xF8]; } HidGestureSharedMemoryFormat; // End HidGesture /// HidConsoleSixAxisSensor typedef struct { u64 sampling_number; ///< SamplingNumber u8 is_seven_six_axis_sensor_at_rest; ///< IsSevenSixAxisSensorAtRest u8 pad[0x3]; ///< Padding float verticalization_error; ///< VerticalizationError UtilFloat3 gyro_bias; ///< GyroBias u8 pad2[0x4]; ///< Padding } HidConsoleSixAxisSensor; /// HidSharedMemory typedef struct HidSharedMemory { HidDebugPadSharedMemoryFormat debug_pad; HidTouchScreenSharedMemoryFormat touchscreen; HidMouseSharedMemoryFormat mouse; HidKeyboardSharedMemoryFormat keyboard; union { HidBasicXpadSharedMemoryFormat basic_xpad; ///< [1.0.0-9.2.0] BasicXpad HidDigitizerSharedMemoryFormat digitizer; ///< [10.0.0+] Digitizer }; HidHomeButtonSharedMemoryFormat home_button; HidSleepButtonSharedMemoryFormat sleep_button; HidCaptureButtonSharedMemoryFormat capture_button; HidInputDetectorSharedMemoryFormat input_detector; HidUniquePadSharedMemoryFormat unique_pad; ///< [1.0.0-4.1.0] UniquePad HidNpadSharedMemoryFormat npad; HidGestureSharedMemoryFormat gesture; HidConsoleSixAxisSensor console_six_axis_sensor; ///< [5.0.0+] ConsoleSixAxisSensor u8 unk_x3C220[0x3DE0]; } HidSharedMemory; /// HidSevenSixAxisSensorState typedef struct { u64 timestamp0; u64 sampling_number; u64 unk_x10; float unk_x18[10]; } HidSevenSixAxisSensorState; /// HidSevenSixAxisSensorStateEntry typedef struct { u64 sampling_number; u64 unused; HidSevenSixAxisSensorState state; } HidSevenSixAxisSensorStateEntry; /// HidSevenSixAxisSensorStates typedef struct { HidCommonLifoHeader header; HidSevenSixAxisSensorStateEntry storage[0x21]; } HidSevenSixAxisSensorStates; /// HidSixAxisSensorHandle typedef union HidSixAxisSensorHandle { u32 type_value; ///< TypeValue struct { u32 npad_style_index : 8; ///< NpadStyleIndex u32 player_number : 8; ///< PlayerNumber u32 device_idx : 8; ///< DeviceIdx u32 pad : 8; ///< Padding }; } HidSixAxisSensorHandle; /// HidVibrationDeviceHandle typedef union HidVibrationDeviceHandle { u32 type_value; ///< TypeValue struct { u32 npad_style_index : 8; ///< NpadStyleIndex u32 player_number : 8; ///< PlayerNumber u32 device_idx : 8; ///< DeviceIdx u32 pad : 8; ///< Padding }; } HidVibrationDeviceHandle; /// HidVibrationDeviceInfo typedef struct HidVibrationDeviceInfo { u32 type; ///< \ref HidVibrationDeviceType u32 position; ///< \ref HidVibrationDevicePosition } HidVibrationDeviceInfo; /// HidVibrationValue typedef struct HidVibrationValue { float amp_low; ///< Low Band amplitude. 1.0f: Max amplitude. float freq_low; ///< Low Band frequency in Hz. float amp_high; ///< High Band amplitude. 1.0f: Max amplitude. float freq_high; ///< High Band frequency in Hz. } HidVibrationValue; /// PalmaConnectionHandle typedef struct HidPalmaConnectionHandle { u64 handle; ///< Handle } HidPalmaConnectionHandle; /// PalmaOperationInfo typedef struct HidPalmaOperationInfo { u32 type; ///< \ref HidPalmaOperationType Result res; ///< Result u8 data[0x140]; ///< Data } HidPalmaOperationInfo; /// PalmaApplicationSectionAccessBuffer typedef struct HidPalmaApplicationSectionAccessBuffer { u8 data[0x100]; ///< Application data. } HidPalmaApplicationSectionAccessBuffer; /// PalmaActivityEntry typedef struct HidPalmaActivityEntry { u16 rgb_led_pattern_index; ///< RgbLedPatternIndex u16 pad; ///< Padding u32 wave_set; ///< \ref HidPalmaWaveSet u16 wave_index; ///< WaveIndex } HidPalmaActivityEntry; /// Initialize hid. Called automatically during app startup. Result hidInitialize(void); /// Exit hid. Called automatically during app exit. void hidExit(void); /// Gets the Service object for the actual hid service session. Service* hidGetServiceSession(void); /// Gets the address of the SharedMemory. void* hidGetSharedmemAddr(void); ///@name TouchScreen ///@{ /// Initialize TouchScreen. Must be called when TouchScreen is being used. Used automatically by \ref hidScanInput when required. void hidInitializeTouchScreen(void); /** * @brief Gets \ref HidTouchScreenState. * @param[out] states Output array of \ref HidTouchScreenState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetTouchScreenStates(HidTouchScreenState *states, size_t count); ///@} ///@name Mouse ///@{ /// Initialize Mouse. Must be called when Mouse is being used. Used automatically by \ref hidScanInput when required. void hidInitializeMouse(void); /** * @brief Gets \ref HidMouseState. * @param[out] states Output array of \ref HidMouseState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetMouseStates(HidMouseState *states, size_t count); ///@} ///@name Keyboard ///@{ /// Initialize Keyboard. Must be called when Keyboard is being used. Used automatically by \ref hidScanInput when required. void hidInitializeKeyboard(void); /** * @brief Gets \ref HidKeyboardState. * @param[out] states Output array of \ref HidKeyboardState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetKeyboardStates(HidKeyboardState *states, size_t count); /** * @brief Gets the state of a key in a \ref HidKeyboardState. * @param[in] state \ref HidKeyboardState. * @param[in] key \ref HidKeyboardKey. * @return true if the key is pressed, false if not. */ NX_CONSTEXPR bool hidKeyboardStateGetKey(const HidKeyboardState *state, HidKeyboardKey key) { return (state->keys[key / 64] & (1UL << (key & 63))) != 0; } ///@} ///@name HomeButton ///@{ /** * @brief Gets \ref HidHomeButtonState. * @note Home button shmem must be activated with \ref hidsysActivateHomeButton * @param[out] states Output array of \ref HidHomeButtonState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetHomeButtonStates(HidHomeButtonState *states, size_t count); ///@} ///@name SleepButton ///@{ /** * @brief Gets \ref HidSleepButtonState. * @note Sleep button shmem must be activated with \ref hidsysActivateSleepButton * @param[out] states Output array of \ref HidSleepButtonState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetSleepButtonStates(HidSleepButtonState *states, size_t count); ///@} ///@name CaptureButton ///@{ /** * @brief Gets \ref HidCaptureButtonState. * @note Capture button shmem must be activated with \ref hidsysActivateCaptureButton * @param[out] states Output array of \ref HidCaptureButtonState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetCaptureButtonStates(HidCaptureButtonState *states, size_t count); ///@} ///@name Npad ///@{ /// Initialize Npad. Must be called when Npad is being used. Used automatically by \ref hidScanInput when required. void hidInitializeNpad(void); /** * @brief Gets the StyleSet for the specified Npad. * @param[in] id \ref HidNpadIdType * @return Bitfield of \ref HidNpadStyleTag. */ u32 hidGetNpadStyleSet(HidNpadIdType id); /** * @brief Gets the \ref HidNpadJoyAssignmentMode for the specified Npad. * @param[in] id \ref HidNpadIdType * @return \ref HidNpadJoyAssignmentMode */ HidNpadJoyAssignmentMode hidGetNpadJoyAssignment(HidNpadIdType id); /** * @brief Gets the main \ref HidNpadControllerColor for the specified Npad. * @param[in] id \ref HidNpadIdType * @param[out] color \ref HidNpadControllerColor */ Result hidGetNpadControllerColorSingle(HidNpadIdType id, HidNpadControllerColor *color); /** * @brief Gets the left/right \ref HidNpadControllerColor for the specified Npad (Joy-Con pair in dual mode). * @param[in] id \ref HidNpadIdType * @param[out] color_left \ref HidNpadControllerColor * @param[out] color_right \ref HidNpadControllerColor */ Result hidGetNpadControllerColorSplit(HidNpadIdType id, HidNpadControllerColor *color_left, HidNpadControllerColor *color_right); /** * @brief Gets the DeviceType for the specified Npad. * @param[in] id \ref HidNpadIdType * @return Bitfield of \ref HidDeviceTypeBits. */ u32 hidGetNpadDeviceType(HidNpadIdType id); /** * @brief Gets the \ref HidNpadSystemProperties for the specified Npad. * @param[in] id \ref HidNpadIdType * @param[out] out \ref HidNpadSystemProperties */ void hidGetNpadSystemProperties(HidNpadIdType id, HidNpadSystemProperties *out); /** * @brief Gets the \ref HidNpadSystemButtonProperties for the specified Npad. * @param[in] id \ref HidNpadIdType * @param[out] out \ref HidNpadSystemButtonProperties */ void hidGetNpadSystemButtonProperties(HidNpadIdType id, HidNpadSystemButtonProperties *out); /** * @brief Gets the main \ref HidPowerInfo for the specified Npad. * @param[in] id \ref HidNpadIdType * @param[out] info \ref HidPowerInfo */ void hidGetNpadPowerInfoSingle(HidNpadIdType id, HidPowerInfo *info); /** * @brief Gets the left/right \ref HidPowerInfo for the specified Npad (Joy-Con pair in dual mode). * @param[in] id \ref HidNpadIdType * @param[out] info_left \ref HidPowerInfo * @param[out] info_right \ref HidPowerInfo */ void hidGetNpadPowerInfoSplit(HidNpadIdType id, HidPowerInfo *info_left, HidPowerInfo *info_right); /** * @brief Gets the AppletFooterUiAttributesSet for the specified Npad. * @note Only available on [9.0.0+]. * @param[in] id \ref HidNpadIdType * @return Bitfield of AppletFooterUiAttribute (system). */ u32 hidGetAppletFooterUiAttributesSet(HidNpadIdType id); /** * @brief Gets \ref HidAppletFooterUiType for the specified Npad. * @note Only available on [9.0.0+]. * @param[in] id \ref HidNpadIdType * @return \ref HidAppletFooterUiType */ HidAppletFooterUiType hidGetAppletFooterUiTypes(HidNpadIdType id); /** * @brief Gets \ref HidNpadLagerType for the specified Npad. * @param[in] id \ref HidNpadIdType * @return \ref HidNpadLagerType */ HidNpadLagerType hidGetNpadLagerType(HidNpadIdType id); /** * @brief Gets \ref HidNpadFullKeyState. * @param[out] states Output array of \ref HidNpadFullKeyState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesFullKey(HidNpadIdType id, HidNpadFullKeyState *states, size_t count); /** * @brief Gets \ref HidNpadHandheldState. * @param[out] states Output array of \ref HidNpadHandheldState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesHandheld(HidNpadIdType id, HidNpadHandheldState *states, size_t count); /** * @brief Gets \ref HidNpadJoyDualState. * @param[out] states Output array of \ref HidNpadJoyDualState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesJoyDual(HidNpadIdType id, HidNpadJoyDualState *states, size_t count); /** * @brief Gets \ref HidNpadJoyLeftState. * @param[out] states Output array of \ref HidNpadJoyLeftState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesJoyLeft(HidNpadIdType id, HidNpadJoyLeftState *states, size_t count); /** * @brief Gets \ref HidNpadJoyRightState. * @param[out] states Output array of \ref HidNpadJoyRightState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesJoyRight(HidNpadIdType id, HidNpadJoyRightState *states, size_t count); /** * @brief Gets \ref HidNpadGcState. * @param[out] states Output array of \ref HidNpadGcState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesGc(HidNpadIdType id, HidNpadGcState *states, size_t count); /** * @brief Gets \ref HidNpadPalmaState. * @param[out] states Output array of \ref HidNpadPalmaState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesPalma(HidNpadIdType id, HidNpadPalmaState *states, size_t count); /** * @brief Gets \ref HidNpadLarkState. * @param[out] states Output array of \ref HidNpadLarkState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesLark(HidNpadIdType id, HidNpadLarkState *states, size_t count); /** * @brief Gets \ref HidNpadHandheldLarkState. * @param[out] states Output array of \ref HidNpadHandheldLarkState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesHandheldLark(HidNpadIdType id, HidNpadHandheldLarkState *states, size_t count); /** * @brief Gets \ref HidNpadLuciaState. * @param[out] states Output array of \ref HidNpadLuciaState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesLucia(HidNpadIdType id, HidNpadLuciaState *states, size_t count); /** * @brief Gets \ref HidNpadLagerState. * @param[out] states Output array of \ref HidNpadLagerState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesLager(HidNpadIdType id, HidNpadLagerState *states, size_t count); /** * @brief Gets \ref HidNpadSystemExtState. * @param[out] states Output array of \ref HidNpadSystemExtState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesSystemExt(HidNpadIdType id, HidNpadSystemExtState *states, size_t count); /** * @brief Gets \ref HidNpadSystemState. * @param[out] states Output array of \ref HidNpadSystemState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetNpadStatesSystem(HidNpadIdType id, HidNpadSystemState *states, size_t count); /** * @brief Gets \ref HidSixAxisSensorState for the specified handle. * @param[in] handle \ref HidSixAxisSensorHandle * @param[out] states Output array of \ref HidSixAxisSensorState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetSixAxisSensorStates(HidSixAxisSensorHandle handle, HidSixAxisSensorState *states, size_t count); ///@} ///@name Gesture ///@{ /// Initialize Gesture. Must be called when Gesture is being used. void hidInitializeGesture(void); /** * @brief Gets \ref HidGestureState. * @param[out] states Output array of \ref HidGestureState. * @param[in] count Size of the states array in entries. * @return Total output entries. */ size_t hidGetGestureStates(HidGestureState *states, size_t count); ///@} /** * @brief SendKeyboardLockKeyEvent * @note Same as \ref hidsysSendKeyboardLockKeyEvent. * @note Only available on [6.0.0+]. * @param[in] events Bitfield of \ref HidKeyboardLockKeyEvent. */ Result hidSendKeyboardLockKeyEvent(u32 events); /** * @brief Gets SixAxisSensorHandles. * @note Only ::HidNpadStyleTag_NpadJoyDual supports total_handles==2. * @param[out] handles Output array of \ref HidSixAxisSensorHandle. * @param[in] total_handles Total handles for the handles array. Must be 1 or 2, if 2 handles aren't supported by the specified style an error is thrown. * @param[in] id \ref HidNpadIdType * @param[in] style \ref HidNpadStyleTag */ Result hidGetSixAxisSensorHandles(HidSixAxisSensorHandle *handles, s32 total_handles, HidNpadIdType id, HidNpadStyleTag style); /** * @brief Starts the SixAxisSensor for the specified handle. * @param[in] handle \ref HidSixAxisSensorHandle */ Result hidStartSixAxisSensor(HidSixAxisSensorHandle handle); /** * @brief Stops the SixAxisSensor for the specified handle. * @param[in] handle \ref HidSixAxisSensorHandle */ Result hidStopSixAxisSensor(HidSixAxisSensorHandle handle); /** * @brief IsSixAxisSensorFusionEnabled * @param[in] handle \ref HidSixAxisSensorHandle * @param[out] out Output flag. */ Result hidIsSixAxisSensorFusionEnabled(HidSixAxisSensorHandle handle, bool *out); /** * @brief EnableSixAxisSensorFusion * @param[in] handle \ref HidSixAxisSensorHandle * @param[in] flag Flag */ Result hidEnableSixAxisSensorFusion(HidSixAxisSensorHandle handle, bool flag); /** * @brief SetSixAxisSensorFusionParameters * @param[in] handle \ref HidSixAxisSensorHandle * @param[in] unk0 Must be 0.0f-1.0f. * @param[in] unk1 Unknown */ Result hidSetSixAxisSensorFusionParameters(HidSixAxisSensorHandle handle, float unk0, float unk1); /** * @brief GetSixAxisSensorFusionParameters * @param[in] handle \ref HidSixAxisSensorHandle * @param[out] unk0 Unknown * @param[out] unk1 Unknown */ Result hidGetSixAxisSensorFusionParameters(HidSixAxisSensorHandle handle, float *unk0, float *unk1); /** * @brief ResetSixAxisSensorFusionParameters * @param[in] handle \ref HidSixAxisSensorHandle */ Result hidResetSixAxisSensorFusionParameters(HidSixAxisSensorHandle handle); /** * @brief Sets the ::HidGyroscopeZeroDriftMode for the specified SixAxisSensorHandle. * @param[in] handle \ref HidSixAxisSensorHandle * @param[in] mode \ref HidGyroscopeZeroDriftMode */ Result hidSetGyroscopeZeroDriftMode(HidSixAxisSensorHandle handle, HidGyroscopeZeroDriftMode mode); /** * @brief Gets the ::HidGyroscopeZeroDriftMode for the specified SixAxisSensorHandle. * @param[in] handle \ref HidSixAxisSensorHandle * @param[out] mode \ref HidGyroscopeZeroDriftMode */ Result hidGetGyroscopeZeroDriftMode(HidSixAxisSensorHandle handle, HidGyroscopeZeroDriftMode *mode); /** * @brief Resets the ::HidGyroscopeZeroDriftMode for the specified SixAxisSensorHandle to ::HidGyroscopeZeroDriftMode_Standard. * @param[in] handle \ref HidSixAxisSensorHandle */ Result hidResetGyroscopeZeroDriftMode(HidSixAxisSensorHandle handle); /** * @brief IsSixAxisSensorAtRest * @param[in] handle \ref HidSixAxisSensorHandle * @param[out] out Output flag. */ Result hidIsSixAxisSensorAtRest(HidSixAxisSensorHandle handle, bool *out); /** * @brief IsFirmwareUpdateAvailableForSixAxisSensor * @note Only available on [6.0.0+]. * @param[in] handle \ref HidSixAxisSensorHandle * @param[out] out Output flag. */ Result hidIsFirmwareUpdateAvailableForSixAxisSensor(HidSixAxisSensorHandle handle, bool *out); /** * @brief Sets which controller styles are supported. * @note This is automatically called with the needed styles in \ref hidScanInput when required. * @param[in] style_set Bitfield of \ref HidNpadStyleTag. */ Result hidSetSupportedNpadStyleSet(u32 style_set); /** * @brief Gets which controller styles are supported. * @param[out] style_set Bitfield of \ref HidNpadStyleTag. */ Result hidGetSupportedNpadStyleSet(u32 *style_set); /** * @brief Sets which \ref HidNpadIdType are supported. * @note This is automatically called with HidNpadIdType_No{1-8} and HidNpadIdType_Handheld when required in \ref hidScanInput. * @param[in] ids Input array of \ref HidNpadIdType. * @param[in] count Total entries in the ids array. Must be <=10. */ Result hidSetSupportedNpadIdType(const HidNpadIdType *ids, size_t count); /** * @brief Gets an Event which is signaled when the \ref hidGetNpadStyleSet output is updated for the specified controller. * @note The Event must be closed by the user once finished with it. * @param[in] id \ref HidNpadIdType * @param[out] out_event Output Event. * @param[in] autoclear The autoclear for the Event. **/ Result hidAcquireNpadStyleSetUpdateEventHandle(HidNpadIdType id, Event* out_event, bool autoclear); /** * @brief DisconnectNpad * @param[in] id \ref HidNpadIdType */ Result hidDisconnectNpad(HidNpadIdType id); /** * @brief GetPlayerLedPattern * @param[in] id \ref HidNpadIdType * @param[out] out Output value. */ Result hidGetPlayerLedPattern(HidNpadIdType id, u8 *out); /** * @brief Sets the \ref HidNpadJoyHoldType. * @note Used automatically by \ref hidScanInput when required. * @param[in] type \ref HidNpadJoyHoldType */ Result hidSetNpadJoyHoldType(HidNpadJoyHoldType type); /** * @brief Gets the \ref HidNpadJoyHoldType. * @param[out] type \ref HidNpadJoyHoldType */ Result hidGetNpadJoyHoldType(HidNpadJoyHoldType *type); /** * @brief This is the same as \ref hidSetNpadJoyAssignmentModeSingle, except ::HidNpadJoyDeviceType_Left is used for the type. * @param[in] id \ref HidNpadIdType, must be HidNpadIdType_No*. */ Result hidSetNpadJoyAssignmentModeSingleByDefault(HidNpadIdType id); /** * @brief This is the same as \ref hidSetNpadJoyAssignmentModeSingleWithDestination, except without the output params. * @param[in] id \ref HidNpadIdType, must be HidNpadIdType_No*. * @param[in] type \ref HidNpadJoyDeviceType */ Result hidSetNpadJoyAssignmentModeSingle(HidNpadIdType id, HidNpadJoyDeviceType type); /** * @brief Use this if you want to use a pair of joy-cons as a single HidNpadIdType_No*. When used, both joy-cons in a pair should be used with this (HidNpadIdType_No1 and HidNpadIdType_No2 for example). * @note Used automatically by \ref hidScanInput when required. * @param[in] id \ref HidNpadIdType, must be HidNpadIdType_No*. */ Result hidSetNpadJoyAssignmentModeDual(HidNpadIdType id); /** * @brief Merge two single joy-cons into a dual-mode controller. Use this after \ref hidSetNpadJoyAssignmentModeDual, when \ref hidSetNpadJoyAssignmentModeSingleByDefault was previously used (this includes using this manually at application exit). * @brief To be successful, id0/id1 must correspond to controllers supporting styles HidNpadStyleTag_NpadJoyLeft/Right, or HidNpadStyleTag_NpadJoyRight/Left. * @brief If successful, the id of the resulting dual controller is set to id0. * @param[in] id0 \ref HidNpadIdType * @param[in] id1 \ref HidNpadIdType */ Result hidMergeSingleJoyAsDualJoy(HidNpadIdType id0, HidNpadIdType id1); /** * @brief StartLrAssignmentMode */ Result hidStartLrAssignmentMode(void); /** * @brief StopLrAssignmentMode */ Result hidStopLrAssignmentMode(void); /** * @brief Sets the \ref HidNpadHandheldActivationMode. * @param[in] mode \ref HidNpadHandheldActivationMode */ Result hidSetNpadHandheldActivationMode(HidNpadHandheldActivationMode mode); /** * @brief Gets the \ref HidNpadHandheldActivationMode. * @param[out] out \ref HidNpadHandheldActivationMode */ Result hidGetNpadHandheldActivationMode(HidNpadHandheldActivationMode *out); /** * @brief SwapNpadAssignment * @param[in] id0 \ref HidNpadIdType * @param[in] id1 \ref HidNpadIdType */ Result hidSwapNpadAssignment(HidNpadIdType id0, HidNpadIdType id1); /** * @brief EnableUnintendedHomeButtonInputProtection * @note To get the state of this, use \ref hidGetNpadSystemButtonProperties to access HidNpadSystemButtonProperties::is_unintended_home_button_input_protection_enabled. * @param[in] id \ref HidNpadIdType * @param[in] flag Whether UnintendedHomeButtonInputProtection is enabled. */ Result hidEnableUnintendedHomeButtonInputProtection(HidNpadIdType id, bool flag); /** * @brief Use this if you want to use a single joy-con as a dedicated HidNpadIdType_No*. When used, both joy-cons in a pair should be used with this (HidNpadIdType_No1 and HidNpadIdType_No2 for example). * @note Only available on [5.0.0+]. * @param[in] id \ref HidNpadIdType, must be HidNpadIdType_No*. * @param[in] type \ref HidNpadJoyDeviceType * @param[out] flag Whether the dest output is set. * @param[out] dest \ref HidNpadIdType */ Result hidSetNpadJoyAssignmentModeSingleWithDestination(HidNpadIdType id, HidNpadJoyDeviceType type, bool *flag, HidNpadIdType *dest); /** * @brief SetNpadAnalogStickUseCenterClamp * @note Only available on [6.1.0+]. * @param[in] flag Flag */ Result hidSetNpadAnalogStickUseCenterClamp(bool flag); /** * @brief Assigns the button(s) which trigger the CaptureButton. * @note Only available on [8.0.0+]. * @param[in] style \ref HidNpadStyleTag, exactly 1 bit must be set. * @param[in] buttons Bitfield of \ref HidNpadButton, multiple bits can be set. */ Result hidSetNpadCaptureButtonAssignment(HidNpadStyleTag style, u64 buttons); /** * @brief ClearNpadCaptureButtonAssignment * @note Only available on [8.0.0+]. */ Result hidClearNpadCaptureButtonAssignment(void); /** * @brief Gets and initializes vibration handles. * @note Only the following styles support total_handles 2: ::HidNpadStyleTag_NpadFullKey, ::HidNpadStyleTag_NpadHandheld, ::HidNpadStyleTag_NpadJoyDual, ::HidNpadStyleTag_NpadHandheldLark, ::HidNpadStyleTag_NpadSystem, ::HidNpadStyleTag_NpadSystemExt. * @param[out] handles Output array of \ref HidVibrationDeviceHandle. * @param[in] total_handles Total handles for the handles array. Must be 1 or 2, if 2 handles aren't supported by the specified style an error is thrown. * @param[in] id \ref HidNpadIdType * @param[in] style \ref HidNpadStyleTag */ Result hidInitializeVibrationDevices(HidVibrationDeviceHandle *handles, s32 total_handles, HidNpadIdType id, HidNpadStyleTag style); /** * @brief Gets \ref HidVibrationDeviceInfo for the specified device. * @param[in] handle \ref HidVibrationDeviceHandle * @param[out] out \ref HidVibrationDeviceInfo */ Result hidGetVibrationDeviceInfo(HidVibrationDeviceHandle handle, HidVibrationDeviceInfo *out); /** * @brief Sends the \ref HidVibrationDeviceHandle to the specified device. * @note With ::HidVibrationDeviceType_GcErm, use \ref hidSendVibrationGcErmCommand instead. * @param[in] handle \ref HidVibrationDeviceHandle * @param[in] value \ref HidVibrationValue */ Result hidSendVibrationValue(HidVibrationDeviceHandle handle, const HidVibrationValue *value); /** * @brief Gets the current \ref HidVibrationValue for the specified device. * @note With ::HidVibrationDeviceType_GcErm, use \ref hidGetActualVibrationGcErmCommand instead. * @param[in] handle \ref HidVibrationDeviceHandle * @param[out] out \ref HidVibrationValue */ Result hidGetActualVibrationValue(HidVibrationDeviceHandle handle, HidVibrationValue *out); /** * @brief Sets whether vibration is allowed, this also affects the config displayed by System Settings. * @param[in] flag Flag */ Result hidPermitVibration(bool flag); /** * @brief Gets whether vibration is allowed. * @param[out] flag Flag */ Result hidIsVibrationPermitted(bool *flag); /** * @brief Send vibration values[index] to handles[index]. * @note With ::HidVibrationDeviceType_GcErm, use \ref hidSendVibrationGcErmCommand instead. * @param[in] handles Input array of \ref HidVibrationDeviceHandle. * @param[in] values Input array of \ref HidVibrationValue. * @param[in] count Total entries in the handles/values arrays. */ Result hidSendVibrationValues(const HidVibrationDeviceHandle *handles, const HidVibrationValue *values, s32 count); /** * @brief Send \ref HidVibrationGcErmCommand to the specified device, for ::HidVibrationDeviceType_GcErm. * @note Only available on [4.0.0+]. * @param[in] handle \ref HidVibrationDeviceHandle * @param[in] cmd \ref HidVibrationGcErmCommand */ Result hidSendVibrationGcErmCommand(HidVibrationDeviceHandle handle, HidVibrationGcErmCommand cmd); /** * @brief Get \ref HidVibrationGcErmCommand for the specified device, for ::HidVibrationDeviceType_GcErm. * @note Only available on [4.0.0+]. * @param[in] handle \ref HidVibrationDeviceHandle * @param[out] out \ref HidVibrationGcErmCommand */ Result hidGetActualVibrationGcErmCommand(HidVibrationDeviceHandle handle, HidVibrationGcErmCommand *out); /** * @brief Begins a forced-permitted vibration session. * @note Only available on [4.0.0+]. */ Result hidBeginPermitVibrationSession(void); /** * @brief Ends the session started by \ref hidBeginPermitVibrationSession. * @note Only available on [4.0.0+]. */ Result hidEndPermitVibrationSession(void); /** * @brief Gets whether vibration is available with the specified device. * @note Only available on [7.0.0+]. * @param[in] handle \ref HidVibrationDeviceHandle * @param[out] flag Flag */ Result hidIsVibrationDeviceMounted(HidVibrationDeviceHandle handle, bool *flag); /** * @brief Starts the SevenSixAxisSensor. * @note Only available on [5.0.0+]. */ Result hidStartSevenSixAxisSensor(void); /** * @brief Stops the SevenSixAxisSensor. * @note Only available on [5.0.0+]. */ Result hidStopSevenSixAxisSensor(void); /** * @brief Initializes the SevenSixAxisSensor. * @note Only available on [5.0.0+]. */ Result hidInitializeSevenSixAxisSensor(void); /** * @brief Finalizes the SevenSixAxisSensor. * @note This must be called before \ref hidExit. * @note Only available on [5.0.0+]. */ Result hidFinalizeSevenSixAxisSensor(void); /** * @brief Sets the SevenSixAxisSensor FusionStrength. * @note Only available on [5.0.0+]. * @param[in] strength Strength */ Result hidSetSevenSixAxisSensorFusionStrength(float strength); /** * @brief Gets the SevenSixAxisSensor FusionStrength. * @note Only available on [5.0.0+]. * @param[out] strength Strength */ Result hidGetSevenSixAxisSensorFusionStrength(float *strength); /** * @brief Resets the timestamp for the SevenSixAxisSensor. * @note Only available on [6.0.0+]. */ Result hidResetSevenSixAxisSensorTimestamp(void); /** * @brief GetSevenSixAxisSensorStates * @note Only available when \ref hidInitializeSevenSixAxisSensor was previously used. * @param[out] states Output array of \ref HidSevenSixAxisSensorState. * @param[in] count Size of the states array in entries. * @param[out] total_out Total output entries. */ Result hidGetSevenSixAxisSensorStates(HidSevenSixAxisSensorState *states, size_t count, size_t *total_out); /** * @brief IsSevenSixAxisSensorAtRest * @note Only available when \ref hidInitializeSevenSixAxisSensor was previously used. * @param[out] out Output flag. */ Result hidIsSevenSixAxisSensorAtRest(bool *out); /** * @brief GetSensorFusionError * @note Only available when \ref hidInitializeSevenSixAxisSensor was previously used. * @param[out] out Output data. */ Result hidGetSensorFusionError(float *out); /** * @brief GetGyroBias * @note Only available when \ref hidInitializeSevenSixAxisSensor was previously used. * @param[out] out \ref UtilFloat3 */ Result hidGetGyroBias(UtilFloat3 *out); /** * @brief IsUsbFullKeyControllerEnabled * @note Only available on [3.0.0+]. * @param[out] out Output flag. */ Result hidIsUsbFullKeyControllerEnabled(bool *out); /** * @brief EnableUsbFullKeyController * @note Only available on [3.0.0+]. * @param[in] flag Flag */ Result hidEnableUsbFullKeyController(bool flag); /** * @brief IsUsbFullKeyControllerConnected * @note Only available on [3.0.0+]. * @param[in] id \ref HidNpadIdType * @param[out] out Output flag. */ Result hidIsUsbFullKeyControllerConnected(HidNpadIdType id, bool *out); /** * @brief Gets the \ref HidNpadInterfaceType for the specified controller. * @note When available, \ref hidsysGetNpadInterfaceType should be used instead. * @note Only available on [4.0.0+]. * @param[in] id \ref HidNpadIdType * @param[out] out \ref HidNpadInterfaceType */ Result hidGetNpadInterfaceType(HidNpadIdType id, u8 *out); /** * @brief GetNpadOfHighestBatteryLevel * @note Only available on [10.0.0+]. * @param[in] ids Input array of \ref HidNpadIdType, ::HidNpadIdType_Handheld is ignored. * @param[in] count Total entries in the ids array. * @param[out] out \ref HidNpadIdType */ Result hidGetNpadOfHighestBatteryLevel(const HidNpadIdType *ids, size_t count, HidNpadIdType *out); ///@name Palma, see ::HidNpadStyleTag_NpadPalma. ///@{ /** * @brief GetPalmaConnectionHandle * @note Only available on [5.0.0+]. * @param[in] id \ref HidNpadIdType * @param[out] out \ref HidPalmaConnectionHandle */ Result hidGetPalmaConnectionHandle(HidNpadIdType id, HidPalmaConnectionHandle *out); /** * @brief InitializePalma * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidInitializePalma(HidPalmaConnectionHandle handle); /** * @brief Gets an Event which is signaled when data is available with \ref hidGetPalmaOperationInfo. * @note The Event must be closed by the user once finished with it. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[out] out_event Output Event. * @param[in] autoclear The autoclear for the Event. **/ Result hidAcquirePalmaOperationCompleteEvent(HidPalmaConnectionHandle handle, Event* out_event, bool autoclear); /** * @brief Gets \ref HidPalmaOperationInfo for a completed operation. * @note This must be used at some point following using any of the other Palma cmds which trigger an Operation, once the Event from \ref hidAcquirePalmaOperationCompleteEvent is signaled. Up to 4 Operations can be queued at once, the other cmds will throw an error once there's too many operations. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[out] out \ref HidPalmaOperationInfo */ Result hidGetPalmaOperationInfo(HidPalmaConnectionHandle handle, HidPalmaOperationInfo *out); /** * @brief PlayPalmaActivity * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] val Input value. */ Result hidPlayPalmaActivity(HidPalmaConnectionHandle handle, u16 val); /** * @brief SetPalmaFrModeType * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] type \ref HidPalmaFrModeType */ Result hidSetPalmaFrModeType(HidPalmaConnectionHandle handle, HidPalmaFrModeType type); /** * @brief ReadPalmaStep * @note See \ref hidGetPalmaOperationInfo. * @note \ref hidEnablePalmaStep should be used before this. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidReadPalmaStep(HidPalmaConnectionHandle handle); /** * @brief EnablePalmaStep * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] flag Flag */ Result hidEnablePalmaStep(HidPalmaConnectionHandle handle, bool flag); /** * @brief ResetPalmaStep * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidResetPalmaStep(HidPalmaConnectionHandle handle); /** * @brief ReadPalmaApplicationSection * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] inval0 First input value. * @param[in] size This must be within the size of \ref HidPalmaApplicationSectionAccessBuffer. */ Result hidReadPalmaApplicationSection(HidPalmaConnectionHandle handle, s32 inval0, u64 size); /** * @brief WritePalmaApplicationSection * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] inval0 First input value. * @param[in] size Size of the data in \ref HidPalmaApplicationSectionAccessBuffer. * @param[in] buf \ref HidPalmaApplicationSectionAccessBuffer */ Result hidWritePalmaApplicationSection(HidPalmaConnectionHandle handle, s32 inval0, u64 size, const HidPalmaApplicationSectionAccessBuffer *buf); /** * @brief ReadPalmaUniqueCode * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidReadPalmaUniqueCode(HidPalmaConnectionHandle handle); /** * @brief SetPalmaUniqueCodeInvalid * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidSetPalmaUniqueCodeInvalid(HidPalmaConnectionHandle handle); /** * @brief WritePalmaActivityEntry * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] unk Unknown * @param[in] entry \ref HidPalmaActivityEntry */ Result hidWritePalmaActivityEntry(HidPalmaConnectionHandle handle, u16 unk, const HidPalmaActivityEntry *entry); /** * @brief WritePalmaRgbLedPatternEntry * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] unk Unknown * @param[in] buffer Input buffer. * @param[in] size Input buffer size. */ Result hidWritePalmaRgbLedPatternEntry(HidPalmaConnectionHandle handle, u16 unk, const void* buffer, size_t size); /** * @brief WritePalmaWaveEntry * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] wave_set \ref HidPalmaWaveSet * @param[in] unk Unknown * @param[in] buffer TransferMemory buffer, must be 0x1000-byte aligned. * @param[in] tmem_size TransferMemory buffer size, must be 0x1000-byte aligned. * @param[in] size Actual size of the data in the buffer. */ Result hidWritePalmaWaveEntry(HidPalmaConnectionHandle handle, HidPalmaWaveSet wave_set, u16 unk, const void* buffer, size_t tmem_size, size_t size); /** * @brief SetPalmaDataBaseIdentificationVersion * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] version Version */ Result hidSetPalmaDataBaseIdentificationVersion(HidPalmaConnectionHandle handle, s32 version); /** * @brief GetPalmaDataBaseIdentificationVersion * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidGetPalmaDataBaseIdentificationVersion(HidPalmaConnectionHandle handle); /** * @brief SuspendPalmaFeature * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] features Bitfield of \ref HidPalmaFeature. */ Result hidSuspendPalmaFeature(HidPalmaConnectionHandle handle, u32 features); /** * @brief ReadPalmaPlayLog * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.1.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] unk Unknown */ Result hidReadPalmaPlayLog(HidPalmaConnectionHandle handle, u16 unk); /** * @brief ResetPalmaPlayLog * @note See \ref hidGetPalmaOperationInfo. * @note Only available on [5.1.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[in] unk Unknown */ Result hidResetPalmaPlayLog(HidPalmaConnectionHandle handle, u16 unk); /** * @brief Sets whether any Palma can connect. * @note Only available on [5.1.0+]. * @param[in] flag Flag */ Result hidSetIsPalmaAllConnectable(bool flag); /** * @brief Sets whether paired Palma can connect. * @note Only available on [5.1.0+]. * @param[in] flag Flag */ Result hidSetIsPalmaPairedConnectable(bool flag); /** * @brief PairPalma * @note Only available on [5.1.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidPairPalma(HidPalmaConnectionHandle handle); /** * @brief CancelWritePalmaWaveEntry * @note Only available on [7.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle */ Result hidCancelWritePalmaWaveEntry(HidPalmaConnectionHandle handle); /** * @brief EnablePalmaBoostMode * @note Only available on [5.1.0+]. Uses cmd EnablePalmaBoostMode on [8.0.0+], otherwise cmd SetPalmaBoostMode is used. * @param[in] flag Flag */ Result hidEnablePalmaBoostMode(bool flag); /** * @brief GetPalmaBluetoothAddress * @note Only available on [8.0.0+]. * @param[in] handle \ref HidPalmaConnectionHandle * @param[out] out \ref BtdrvAddress */ Result hidGetPalmaBluetoothAddress(HidPalmaConnectionHandle handle, BtdrvAddress *out); /** * @brief SetDisallowedPalmaConnection * @note Only available on [8.0.0+]. * @param[in] addrs Input array of \ref BtdrvAddress. * @param[in] count Total entries in the addrs array. */ Result hidSetDisallowedPalmaConnection(const BtdrvAddress *addrs, s32 count); ///@} /** * @brief SetNpadCommunicationMode * @note [2.0.0+] Stubbed, just returns 0. * @param[in] mode \ref HidNpadCommunicationMode */ Result hidSetNpadCommunicationMode(HidNpadCommunicationMode mode); /** * @brief GetNpadCommunicationMode * @note [2.0.0+] Stubbed, always returns output mode ::HidNpadCommunicationMode_Default. * @param[out] out \ref HidNpadCommunicationMode */ Result hidGetNpadCommunicationMode(HidNpadCommunicationMode *out); /** * @brief SetTouchScreenConfiguration * @note Only available on [9.0.0+]. * @param[in] config \ref HidTouchScreenConfigurationForNx */ Result hidSetTouchScreenConfiguration(const HidTouchScreenConfigurationForNx *config); /** * @brief IsFirmwareUpdateNeededForNotification * @note Only available on [9.0.0+]. * @param[out] out Output flag. */ Result hidIsFirmwareUpdateNeededForNotification(bool *out);