alexx009/jinx
Archived
1
0
Fork 0
forked from Mirror/Ryujinx
Code Pull requests Activity

[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>
public class GamepadButtonAssigner : IButtonAssigner
{
private IGamepad _gamepad;
private readonly IGamepad _gamepad;
private GamepadStateSnapshot _currState;
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)
{
@ -35,7 +35,7 @@ namespace Ryujinx.Input.Assigner
{
_currState = _gamepad.GetStateSnapshot();
_prevState = _currState;
}
}
}
public void ReadInput()
@ -116,7 +116,7 @@ namespace Ryujinx.Input.Assigner
private class JoystickButtonDetector
{
private Dictionary<GamepadButtonInputId, InputSummary> _stats;
private readonly Dictionary<GamepadButtonInputId, InputSummary> _stats;
public JoystickButtonDetector()
{
@ -135,9 +135,8 @@ namespace Ryujinx.Input.Assigner
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();
_stats.Add(button, inputSummary);
@ -148,7 +147,7 @@ namespace Ryujinx.Input.Assigner
public override string ToString()
{
StringWriter writer = new StringWriter();
StringWriter writer = new();
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>
string GetPressedButton();
}
}
}

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

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

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

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

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

@ -23,6 +23,6 @@ namespace Ryujinx.Input
/// Motion
/// <remarks>Also named sixaxis</remarks>
/// </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);
}
public TouchScreenManager CreateTouchScreenManager()
{
if (MouseDriver == null)
@ -48,6 +48,7 @@ namespace Ryujinx.Input.HLE
public void Dispose()
{
GC.SuppressFinalize(this);
Dispose(true);
}
}

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

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

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

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

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

@ -31,7 +31,7 @@ namespace Ryujinx.Input.HLE
MouseStateSnapshot snapshot = IMouse.GetMouseStateSnapshot(_mouse);
var touchPosition = IMouse.GetScreenPosition(snapshot.Position, _mouse.ClientSize, aspectRatio);
TouchPoint currentPoint = new TouchPoint
TouchPoint currentPoint = new()
{
Attribute = TouchAttribute.End,
@ -41,7 +41,7 @@ namespace Ryujinx.Input.HLE
// Placeholder values till more data is acquired
DiameterX = 10,
DiameterY = 10,
Angle = 90
Angle = 90,
};
_device.Hid.Touchscreen.Update(currentPoint);
@ -71,7 +71,7 @@ namespace Ryujinx.Input.HLE
attribute = TouchAttribute.End;
}
TouchPoint currentPoint = new TouchPoint
TouchPoint currentPoint = new()
{
Attribute = attribute,
@ -81,7 +81,7 @@ namespace Ryujinx.Input.HLE
// Placeholder values till more data is acquired
DiameterX = 10,
DiameterY = 10,
Angle = 90
Angle = 90,
};
_device.Hid.Touchscreen.Update(currentPoint);
@ -94,6 +94,9 @@ namespace Ryujinx.Input.HLE
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>
public interface IMouse : IGamepad
{
#pragma warning disable IDE0051 // Remove unused private member
private const int SwitchPanelWidth = 1280;
#pragma warning restore IDE0051
private const int SwitchPanelHeight = 720;
/// <summary>
@ -101,4 +103,4 @@ namespace Ryujinx.Input
return new Vector2();
}
}
}
}

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

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

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

