diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index 3f74aed061..3c4259d270 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -2,7 +2,10 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include #include "common/logging/log.h" +#include "core/core_timing.h" +#include "core/frontend/input.h" #include "core/hle/ipc_helpers.h" #include "core/hle/kernel/client_port.h" #include "core/hle/kernel/client_session.h" @@ -13,6 +16,12 @@ namespace Service { namespace HID { +// Updating period for each HID device. +// TODO(shinyquagsire23): These need better values. +constexpr u64 pad_update_ticks = BASE_CLOCK_RATE / 234; +constexpr u64 accelerometer_update_ticks = BASE_CLOCK_RATE / 104; +constexpr u64 gyroscope_update_ticks = BASE_CLOCK_RATE / 101; + class IAppletResource final : public ServiceFramework { public: IAppletResource() : ServiceFramework("IAppletResource") { @@ -24,6 +33,15 @@ public: shared_mem = Kernel::SharedMemory::Create( nullptr, 0x40000, Kernel::MemoryPermission::ReadWrite, Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "HID:SharedMemory"); + + // Register update callbacks + pad_update_event = CoreTiming::RegisterEvent( + "HID::UpdatePadCallback", + [this](u64 userdata, int cycles_late) { UpdatePadCallback(userdata, cycles_late); }); + + // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?) + + CoreTiming::ScheduleEvent(pad_update_ticks, pad_update_event); } private: @@ -34,8 +52,76 @@ private: LOG_DEBUG(Service, "called"); } + void LoadInputDevices() { + std::transform(Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_BEGIN, + Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_END, + buttons.begin(), Input::CreateDevice); + // TODO(shinyquagsire23): sticks, gyro, touch, mouse, keyboard + } + + void UpdatePadCallback(u64 userdata, int cycles_late) { + SharedMemory* mem = reinterpret_cast(shared_mem->GetPointer()); + + if (is_device_reload_pending.exchange(false)) + LoadInputDevices(); + + // TODO(shinyquagsire23): This is a hack! + ControllerPadState& state = + mem->controllers[Controller_Handheld].layouts[Layout_Default].entries[0].buttons; + using namespace Settings::NativeButton; + state.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus()); + state.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus()); + state.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus()); + state.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus()); + state.lstick.Assign(buttons[LStick - BUTTON_HID_BEGIN]->GetStatus()); + state.rstick.Assign(buttons[RStick - BUTTON_HID_BEGIN]->GetStatus()); + state.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus()); + state.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus()); + state.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus()); + state.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus()); + state.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus()); + state.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus()); + + state.dleft.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus()); + state.dup.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus()); + state.dright.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus()); + state.ddown.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus()); + + state.lstick_left.Assign(buttons[LStick_Left - BUTTON_HID_BEGIN]->GetStatus()); + state.lstick_up.Assign(buttons[LStick_Up - BUTTON_HID_BEGIN]->GetStatus()); + state.lstick_right.Assign(buttons[LStick_Right - BUTTON_HID_BEGIN]->GetStatus()); + state.lstick_down.Assign(buttons[LStick_Down - BUTTON_HID_BEGIN]->GetStatus()); + + state.rstick_left.Assign(buttons[RStick_Left - BUTTON_HID_BEGIN]->GetStatus()); + state.rstick_up.Assign(buttons[RStick_Up - BUTTON_HID_BEGIN]->GetStatus()); + state.rstick_right.Assign(buttons[RStick_Right - BUTTON_HID_BEGIN]->GetStatus()); + state.rstick_down.Assign(buttons[RStick_Down - BUTTON_HID_BEGIN]->GetStatus()); + + state.sl.Assign(buttons[SL - BUTTON_HID_BEGIN]->GetStatus()); + state.sr.Assign(buttons[SR - BUTTON_HID_BEGIN]->GetStatus()); + + // TODO(shinyquagsire23): Analog stick vals + + // TODO(shinyquagsire23): Update pad info proper, (circular buffers, timestamps, layouts) + + // TODO(shinyquagsire23): Update touch info + + // TODO(shinyquagsire23): Signal events + + // Reschedule recurrent event + CoreTiming::ScheduleEvent(pad_update_ticks - cycles_late, pad_update_event); + } + // Handle to shared memory region designated to HID service Kernel::SharedPtr shared_mem; + + // CoreTiming update events + CoreTiming::EventType* pad_update_event; + + // Stored input state info + std::atomic is_device_reload_pending{true}; + std::array, Settings::NativeButton::NUM_BUTTONS_HID> + buttons; }; class Hid final : public ServiceFramework { diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h index f7621f62d1..486e648007 100644 --- a/src/core/hle/service/hid/hid.h +++ b/src/core/hle/service/hid/hid.h @@ -5,10 +5,322 @@ #pragma once #include "core/hle/service/service.h" +#include "core/settings.h" namespace Service { namespace HID { +// Begin enums and output structs + +enum ControllerType : u32 { + ControllerType_ProController = 1 << 0, + ControllerType_Handheld = 1 << 1, + ControllerType_JoyconPair = 1 << 2, + ControllerType_JoyconLeft = 1 << 3, + ControllerType_JoyconRight = 1 << 4, +}; + +enum ControllerLayoutType : u32 { + Layout_ProController = 0, // Pro Controller or HID gamepad + 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_Left = 3, // Only raw left Joy-Con state, no orientation adjustment + Layout_Right = 4, // Only raw right Joy-Con state, no orientation adjustment + Layout_DefaultDigital = 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 +}; + +enum ControllerColorDescription { + ColorDesc_ColorsNonexistent = 1 << 1, +}; + +enum ControllerConnectionState { + ConnectionState_Connected = 1 << 0, + ConnectionState_Wired = 1 << 1, +}; + +enum ControllerID { + Controller_Player1 = 0, + Controller_Player2 = 1, + Controller_Player3 = 2, + Controller_Player4 = 3, + Controller_Player5 = 4, + Controller_Player6 = 5, + Controller_Player7 = 6, + Controller_Player8 = 7, + Controller_Handheld = 8, + Controller_Unknown = 9, +}; + +// End enums and output structs + +// Begin TouchScreen + +struct TouchScreenHeader { + u64 timestampTicks; + u64 numEntries; + u64 latestEntry; + u64 maxEntryIndex; + u64 timestamp; +}; +static_assert(sizeof(TouchScreenHeader) == 0x28, + "HID touch screen header structure has incorrect size"); + +struct TouchScreenEntryHeader { + u64 timestamp; + u64 numTouches; +}; +static_assert(sizeof(TouchScreenEntryHeader) == 0x10, + "HID touch screen entry header structure has incorrect size"); + +struct TouchScreenEntryTouch { + u64 timestamp; + u32 padding; + u32 touchIndex; + u32 x; + u32 y; + u32 diameterX; + u32 diameterY; + u32 angle; + u32 padding_2; +}; +static_assert(sizeof(TouchScreenEntryTouch) == 0x28, + "HID touch screen touch structure has incorrect size"); + +struct TouchScreenEntry { + TouchScreenEntryHeader header; + std::array touches; + u64 unk; +}; +static_assert(sizeof(TouchScreenEntry) == 0x298, + "HID touch screen entry structure has incorrect size"); + +struct TouchScreen { + TouchScreenHeader header; + std::array entries; + std::array padding; +}; +static_assert(sizeof(TouchScreen) == 0x3000, "HID touch screen structure has incorrect size"); + +// End TouchScreen + +// Begin Mouse + +struct MouseHeader { + u64 timestampTicks; + u64 numEntries; + u64 latestEntry; + u64 maxEntryIndex; +}; +static_assert(sizeof(MouseHeader) == 0x20, "HID mouse header structure has incorrect size"); + +struct MouseButtonState { + union { + u64 hex{}; + + // Buttons + BitField<0, 1, u64> left; + BitField<1, 1, u64> right; + BitField<2, 1, u64> middle; + BitField<3, 1, u64> forward; + BitField<4, 1, u64> back; + }; +}; + +struct MouseEntry { + u64 timestamp; + u64 timestamp_2; + u32 x; + u32 y; + u32 velocityX; + u32 velocityY; + u32 scrollVelocityX; + u32 scrollVelocityY; + MouseButtonState buttons; +}; +static_assert(sizeof(MouseEntry) == 0x30, "HID mouse entry structure has incorrect size"); + +struct Mouse { + MouseHeader header; + std::array entries; + std::array padding; +}; +static_assert(sizeof(Mouse) == 0x400, "HID mouse structure has incorrect size"); + +// End Mouse + +// Begin Keyboard + +struct KeyboardHeader { + u64 timestampTicks; + u64 numEntries; + u64 latestEntry; + u64 maxEntryIndex; +}; +static_assert(sizeof(KeyboardHeader) == 0x20, "HID keyboard header structure has incorrect size"); + +struct KeyboardModifierKeyState { + union { + u64 hex{}; + + // Buttons + BitField<0, 1, u64> lctrl; + BitField<1, 1, u64> lshift; + BitField<2, 1, u64> lalt; + BitField<3, 1, u64> lmeta; + BitField<4, 1, u64> rctrl; + BitField<5, 1, u64> rshift; + BitField<6, 1, u64> ralt; + BitField<7, 1, u64> rmeta; + BitField<8, 1, u64> capslock; + BitField<9, 1, u64> scrolllock; + BitField<10, 1, u64> numlock; + }; +}; + +struct KeyboardEntry { + u64 timestamp; + u64 timestamp_2; + KeyboardModifierKeyState modifier; + u32 keys[8]; +}; +static_assert(sizeof(KeyboardEntry) == 0x38, "HID keyboard entry structure has incorrect size"); + +struct Keyboard { + KeyboardHeader header; + std::array entries; + std::array padding; +}; +static_assert(sizeof(Keyboard) == 0x400, "HID keyboard structure has incorrect size"); + +// End Keyboard + +// Begin Controller + +struct ControllerMAC { + u64 timestamp; + std::array mac; + u64 unk; + u64 timestamp_2; +}; +static_assert(sizeof(ControllerMAC) == 0x20, "HID controller MAC structure has incorrect size"); + +struct ControllerHeader { + u32 type; + u32 isHalf; + u32 singleColorsDescriptor; + u32 singleColorBody; + u32 singleColorButtons; + u32 splitColorsDescriptor; + u32 leftColorBody; + u32 leftColorButtons; + u32 rightColorBody; + u32 rightColorbuttons; +}; +static_assert(sizeof(ControllerHeader) == 0x28, + "HID controller header structure has incorrect size"); + +struct ControllerLayoutHeader { + u64 timestampTicks; + u64 numEntries; + u64 latestEntry; + u64 maxEntryIndex; +}; +static_assert(sizeof(ControllerLayoutHeader) == 0x20, + "HID controller layout header structure has incorrect size"); + +struct ControllerPadState { + union { + u64 hex{}; + + // Buttons + BitField<0, 1, u64> a; + BitField<1, 1, u64> b; + BitField<2, 1, u64> x; + BitField<3, 1, u64> y; + BitField<4, 1, u64> lstick; + BitField<5, 1, u64> rstick; + BitField<6, 1, u64> l; + BitField<7, 1, u64> r; + BitField<8, 1, u64> zl; + BitField<9, 1, u64> zr; + BitField<10, 1, u64> plus; + BitField<11, 1, u64> minus; + + // D-pad buttons + BitField<12, 1, u64> dleft; + BitField<13, 1, u64> dup; + BitField<14, 1, u64> dright; + BitField<15, 1, u64> ddown; + + // Left stick directions + BitField<16, 1, u64> lstick_left; + BitField<17, 1, u64> lstick_up; + BitField<18, 1, u64> lstick_right; + BitField<19, 1, u64> lstick_down; + + // Right stick directions + BitField<20, 1, u64> rstick_left; + BitField<21, 1, u64> rstick_up; + BitField<22, 1, u64> rstick_right; + BitField<23, 1, u64> rstick_down; + + BitField<24, 1, u64> sl; + BitField<25, 1, u64> sr; + }; +}; + +struct ControllerInputEntry { + u64 timestamp; + u64 timestamp_2; + ControllerPadState buttons; + u32 joystickLeftX; + u32 joystickLeftY; + u32 joystickRightX; + u32 joystickRightY; + u64 connectionState; +}; +static_assert(sizeof(ControllerInputEntry) == 0x30, + "HID controller input entry structure has incorrect size"); + +struct ControllerLayout { + ControllerLayoutHeader header; + std::array entries; +}; +static_assert(sizeof(ControllerLayout) == 0x350, + "HID controller layout structure has incorrect size"); + +struct Controller { + ControllerHeader header; + std::array layouts; + std::array unk_1; + ControllerMAC macLeft; + ControllerMAC macRight; + std::array unk_2; +}; +static_assert(sizeof(Controller) == 0x5000, "HID controller structure has incorrect size"); + +// End Controller + +struct SharedMemory { + std::array header; + TouchScreen touchscreen; + Mouse mouse; + Keyboard keyboard; + std::array unkSection1; + std::array unkSection2; + std::array unkSection3; + std::array unkSection4; + std::array unkSection5; + std::array unkSection6; + std::array unkSection7; + std::array unkSection8; + std::array controllerSerials; + std::array controllers; + std::array unkSection9; +}; +static_assert(sizeof(SharedMemory) == 0x40000, "HID Shared Memory structure has incorrect size"); + /// Reload input devices. Used when input configuration changed void ReloadInputDevices(); diff --git a/src/core/settings.h b/src/core/settings.h index f2c88e5d40..bd9a3d9feb 100644 --- a/src/core/settings.h +++ b/src/core/settings.h @@ -16,52 +16,87 @@ enum Values { B, X, Y, - Up, - Down, - Left, - Right, + LStick, + RStick, L, R, - Start, - Select, - ZL, ZR, + Plus, + Minus, + + DLeft, + DUp, + DRight, + DDown, + + LStick_Left, + LStick_Up, + LStick_Right, + LStick_Down, + + RStick_Left, + RStick_Up, + RStick_Right, + RStick_Down, + + SL, + SR, Home, + Screenshot, NumButtons, }; constexpr int BUTTON_HID_BEGIN = A; -constexpr int BUTTON_IR_BEGIN = ZL; constexpr int BUTTON_NS_BEGIN = Home; -constexpr int BUTTON_HID_END = BUTTON_IR_BEGIN; -constexpr int BUTTON_IR_END = BUTTON_NS_BEGIN; +constexpr int BUTTON_HID_END = BUTTON_NS_BEGIN; constexpr int BUTTON_NS_END = NumButtons; constexpr int NUM_BUTTONS_HID = BUTTON_HID_END - BUTTON_HID_BEGIN; -constexpr int NUM_BUTTONS_IR = BUTTON_IR_END - BUTTON_IR_BEGIN; constexpr int NUM_BUTTONS_NS = BUTTON_NS_END - BUTTON_NS_BEGIN; static const std::array mapping = {{ - "button_a", "button_b", "button_x", "button_y", "button_up", "button_down", "button_left", - "button_right", "button_l", "button_r", "button_start", "button_select", "button_zl", - "button_zr", "button_home", + "button_a", + "button_b", + "button_x", + "button_y", + "button_lstick", + "button_rstick", + "button_l", + "button_r", + "button_zl", + "button_zr", + "button_plus", + "button_minus", + "button_dleft", + "button_dup", + "button_dright", + "button_ddown", + "button_lstick_left", + "button_lstick_up", + "button_lstick_right", + "button_lstick_down", + "button_sl", + "button_sr", + "button_home", + "button_screenshot", }}; } // namespace NativeButton namespace NativeAnalog { enum Values { - CirclePad, - CStick, + LStick, + RStick, NumAnalogs, }; static const std::array mapping = {{ - "circle_pad", "c_stick", + "lstick", + "rstick", }}; } // namespace NativeAnalog diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp index 4c713fcbc7..9ce851d174 100644 --- a/src/yuzu/configuration/config.cpp +++ b/src/yuzu/configuration/config.cpp @@ -19,16 +19,18 @@ Config::Config() { } const std::array Config::default_buttons = { - Qt::Key_A, Qt::Key_S, Qt::Key_Z, Qt::Key_X, Qt::Key_T, Qt::Key_G, Qt::Key_F, Qt::Key_H, - Qt::Key_Q, Qt::Key_W, Qt::Key_M, Qt::Key_N, Qt::Key_1, Qt::Key_2, Qt::Key_B, + Qt::Key_A, Qt::Key_S, Qt::Key_Z, Qt::Key_X, Qt::Key_3, Qt::Key_4, Qt::Key_Q, Qt::Key_W, + Qt::Key_1, Qt::Key_2, Qt::Key_N, Qt::Key_M, Qt::Key_F, Qt::Key_T, Qt::Key_H, Qt::Key_G, + Qt::Key_Left, Qt::Key_Up, Qt::Key_Right, Qt::Key_Down, Qt::Key_J, Qt::Key_I, Qt::Key_L, + Qt::Key_K, Qt::Key_D, Qt::Key_C, Qt::Key_B, Qt::Key_V, }; const std::array, Settings::NativeAnalog::NumAnalogs> Config::default_analogs{{ { - Qt::Key_Up, Qt::Key_Down, Qt::Key_Left, Qt::Key_Right, Qt::Key_D, + Qt::Key_Up, Qt::Key_Down, Qt::Key_Left, Qt::Key_Right, Qt::Key_E, }, { - Qt::Key_I, Qt::Key_K, Qt::Key_J, Qt::Key_L, Qt::Key_D, + Qt::Key_I, Qt::Key_K, Qt::Key_J, Qt::Key_L, Qt::Key_R, }, }}; diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp index 4c2a3e7380..d92a1fed9f 100644 --- a/src/yuzu/configuration/configure_input.cpp +++ b/src/yuzu/configuration/configure_input.cpp @@ -54,19 +54,23 @@ ConfigureInput::ConfigureInput(QWidget* parent) setFocusPolicy(Qt::ClickFocus); button_map = { - ui->buttonA, ui->buttonB, ui->buttonX, ui->buttonY, ui->buttonDpadUp, - ui->buttonDpadDown, ui->buttonDpadLeft, ui->buttonDpadRight, ui->buttonL, ui->buttonR, - ui->buttonStart, ui->buttonSelect, ui->buttonZL, ui->buttonZR, ui->buttonHome, + ui->buttonA, ui->buttonB, ui->buttonX, ui->buttonY, + ui->buttonLStick, ui->buttonRStick, ui->buttonL, ui->buttonR, + ui->buttonZL, ui->buttonZR, ui->buttonPlus, ui->buttonMinus, + ui->buttonDpadLeft, ui->buttonDpadUp, ui->buttonDpadRight, ui->buttonDpadDown, + ui->buttonLStickLeft, ui->buttonLStickUp, ui->buttonLStickRight, ui->buttonLStickDown, + ui->buttonRStickLeft, ui->buttonRStickUp, ui->buttonRStickRight, ui->buttonRStickDown, + ui->buttonSL, ui->buttonSR, ui->buttonHome, ui->buttonScreenshot, }; analog_map = {{ { - ui->buttonCircleUp, ui->buttonCircleDown, ui->buttonCircleLeft, ui->buttonCircleRight, - ui->buttonCircleMod, + ui->buttonLStickUp, ui->buttonLStickDown, ui->buttonLStickLeft, ui->buttonLStickRight, + ui->buttonLStickMod, }, { - ui->buttonCStickUp, ui->buttonCStickDown, ui->buttonCStickLeft, ui->buttonCStickRight, - nullptr, + ui->buttonRStickUp, ui->buttonRStickDown, ui->buttonRStickLeft, ui->buttonRStickRight, + ui->buttonRStickMod, }, }}; diff --git a/src/yuzu/configuration/configure_input.ui b/src/yuzu/configuration/configure_input.ui index 2760787e59..5143c9d725 100644 --- a/src/yuzu/configuration/configure_input.ui +++ b/src/yuzu/configuration/configure_input.ui @@ -6,8 +6,8 @@ 0 0 - 370 - 534 + 343 + 665 @@ -190,7 +190,108 @@ - + + + + Misc. + + + false + + + false + + + + + + + + Plus: + + + + + + + + + + + + + + + + + + Minus: + + + + + + + + + + + + + + + + + + Home: + + + + + + + + + + + + + + + + + + Screen +Capture: + + + + + + + + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Shoulder Buttons @@ -274,13 +375,49 @@ + + + + + + SL: + + + + + + + + + + + + + + + + + + SR: + + + + + + + + + + + + - + - Circle Pad + Left Stick false @@ -299,7 +436,7 @@ - + @@ -317,7 +454,7 @@ - + @@ -335,7 +472,7 @@ - + @@ -353,7 +490,43 @@ - + + + + + + + + + + + + + + Pressed: + + + + + + + + + + + + + + + + + + Modifier: + + + + + @@ -364,10 +537,13 @@ - + - C-Stick + Right Stick + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter false @@ -376,17 +552,17 @@ false - - + + - + - Left: + Down: - + @@ -404,7 +580,7 @@ - + @@ -422,7 +598,7 @@ - + @@ -430,50 +606,17 @@ - - - - - - Down: - - - - - - - - - - - - - - - - - - - Misc. - - - false - - - false - - - + - + - Start: + Left: - + @@ -481,17 +624,17 @@ - - + + - + - Select: + Modifier: - + @@ -499,35 +642,17 @@ - - + + - + - Home: + Pressed: - - - - - - - - - - - - - - Circle Mod: - - - - - + diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h index e7941ecebb..469df96cc1 100644 --- a/src/yuzu_cmd/default_ini.h +++ b/src/yuzu_cmd/default_ini.h @@ -30,17 +30,26 @@ button_a= button_b= button_x= button_y= -button_up= -button_down= -button_left= -button_right= +button_lstick= +button_rstick= button_l= button_r= -button_start= -button_select= button_zl= button_zr= +button_plus= +button_minus= +button_dleft= +button_dup= +button_dright= +button_ddown= +button_lstick_left= +button_lstick_up= +button_lstick_right= +button_lstick_down= +button_sl= +button_sr= button_home= +button_screenshot= # for analog input, the following devices are available: # - "analog_from_button" (default) for emulating analog input from direction buttons. Required parameters: @@ -53,8 +62,8 @@ button_home= # - "joystick": the index of the joystick to bind # - "axis_x": the index of the axis to bind as x-axis (default to 0) # - "axis_y": the index of the axis to bind as y-axis (default to 1) -circle_pad= -c_stick= +lstick= +rstick= # for motion input, the following devices are available: # - "motion_emu" (default) for emulating motion input from mouse input. Required parameters: