Mirrors/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[Ryujinx.Input] Address dotnet-format issues (#5384)

Browse source 
* dotnet format style --severity info

Some changes were manually reverted.

* dotnet format analyzers --serverity info

Some changes have been minimally adapted.

* Restore a few unused methods and variables

* Address dotnet format CA1816 warnings

* Address or silence dotnet format CA1806 and a few CA1854 warnings

* Address most dotnet format whitespace warnings

* Apply dotnet format whitespace formatting

A few of them have been manually reverted and the corresponding warning was silenced

* Add comments to disabled warnings

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* Remove redundant code, convert to auto-properties and fix naming rule violations

* Remove bogus change

* Address review feedback
This commit is contained in:
TSRBerry 2023-06-28 18:23:00 +02:00 committed by GitHub
parent 40f2bd37e3
commit 46b7c905f5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
24 changed files with 344 additions and 343 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
src/Ryujinx.Input/Assigner/GamepadButtonAssigner.cs
View file

@ -10,15 +10,15 @@ namespace Ryujinx.Input.Assigner
/// </summary> /// </summary>
public class GamepadButtonAssigner : IButtonAssigner public class GamepadButtonAssigner : IButtonAssigner
{ {
private IGamepad _gamepad; private readonly IGamepad _gamepad;
private GamepadStateSnapshot _currState; private GamepadStateSnapshot _currState;
private GamepadStateSnapshot _prevState; private GamepadStateSnapshot _prevState;
private JoystickButtonDetector _detector; private readonly JoystickButtonDetector _detector;
private bool _forStick; private readonly bool _forStick;
public GamepadButtonAssigner(IGamepad gamepad, float triggerThreshold, bool forStick) public GamepadButtonAssigner(IGamepad gamepad, float triggerThreshold, bool forStick)
{ {
@ -35,7 +35,7 @@ namespace Ryujinx.Input.Assigner
{ {
_currState = _gamepad.GetStateSnapshot(); _currState = _gamepad.GetStateSnapshot();
_prevState = _currState; _prevState = _currState;
} }
} }
public void ReadInput() public void ReadInput()
@ -116,7 +116,7 @@ namespace Ryujinx.Input.Assigner
private class JoystickButtonDetector private class JoystickButtonDetector
{ {
private Dictionary<GamepadButtonInputId, InputSummary> _stats; private readonly Dictionary<GamepadButtonInputId, InputSummary> _stats;
public JoystickButtonDetector() public JoystickButtonDetector()
{ {
@ -135,9 +135,8 @@ namespace Ryujinx.Input.Assigner
public void AddInput(GamepadButtonInputId button, float value) public void AddInput(GamepadButtonInputId button, float value)
{ {
InputSummary inputSummary;
if (!_stats.TryGetValue(button, out inputSummary)) if (!_stats.TryGetValue(button, out InputSummary inputSummary))
{ {
inputSummary = new InputSummary(); inputSummary = new InputSummary();
_stats.Add(button, inputSummary); _stats.Add(button, inputSummary);
@ -148,7 +147,7 @@ namespace Ryujinx.Input.Assigner
public override string ToString() public override string ToString()
{ {
StringWriter writer = new StringWriter(); StringWriter writer = new();
foreach (var kvp in _stats) foreach (var kvp in _stats)
{ {

2
src/Ryujinx.Input/Assigner/IButtonAssigner.cs
View file

@ -33,4 +33,4 @@ namespace Ryujinx.Input.Assigner
/// <returns>The pressed button that was read</returns> /// <returns>The pressed button that was read</returns>
string GetPressedButton(); string GetPressedButton();
} }
} }

4
src/Ryujinx.Input/Assigner/KeyboardKeyAssigner.cs
View file

@ -5,7 +5,7 @@ namespace Ryujinx.Input.Assigner
/// </summary> /// </summary>
public class KeyboardKeyAssigner : IButtonAssigner public class KeyboardKeyAssigner : IButtonAssigner
{ {
private IKeyboard _keyboard; private readonly IKeyboard _keyboard;
private KeyboardStateSnapshot _keyboardState; private KeyboardStateSnapshot _keyboardState;
@ -47,4 +47,4 @@ namespace Ryujinx.Input.Assigner
return !ShouldCancel() ? keyPressed : ""; return !ShouldCancel() ? keyPressed : "";
} }
} }
} }

2
src/Ryujinx.Input/GamepadButtonInputId.cs
View file

@ -52,6 +52,6 @@
SingleLeftTrigger1, SingleLeftTrigger1,
SingleRightTrigger1, SingleRightTrigger1,
Count Count,
} }
} }

2
src/Ryujinx.Input/GamepadFeaturesFlag.cs
View file

@ -23,6 +23,6 @@ namespace Ryujinx.Input
/// Motion /// Motion
/// <remarks>Also named sixaxis</remarks> /// <remarks>Also named sixaxis</remarks>
/// </summary> /// </summary>
Motion Motion,
} }
} }

3
src/Ryujinx.Input/HLE/InputManager.cs
View file

@ -25,7 +25,7 @@ namespace Ryujinx.Input.HLE
{ {
return new NpadManager(KeyboardDriver, GamepadDriver, MouseDriver); return new NpadManager(KeyboardDriver, GamepadDriver, MouseDriver);
} }
public TouchScreenManager CreateTouchScreenManager() public TouchScreenManager CreateTouchScreenManager()
{ {
if (MouseDriver == null) if (MouseDriver == null)
@ -48,6 +48,7 @@ namespace Ryujinx.Input.HLE
public void Dispose() public void Dispose()
{ {
GC.SuppressFinalize(this);
Dispose(true); Dispose(true);
} }
} }

352
src/Ryujinx.Input/HLE/NpadController.cs
View file