@ -7,7 +7,7 @@ namespace Ryujinx.Input
/// </summary>
public class KeyboardStateSnapshot
{
private bool[] _keysState;
private readonly bool[] _keysState;
/// <summary>
/// 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 const uint Magic = 0x43555344; // DSUC
public const uint Magic = 0x43555344; // DSUC
public const ushort Version = 1001;
private bool _active;
@ -29,15 +29,15 @@ namespace Ryujinx.Input.Motion.CemuHook
private readonly Dictionary<int, UdpClient> _clients;
private readonly bool[] _clientErrorStatus = new bool[Enum.GetValues<PlayerIndex>().Length];
private readonly long[] _clientRetryTimer = new long[Enum.GetValues<PlayerIndex>().Length];
private NpadManager _npadManager;
private readonly long[] _clientRetryTimer = new long[Enum.GetValues<PlayerIndex>().Length];
private readonly NpadManager _npadManager;
public Client(NpadManager npadManager)
{
_npadManager = npadManager;
_hosts = new Dictionary<int, IPEndPoint>();
_motionData = new Dictionary<int, Dictionary<int, MotionInput>>();
_clients = new Dictionary<int, UdpClient>();
_hosts = new Dictionary<int, IPEndPoint>();
_motionData = new Dictionary<int, Dictionary<int, MotionInput>>();
_clients = new Dictionary<int, UdpClient>();
CloseClients();
}
@ -84,7 +84,7 @@ namespace Ryujinx.Input.Motion.CemuHook
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(host), port);
IPEndPoint endPoint = new(IPAddress.Parse(host), port);
client = new UdpClient(host, port);
@ -141,9 +141,9 @@ namespace Ryujinx.Input.Motion.CemuHook
{
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;
}
@ -164,26 +164,26 @@ namespace Ryujinx.Input.Motion.CemuHook
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
{
_client?.Send(data, data.Length);
client?.Send(data, data.Length);
}
catch (SocketException socketException)
{
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;
RemoveClient(clientId);
_client?.Dispose();
client?.Dispose();
SetRetryTimer(clientId);
}
@ -193,7 +193,7 @@ namespace Ryujinx.Input.Motion.CemuHook
RemoveClient(clientId);
_client?.Dispose();
client?.Dispose();
SetRetryTimer(clientId);
}
@ -203,13 +203,13 @@ namespace Ryujinx.Input.Motion.CemuHook
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)
{
@ -242,9 +242,9 @@ namespace Ryujinx.Input.Motion.CemuHook
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
{
@ -271,7 +271,7 @@ namespace Ryujinx.Input.Motion.CemuHook
RemoveClient(clientId);
_client?.Dispose();
client?.Dispose();
SetRetryTimer(clientId);
}
@ -281,7 +281,7 @@ namespace Ryujinx.Input.Motion.CemuHook
RemoveClient(clientId);
_client?.Dispose();
client?.Dispose();
SetRetryTimer(clientId);
}
@ -297,8 +297,8 @@ namespace Ryujinx.Input.Motion.CemuHook
data = data.AsSpan()[16..].ToArray();
using MemoryStream stream = new MemoryStream(data);
using BinaryReader reader = new BinaryReader(stream);
using MemoryStream stream = new(data);
using BinaryReader reader = new(stream);
switch (type)
{
@ -310,18 +310,18 @@ namespace Ryujinx.Input.Motion.CemuHook
case MessageType.Data:
ControllerDataResponse inputData = reader.ReadStruct<ControllerDataResponse>();
Vector3 accelerometer = new Vector3()
Vector3 accelerometer = new()
{
X = -inputData.AccelerometerX,
Y = inputData.AccelerometerZ,
Z = -inputData.AccelerometerY
Z = -inputData.AccelerometerY,
};
Vector3 gyroscrope = new Vector3()
Vector3 gyroscrope = new()
{
X = inputData.GyroscopePitch,
Y = inputData.GyroscopeRoll,
Z = -inputData.GyroscopeYaw
Z = -inputData.GyroscopeYaw,
};
ulong timestamp = inputData.MotionTimestamp;
@ -346,7 +346,7 @@ namespace Ryujinx.Input.Motion.CemuHook
}
else
{
MotionInput input = new MotionInput();
MotionInput input = new();
input.Update(accelerometer, gyroscrope, timestamp, cemuHookConfig.Sensitivity, (float)cemuHookConfig.GyroDeadzone);
@ -355,11 +355,11 @@ namespace Ryujinx.Input.Motion.CemuHook
}
else
{
MotionInput input = new MotionInput();
MotionInput input = new();
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
@ -380,38 +380,37 @@ namespace Ryujinx.Input.Motion.CemuHook
Header header = GenerateHeader(clientId);
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
using (BinaryWriter writer = new BinaryWriter(stream))
using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
using BinaryWriter writer = new(stream);
writer.WriteStruct(header);
ControllerInfoRequest request = new()
{
writer.WriteStruct(header);
Type = MessageType.Info,
PortsCount = 4,
};
ControllerInfoRequest request = new ControllerInfoRequest()
{
Type = MessageType.Info,
PortsCount = 4
};
request.PortIndices[0] = (byte)slot;
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);
writer.Write(header.Length);
Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
writer.Seek(8, SeekOrigin.Begin);
writer.Write(header.Crc32.AsSpan());
writer.Seek(8, SeekOrigin.Begin);
writer.Write(header.Crc32.AsSpan());
byte[] data = stream.ToArray();
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)
{
@ -420,44 +419,43 @@ namespace Ryujinx.Input.Motion.CemuHook
Header header = GenerateHeader(clientId);
using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
using (BinaryWriter writer = new BinaryWriter(stream))
using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
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()
{
Type = MessageType.Data,
Slot = (byte)slot,
SubscriberType = SubscriberType.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);
writer.Write(header.Length);
Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
writer.Seek(8, SeekOrigin.Begin);
writer.Write(header.Crc32.AsSpan());
writer.Seek(8, SeekOrigin.Begin);
writer.Write(header.Crc32.AsSpan());
byte[] data = stream.ToArray();
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,
Version = Version,
Length = 0
Version = Version,
Length = 0,
};
return header;
@ -465,9 +463,10 @@ namespace Ryujinx.Input.Motion.CemuHook
public void Dispose()
{
GC.SuppressFinalize(this);
_active = false;
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 SharedResponse Shared;
public byte Connected;
public uint PacketId;
public byte ExtraButtons;
public byte MainButtons;
public ushort PSExtraInput;
public ushort LeftStickXY;
public ushort RightStickXY;
public uint DPadAnalog;
public ulong MainButtonsAnalog;
public byte Connected;
public uint PacketId;
public byte ExtraButtons;
public byte MainButtons;
public ushort PSExtraInput;
public ushort LeftStickXY;
public ushort RightStickXY;
public uint DPadAnalog;
public ulong MainButtonsAnalog;
public Array6<byte> Touch1;
public Array6<byte> Touch2;
@ -42,6 +42,6 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
{
All,
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 SharedResponse Shared;
private byte _zero;
private readonly byte _zero;
}
[StructLayout(LayoutKind.Sequential, Pack = 1)]
@ -17,4 +17,4 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
public int PortsCount;
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 uint Id;
}
}
}

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

