Move solution and projects to src

src/Ryujinx.Common/Configuration/Hid/Controller/GamepadInputId.cs

@@ -0,0 +1,58 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid.Controller
+{
+    [JsonConverter(typeof(TypedStringEnumConverter<GamepadInputId>))]
+    public enum GamepadInputId : byte
+    {
+        Unbound,
+        A,
+        B,
+        X,
+        Y,
+        LeftStick,
+        RightStick,
+        LeftShoulder,
+        RightShoulder,
+
+        // Likely axis
+        LeftTrigger,
+        // Likely axis
+        RightTrigger,
+
+        DpadUp,
+        DpadDown,
+        DpadLeft,
+        DpadRight,
+
+        // Special buttons
+
+        Minus,
+        Plus,
+
+        Back = Minus,
+        Start = Plus,
+
+        Guide,
+        Misc1,
+
+        // Xbox Elite paddle
+        Paddle1,
+        Paddle2,
+        Paddle3,
+        Paddle4,
+
+        // PS5 touchpad button
+        Touchpad,
+
+        // Virtual buttons for single joycon
+        SingleLeftTrigger0,
+        SingleRightTrigger0,
+
+        SingleLeftTrigger1,
+        SingleRightTrigger1,
+
+        Count
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/GenericControllerInputConfig.cs

@@ -0,0 +1,82 @@
+using Ryujinx.Common.Configuration.Hid.Controller.Motion;
+using System;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid.Controller
+{
+    public class GenericControllerInputConfig<Button, Stick> : GenericInputConfigurationCommon<Button> where Button : unmanaged where Stick : unmanaged
+    {
+        [JsonIgnore]
+        private float _deadzoneLeft;
+        [JsonIgnore]
+        private float _deadzoneRight;
+        [JsonIgnore]
+        private float _triggerThreshold;
+
+        /// <summary>
+        /// Left JoyCon Controller Stick Bindings
+        /// </summary>
+        public JoyconConfigControllerStick<Button, Stick> LeftJoyconStick { get; set; }
+
+        /// <summary>
+        /// Right JoyCon Controller Stick Bindings
+        /// </summary>
+        public JoyconConfigControllerStick<Button, Stick> RightJoyconStick { get; set; }
+
+        /// <summary>
+        /// Controller Left Analog Stick Deadzone
+        /// </summary>
+        public float DeadzoneLeft
+        {
+            get => _deadzoneLeft; set
+            {
+                _deadzoneLeft = MathF.Round(value, 3);
+                OnPropertyChanged();
+            }
+        }
+
+        /// <summary>
+        /// Controller Right Analog Stick Deadzone
+        /// </summary>
+        public float DeadzoneRight
+        {
+            get => _deadzoneRight; set
+            {
+                _deadzoneRight = MathF.Round(value, 3);
+                OnPropertyChanged();
+            }
+        }
+
+        /// <summary>
+        /// Controller Left Analog Stick Range
+        /// </summary>
+        public float RangeLeft { get; set; }
+
+        /// <summary>
+        /// Controller Right Analog Stick Range
+        /// </summary>
+        public float RangeRight { get; set; }
+
+        /// <summary>
+        /// Controller Trigger Threshold
+        /// </summary>
+        public float TriggerThreshold
+        {
+            get => _triggerThreshold; set
+            {
+                _triggerThreshold = MathF.Round(value, 3);
+                OnPropertyChanged();
+            }
+        }
+
+        /// <summary>
+        /// Controller Motion Settings
+        /// </summary>
+        public MotionConfigController Motion { get; set; }
+
+        /// <summary>
+        /// Controller Rumble Settings
+        /// </summary>
+        public RumbleConfigController Rumble { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/JoyconConfigControllerStick.cs

@@ -0,0 +1,11 @@
+namespace Ryujinx.Common.Configuration.Hid.Controller
+{
+    public class JoyconConfigControllerStick<Button, Stick> where Button: unmanaged where Stick: unmanaged
+    {
+        public Stick Joystick { get; set; }
+        public bool InvertStickX { get; set; }
+        public bool InvertStickY { get; set; }
+        public bool Rotate90CW { get; set; }
+        public Button StickButton { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/Motion/CemuHookMotionConfigController.cs

@@ -0,0 +1,30 @@
+namespace Ryujinx.Common.Configuration.Hid.Controller.Motion
+{
+    public class CemuHookMotionConfigController : MotionConfigController
+    {
+        /// <summary>
+        /// Motion Controller Slot
+        /// </summary>
+        public int Slot { get; set; }
+
+        /// <summary>
+        /// Motion Controller Alternative Slot, for RightJoyCon in Pair mode
+        /// </summary>
+        public int AltSlot { get; set; }
+
+        /// <summary>
+        /// Mirror motion input in Pair mode
+        /// </summary>
+        public bool MirrorInput { get; set; }
+
+        /// <summary>
+        /// Host address of the DSU Server
+        /// </summary>
+        public string DsuServerHost { get; set; }
+
+        /// <summary>
+        /// Port of the DSU Server
+        /// </summary>
+        public int DsuServerPort { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/Motion/JsonMotionConfigControllerConverter.cs

@@ -0,0 +1,79 @@
+using Ryujinx.Common.Utilities;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid.Controller.Motion
+{
+    class JsonMotionConfigControllerConverter : JsonConverter<MotionConfigController>
+    {
+        private static readonly MotionConfigJsonSerializerContext SerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+
+        private static MotionInputBackendType GetMotionInputBackendType(ref Utf8JsonReader reader)
+        {
+            // Temporary reader to get the backend type
+            Utf8JsonReader tempReader = reader;
+
+            MotionInputBackendType result = MotionInputBackendType.Invalid;
+
+            while (tempReader.Read())
+            {
+                // NOTE: We scan all properties ignoring the depth entirely on purpose.
+                // The reason behind this is that we cannot track in a reliable way the depth of the object because Utf8JsonReader never emit the first TokenType == StartObject if the json start with an object.
+                // As such, this code will try to parse very field named "motion_backend" to the correct enum.
+                if (tempReader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = tempReader.GetString();
+
+                    if (propertyName.Equals("motion_backend"))
+                    {
+                        tempReader.Read();
+
+                        if (tempReader.TokenType == JsonTokenType.String)
+                        {
+                            string backendTypeRaw = tempReader.GetString();
+
+                            if (!Enum.TryParse(backendTypeRaw, out result))
+                            {
+                                result = MotionInputBackendType.Invalid;
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        public override MotionConfigController Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            MotionInputBackendType motionBackendType = GetMotionInputBackendType(ref reader);
+
+            return motionBackendType switch
+            {
+                MotionInputBackendType.GamepadDriver => JsonSerializer.Deserialize(ref reader, SerializerContext.StandardMotionConfigController),
+                MotionInputBackendType.CemuHook => JsonSerializer.Deserialize(ref reader, SerializerContext.CemuHookMotionConfigController),
+                _ => throw new InvalidOperationException($"Unknown backend type {motionBackendType}"),
+            };
+        }
+
+        public override void Write(Utf8JsonWriter writer, MotionConfigController value, JsonSerializerOptions options)
+        {
+            switch (value.MotionBackend)
+            {
+                case MotionInputBackendType.GamepadDriver:
+                    JsonSerializer.Serialize(writer, value as StandardMotionConfigController, SerializerContext.StandardMotionConfigController);
+                    break;
+                case MotionInputBackendType.CemuHook:
+                    JsonSerializer.Serialize(writer, value as CemuHookMotionConfigController, SerializerContext.CemuHookMotionConfigController);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown motion backend type {value.MotionBackend}");
+            }
+        }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/Motion/MotionConfigController.cs

@@ -0,0 +1,25 @@
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid.Controller.Motion
+{
+    [JsonConverter(typeof(JsonMotionConfigControllerConverter))]
+    public class MotionConfigController
+    {
+        public MotionInputBackendType MotionBackend { get; set; }
+
+        /// <summary>
+        /// Gyro Sensitivity
+        /// </summary>
+        public int Sensitivity { get; set; }
+
+        /// <summary>
+        /// Gyro Deadzone
+        /// </summary>
+        public double GyroDeadzone { get; set; }
+
+        /// <summary>
+        /// Enable Motion Controls
+        /// </summary>
+        public bool EnableMotion { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/Motion/MotionConfigJsonSerializerContext.cs

@@ -0,0 +1,12 @@
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid.Controller.Motion
+{
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(MotionConfigController))]
+    [JsonSerializable(typeof(CemuHookMotionConfigController))]
+    [JsonSerializable(typeof(StandardMotionConfigController))]
+    public partial class MotionConfigJsonSerializerContext : JsonSerializerContext
+    {
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/Motion/MotionInputBackendType.cs

@@ -0,0 +1,13 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid.Controller.Motion
+{
+    [JsonConverter(typeof(TypedStringEnumConverter<MotionInputBackendType>))]
+    public enum MotionInputBackendType : byte
+    {
+        Invalid,
+        GamepadDriver,
+        CemuHook
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/Motion/StandardMotionConfigController.cs

@@ -0,0 +1,4 @@
+namespace Ryujinx.Common.Configuration.Hid.Controller.Motion
+{
+    public class StandardMotionConfigController : MotionConfigController { }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/RumbleConfigController.cs

@@ -0,0 +1,20 @@
+namespace Ryujinx.Common.Configuration.Hid.Controller
+{
+    public class RumbleConfigController
+    {
+        /// <summary>
+        /// Controller Strong Rumble Multiplier
+        /// </summary>
+        public float StrongRumble { get; set; }
+
+        /// <summary>
+        /// Controller Weak Rumble Multiplier
+        /// </summary>
+        public float WeakRumble { get; set; }
+
+        /// <summary>
+        /// Enable Rumble
+        /// </summary>
+        public bool EnableRumble { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/StandardControllerInputConfig.cs

@@ -0,0 +1,4 @@
+namespace Ryujinx.Common.Configuration.Hid.Controller
+{
+    public class StandardControllerInputConfig : GenericControllerInputConfig<GamepadInputId, StickInputId> { }
+}

src/Ryujinx.Common/Configuration/Hid/Controller/StickInputId.cs

@@ -0,0 +1,15 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid.Controller
+{
+    [JsonConverter(typeof(TypedStringEnumConverter<StickInputId>))]
+    public enum StickInputId : byte
+    {
+        Unbound,
+        Left,
+        Right,
+
+        Count
+    }
+}

src/Ryujinx.Common/Configuration/Hid/ControllerType.cs

@@ -0,0 +1,23 @@
+using Ryujinx.Common.Utilities;
+using System;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid
+{
+    // This enum was duplicated from Ryujinx.HLE.HOS.Services.Hid.PlayerIndex and should be kept identical
+    [Flags]
+    [JsonConverter(typeof(TypedStringEnumConverter<ControllerType>))]
+    public enum ControllerType : int
+    {
+        None,
+        ProController  = 1 << 0,
+        Handheld       = 1 << 1,
+        JoyconPair     = 1 << 2,
+        JoyconLeft     = 1 << 3,
+        JoyconRight    = 1 << 4,
+        Invalid        = 1 << 5,
+        Pokeball       = 1 << 6,
+        SystemExternal = 1 << 29,
+        System         = 1 << 30
+    }
+}

src/Ryujinx.Common/Configuration/Hid/GenericInputConfigurationCommon.cs

@@ -0,0 +1,15 @@
+namespace Ryujinx.Common.Configuration.Hid
+{
+    public class GenericInputConfigurationCommon<Button> : InputConfig where Button : unmanaged
+    {
+        /// <summary>
+        /// Left JoyCon Controller Bindings
+        /// </summary>
+        public LeftJoyconCommonConfig<Button> LeftJoycon { get; set; }
+
+        /// <summary>
+        /// Right JoyCon Controller Bindings
+        /// </summary>
+        public RightJoyconCommonConfig<Button> RightJoycon { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/InputBackendType.cs

@@ -0,0 +1,13 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid
+{
+    [JsonConverter(typeof(TypedStringEnumConverter<InputBackendType>))]
+    public enum InputBackendType
+    {
+        Invalid,
+        WindowKeyboard,
+        GamepadSDL2,
+    }
+}

src/Ryujinx.Common/Configuration/Hid/InputConfig.cs

@@ -0,0 +1,41 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid
+{
+    [JsonConverter(typeof(JsonInputConfigConverter))]
+    public class InputConfig : INotifyPropertyChanged
+    {
+        /// <summary>
+        /// The current version of the input file format
+        /// </summary>
+        public const int CurrentVersion = 1;
+
+        public int Version { get; set; }
+
+        public InputBackendType Backend { get; set; }
+
+        /// <summary>
+        /// Controller id
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        ///  Controller's Type
+        /// </summary>
+        public ControllerType ControllerType { get; set; }
+
+        /// <summary>
+        ///  Player's Index for the controller
+        /// </summary>
+        public PlayerIndex PlayerIndex { get; set; }
+        
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/InputConfigJsonSerializerContext.cs

@@ -0,0 +1,14 @@
+using Ryujinx.Common.Configuration.Hid.Controller;
+using Ryujinx.Common.Configuration.Hid.Keyboard;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid
+{
+    [JsonSourceGenerationOptions(WriteIndented = true)]
+    [JsonSerializable(typeof(InputConfig))]
+    [JsonSerializable(typeof(StandardKeyboardInputConfig))]
+    [JsonSerializable(typeof(StandardControllerInputConfig))]
+    public partial class InputConfigJsonSerializerContext : JsonSerializerContext
+    {
+    }
+}

src/Ryujinx.Common/Configuration/Hid/JsonInputConfigConverter.cs

@@ -0,0 +1,81 @@
+using Ryujinx.Common.Configuration.Hid.Controller;
+using Ryujinx.Common.Configuration.Hid.Keyboard;
+using Ryujinx.Common.Utilities;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid
+{
+    public class JsonInputConfigConverter : JsonConverter<InputConfig>
+    {
+        private static readonly InputConfigJsonSerializerContext SerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+
+        private static InputBackendType GetInputBackendType(ref Utf8JsonReader reader)
+        {
+            // Temporary reader to get the backend type
+            Utf8JsonReader tempReader = reader;
+
+            InputBackendType result = InputBackendType.Invalid;
+
+            while (tempReader.Read())
+            {
+                // NOTE: We scan all properties ignoring the depth entirely on purpose.
+                // The reason behind this is that we cannot track in a reliable way the depth of the object because Utf8JsonReader never emit the first TokenType == StartObject if the json start with an object.
+                // As such, this code will try to parse very field named "backend" to the correct enum.
+                if (tempReader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = tempReader.GetString();
+
+                    if (propertyName.Equals("backend"))
+                    {
+                        tempReader.Read();
+
+                        if (tempReader.TokenType == JsonTokenType.String)
+                        {
+                            string backendTypeRaw = tempReader.GetString();
+
+                            if (!Enum.TryParse(backendTypeRaw, out result))
+                            {
+                                result = InputBackendType.Invalid;
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        public override InputConfig Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            InputBackendType backendType = GetInputBackendType(ref reader);
+
+            return backendType switch
+            {
+                InputBackendType.WindowKeyboard => JsonSerializer.Deserialize(ref reader, SerializerContext.StandardKeyboardInputConfig),
+                InputBackendType.GamepadSDL2 => JsonSerializer.Deserialize(ref reader, SerializerContext.StandardControllerInputConfig),
+                _ => throw new InvalidOperationException($"Unknown backend type {backendType}"),
+            };
+        }
+
+        public override void Write(Utf8JsonWriter writer, InputConfig value, JsonSerializerOptions options)
+        {
+            switch (value.Backend)
+            {
+                case InputBackendType.WindowKeyboard:
+                    JsonSerializer.Serialize(writer, value as StandardKeyboardInputConfig, SerializerContext.StandardKeyboardInputConfig);
+                    break;
+                case InputBackendType.GamepadSDL2:
+                    JsonSerializer.Serialize(writer, value as StandardControllerInputConfig, SerializerContext.StandardControllerInputConfig);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown backend type {value.Backend}");
+            }
+        }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Key.cs

@@ -0,0 +1,143 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid
+{
+    [JsonConverter(typeof(TypedStringEnumConverter<Key>))]
+    public enum Key
+    {
+        Unknown,
+        ShiftLeft,
+        ShiftRight,
+        ControlLeft,
+        ControlRight,
+        AltLeft,
+        AltRight,
+        WinLeft,
+        WinRight,
+        Menu,
+        F1,
+        F2,
+        F3,
+        F4,
+        F5,
+        F6,
+        F7,
+        F8,
+        F9,
+        F10,
+        F11,
+        F12,
+        F13,
+        F14,
+        F15,
+        F16,
+        F17,
+        F18,
+        F19,
+        F20,
+        F21,
+        F22,
+        F23,
+        F24,
+        F25,
+        F26,
+        F27,
+        F28,
+        F29,
+        F30,
+        F31,
+        F32,
+        F33,
+        F34,
+        F35,
+        Up,
+        Down,
+        Left,
+        Right,
+        Enter,
+        Escape,
+        Space,
+        Tab,
+        BackSpace,
+        Insert,
+        Delete,
+        PageUp,
+        PageDown,
+        Home,
+        End,
+        CapsLock,
+        ScrollLock,
+        PrintScreen,
+        Pause,
+        NumLock,
+        Clear,
+        Keypad0,
+        Keypad1,
+        Keypad2,
+        Keypad3,
+        Keypad4,
+        Keypad5,
+        Keypad6,
+        Keypad7,
+        Keypad8,
+        Keypad9,
+        KeypadDivide,
+        KeypadMultiply,
+        KeypadSubtract,
+        KeypadAdd,
+        KeypadDecimal,
+        KeypadEnter,
+        A,
+        B,
+        C,
+        D,
+        E,
+        F,
+        G,
+        H,
+        I,
+        J,
+        K,
+        L,
+        M,
+        N,
+        O,
+        P,
+        Q,
+        R,
+        S,
+        T,
+        U,
+        V,
+        W,
+        X,
+        Y,
+        Z,
+        Number0,
+        Number1,
+        Number2,
+        Number3,
+        Number4,
+        Number5,
+        Number6,
+        Number7,
+        Number8,
+        Number9,
+        Tilde,
+        Grave,
+        Minus,
+        Plus,
+        BracketLeft,
+        BracketRight,
+        Semicolon,
+        Quote,
+        Comma,
+        Period,
+        Slash,
+        BackSlash,
+        Unbound,
+
+        Count
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Keyboard/GenericKeyboardInputConfig.cs

@@ -0,0 +1,15 @@
+namespace Ryujinx.Common.Configuration.Hid.Keyboard
+{
+    public class GenericKeyboardInputConfig<Key> : GenericInputConfigurationCommon<Key> where Key : unmanaged
+    {
+        /// <summary>
+        /// Left JoyCon Controller Stick Bindings
+        /// </summary>
+        public JoyconConfigKeyboardStick<Key> LeftJoyconStick { get; set; }
+
+        /// <summary>
+        /// Right JoyCon Controller Stick Bindings
+        /// </summary>
+        public JoyconConfigKeyboardStick<Key> RightJoyconStick { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Keyboard/JoyconConfigKeyboardStick.cs

@@ -0,0 +1,11 @@
+namespace Ryujinx.Common.Configuration.Hid.Keyboard
+{
+    public class JoyconConfigKeyboardStick<Key> where Key: unmanaged
+    {
+        public Key StickUp { get; set; }
+        public Key StickDown { get; set; }
+        public Key StickLeft { get; set; }
+        public Key StickRight { get; set; }
+        public Key StickButton { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/Keyboard/StandardKeyboardInputConfig.cs

@@ -0,0 +1,4 @@
+namespace Ryujinx.Common.Configuration.Hid.Keyboard
+{
+    public class StandardKeyboardInputConfig : GenericKeyboardInputConfig<Key> { }
+}

src/Ryujinx.Common/Configuration/Hid/KeyboardHotkeys.cs

@@ -0,0 +1,17 @@
+namespace Ryujinx.Common.Configuration.Hid
+{
+    // NOTE: Please don't change this to struct.
+    //       This breaks Avalonia's TwoWay binding, which makes us unable to save new KeyboardHotkeys.
+    public class KeyboardHotkeys
+    {
+        public Key ToggleVsync { get; set; }
+        public Key Screenshot { get; set; }
+        public Key ShowUi { get; set; }
+        public Key Pause { get; set; }
+        public Key ToggleMute { get; set; }
+        public Key ResScaleUp { get; set; }
+        public Key ResScaleDown { get; set; }
+        public Key VolumeUp { get; set; }
+        public Key VolumeDown { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/LeftJoyconCommonConfig.cs

@@ -0,0 +1,15 @@
+namespace Ryujinx.Common.Configuration.Hid
+{
+    public class LeftJoyconCommonConfig<Button>
+    {
+        public Button ButtonMinus { get; set; }
+        public Button ButtonL { get; set; }
+        public Button ButtonZl { get; set; }
+        public Button ButtonSl { get; set; }
+        public Button ButtonSr { get; set; }
+        public Button DpadUp { get; set; }
+        public Button DpadDown { get; set; }
+        public Button DpadLeft { get; set; }
+        public Button DpadRight { get; set; }
+    }
+}

src/Ryujinx.Common/Configuration/Hid/PlayerIndex.cs

@@ -0,0 +1,22 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Common.Configuration.Hid
+{
+    // This enum was duplicated from Ryujinx.HLE.HOS.Services.Hid.PlayerIndex and should be kept identical
+    [JsonConverter(typeof(TypedStringEnumConverter<PlayerIndex>))]
+    public enum PlayerIndex : int
+    {
+        Player1  = 0,
+        Player2  = 1,
+        Player3  = 2,
+        Player4  = 3,
+        Player5  = 4,
+        Player6  = 5,
+        Player7  = 6,
+        Player8  = 7,
+        Handheld = 8,
+        Unknown  = 9,
+        Auto     = 10 // Shouldn't be used directly
+    }
+}

src/Ryujinx.Common/Configuration/Hid/RightJoyconCommonConfig.cs

@@ -0,0 +1,15 @@
+namespace Ryujinx.Common.Configuration.Hid
+{
+    public class RightJoyconCommonConfig<Button>
+    {
+        public Button ButtonPlus { get; set; }
+        public Button ButtonR { get; set; }
+        public Button ButtonZr { get; set; }
+        public Button ButtonSl { get; set; }
+        public Button ButtonSr { get; set; }
+        public Button ButtonX { get; set; }
+        public Button ButtonB { get; set; }
+        public Button ButtonY { get; set; }
+        public Button ButtonA { get; set; }
+    }
+}