@ -8,7 +8,6 @@ using System;
using System.Collections.Concurrent; using System.Collections.Concurrent;
using System.Numerics; using System.Numerics;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using CemuHookClient = Ryujinx.Input.Motion.CemuHook.Client; using CemuHookClient = Ryujinx.Input.Motion.CemuHook.Client;
using ConfigControllerType = Ryujinx.Common.Configuration.Hid.ControllerType; using ConfigControllerType = Ryujinx.Common.Configuration.Hid.ControllerType;
@ -28,29 +27,28 @@ namespace Ryujinx.Input.HLE
} }
} }
private static readonly HLEButtonMappingEntry[] _hleButtonMapping = new HLEButtonMappingEntry[] private static readonly HLEButtonMappingEntry[] _hleButtonMapping = {
{ new(GamepadButtonInputId.A, ControllerKeys.A),
new HLEButtonMappingEntry(GamepadButtonInputId.A, ControllerKeys.A), new(GamepadButtonInputId.B, ControllerKeys.B),
new HLEButtonMappingEntry(GamepadButtonInputId.B, ControllerKeys.B), new(GamepadButtonInputId.X, ControllerKeys.X),
new HLEButtonMappingEntry(GamepadButtonInputId.X, ControllerKeys.X), new(GamepadButtonInputId.Y, ControllerKeys.Y),
new HLEButtonMappingEntry(GamepadButtonInputId.Y, ControllerKeys.Y), new(GamepadButtonInputId.LeftStick, ControllerKeys.LStick),
new HLEButtonMappingEntry(GamepadButtonInputId.LeftStick, ControllerKeys.LStick), new(GamepadButtonInputId.RightStick, ControllerKeys.RStick),
new HLEButtonMappingEntry(GamepadButtonInputId.RightStick, ControllerKeys.RStick), new(GamepadButtonInputId.LeftShoulder, ControllerKeys.L),
new HLEButtonMappingEntry(GamepadButtonInputId.LeftShoulder, ControllerKeys.L), new(GamepadButtonInputId.RightShoulder, ControllerKeys.R),
new HLEButtonMappingEntry(GamepadButtonInputId.RightShoulder, ControllerKeys.R), new(GamepadButtonInputId.LeftTrigger, ControllerKeys.Zl),
new HLEButtonMappingEntry(GamepadButtonInputId.LeftTrigger, ControllerKeys.Zl), new(GamepadButtonInputId.RightTrigger, ControllerKeys.Zr),
new HLEButtonMappingEntry(GamepadButtonInputId.RightTrigger, ControllerKeys.Zr), new(GamepadButtonInputId.DpadUp, ControllerKeys.DpadUp),
new HLEButtonMappingEntry(GamepadButtonInputId.DpadUp, ControllerKeys.DpadUp), new(GamepadButtonInputId.DpadDown, ControllerKeys.DpadDown),
new HLEButtonMappingEntry(GamepadButtonInputId.DpadDown, ControllerKeys.DpadDown), new(GamepadButtonInputId.DpadLeft, ControllerKeys.DpadLeft),
new HLEButtonMappingEntry(GamepadButtonInputId.DpadLeft, ControllerKeys.DpadLeft), new(GamepadButtonInputId.DpadRight, ControllerKeys.DpadRight),
new HLEButtonMappingEntry(GamepadButtonInputId.DpadRight, ControllerKeys.DpadRight), new(GamepadButtonInputId.Minus, ControllerKeys.Minus),
new HLEButtonMappingEntry(GamepadButtonInputId.Minus, ControllerKeys.Minus), new(GamepadButtonInputId.Plus, ControllerKeys.Plus),
new HLEButtonMappingEntry(GamepadButtonInputId.Plus, ControllerKeys.Plus),
new HLEButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0, ControllerKeys.SlLeft), new(GamepadButtonInputId.SingleLeftTrigger0, ControllerKeys.SlLeft),
new HLEButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger0, ControllerKeys.SrLeft), new(GamepadButtonInputId.SingleRightTrigger0, ControllerKeys.SrLeft),
new HLEButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger1, ControllerKeys.SlRight), new(GamepadButtonInputId.SingleLeftTrigger1, ControllerKeys.SlRight),
new HLEButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger1, ControllerKeys.SrRight), new(GamepadButtonInputId.SingleRightTrigger1, ControllerKeys.SrRight),
}; };
private class HLEKeyboardMappingEntry private class HLEKeyboardMappingEntry
@ -65,150 +63,147 @@ namespace Ryujinx.Input.HLE
} }
} }
private static readonly HLEKeyboardMappingEntry[] KeyMapping = new HLEKeyboardMappingEntry[] private static readonly HLEKeyboardMappingEntry[] _keyMapping = {
{ new(Key.A, 0x4),
new HLEKeyboardMappingEntry(Key.A, 0x4), new(Key.B, 0x5),
new HLEKeyboardMappingEntry(Key.B, 0x5), new(Key.C, 0x6),
new HLEKeyboardMappingEntry(Key.C, 0x6), new(Key.D, 0x7),
new HLEKeyboardMappingEntry(Key.D, 0x7), new(Key.E, 0x8),
new HLEKeyboardMappingEntry(Key.E, 0x8), new(Key.F, 0x9),
new HLEKeyboardMappingEntry(Key.F, 0x9), new(Key.G, 0xA),
new HLEKeyboardMappingEntry(Key.G, 0xA), new(Key.H, 0xB),
new HLEKeyboardMappingEntry(Key.H, 0xB), new(Key.I, 0xC),
new HLEKeyboardMappingEntry(Key.I, 0xC), new(Key.J, 0xD),
new HLEKeyboardMappingEntry(Key.J, 0xD), new(Key.K, 0xE),
new HLEKeyboardMappingEntry(Key.K, 0xE), new(Key.L, 0xF),
new HLEKeyboardMappingEntry(Key.L, 0xF), new(Key.M, 0x10),
new HLEKeyboardMappingEntry(Key.M, 0x10), new(Key.N, 0x11),
new HLEKeyboardMappingEntry(Key.N, 0x11), new(Key.O, 0x12),
new HLEKeyboardMappingEntry(Key.O, 0x12), new(Key.P, 0x13),
new HLEKeyboardMappingEntry(Key.P, 0x13), new(Key.Q, 0x14),
new HLEKeyboardMappingEntry(Key.Q, 0x14), new(Key.R, 0x15),
new HLEKeyboardMappingEntry(Key.R, 0x15), new(Key.S, 0x16),
new HLEKeyboardMappingEntry(Key.S, 0x16), new(Key.T, 0x17),
new HLEKeyboardMappingEntry(Key.T, 0x17), new(Key.U, 0x18),
new HLEKeyboardMappingEntry(Key.U, 0x18), new(Key.V, 0x19),
new HLEKeyboardMappingEntry(Key.V, 0x19), new(Key.W, 0x1A),
new HLEKeyboardMappingEntry(Key.W, 0x1A), new(Key.X, 0x1B),
new HLEKeyboardMappingEntry(Key.X, 0x1B), new(Key.Y, 0x1C),
new HLEKeyboardMappingEntry(Key.Y, 0x1C), new(Key.Z, 0x1D),
new HLEKeyboardMappingEntry(Key.Z, 0x1D),
new HLEKeyboardMappingEntry(Key.Number1, 0x1E), new(Key.Number1, 0x1E),
new HLEKeyboardMappingEntry(Key.Number2, 0x1F), new(Key.Number2, 0x1F),
new HLEKeyboardMappingEntry(Key.Number3, 0x20), new(Key.Number3, 0x20),
new HLEKeyboardMappingEntry(Key.Number4, 0x21), new(Key.Number4, 0x21),
new HLEKeyboardMappingEntry(Key.Number5, 0x22), new(Key.Number5, 0x22),
new HLEKeyboardMappingEntry(Key.Number6, 0x23), new(Key.Number6, 0x23),
new HLEKeyboardMappingEntry(Key.Number7, 0x24), new(Key.Number7, 0x24),
new HLEKeyboardMappingEntry(Key.Number8, 0x25), new(Key.Number8, 0x25),
new HLEKeyboardMappingEntry(Key.Number9, 0x26), new(Key.Number9, 0x26),
new HLEKeyboardMappingEntry(Key.Number0, 0x27), new(Key.Number0, 0x27),
new HLEKeyboardMappingEntry(Key.Enter, 0x28), new(Key.Enter, 0x28),
new HLEKeyboardMappingEntry(Key.Escape, 0x29), new(Key.Escape, 0x29),
new HLEKeyboardMappingEntry(Key.BackSpace, 0x2A), new(Key.BackSpace, 0x2A),
new HLEKeyboardMappingEntry(Key.Tab, 0x2B), new(Key.Tab, 0x2B),
new HLEKeyboardMappingEntry(Key.Space, 0x2C), new(Key.Space, 0x2C),
new HLEKeyboardMappingEntry(Key.Minus, 0x2D), new(Key.Minus, 0x2D),
new HLEKeyboardMappingEntry(Key.Plus, 0x2E), new(Key.Plus, 0x2E),
new HLEKeyboardMappingEntry(Key.BracketLeft, 0x2F), new(Key.BracketLeft, 0x2F),
new HLEKeyboardMappingEntry(Key.BracketRight, 0x30), new(Key.BracketRight, 0x30),
new HLEKeyboardMappingEntry(Key.BackSlash, 0x31), new(Key.BackSlash, 0x31),
new HLEKeyboardMappingEntry(Key.Tilde, 0x32), new(Key.Tilde, 0x32),
new HLEKeyboardMappingEntry(Key.Semicolon, 0x33), new(Key.Semicolon, 0x33),
new HLEKeyboardMappingEntry(Key.Quote, 0x34), new(Key.Quote, 0x34),
new HLEKeyboardMappingEntry(Key.Grave, 0x35), new(Key.Grave, 0x35),
new HLEKeyboardMappingEntry(Key.Comma, 0x36), new(Key.Comma, 0x36),
new HLEKeyboardMappingEntry(Key.Period, 0x37), new(Key.Period, 0x37),
new HLEKeyboardMappingEntry(Key.Slash, 0x38), new(Key.Slash, 0x38),
new HLEKeyboardMappingEntry(Key.CapsLock, 0x39), new(Key.CapsLock, 0x39),
new HLEKeyboardMappingEntry(Key.F1, 0x3a), new(Key.F1, 0x3a),
new HLEKeyboardMappingEntry(Key.F2, 0x3b), new(Key.F2, 0x3b),
new HLEKeyboardMappingEntry(Key.F3, 0x3c), new(Key.F3, 0x3c),
new HLEKeyboardMappingEntry(Key.F4, 0x3d), new(Key.F4, 0x3d),
new HLEKeyboardMappingEntry(Key.F5, 0x3e), new(Key.F5, 0x3e),
new HLEKeyboardMappingEntry(Key.F6, 0x3f), new(Key.F6, 0x3f),
new HLEKeyboardMappingEntry(Key.F7, 0x40), new(Key.F7, 0x40),
new HLEKeyboardMappingEntry(Key.F8, 0x41), new(Key.F8, 0x41),
new HLEKeyboardMappingEntry(Key.F9, 0x42), new(Key.F9, 0x42),
new HLEKeyboardMappingEntry(Key.F10, 0x43), new(Key.F10, 0x43),
new HLEKeyboardMappingEntry(Key.F11, 0x44), new(Key.F11, 0x44),
new HLEKeyboardMappingEntry(Key.F12, 0x45), new(Key.F12, 0x45),
new HLEKeyboardMappingEntry(Key.PrintScreen, 0x46), new(Key.PrintScreen, 0x46),
new HLEKeyboardMappingEntry(Key.ScrollLock, 0x47), new(Key.ScrollLock, 0x47),
new HLEKeyboardMappingEntry(Key.Pause, 0x48), new(Key.Pause, 0x48),
new HLEKeyboardMappingEntry(Key.Insert, 0x49), new(Key.Insert, 0x49),
new HLEKeyboardMappingEntry(Key.Home, 0x4A), new(Key.Home, 0x4A),
new HLEKeyboardMappingEntry(Key.PageUp, 0x4B), new(Key.PageUp, 0x4B),
new HLEKeyboardMappingEntry(Key.Delete, 0x4C), new(Key.Delete, 0x4C),
new HLEKeyboardMappingEntry(Key.End, 0x4D), new(Key.End, 0x4D),
new HLEKeyboardMappingEntry(Key.PageDown, 0x4E), new(Key.PageDown, 0x4E),
new HLEKeyboardMappingEntry(Key.Right, 0x4F), new(Key.Right, 0x4F),
new HLEKeyboardMappingEntry(Key.Left, 0x50), new(Key.Left, 0x50),
new HLEKeyboardMappingEntry(Key.Down, 0x51), new(Key.Down, 0x51),
new HLEKeyboardMappingEntry(Key.Up, 0x52), new(Key.Up, 0x52),
new HLEKeyboardMappingEntry(Key.NumLock, 0x53), new(Key.NumLock, 0x53),
new HLEKeyboardMappingEntry(Key.KeypadDivide, 0x54), new(Key.KeypadDivide, 0x54),
new HLEKeyboardMappingEntry(Key.KeypadMultiply, 0x55), new(Key.KeypadMultiply, 0x55),
new HLEKeyboardMappingEntry(Key.KeypadSubtract, 0x56), new(Key.KeypadSubtract, 0x56),
new HLEKeyboardMappingEntry(Key.KeypadAdd, 0x57), new(Key.KeypadAdd, 0x57),
new HLEKeyboardMappingEntry(Key.KeypadEnter, 0x58), new(Key.KeypadEnter, 0x58),
new HLEKeyboardMappingEntry(Key.Keypad1, 0x59), new(Key.Keypad1, 0x59),
new HLEKeyboardMappingEntry(Key.Keypad2, 0x5A), new(Key.Keypad2, 0x5A),
new HLEKeyboardMappingEntry(Key.Keypad3, 0x5B), new(Key.Keypad3, 0x5B),
new HLEKeyboardMappingEntry(Key.Keypad4, 0x5C), new(Key.Keypad4, 0x5C),
new HLEKeyboardMappingEntry(Key.Keypad5, 0x5D), new(Key.Keypad5, 0x5D),
new HLEKeyboardMappingEntry(Key.Keypad6, 0x5E), new(Key.Keypad6, 0x5E),
new HLEKeyboardMappingEntry(Key.Keypad7, 0x5F), new(Key.Keypad7, 0x5F),
new HLEKeyboardMappingEntry(Key.Keypad8, 0x60), new(Key.Keypad8, 0x60),
new HLEKeyboardMappingEntry(Key.Keypad9, 0x61), new(Key.Keypad9, 0x61),
new HLEKeyboardMappingEntry(Key.Keypad0, 0x62), new(Key.Keypad0, 0x62),
new HLEKeyboardMappingEntry(Key.KeypadDecimal, 0x63), new(Key.KeypadDecimal, 0x63),
new HLEKeyboardMappingEntry(Key.F13, 0x68), new(Key.F13, 0x68),
new HLEKeyboardMappingEntry(Key.F14, 0x69), new(Key.F14, 0x69),
new HLEKeyboardMappingEntry(Key.F15, 0x6A), new(Key.F15, 0x6A),
new HLEKeyboardMappingEntry(Key.F16, 0x6B), new(Key.F16, 0x6B),
new HLEKeyboardMappingEntry(Key.F17, 0x6C), new(Key.F17, 0x6C),
new HLEKeyboardMappingEntry(Key.F18, 0x6D), new(Key.F18, 0x6D),
new HLEKeyboardMappingEntry(Key.F19, 0x6E), new(Key.F19, 0x6E),
new HLEKeyboardMappingEntry(Key.F20, 0x6F), new(Key.F20, 0x6F),
new HLEKeyboardMappingEntry(Key.F21, 0x70), new(Key.F21, 0x70),
new HLEKeyboardMappingEntry(Key.F22, 0x71), new(Key.F22, 0x71),
new HLEKeyboardMappingEntry(Key.F23, 0x72), new(Key.F23, 0x72),
new HLEKeyboardMappingEntry(Key.F24, 0x73), new(Key.F24, 0x73),
new HLEKeyboardMappingEntry(Key.ControlLeft, 0xE0), new(Key.ControlLeft, 0xE0),
new HLEKeyboardMappingEntry(Key.ShiftLeft, 0xE1), new(Key.ShiftLeft, 0xE1),
new HLEKeyboardMappingEntry(Key.AltLeft, 0xE2), new(Key.AltLeft, 0xE2),
new HLEKeyboardMappingEntry(Key.WinLeft, 0xE3), new(Key.WinLeft, 0xE3),
new HLEKeyboardMappingEntry(Key.ControlRight, 0xE4), new(Key.ControlRight, 0xE4),
new HLEKeyboardMappingEntry(Key.ShiftRight, 0xE5), new(Key.ShiftRight, 0xE5),
new HLEKeyboardMappingEntry(Key.AltRight, 0xE6), new(Key.AltRight, 0xE6),
new HLEKeyboardMappingEntry(Key.WinRight, 0xE7), new(Key.WinRight, 0xE7),
}; };
private static readonly HLEKeyboardMappingEntry[] KeyModifierMapping = new HLEKeyboardMappingEntry[] private static readonly HLEKeyboardMappingEntry[] _keyModifierMapping = {
{ new(Key.ControlLeft, 0),
new HLEKeyboardMappingEntry(Key.ControlLeft, 0), new(Key.ShiftLeft, 1),
new HLEKeyboardMappingEntry(Key.ShiftLeft, 1), new(Key.AltLeft, 2),
new HLEKeyboardMappingEntry(Key.AltLeft, 2), new(Key.WinLeft, 3),
new HLEKeyboardMappingEntry(Key.WinLeft, 3), new(Key.ControlRight, 4),
new HLEKeyboardMappingEntry(Key.ControlRight, 4), new(Key.ShiftRight, 5),
new HLEKeyboardMappingEntry(Key.ShiftRight, 5), new(Key.AltRight, 6),
new HLEKeyboardMappingEntry(Key.AltRight, 6), new(Key.WinRight, 7),
new HLEKeyboardMappingEntry(Key.WinRight, 7), new(Key.CapsLock, 8),
new HLEKeyboardMappingEntry(Key.CapsLock, 8), new(Key.ScrollLock, 9),
new HLEKeyboardMappingEntry(Key.ScrollLock, 9), new(Key.NumLock, 10),
new HLEKeyboardMappingEntry(Key.NumLock, 10),
}; };
private bool _isValid; private bool _isValid;
private string _id;
private MotionInput _leftMotionInput; private MotionInput _leftMotionInput;
private MotionInput _rightMotionInput; private MotionInput _rightMotionInput;
@ -219,14 +214,14 @@ namespace Ryujinx.Input.HLE
public IGamepadDriver GamepadDriver { get; private set; } public IGamepadDriver GamepadDriver { get; private set; }
public GamepadStateSnapshot State { get; private set; } public GamepadStateSnapshot State { get; private set; }
public string Id => _id; public string Id { get; private set; }
private CemuHookClient _cemuHookClient; private readonly CemuHookClient _cemuHookClient;
public NpadController(CemuHookClient cemuHookClient) public NpadController(CemuHookClient cemuHookClient)
{ {
State = default; State = default;
_id = null; Id = null;
_isValid = false; _isValid = false;
_cemuHookClient = cemuHookClient; _cemuHookClient = cemuHookClient;
} }
@ -237,8 +232,8 @@ namespace Ryujinx.Input.HLE
_gamepad?.Dispose(); _gamepad?.Dispose();
_id = config.Id; Id = config.Id;
_gamepad = GamepadDriver.GetGamepad(_id); _gamepad = GamepadDriver.GetGamepad(Id);
_isValid = _gamepad != null; _isValid = _gamepad != null;
UpdateUserConfiguration(config); UpdateUserConfiguration(config);
@ -278,7 +273,7 @@ namespace Ryujinx.Input.HLE
if (motionConfig.MotionBackend != MotionInputBackendType.CemuHook) if (motionConfig.MotionBackend != MotionInputBackendType.CemuHook)
{ {
_leftMotionInput = new MotionInput(); _leftMotionInput = new MotionInput();
} }
else else
{ {
_leftMotionInput = null; _leftMotionInput = null;
@ -347,7 +342,7 @@ namespace Ryujinx.Input.HLE
public GamepadInput GetHLEInputState() public GamepadInput GetHLEInputState()
{ {
GamepadInput state = new GamepadInput(); GamepadInput state = new();
// First update all buttons // First update all buttons
foreach (HLEButtonMappingEntry entry in _hleButtonMapping) foreach (HLEButtonMappingEntry entry in _hleButtonMapping)
@ -366,13 +361,13 @@ namespace Ryujinx.Input.HLE
state.LStick = new JoystickPosition state.LStick = new JoystickPosition
{ {
Dx = ClampAxis(leftAxisX), Dx = ClampAxis(leftAxisX),
Dy = ClampAxis(leftAxisY) Dy = ClampAxis(leftAxisY),
}; };
state.RStick = new JoystickPosition state.RStick = new JoystickPosition
{ {
Dx = ClampAxis(rightAxisX), Dx = ClampAxis(rightAxisX),
Dy = ClampAxis(rightAxisY) Dy = ClampAxis(rightAxisY),
}; };
} }
else if (_config is StandardControllerInputConfig controllerConfig) else if (_config is StandardControllerInputConfig controllerConfig)
@ -391,16 +386,16 @@ namespace Ryujinx.Input.HLE
private static JoystickPosition ApplyDeadzone(float x, float y, float deadzone) private static JoystickPosition ApplyDeadzone(float x, float y, float deadzone)
{ {
float magnitudeClamped = Math.Min(MathF.Sqrt(x * x + y * y), 1f); float magnitudeClamped = Math.Min(MathF.Sqrt(x * x + y * y), 1f);
if (magnitudeClamped <= deadzone) if (magnitudeClamped <= deadzone)
{ {
return new JoystickPosition() {Dx = 0, Dy = 0}; return new JoystickPosition { Dx = 0, Dy = 0 };
} }
return new JoystickPosition() return new JoystickPosition
{ {
Dx = ClampAxis((x / magnitudeClamped) * ((magnitudeClamped - deadzone) / (1 - deadzone))), Dx = ClampAxis((x / magnitudeClamped) * ((magnitudeClamped - deadzone) / (1 - deadzone))),
Dy = ClampAxis((y / magnitudeClamped) * ((magnitudeClamped - deadzone) / (1 - deadzone))) Dy = ClampAxis((y / magnitudeClamped) * ((magnitudeClamped - deadzone) / (1 - deadzone))),
}; };
} }
@ -428,7 +423,7 @@ namespace Ryujinx.Input.HLE
return new JoystickPosition return new JoystickPosition
{ {
Dx = (int)point.X, Dx = (int)point.X,
Dy = (int)point.Y Dy = (int)point.Y,
}; };
} }
@ -476,12 +471,12 @@ namespace Ryujinx.Input.HLE
rotation = new Vector3(); rotation = new Vector3();
} }
return new SixAxisInput() return new SixAxisInput
{ {
Accelerometer = accelerometer, Accelerometer = accelerometer,
Gyroscope = gyroscope, Gyroscope = gyroscope,
Rotation = rotation, Rotation = rotation,
Orientation = orientationForHLE Orientation = orientationForHLE,
}; };
} }
@ -502,20 +497,20 @@ namespace Ryujinx.Input.HLE
{ {
KeyboardStateSnapshot keyboardState = keyboard.GetKeyboardStateSnapshot(); KeyboardStateSnapshot keyboardState = keyboard.GetKeyboardStateSnapshot();
KeyboardInput hidKeyboard = new KeyboardInput KeyboardInput hidKeyboard = new()
{ {
Modifier = 0, Modifier = 0,
Keys = new ulong[0x4] Keys = new ulong[0x4],
}; };
foreach (HLEKeyboardMappingEntry entry in KeyMapping) foreach (HLEKeyboardMappingEntry entry in _keyMapping)
{ {
ulong value = keyboardState.IsPressed(entry.TargetKey) ? 1UL : 0UL; ulong value = keyboardState.IsPressed(entry.TargetKey) ? 1UL : 0UL;
hidKeyboard.Keys[entry.Target / 0x40] |= (value << (entry.Target % 0x40)); hidKeyboard.Keys[entry.Target / 0x40] |= (value << (entry.Target % 0x40));
} }
foreach (HLEKeyboardMappingEntry entry in KeyModifierMapping) foreach (HLEKeyboardMappingEntry entry in _keyModifierMapping)
{ {
int value = keyboardState.IsPressed(entry.TargetKey) ? 1 : 0; int value = keyboardState.IsPressed(entry.TargetKey) ? 1 : 0;
@ -539,6 +534,7 @@ namespace Ryujinx.Input.HLE
public void Dispose() public void Dispose()
{ {
GC.SuppressFinalize(this);
Dispose(true); Dispose(true);
} }

33
src/Ryujinx.Input/HLE/NpadManager.cs
View file

@ -7,13 +7,15 @@ using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using CemuHookClient = Ryujinx.Input.Motion.CemuHook.Client; using CemuHookClient = Ryujinx.Input.Motion.CemuHook.Client;
using ControllerType = Ryujinx.Common.Configuration.Hid.ControllerType;
using PlayerIndex = Ryujinx.HLE.HOS.Services.Hid.PlayerIndex;
using Switch = Ryujinx.HLE.Switch; using Switch = Ryujinx.HLE.Switch;
namespace Ryujinx.Input.HLE namespace Ryujinx.Input.HLE
{ {
public class NpadManager : IDisposable public class NpadManager : IDisposable
{ {
private CemuHookClient _cemuHookClient; private readonly CemuHookClient _cemuHookClient;
private readonly object _lock = new(); private readonly object _lock = new();
@ -21,7 +23,7 @@ namespace Ryujinx.Input.HLE
private const int MaxControllers = 9; private const int MaxControllers = 9;
private NpadController[] _controllers; private readonly NpadController[] _controllers;
private readonly IGamepadDriver _keyboardDriver; private readonly IGamepadDriver _keyboardDriver;
private readonly IGamepadDriver _gamepadDriver; private readonly IGamepadDriver _gamepadDriver;
@ -51,7 +53,7 @@ namespace Ryujinx.Input.HLE
{ {
lock (_lock) lock (_lock)
{ {
List<InputConfig> validInputs = new List<InputConfig>(); List<InputConfig> validInputs = new();
foreach (var inputConfigEntry in _inputConfig) foreach (var inputConfigEntry in _inputConfig)
{ {
if (_controllers[(int)inputConfigEntry.PlayerIndex] != null) if (_controllers[(int)inputConfigEntry.PlayerIndex] != null)
@ -96,10 +98,8 @@ namespace Ryujinx.Input.HLE
{ {
return controller.UpdateDriverConfiguration(targetDriver, config); return controller.UpdateDriverConfiguration(targetDriver, config);
} }
else
{ return controller.GamepadDriver != null;
return controller.GamepadDriver != null;
}
} }
public void ReloadConfiguration(List<InputConfig> inputConfig, bool enableKeyboard, bool enableMouse) public void ReloadConfiguration(List<InputConfig> inputConfig, bool enableKeyboard, bool enableMouse)
@ -112,11 +112,11 @@ namespace Ryujinx.Input.HLE
_controllers[i] = null; _controllers[i] = null;
} }
List<InputConfig> validInputs = new List<InputConfig>(); List<InputConfig> validInputs = new();
foreach (InputConfig inputConfigEntry in inputConfig) foreach (InputConfig inputConfigEntry in inputConfig)
{ {
NpadController controller = new NpadController(_cemuHookClient); NpadController controller = new(_cemuHookClient);
bool isValid = DriverConfigurationUpdate(ref controller, inputConfigEntry); bool isValid = DriverConfigurationUpdate(ref controller, inputConfigEntry);
@ -131,9 +131,9 @@ namespace Ryujinx.Input.HLE
} }
} }
_inputConfig = inputConfig; _inputConfig = inputConfig;
_enableKeyboard = enableKeyboard; _enableKeyboard = enableKeyboard;
_enableMouse = enableMouse; _enableMouse = enableMouse;
_device.Hid.RefreshInputConfig(validInputs); _device.Hid.RefreshInputConfig(validInputs);
} }
@ -167,8 +167,8 @@ namespace Ryujinx.Input.HLE
{ {
lock (_lock) lock (_lock)
{ {
List<GamepadInput> hleInputStates = new List<GamepadInput>(); List<GamepadInput> hleInputStates = new();
List<SixAxisInput> hleMotionStates = new List<SixAxisInput>(NpadDevices.MaxControllers); List<SixAxisInput> hleMotionStates = new(NpadDevices.MaxControllers);
KeyboardInput? hleKeyboardInput = null; KeyboardInput? hleKeyboardInput = null;
@ -178,7 +178,7 @@ namespace Ryujinx.Input.HLE
(SixAxisInput, SixAxisInput) motionState = default; (SixAxisInput, SixAxisInput) motionState = default;
NpadController controller = _controllers[(int)inputConfig.PlayerIndex]; NpadController controller = _controllers[(int)inputConfig.PlayerIndex];
Ryujinx.HLE.HOS.Services.Hid.PlayerIndex playerIndex = (Ryujinx.HLE.HOS.Services.Hid.PlayerIndex)inputConfig.PlayerIndex; PlayerIndex playerIndex = (PlayerIndex)inputConfig.PlayerIndex;
bool isJoyconPair = false; bool isJoyconPair = false;
@ -195,7 +195,7 @@ namespace Ryujinx.Input.HLE
inputState.Buttons |= _device.Hid.UpdateStickButtons(inputState.LStick, inputState.RStick); inputState.Buttons |= _device.Hid.UpdateStickButtons(inputState.LStick, inputState.RStick);
isJoyconPair = inputConfig.ControllerType == Common.Configuration.Hid.ControllerType.JoyconPair; isJoyconPair = inputConfig.ControllerType == ControllerType.JoyconPair;
var altMotionState = isJoyconPair ? controller.GetHLEMotionState(true) : default; var altMotionState = isJoyconPair ? controller.GetHLEMotionState(true) : default;
@ -284,7 +284,7 @@ namespace Ryujinx.Input.HLE
{ {
lock (_lock) lock (_lock)
{ {
return _inputConfig.Find(x => x.PlayerIndex == (Ryujinx.Common.Configuration.Hid.PlayerIndex)index); return _inputConfig.Find(x => x.PlayerIndex == (Common.Configuration.Hid.PlayerIndex)index);
} }
} }
@ -314,6 +314,7 @@ namespace Ryujinx.Input.HLE
public void Dispose() public void Dispose()
{ {
GC.SuppressFinalize(this);
Dispose(true); Dispose(true);
} }
} }

15
src/Ryujinx.Input/HLE/TouchScreenManager.cs
View file

@ -31,7 +31,7 @@ namespace Ryujinx.Input.HLE
MouseStateSnapshot snapshot = IMouse.GetMouseStateSnapshot(_mouse); MouseStateSnapshot snapshot = IMouse.GetMouseStateSnapshot(_mouse);
var touchPosition = IMouse.GetScreenPosition(snapshot.Position, _mouse.ClientSize, aspectRatio); var touchPosition = IMouse.GetScreenPosition(snapshot.Position, _mouse.ClientSize, aspectRatio);
TouchPoint currentPoint = new TouchPoint TouchPoint currentPoint = new()
{ {
Attribute = TouchAttribute.End, Attribute = TouchAttribute.End,
@ -41,7 +41,7 @@ namespace Ryujinx.Input.HLE
// Placeholder values till more data is acquired // Placeholder values till more data is acquired
DiameterX = 10, DiameterX = 10,
DiameterY = 10, DiameterY = 10,
Angle = 90 Angle = 90,
}; };
_device.Hid.Touchscreen.Update(currentPoint); _device.Hid.Touchscreen.Update(currentPoint);
@ -71,7 +71,7 @@ namespace Ryujinx.Input.HLE
attribute = TouchAttribute.End; attribute = TouchAttribute.End;
} }
TouchPoint currentPoint = new TouchPoint TouchPoint currentPoint = new()
{ {
Attribute = attribute, Attribute = attribute,
@ -81,7 +81,7 @@ namespace Ryujinx.Input.HLE
// Placeholder values till more data is acquired // Placeholder values till more data is acquired
DiameterX = 10, DiameterX = 10,
DiameterY = 10, DiameterY = 10,
Angle = 90 Angle = 90,
}; };
_device.Hid.Touchscreen.Update(currentPoint); _device.Hid.Touchscreen.Update(currentPoint);
@ -94,6 +94,9 @@ namespace Ryujinx.Input.HLE
return false; return false;
} }
public void Dispose() { } public void Dispose()
{
GC.SuppressFinalize(this);
}
} }
} }