@ -4,6 +4,6 @@
{
Protocol = 0x100000,
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)]
public struct SharedResponse
{
public MessageType Type;
public byte Slot;
public SlotState State;
public MessageType Type;
public byte Slot;
public SlotState State;
public DeviceModelType ModelType;
public ConnectionType ConnectionType;
public ConnectionType ConnectionType;
public Array6<byte> MacAddress;
public BatteryStatus BatteryStatus;
@ -20,21 +20,21 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
{
Disconnected,
Reserved,
Connected
Connected,
}
public enum DeviceModelType : byte
{
None,
PartialGyro,
FullGyro
FullGyro,
}
public enum ConnectionType : byte
{
None,
USB,
Bluetooth
Bluetooth,
}
public enum BatteryStatus : byte
@ -46,6 +46,6 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
High,
Full,
Charging,
Charged
Charged,
}
}
}

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

@ -6,19 +6,19 @@ namespace Ryujinx.Input
{
public class MotionInput
{
public ulong TimeStamp { get; set; }
public ulong TimeStamp { get; set; }
public Vector3 Accelerometer { get; set; }
public Vector3 Gyroscrope { get; set; }
public Vector3 Rotation { get; set; }
public Vector3 Gyroscrope { get; set; }
public Vector3 Rotation { get; set; }
private readonly MotionSensorFilter _filter;
public MotionInput()
{
TimeStamp = 0;
TimeStamp = 0;
Accelerometer = new Vector3();
Gyroscrope = new Vector3();
Rotation = new Vector3();
Gyroscrope = new Vector3();
Rotation = new Vector3();
// TODO: RE the correct filter.
_filter = new MotionSensorFilter(0f);
@ -62,4 +62,4 @@ namespace Ryujinx.Input
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;
// Estimated direction of gravity.
Vector3 gravity = new Vector3()
Vector3 gravity = new()
{
X = 2f * (q2 * q4 - q1 * q3),
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.
Vector3 error = new Vector3()
Vector3 error = new()
{
X = accel.Y * gravity.Z - accel.Z * gravity.Y,
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)
@ -134,7 +134,7 @@ namespace Ryujinx.Input.Motion
gyro += (Kp * error) + (Ki * _intergralError);
// 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);
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);
// Normalise quaternion.
Quaternion quaternion = new Quaternion(q2, q3, q4, q1);
Quaternion quaternion = new(q2, q3, q4, q1);
norm = 1f / quaternion.Length();
@ -159,4 +159,4 @@ namespace Ryujinx.Input.Motion
Quaternion = Quaternion.Identity;
}
}
}
}

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

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

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

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

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

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

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

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