4
src/Ryujinx.Input/IMouse.cs
View file

@ -8,7 +8,9 @@ namespace Ryujinx.Input
/// </summary> /// </summary>
public interface IMouse : IGamepad public interface IMouse : IGamepad
{ {
#pragma warning disable IDE0051 // Remove unused private member
private const int SwitchPanelWidth = 1280; private const int SwitchPanelWidth = 1280;
#pragma warning restore IDE0051
private const int SwitchPanelHeight = 720; private const int SwitchPanelHeight = 720;
/// <summary> /// <summary>
@ -101,4 +103,4 @@ namespace Ryujinx.Input
return new Vector2(); return new Vector2();
} }
} }
} }

4
src/Ryujinx.Input/Key.cs
View file

@ -137,6 +137,6 @@
BackSlash, BackSlash,
Unbound, Unbound,
Count Count,
} }
} }

2
src/Ryujinx.Input/KeyboardStateSnapshot.cs
View file

@ -7,7 +7,7 @@ namespace Ryujinx.Input
/// </summary> /// </summary>
public class KeyboardStateSnapshot public class KeyboardStateSnapshot
{ {
private bool[] _keysState; private readonly bool[] _keysState;
/// <summary> /// <summary>
/// Create a new <see cref="KeyboardStateSnapshot"/>. /// Create a new <see cref="KeyboardStateSnapshot"/>.

157
src/Ryujinx.Input/Motion/CemuHook/Client.cs
View file

@ -19,7 +19,7 @@ namespace Ryujinx.Input.Motion.CemuHook
{ {
public class Client : IDisposable public class Client : IDisposable
{ {
public const uint Magic = 0x43555344; // DSUC public const uint Magic = 0x43555344; // DSUC
public const ushort Version = 1001; public const ushort Version = 1001;
private bool _active; private bool _active;
@ -29,15 +29,15 @@ namespace Ryujinx.Input.Motion.CemuHook
private readonly Dictionary<int, UdpClient> _clients; private readonly Dictionary<int, UdpClient> _clients;
private readonly bool[] _clientErrorStatus = new bool[Enum.GetValues<PlayerIndex>().Length]; private readonly bool[] _clientErrorStatus = new bool[Enum.GetValues<PlayerIndex>().Length];
private readonly long[] _clientRetryTimer = new long[Enum.GetValues<PlayerIndex>().Length]; private readonly long[] _clientRetryTimer = new long[Enum.GetValues<PlayerIndex>().Length];
private NpadManager _npadManager; private readonly NpadManager _npadManager;
public Client(NpadManager npadManager) public Client(NpadManager npadManager)
{ {
_npadManager = npadManager; _npadManager = npadManager;
_hosts = new Dictionary<int, IPEndPoint>(); _hosts = new Dictionary<int, IPEndPoint>();
_motionData = new Dictionary<int, Dictionary<int, MotionInput>>(); _motionData = new Dictionary<int, Dictionary<int, MotionInput>>();
_clients = new Dictionary<int, UdpClient>(); _clients = new Dictionary<int, UdpClient>();
CloseClients(); CloseClients();
} }
@ -84,7 +84,7 @@ namespace Ryujinx.Input.Motion.CemuHook
try try
{ {
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(host), port); IPEndPoint endPoint = new(IPAddress.Parse(host), port);
client = new UdpClient(host, port); client = new UdpClient(host, port);
@ -141,9 +141,9 @@ namespace Ryujinx.Input.Motion.CemuHook
{ {
lock (_motionData) lock (_motionData)
{ {
if (_motionData.ContainsKey(player)) if (_motionData.TryGetValue(player, out Dictionary<int, MotionInput> value))
{ {
if (_motionData[player].TryGetValue(slot, out input)) if (value.TryGetValue(slot, out input))
{ {
return true; return true;
} }
@ -164,26 +164,26 @@ namespace Ryujinx.Input.Motion.CemuHook
private void Send(byte[] data, int clientId) private void Send(byte[] data, int clientId)
{ {
if (_clients.TryGetValue(clientId, out UdpClient _client)) if (_clients.TryGetValue(clientId, out UdpClient client))
{ {
if (_client != null && _client.Client != null && _client.Client.Connected) if (client != null && client.Client != null && client.Client.Connected)
{ {
try try
{ {
_client?.Send(data, data.Length); client?.Send(data, data.Length);
} }
catch (SocketException socketException) catch (SocketException socketException)
{ {
if (!_clientErrorStatus[clientId]) if (!_clientErrorStatus[clientId])
{ {
Logger.Warning?.PrintMsg(LogClass.Hid, $"Unable to send data request to motion source at {_client.Client.RemoteEndPoint}. Error: {socketException.ErrorCode}"); Logger.Warning?.PrintMsg(LogClass.Hid, $"Unable to send data request to motion source at {client.Client.RemoteEndPoint}. Error: {socketException.ErrorCode}");
} }
_clientErrorStatus[clientId] = true; _clientErrorStatus[clientId] = true;
RemoveClient(clientId); RemoveClient(clientId);
_client?.Dispose(); client?.Dispose();
SetRetryTimer(clientId); SetRetryTimer(clientId);
} }
@ -193,7 +193,7 @@ namespace Ryujinx.Input.Motion.CemuHook
RemoveClient(clientId); RemoveClient(clientId);
_client?.Dispose(); client?.Dispose();
SetRetryTimer(clientId); SetRetryTimer(clientId);
} }
@ -203,13 +203,13 @@ namespace Ryujinx.Input.Motion.CemuHook
private byte[] Receive(int clientId, int timeout = 0) private byte[] Receive(int clientId, int timeout = 0)
{ {
if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient _client)) if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient client))
{ {
if (_client != null && _client.Client != null && _client.Client.Connected) if (client != null && client.Client != null && client.Client.Connected)
{ {
_client.Client.ReceiveTimeout = timeout; client.Client.ReceiveTimeout = timeout;
var result = _client?.Receive(ref endPoint); var result = client?.Receive(ref endPoint);
if (result.Length > 0) if (result.Length > 0)
{ {
@ -242,9 +242,9 @@ namespace Ryujinx.Input.Motion.CemuHook
public void ReceiveLoop(int clientId) public void ReceiveLoop(int clientId)
{ {
if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient _client)) if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient client))
{ {
if (_client != null && _client.Client != null && _client.Client.Connected) if (client != null && client.Client != null && client.Client.Connected)
{ {
try try
{ {
@ -271,7 +271,7 @@ namespace Ryujinx.Input.Motion.CemuHook
RemoveClient(clientId); RemoveClient(clientId);
_client?.Dispose(); client?.Dispose();
SetRetryTimer(clientId); SetRetryTimer(clientId);
} }
@ -281,7 +281,7 @@ namespace Ryujinx.Input.Motion.CemuHook
RemoveClient(clientId); RemoveClient(clientId);
_client?.Dispose(); client?.Dispose();
SetRetryTimer(clientId); SetRetryTimer(clientId);
} }
@ -297,8 +297,8 @@ namespace Ryujinx.Input.Motion.CemuHook
data = data.AsSpan()[16..].ToArray(); data = data.AsSpan()[16..].ToArray();
using MemoryStream stream = new MemoryStream(data); using MemoryStream stream = new(data);
using BinaryReader reader = new BinaryReader(stream); using BinaryReader reader = new(stream);
switch (type) switch (type)
{ {
@ -310,18 +310,18 @@ namespace Ryujinx.Input.Motion.CemuHook
case MessageType.Data: case MessageType.Data:
ControllerDataResponse inputData = reader.ReadStruct<ControllerDataResponse>(); ControllerDataResponse inputData = reader.ReadStruct<ControllerDataResponse>();
Vector3 accelerometer = new Vector3() Vector3 accelerometer = new()
{ {
X = -inputData.AccelerometerX, X = -inputData.AccelerometerX,
Y = inputData.AccelerometerZ, Y = inputData.AccelerometerZ,
Z = -inputData.AccelerometerY Z = -inputData.AccelerometerY,
}; };
Vector3 gyroscrope = new Vector3() Vector3 gyroscrope = new()
{ {
X = inputData.GyroscopePitch, X = inputData.GyroscopePitch,
Y = inputData.GyroscopeRoll, Y = inputData.GyroscopeRoll,
Z = -inputData.GyroscopeYaw Z = -inputData.GyroscopeYaw,
}; };
ulong timestamp = inputData.MotionTimestamp; ulong timestamp = inputData.MotionTimestamp;
@ -346,7 +346,7 @@ namespace Ryujinx.Input.Motion.CemuHook
} }
else else
{ {
MotionInput input = new MotionInput(); MotionInput input = new();
input.Update(accelerometer, gyroscrope, timestamp, cemuHookConfig.Sensitivity, (float)cemuHookConfig.GyroDeadzone); input.Update(accelerometer, gyroscrope, timestamp, cemuHookConfig.Sensitivity, (float)cemuHookConfig.GyroDeadzone);
@ -355,11 +355,11 @@ namespace Ryujinx.Input.Motion.CemuHook
} }
else else
{ {
MotionInput input = new MotionInput(); MotionInput input = new();
input.Update(accelerometer, gyroscrope, timestamp, cemuHookConfig.Sensitivity, (float)cemuHookConfig.GyroDeadzone); input.Update(accelerometer, gyroscrope, timestamp, cemuHookConfig.Sensitivity, (float)cemuHookConfig.GyroDeadzone);
_motionData.Add(clientId, new Dictionary<int, MotionInput>() { { slot, input } }); _motionData.Add(clientId, new Dictionary<int, MotionInput> { { slot, input } });
} }
} }
else else
@ -380,38 +380,37 @@ namespace Ryujinx.Input.Motion.CemuHook
Header header = GenerateHeader(clientId); Header header = GenerateHeader(clientId);
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream()) using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
writer.WriteStruct(header);
ControllerInfoRequest request = new()
{ {
writer.WriteStruct(header); Type = MessageType.Info,
PortsCount = 4,
};
ControllerInfoRequest request = new ControllerInfoRequest() request.PortIndices[0] = (byte)slot;
{
Type = MessageType.Info,
PortsCount = 4
};
request.PortIndices[0] = (byte)slot; writer.WriteStruct(request);
writer.WriteStruct(request); header.Length = (ushort)(stream.Length - 16);
header.Length = (ushort)(stream.Length - 16); writer.Seek(6, SeekOrigin.Begin);
writer.Write(header.Length);
writer.Seek(6, SeekOrigin.Begin); Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
writer.Write(header.Length);
Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan()); writer.Seek(8, SeekOrigin.Begin);
writer.Write(header.Crc32.AsSpan());
writer.Seek(8, SeekOrigin.Begin); byte[] data = stream.ToArray();
writer.Write(header.Crc32.AsSpan());
byte[] data = stream.ToArray(); Send(data, clientId);
Send(data, clientId);
}
} }
public unsafe void RequestData(int clientId, int slot) public void RequestData(int clientId, int slot)
{ {
if (!_active) if (!_active)
{ {
@ -420,44 +419,43 @@ namespace Ryujinx.Input.Motion.CemuHook
Header header = GenerateHeader(clientId); Header header = GenerateHeader(clientId);
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream()) using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using (BinaryWriter writer = new BinaryWriter(stream)) using BinaryWriter writer = new(stream);
writer.WriteStruct(header);
ControllerDataRequest request = new()
{ {
writer.WriteStruct(header); Type = MessageType.Data,
Slot = (byte)slot,
SubscriberType = SubscriberType.Slot,
};
ControllerDataRequest request = new ControllerDataRequest() writer.WriteStruct(request);
{
Type = MessageType.Data,
Slot = (byte)slot,
SubscriberType = SubscriberType.Slot
};
writer.WriteStruct(request); header.Length = (ushort)(stream.Length - 16);
header.Length = (ushort)(stream.Length - 16); writer.Seek(6, SeekOrigin.Begin);
writer.Write(header.Length);
writer.Seek(6, SeekOrigin.Begin); Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
writer.Write(header.Length);
Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan()); writer.Seek(8, SeekOrigin.Begin);
writer.Write(header.Crc32.AsSpan());
writer.Seek(8, SeekOrigin.Begin); byte[] data = stream.ToArray();
writer.Write(header.Crc32.AsSpan());
byte[] data = stream.ToArray(); Send(data, clientId);
Send(data, clientId);
}
} }
private Header GenerateHeader(int clientId) private static Header GenerateHeader(int clientId)
{ {
Header header = new Header() Header header = new()
{ {
Id = (uint)clientId, Id = (uint)clientId,
MagicString = Magic, MagicString = Magic,
Version = Version, Version = Version,
Length = 0 Length = 0,
}; };
return header; return header;
@ -465,9 +463,10 @@ namespace Ryujinx.Input.Motion.CemuHook
public void Dispose() public void Dispose()
{ {
GC.SuppressFinalize(this);
_active = false; _active = false;
CloseClients(); CloseClients();
} }
} }
} }

22
src/Ryujinx.Input/Motion/CemuHook/Protocol/ControllerData.cs
View file

@ -16,15 +16,15 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
public struct ControllerDataResponse public struct ControllerDataResponse
{ {
public SharedResponse Shared; public SharedResponse Shared;
public byte Connected; public byte Connected;
public uint PacketId; public uint PacketId;
public byte ExtraButtons; public byte ExtraButtons;
public byte MainButtons; public byte MainButtons;
public ushort PSExtraInput; public ushort PSExtraInput;
public ushort LeftStickXY; public ushort LeftStickXY;
public ushort RightStickXY; public ushort RightStickXY;
public uint DPadAnalog; public uint DPadAnalog;
public ulong MainButtonsAnalog; public ulong MainButtonsAnalog;
public Array6<byte> Touch1; public Array6<byte> Touch1;
public Array6<byte> Touch2; public Array6<byte> Touch2;
@ -42,6 +42,6 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
{ {
All, All,
Slot, Slot,
Mac Mac,
} }
} }

4
src/Ryujinx.Input/Motion/CemuHook/Protocol/ControllerInfo.cs
View file

@ -7,7 +7,7 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
public struct ControllerInfoResponse public struct ControllerInfoResponse
{ {
public SharedResponse Shared; public SharedResponse Shared;
private byte _zero; private readonly byte _zero;
} }
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]
@ -17,4 +17,4 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
public int PortsCount; public int PortsCount;
public Array4<byte> PortIndices; public Array4<byte> PortIndices;
} }
} }

2
src/Ryujinx.Input/Motion/CemuHook/Protocol/Header.cs
View file

@ -12,4 +12,4 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
public Array4<byte> Crc32; public Array4<byte> Crc32;
public uint Id; public uint Id;
} }
} }

4
src/Ryujinx.Input/Motion/CemuHook/Protocol/MessageType.cs
View file

@ -4,6 +4,6 @@
{ {
Protocol = 0x100000, Protocol = 0x100000,
Info, Info,
Data Data,
} }
} }

18
src/Ryujinx.Input/Motion/CemuHook/Protocol/SharedResponse.cs
View file

@ -6,11 +6,11 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
[StructLayout(LayoutKind.Sequential, Pack = 1)] [StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct SharedResponse public struct SharedResponse
{ {
public MessageType Type; public MessageType Type;
public byte Slot; public byte Slot;
public SlotState State; public SlotState State;
public DeviceModelType ModelType; public DeviceModelType ModelType;
public ConnectionType ConnectionType; public ConnectionType ConnectionType;
public Array6<byte> MacAddress; public Array6<byte> MacAddress;
public BatteryStatus BatteryStatus; public BatteryStatus BatteryStatus;
@ -20,21 +20,21 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
{ {
Disconnected, Disconnected,
Reserved, Reserved,
Connected Connected,
} }
public enum DeviceModelType : byte public enum DeviceModelType : byte
{ {
None, None,
PartialGyro, PartialGyro,
FullGyro FullGyro,
} }
public enum ConnectionType : byte public enum ConnectionType : byte
{ {
None, None,
USB, USB,
Bluetooth Bluetooth,
} }
public enum BatteryStatus : byte public enum BatteryStatus : byte
@ -46,6 +46,6 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
High, High,
Full, Full,
Charging, Charging,
Charged Charged,
} }
} }

14
src/Ryujinx.Input/Motion/MotionInput.cs
View file

@ -6,19 +6,19 @@ namespace Ryujinx.Input
{ {
public class MotionInput public class MotionInput
{ {
public ulong TimeStamp { get; set; } public ulong TimeStamp { get; set; }
public Vector3 Accelerometer { get; set; } public Vector3 Accelerometer { get; set; }
public Vector3 Gyroscrope { get; set; } public Vector3 Gyroscrope { get; set; }
public Vector3 Rotation { get; set; } public Vector3 Rotation { get; set; }
private readonly MotionSensorFilter _filter; private readonly MotionSensorFilter _filter;
public MotionInput() public MotionInput()
{ {
TimeStamp = 0; TimeStamp = 0;
Accelerometer = new Vector3(); Accelerometer = new Vector3();
Gyroscrope = new Vector3(); Gyroscrope = new Vector3();
Rotation = new Vector3(); Rotation = new Vector3();
// TODO: RE the correct filter. // TODO: RE the correct filter.
_filter = new MotionSensorFilter(0f); _filter = new MotionSensorFilter(0f);
@ -62,4 +62,4 @@ namespace Ryujinx.Input
return degree * (MathF.PI / 180); return degree * (MathF.PI / 180);
} }
} }
} }

14
src/Ryujinx.Input/Motion/MotionSensorFilter.cs
View file

@ -106,19 +106,19 @@ namespace Ryujinx.Input.Motion
float q1 = Quaternion.W; float q1 = Quaternion.W;
// Estimated direction of gravity. // Estimated direction of gravity.
Vector3 gravity = new Vector3() Vector3 gravity = new()
{ {
X = 2f * (q2 * q4 - q1 * q3), X = 2f * (q2 * q4 - q1 * q3),
Y = 2f * (q1 * q2 + q3 * q4), Y = 2f * (q1 * q2 + q3 * q4),
Z = q1 * q1 - q2 * q2 - q3 * q3 + q4 * q4 Z = q1 * q1 - q2 * q2 - q3 * q3 + q4 * q4,
}; };
// Error is cross product between estimated direction and measured direction of gravity. // Error is cross product between estimated direction and measured direction of gravity.
Vector3 error = new Vector3() Vector3 error = new()
{ {
X = accel.Y * gravity.Z - accel.Z * gravity.Y, X = accel.Y * gravity.Z - accel.Z * gravity.Y,
Y = accel.Z * gravity.X - accel.X * gravity.Z, Y = accel.Z * gravity.X - accel.X * gravity.Z,
Z = accel.X * gravity.Y - accel.Y * gravity.X Z = accel.X * gravity.Y - accel.Y * gravity.X,
}; };
if (Ki > 0f) if (Ki > 0f)
@ -134,7 +134,7 @@ namespace Ryujinx.Input.Motion
gyro += (Kp * error) + (Ki * _intergralError); gyro += (Kp * error) + (Ki * _intergralError);
// Integrate rate of change of quaternion. // Integrate rate of change of quaternion.
Vector3 delta = new Vector3(q2, q3, q4); Vector3 delta = new(q2, q3, q4);
q1 += (-q2 * gyro.X - q3 * gyro.Y - q4 * gyro.Z) * (SampleRateCoefficient * SamplePeriod); q1 += (-q2 * gyro.X - q3 * gyro.Y - q4 * gyro.Z) * (SampleRateCoefficient * SamplePeriod);
q2 += (q1 * gyro.X + delta.Y * gyro.Z - delta.Z * gyro.Y) * (SampleRateCoefficient * SamplePeriod); q2 += (q1 * gyro.X + delta.Y * gyro.Z - delta.Z * gyro.Y) * (SampleRateCoefficient * SamplePeriod);
@ -142,7 +142,7 @@ namespace Ryujinx.Input.Motion
q4 += (q1 * gyro.Z + delta.X * gyro.Y - delta.Y * gyro.X) * (SampleRateCoefficient * SamplePeriod); q4 += (q1 * gyro.Z + delta.X * gyro.Y - delta.Y * gyro.X) * (SampleRateCoefficient * SamplePeriod);
// Normalise quaternion. // Normalise quaternion.
Quaternion quaternion = new Quaternion(q2, q3, q4, q1); Quaternion quaternion = new(q2, q3, q4, q1);
norm = 1f / quaternion.Length(); norm = 1f / quaternion.Length();
@ -159,4 +159,4 @@ namespace Ryujinx.Input.Motion
Quaternion = Quaternion.Identity; Quaternion = Quaternion.Identity;
} }
} }
} }

2
src/Ryujinx.Input/MotionInputId.cs
View file

@ -20,6 +20,6 @@
/// Gyroscope. /// Gyroscope.
/// </summary> /// </summary>
/// <remarks>Values are in degrees</remarks> /// <remarks>Values are in degrees</remarks>
Gyroscope Gyroscope,
} }
} }

4
src/Ryujinx.Input/MouseButton.cs
View file

@ -11,6 +11,6 @@ namespace Ryujinx.Input
Button7, Button7,
Button8, Button8,
Button9, Button9,
Count Count,
} }
} }

6
src/Ryujinx.Input/MouseStateSnapshot.cs
View file

@ -8,7 +8,7 @@ namespace Ryujinx.Input
/// </summary> /// </summary>
public class MouseStateSnapshot public class MouseStateSnapshot
{ {
private bool[] _buttonState; private readonly bool[] _buttonState;
/// <summary> /// <summary>
/// The position of the mouse cursor /// The position of the mouse cursor
@ -31,7 +31,7 @@ namespace Ryujinx.Input
_buttonState = buttonState; _buttonState = buttonState;
Position = position; Position = position;
Scroll = scroll; Scroll = scroll;
} }
/// <summary> /// <summary>
@ -42,4 +42,4 @@ namespace Ryujinx.Input
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool IsPressed(MouseButton button) => _buttonState[(int)button]; public bool IsPressed(MouseButton button) => _buttonState[(int)button];
} }
} }

2
src/Ryujinx.Input/StickInputId.cs
View file

@ -9,6 +9,6 @@
Left, Left,
Right, Right,
Count Count,
} }
} }