Merge branch 'master' into master

Moved the Views that existed in the Controls namespace into the Ryujinx.Ava.UI.Views.Misc namespace
Moved UpdateWaitWindow to Ryujinx.Ava.UI.Windows

src/Ryujinx.Graphics.GAL/IRenderer.cs

@@ -1,4 +1,6 @@
 using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.GAL.Multithreading;
 using System;
 using System.Threading;
 
@@ -10,6 +12,20 @@ namespace Ryujinx.Graphics.GAL
 
         bool PreferThreading { get; }
 
+        public IRenderer TryMakeThreaded(BackendThreading backendThreading = BackendThreading.Auto)
+        {
+            if (backendThreading is BackendThreading.On ||
+                (backendThreading is BackendThreading.Auto && PreferThreading))
+            {
+                Logger.Info?.PrintMsg(LogClass.Gpu, $"Backend Threading ({backendThreading}): True");
+                return new ThreadedRenderer(this);
+            }
+            
+            Logger.Info?.PrintMsg(LogClass.Gpu, $"Backend Threading ({backendThreading}): False");
+
+            return this;
+        }
+
         IPipeline Pipeline { get; }
 
         IWindow Window { get; }

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/LdnMitmClient.cs

@@ -19,7 +19,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
 
         private readonly LanDiscovery _lanDiscovery;
 
-        public LdnMitmClient(HLEConfiguration config)
+        public LdnMitmClient(HleConfiguration config)
         {
             UnicastIPAddressInformation localIpInterface = NetworkHelpers.GetLocalInterface(config.MultiplayerLanInterfaceId).Item2;
 

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/LdnMasterProxyClient.cs

@@ -51,13 +51,13 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu
         private string _passphrase;
         private byte[] _gameVersion = new byte[0x10];
 
-        private readonly HLEConfiguration _config;
+        private readonly HleConfiguration _config;
 
         public event EventHandler<NetworkChangeEventArgs> NetworkChange;
 
         public ProxyConfig Config { get; private set; }
 
-        public LdnMasterProxyClient(string address, int port, HLEConfiguration config) : base(address, port)
+        public LdnMasterProxyClient(string address, int port, HleConfiguration config) : base(address, port)
         {
             if (ProxyHelpers.SupportsNoDelay())
             {

src/Ryujinx.HLE/HleConfiguration.cs

@@ -15,55 +15,55 @@ namespace Ryujinx.HLE
     /// <summary>
     /// HLE configuration.
     /// </summary>
-    public class HLEConfiguration
+    public class HleConfiguration
     {
         /// <summary>
         /// The virtual file system used by the FS service.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        internal readonly VirtualFileSystem VirtualFileSystem;
+        internal VirtualFileSystem VirtualFileSystem { get; private set; }
 
         /// <summary>
         /// The manager for handling a LibHac Horizon instance.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        internal readonly LibHacHorizonManager LibHacHorizonManager;
+        internal LibHacHorizonManager LibHacHorizonManager { get; private set; }
 
         /// <summary>
         /// The account manager used by the account service.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        internal readonly AccountManager AccountManager;
+        internal AccountManager AccountManager { get; private set; }
 
         /// <summary>
         /// The content manager used by the NCM service.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        internal readonly ContentManager ContentManager;
+        internal ContentManager ContentManager { get; private set; }
 
         /// <summary>
         /// The persistent information between run for multi-application capabilities.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        public readonly UserChannelPersistence UserChannelPersistence;
+        public UserChannelPersistence UserChannelPersistence { get; private set; }
 
         /// <summary>
         /// The GPU renderer to use for all GPU operations.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        internal readonly IRenderer GpuRenderer;
+        internal IRenderer GpuRenderer { get; private set; }
 
         /// <summary>
         /// The audio device driver to use for all audio operations.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        internal readonly IHardwareDeviceDriver AudioDeviceDriver;
+        internal IHardwareDeviceDriver AudioDeviceDriver { get; private set; }
 
         /// <summary>
         /// The handler for various UI related operations needed outside of HLE.
         /// </summary>
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
-        internal readonly IHostUIHandler HostUIHandler;
+        internal IHostUIHandler HostUIHandler { get; private set; }
 
         /// <summary>
         /// Control the memory configuration used by the emulation context.
@@ -195,15 +195,7 @@ namespace Ryujinx.HLE
         /// <remarks>This cannot be changed after <see cref="Switch"/> instantiation.</remarks>
         public EnabledDirtyHack[] Hacks { internal get; set; }
 
-        public HLEConfiguration(VirtualFileSystem virtualFileSystem,
+        public HleConfiguration(MemoryConfiguration memoryConfiguration,
-                                LibHacHorizonManager libHacHorizonManager,
-                                ContentManager contentManager,
-                                AccountManager accountManager,
-                                UserChannelPersistence userChannelPersistence,
-                                IRenderer gpuRenderer,
-                                IHardwareDeviceDriver audioDeviceDriver,
-                                MemoryConfiguration memoryConfiguration,
-                                IHostUIHandler hostUIHandler,
                                 SystemLanguage systemLanguage,
                                 RegionCode region,
                                 VSyncMode vSyncMode,
@@ -227,15 +219,7 @@ namespace Ryujinx.HLE
                                 int customVSyncInterval,
                                 EnabledDirtyHack[] dirtyHacks = null)
         {
-            VirtualFileSystem = virtualFileSystem;
-            LibHacHorizonManager = libHacHorizonManager;
-            AccountManager = accountManager;
-            ContentManager = contentManager;
-            UserChannelPersistence = userChannelPersistence;
-            GpuRenderer = gpuRenderer;
-            AudioDeviceDriver = audioDeviceDriver;
             MemoryConfiguration = memoryConfiguration;
-            HostUIHandler = hostUIHandler;
             SystemLanguage = systemLanguage;
             Region = region;
             VSyncMode = vSyncMode;
@@ -259,5 +243,30 @@ namespace Ryujinx.HLE
             MultiplayerLdnServer = multiplayerLdnServer;
             Hacks = dirtyHacks ?? [];
         }
+
+        /// <summary>
+        /// Set the pre-configured services to use for this <see cref="HleConfiguration"/> instance.
+        /// </summary>
+        public HleConfiguration Configure(
+            VirtualFileSystem virtualFileSystem,
+            LibHacHorizonManager libHacHorizonManager,
+            ContentManager contentManager,
+            AccountManager accountManager,
+            UserChannelPersistence userChannelPersistence,
+            IRenderer gpuRenderer,
+            IHardwareDeviceDriver audioDeviceDriver,
+            IHostUIHandler hostUIHandler
+        )
+        {
+            VirtualFileSystem = virtualFileSystem;
+            LibHacHorizonManager = libHacHorizonManager;
+            AccountManager = accountManager;
+            ContentManager = contentManager;
+            UserChannelPersistence = userChannelPersistence;
+            GpuRenderer = gpuRenderer;
+            AudioDeviceDriver = audioDeviceDriver;
+            HostUIHandler = hostUIHandler;
+            return this;
+        }
     }
 }

src/Ryujinx.HLE/Switch.cs

@@ -20,7 +20,7 @@ namespace Ryujinx.HLE
     {
         public static Switch Shared { get; private set; }
         
-        public HLEConfiguration Configuration { get; }
+        public HleConfiguration Configuration { get; }
         public IHardwareDeviceDriver AudioDeviceDriver { get; }
         public MemoryBlock Memory { get; }
         public GpuContext Gpu { get; }
@@ -44,7 +44,7 @@ namespace Ryujinx.HLE
 
         public DirtyHacks DirtyHacks { get; }
 
-        public Switch(HLEConfiguration configuration)
+        public Switch(HleConfiguration configuration)
         {
             ArgumentNullException.ThrowIfNull(configuration.GpuRenderer);
             ArgumentNullException.ThrowIfNull(configuration.AudioDeviceDriver);
@@ -94,16 +94,20 @@ namespace Ryujinx.HLE
             Gpu.GPFifo.DispatchCalls();
         }
 
-        public void IncrementCustomVSyncInterval()
+        public int IncrementCustomVSyncInterval()
         {
             CustomVSyncInterval += 1;
             UpdateVSyncInterval();
+
+            return CustomVSyncInterval;
         }
 
-        public void DecrementCustomVSyncInterval()
+        public int DecrementCustomVSyncInterval()
         {
             CustomVSyncInterval -= 1;
             UpdateVSyncInterval();
+
+            return CustomVSyncInterval;
         }
 
         public void UpdateVSyncInterval()

src/Ryujinx.Input.SDL2/SDL2GamepadDriver.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.SDL2.Common;
 using System;
 using System.Collections.Generic;
@@ -36,6 +37,7 @@ namespace Ryujinx.Input.SDL2
             SDL2Driver.Instance.Initialize();
             SDL2Driver.Instance.OnJoyStickConnected += HandleJoyStickConnected;
             SDL2Driver.Instance.OnJoystickDisconnected += HandleJoyStickDisconnected;
+            SDL2Driver.Instance.OnJoyBatteryUpdated += HandleJoyBatteryUpdated;
 
             // Add already connected gamepads
             int numJoysticks = SDL_NumJoysticks();
@@ -83,19 +85,30 @@ namespace Ryujinx.Input.SDL2
 
         private void HandleJoyStickDisconnected(int joystickInstanceId)
         {
+            bool joyConPairDisconnected = false;
             if (!_gamepadsInstanceIdsMapping.Remove(joystickInstanceId, out string id))
                 return;
 
             lock (_lock)
             {
                 _gamepadsIds.Remove(id);
+                if (!SDL2JoyConPair.IsCombinable(_gamepadsIds))
+                {
+                    _gamepadsIds.Remove(SDL2JoyConPair.Id);
+                    joyConPairDisconnected = true;
+                }
             }
 
             OnGamepadDisconnected?.Invoke(id);
+            if (joyConPairDisconnected)
+            {
+                OnGamepadDisconnected?.Invoke(SDL2JoyConPair.Id);
+            }
         }
 
         private void HandleJoyStickConnected(int joystickDeviceId, int joystickInstanceId)
         {
+            bool joyConPairConnected = false;
             if (SDL_IsGameController(joystickDeviceId) == SDL_bool.SDL_TRUE)
             {
                 if (_gamepadsInstanceIdsMapping.ContainsKey(joystickInstanceId))
@@ -120,13 +133,29 @@ namespace Ryujinx.Input.SDL2
                             _gamepadsIds.Insert(joystickDeviceId, id);
                         else
                             _gamepadsIds.Add(id);
+                        if (SDL2JoyConPair.IsCombinable(_gamepadsIds))
+                        {
+                            _gamepadsIds.Remove(SDL2JoyConPair.Id);
+                            _gamepadsIds.Add(SDL2JoyConPair.Id);
+                            joyConPairConnected = true;
+                        }
                     }
 
                     OnGamepadConnected?.Invoke(id);
+                    if (joyConPairConnected)
+                    {
+                        OnGamepadConnected?.Invoke(SDL2JoyConPair.Id);
+                    }
                 }
             }
         }
 
+        private void HandleJoyBatteryUpdated(int joystickDeviceId, SDL_JoystickPowerLevel powerLevel)
+        {
+            Logger.Info?.Print(LogClass.Hid,
+                $"{SDL_GameControllerNameForIndex(joystickDeviceId)} power level: {powerLevel}");
+        }
+
         protected virtual void Dispose(bool disposing)
         {
             if (disposing)
@@ -157,6 +186,14 @@ namespace Ryujinx.Input.SDL2
 
         public IGamepad GetGamepad(string id)
         {
+            if (id == SDL2JoyConPair.Id)
+            {
+                lock (_lock)
+                {
+                    return SDL2JoyConPair.GetGamepad(_gamepadsIds);
+                }
+            }
+
             int joystickIndex = GetJoystickIndexByGamepadId(id);
 
             if (joystickIndex == -1)
@@ -165,12 +202,16 @@ namespace Ryujinx.Input.SDL2
             }
 
             nint gamepadHandle = SDL_GameControllerOpen(joystickIndex);
-
             if (gamepadHandle == nint.Zero)
             {
                 return null;
             }
 
+            if (SDL_GameControllerName(gamepadHandle).StartsWith(SDL2JoyCon.Prefix))
+            {
+                return new SDL2JoyCon(gamepadHandle, id);    
+            }
+
             return new SDL2Gamepad(gamepadHandle, id);
         }
 

src/Ryujinx.Input.SDL2/SDL2JoyCon.cs

@@ -0,0 +1,409 @@
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Hid.Controller;
+using Ryujinx.Common.Logging;
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Threading;
+using static SDL2.SDL;
+
+namespace Ryujinx.Input.SDL2
+{
+    internal class SDL2JoyCon : IGamepad
+    {
+        private bool HasConfiguration => _configuration != null;
+
+        private readonly record struct ButtonMappingEntry(GamepadButtonInputId To, GamepadButtonInputId From)
+        {
+            public bool IsValid => To is not GamepadButtonInputId.Unbound && From is not GamepadButtonInputId.Unbound;
+        }
+
+        private StandardControllerInputConfig _configuration;
+
+        private readonly Dictionary<GamepadButtonInputId,SDL_GameControllerButton> _leftButtonsDriverMapping = new()
+        {
+            { GamepadButtonInputId.LeftStick , SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK },
+             {GamepadButtonInputId.DpadUp ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y},
+             {GamepadButtonInputId.DpadDown ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A},
+             {GamepadButtonInputId.DpadLeft ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B},
+             {GamepadButtonInputId.DpadRight ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X},
+             {GamepadButtonInputId.Minus ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START},
+             {GamepadButtonInputId.LeftShoulder,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE2},
+             {GamepadButtonInputId.LeftTrigger,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE4},
+             {GamepadButtonInputId.SingleRightTrigger0,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+             {GamepadButtonInputId.SingleLeftTrigger0,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
+        };
+        private readonly Dictionary<GamepadButtonInputId,SDL_GameControllerButton> _rightButtonsDriverMapping = new()
+        {
+             {GamepadButtonInputId.RightStick,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK},
+             {GamepadButtonInputId.A,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B},
+             {GamepadButtonInputId.B,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y},
+             {GamepadButtonInputId.X,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A},
+             {GamepadButtonInputId.Y,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X},
+             {GamepadButtonInputId.Plus,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START},
+             {GamepadButtonInputId.RightShoulder,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE1},
+             {GamepadButtonInputId.RightTrigger,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE3},
+             {GamepadButtonInputId.SingleRightTrigger1,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+             {GamepadButtonInputId.SingleLeftTrigger1,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER}
+        };
+
+        private readonly Dictionary<GamepadButtonInputId, SDL_GameControllerButton> _buttonsDriverMapping;
+        private readonly Lock _userMappingLock = new();
+
+        private readonly List<ButtonMappingEntry> _buttonsUserMapping;
+
+        private readonly StickInputId[] _stickUserMapping = new StickInputId[(int)StickInputId.Count]
+        {
+            StickInputId.Unbound, StickInputId.Left, StickInputId.Right,
+        };
+
+        public GamepadFeaturesFlag Features { get; }
+
+        private nint _gamepadHandle;
+
+        private enum JoyConType
+        {
+            Left, Right
+        }
+
+        public const string Prefix = "Nintendo Switch Joy-Con";
+        public const string LeftName = "Nintendo Switch Joy-Con (L)";
+        public const string RightName = "Nintendo Switch Joy-Con (R)";
+
+        private readonly JoyConType _joyConType;
+
+        public SDL2JoyCon(nint gamepadHandle, string driverId)
+        {
+            _gamepadHandle = gamepadHandle;
+            _buttonsUserMapping = new List<ButtonMappingEntry>(10);
+
+            Name = SDL_GameControllerName(_gamepadHandle);
+            Id = driverId;
+            Features = GetFeaturesFlag();
+
+            // Enable motion tracking
+            if (Features.HasFlag(GamepadFeaturesFlag.Motion))
+            {
+                if (SDL_GameControllerSetSensorEnabled(_gamepadHandle, SDL_SensorType.SDL_SENSOR_ACCEL,
+                        SDL_bool.SDL_TRUE) != 0)
+                {
+                    Logger.Error?.Print(LogClass.Hid,
+                        $"Could not enable data reporting for SensorType {SDL_SensorType.SDL_SENSOR_ACCEL}.");
+                }
+
+                if (SDL_GameControllerSetSensorEnabled(_gamepadHandle, SDL_SensorType.SDL_SENSOR_GYRO,
+                        SDL_bool.SDL_TRUE) != 0)
+                {
+                    Logger.Error?.Print(LogClass.Hid,
+                        $"Could not enable data reporting for SensorType {SDL_SensorType.SDL_SENSOR_GYRO}.");
+                }
+            }
+
+            switch (Name)
+            {
+                case LeftName:
+                    {
+                        _buttonsDriverMapping = _leftButtonsDriverMapping;
+                        _joyConType = JoyConType.Left;
+                        break;
+                    }
+                case RightName:
+                    {
+                        _buttonsDriverMapping = _rightButtonsDriverMapping;
+                        _joyConType = JoyConType.Right;
+                        break;
+                    }
+            }
+        }
+
+        private GamepadFeaturesFlag GetFeaturesFlag()
+        {
+            GamepadFeaturesFlag result = GamepadFeaturesFlag.None;
+
+            if (SDL_GameControllerHasSensor(_gamepadHandle, SDL_SensorType.SDL_SENSOR_ACCEL) == SDL_bool.SDL_TRUE &&
+                SDL_GameControllerHasSensor(_gamepadHandle, SDL_SensorType.SDL_SENSOR_GYRO) == SDL_bool.SDL_TRUE)
+            {
+                result |= GamepadFeaturesFlag.Motion;
+            }
+
+            int error = SDL_GameControllerRumble(_gamepadHandle, 0, 0, 100);
+
+            if (error == 0)
+            {
+                result |= GamepadFeaturesFlag.Rumble;
+            }
+
+            return result;
+        }
+
+        public string Id { get; }
+        public string Name { get; }
+        public bool IsConnected => SDL_GameControllerGetAttached(_gamepadHandle) == SDL_bool.SDL_TRUE;
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing && _gamepadHandle != nint.Zero)
+            {
+                SDL_GameControllerClose(_gamepadHandle);
+
+                _gamepadHandle = nint.Zero;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+
+        public void SetTriggerThreshold(float triggerThreshold)
+        {
+
+        }
+
+        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            if (!Features.HasFlag(GamepadFeaturesFlag.Rumble))
+                return;
+
+            ushort lowFrequencyRaw = (ushort)(lowFrequency * ushort.MaxValue);
+            ushort highFrequencyRaw = (ushort)(highFrequency * ushort.MaxValue);
+
+            if (durationMs == uint.MaxValue)
+            {
+                if (SDL_GameControllerRumble(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, SDL_HAPTIC_INFINITY) !=
+                    0)
+                    Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
+            }
+            else if (durationMs > SDL_HAPTIC_INFINITY)
+            {
+                Logger.Error?.Print(LogClass.Hid, $"Unsupported rumble duration {durationMs}");
+            }
+            else
+            {
+                if (SDL_GameControllerRumble(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, durationMs) != 0)
+                    Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
+            }
+        }
+
+        public Vector3 GetMotionData(MotionInputId inputId)
+        {
+            SDL_SensorType sensorType = inputId switch
+            {
+                MotionInputId.Accelerometer => SDL_SensorType.SDL_SENSOR_ACCEL,
+                MotionInputId.Gyroscope => SDL_SensorType.SDL_SENSOR_GYRO,
+                _ => SDL_SensorType.SDL_SENSOR_INVALID
+            };
+
+            if (!Features.HasFlag(GamepadFeaturesFlag.Motion) || sensorType is SDL_SensorType.SDL_SENSOR_INVALID)
+                return Vector3.Zero;
+
+            const int ElementCount = 3;
+
+            unsafe
+            {
+                float* values = stackalloc float[ElementCount];
+
+                int result = SDL_GameControllerGetSensorData(_gamepadHandle, sensorType, (nint)values, ElementCount);
+
+                if (result != 0)
+                    return Vector3.Zero;
+
+                Vector3 value = _joyConType switch
+                {
+                    JoyConType.Left => new Vector3(-values[2], values[1], values[0]),
+                    JoyConType.Right => new Vector3(values[2], values[1], -values[0])
+                };
+
+                return inputId switch
+                {
+                    MotionInputId.Gyroscope => RadToDegree(value),
+                    MotionInputId.Accelerometer => GsToMs2(value),
+                    _ => value
+                };
+            }
+        }
+
+        private static Vector3 RadToDegree(Vector3 rad) => rad * (180 / MathF.PI);
+
+        private static Vector3 GsToMs2(Vector3 gs) => gs / SDL_STANDARD_GRAVITY;
+
+        public void SetConfiguration(InputConfig configuration)
+        {
+            lock (_userMappingLock)
+            {
+                _configuration = (StandardControllerInputConfig)configuration;
+
+                _buttonsUserMapping.Clear();
+
+                // First update sticks
+                _stickUserMapping[(int)StickInputId.Left] = (StickInputId)_configuration.LeftJoyconStick.Joystick;
+                _stickUserMapping[(int)StickInputId.Right] = (StickInputId)_configuration.RightJoyconStick.Joystick;
+
+
+                switch (_joyConType)
+                {
+                    case JoyConType.Left:
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftStick, (GamepadButtonInputId)_configuration.LeftJoyconStick.StickButton));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadUp, (GamepadButtonInputId)_configuration.LeftJoycon.DpadUp));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadDown, (GamepadButtonInputId)_configuration.LeftJoycon.DpadDown));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadLeft, (GamepadButtonInputId)_configuration.LeftJoycon.DpadLeft));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadRight, (GamepadButtonInputId)_configuration.LeftJoycon.DpadRight));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Minus, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonMinus));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftShoulder, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonL));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftTrigger, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonZl));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger0, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonSr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonSl));
+                        break;
+                    case JoyConType.Right:
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightStick, (GamepadButtonInputId)_configuration.RightJoyconStick.StickButton));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.A, (GamepadButtonInputId)_configuration.RightJoycon.ButtonA));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.B, (GamepadButtonInputId)_configuration.RightJoycon.ButtonB));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.X, (GamepadButtonInputId)_configuration.RightJoycon.ButtonX));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Y, (GamepadButtonInputId)_configuration.RightJoycon.ButtonY));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Plus, (GamepadButtonInputId)_configuration.RightJoycon.ButtonPlus));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightShoulder, (GamepadButtonInputId)_configuration.RightJoycon.ButtonR));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightTrigger, (GamepadButtonInputId)_configuration.RightJoycon.ButtonZr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger1, (GamepadButtonInputId)_configuration.RightJoycon.ButtonSr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger1, (GamepadButtonInputId)_configuration.RightJoycon.ButtonSl));
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+                
+                SetTriggerThreshold(_configuration.TriggerThreshold);
+            }
+        }
+
+        public GamepadStateSnapshot GetStateSnapshot()
+        {
+            return IGamepad.GetStateSnapshot(this);
+        }
+
+        public GamepadStateSnapshot GetMappedStateSnapshot()
+        {
+            GamepadStateSnapshot rawState = GetStateSnapshot();
+            GamepadStateSnapshot result = default;
+
+            lock (_userMappingLock)
+            {
+                if (_buttonsUserMapping.Count == 0)
+                    return rawState;
+
+
+                // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
+                foreach (ButtonMappingEntry entry in _buttonsUserMapping)
+                {
+                    if (!entry.IsValid)
+                        continue;
+
+                    // Do not touch state of button already pressed
+                    if (!result.IsPressed(entry.To))
+                    {
+                        result.SetPressed(entry.To, rawState.IsPressed(entry.From));
+                    }
+                }
+
+                (float leftStickX, float leftStickY) = rawState.GetStick(_stickUserMapping[(int)StickInputId.Left]);
+                (float rightStickX, float rightStickY) = rawState.GetStick(_stickUserMapping[(int)StickInputId.Right]);
+
+                result.SetStick(StickInputId.Left, leftStickX, leftStickY);
+                result.SetStick(StickInputId.Right, rightStickX, rightStickY);
+            }
+
+            return result;
+        }
+
+
+        private static float ConvertRawStickValue(short value)
+        {
+            const float ConvertRate = 1.0f / (short.MaxValue + 0.5f);
+
+            return value * ConvertRate;
+        }
+
+        private JoyconConfigControllerStick<GamepadInputId, Common.Configuration.Hid.Controller.StickInputId>
+            GetLogicalJoyStickConfig(StickInputId inputId)
+        {
+            switch (inputId)
+            {
+                case StickInputId.Left:
+                    if (_configuration.RightJoyconStick.Joystick ==
+                        Common.Configuration.Hid.Controller.StickInputId.Left)
+                        return _configuration.RightJoyconStick;
+                    else
+                        return _configuration.LeftJoyconStick;
+                case StickInputId.Right:
+                    if (_configuration.LeftJoyconStick.Joystick ==
+                        Common.Configuration.Hid.Controller.StickInputId.Right)
+                        return _configuration.LeftJoyconStick;
+                    else
+                        return _configuration.RightJoyconStick;
+            }
+
+            return null;
+        }
+
+
+        public (float, float) GetStick(StickInputId inputId)
+        {
+            if (inputId == StickInputId.Unbound)
+                return (0.0f, 0.0f);
+
+            if (inputId == StickInputId.Left && _joyConType == JoyConType.Right || inputId == StickInputId.Right && _joyConType == JoyConType.Left)
+            {
+                return (0.0f, 0.0f);
+            }
+            
+            (short stickX, short stickY) = GetStickXY();
+
+            float resultX = ConvertRawStickValue(stickX);
+            float resultY = -ConvertRawStickValue(stickY);
+
+            if (HasConfiguration)
+            {
+                var joyconStickConfig = GetLogicalJoyStickConfig(inputId);
+
+                if (joyconStickConfig != null)
+                {
+                    if (joyconStickConfig.InvertStickX)
+                        resultX = -resultX;
+
+                    if (joyconStickConfig.InvertStickY)
+                        resultY = -resultY;
+
+                    if (joyconStickConfig.Rotate90CW)
+                    {
+                        float temp = resultX;
+                        resultX = resultY;
+                        resultY = -temp;
+                    }
+                }
+            }
+
+            return inputId switch
+            {
+                StickInputId.Left when _joyConType == JoyConType.Left => (resultY, -resultX),
+                StickInputId.Right when _joyConType == JoyConType.Right => (-resultY, resultX),
+                _ => (0.0f, 0.0f)
+            };
+        }
+
+        private (short, short) GetStickXY()
+        {
+            return (
+                SDL_GameControllerGetAxis(_gamepadHandle, SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTX),
+                SDL_GameControllerGetAxis(_gamepadHandle, SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTY));
+        }
+        
+        public bool IsPressed(GamepadButtonInputId inputId)
+        {
+            if (!_buttonsDriverMapping.TryGetValue(inputId, out var button))
+            {
+                return false;
+            }
+
+            return SDL_GameControllerGetButton(_gamepadHandle, button) == 1;
+        }
+    }
+}

src/Ryujinx.Input.SDL2/SDL2JoyConPair.cs

@@ -0,0 +1,142 @@
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Hid.Controller;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using static SDL2.SDL;
+
+namespace Ryujinx.Input.SDL2
+{
+    internal class SDL2JoyConPair(IGamepad left, IGamepad right) : IGamepad
+    {
+        private StandardControllerInputConfig _configuration;
+
+        private readonly StickInputId[] _stickUserMapping =
+        [
+            StickInputId.Unbound,
+            StickInputId.Left,
+            StickInputId.Right
+        ];
+
+        public GamepadFeaturesFlag Features => (left?.Features ?? GamepadFeaturesFlag.None) |
+                                               (right?.Features ?? GamepadFeaturesFlag.None);
+
+        public const string Id = "JoyConPair";
+        string IGamepad.Id => Id;
+
+        public string Name => "* Nintendo Switch Joy-Con (L/R)";
+        public bool IsConnected => left is { IsConnected: true } && right is { IsConnected: true };
+
+        public void Dispose()
+        {
+            left?.Dispose();
+            right?.Dispose();
+        }
+
+        public GamepadStateSnapshot GetMappedStateSnapshot()
+        {
+            return GetStateSnapshot();
+        }
+
+        public Vector3 GetMotionData(MotionInputId inputId)
+        {
+            return inputId switch
+            {
+                MotionInputId.Accelerometer or
+                    MotionInputId.Gyroscope => left.GetMotionData(inputId),
+                MotionInputId.SecondAccelerometer => right.GetMotionData(MotionInputId.Accelerometer),
+                MotionInputId.SecondGyroscope => right.GetMotionData(MotionInputId.Gyroscope),
+                _ => Vector3.Zero
+            };
+        }
+
+        public GamepadStateSnapshot GetStateSnapshot()
+        {
+            return IGamepad.GetStateSnapshot(this);
+        }
+
+        public (float, float) GetStick(StickInputId inputId)
+        {
+            return inputId switch
+            {
+                StickInputId.Left => left.GetStick(StickInputId.Left),
+                StickInputId.Right => right.GetStick(StickInputId.Right),
+                _ => (0, 0)
+            };
+        }
+
+        public bool IsPressed(GamepadButtonInputId inputId)
+        {
+            return left.IsPressed(inputId) || right.IsPressed(inputId);
+        }
+
+        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            if (lowFrequency != 0)
+            {
+                right.Rumble(lowFrequency, lowFrequency, durationMs);
+            }
+
+            if (highFrequency != 0)
+            {
+                left.Rumble(highFrequency, highFrequency, durationMs);
+            }
+
+            if (lowFrequency == 0 && highFrequency == 0)
+            {
+                left.Rumble(0, 0, durationMs);
+                right.Rumble(0, 0, durationMs);
+            }
+        }
+
+        public void SetConfiguration(InputConfig configuration)
+        {
+            left.SetConfiguration(configuration);
+            right.SetConfiguration(configuration);
+        }
+
+        public void SetTriggerThreshold(float triggerThreshold)
+        {
+            left.SetTriggerThreshold(triggerThreshold);
+            right.SetTriggerThreshold(triggerThreshold);
+        }
+
+        public static bool IsCombinable(List<string> gamepadsIds)
+        {
+            (int leftIndex, int rightIndex) = DetectJoyConPair(gamepadsIds);
+            return leftIndex >= 0 && rightIndex >= 0;
+        }
+
+        private static (int leftIndex, int rightIndex) DetectJoyConPair(List<string> gamepadsIds)
+        {
+            var gamepadNames = gamepadsIds.Where(gamepadId => gamepadId != Id)
+                .Select((_, index) => SDL_GameControllerNameForIndex(index)).ToList();
+            int leftIndex = gamepadNames.IndexOf(SDL2JoyCon.LeftName);
+            int rightIndex = gamepadNames.IndexOf(SDL2JoyCon.RightName);
+
+            return (leftIndex, rightIndex);
+        }
+
+        public static IGamepad GetGamepad(List<string> gamepadsIds)
+        {
+            (int leftIndex, int rightIndex) = DetectJoyConPair(gamepadsIds);
+            if (leftIndex == -1 || rightIndex == -1)
+            {
+                return null;
+            }
+
+            nint leftGamepadHandle = SDL_GameControllerOpen(leftIndex);
+            nint rightGamepadHandle = SDL_GameControllerOpen(rightIndex);
+
+            if (leftGamepadHandle == nint.Zero || rightGamepadHandle == nint.Zero)
+            {
+                return null;
+            }
+
+
+            return new SDL2JoyConPair(new SDL2JoyCon(leftGamepadHandle, gamepadsIds[leftIndex]),
+                new SDL2JoyCon(rightGamepadHandle, gamepadsIds[rightIndex]));
+        }
+    }
+}

src/Ryujinx.Input/HLE/NpadController.cs

@@ -269,6 +269,7 @@ namespace Ryujinx.Input.HLE
             if (motionConfig.MotionBackend != MotionInputBackendType.CemuHook)
             {
                 _leftMotionInput = new MotionInput();
+                _rightMotionInput = new MotionInput();
             }
             else
             {
@@ -301,7 +302,20 @@ namespace Ryujinx.Input.HLE
 
                             if (controllerConfig.ControllerType == ConfigControllerType.JoyconPair)
                             {
-                                _rightMotionInput = _leftMotionInput;
+                                if (gamepad.Id== "JoyConPair")
+                                {
+                                    Vector3 rightAccelerometer = gamepad.GetMotionData(MotionInputId.SecondAccelerometer);
+                                    Vector3 rightGyroscope = gamepad.GetMotionData(MotionInputId.SecondGyroscope);
+
+                                    rightAccelerometer = new Vector3(rightAccelerometer.X, -rightAccelerometer.Z, rightAccelerometer.Y);
+                                    rightGyroscope = new Vector3(rightGyroscope.X, -rightGyroscope.Z, rightGyroscope.Y);
+
+                                    _rightMotionInput.Update(rightAccelerometer, rightGyroscope, (ulong)PerformanceCounter.ElapsedNanoseconds / 1000, controllerConfig.Motion.Sensitivity, (float)controllerConfig.Motion.GyroDeadzone);
+                                }
+                                else
+                                {
+                                    _rightMotionInput = _leftMotionInput;
+                                }
                             }
                         }
                     }
@@ -336,6 +350,7 @@ namespace Ryujinx.Input.HLE
                 // Reset states
                 State = default;
                 _leftMotionInput = null;
+                _rightMotionInput = null;
             }
         }
 

src/Ryujinx.Input/MotionInputId.cs

@@ -21,5 +21,17 @@ namespace Ryujinx.Input
         /// </summary>
         /// <remarks>Values are in degrees</remarks>
         Gyroscope,
+
+        /// <summary>
+        /// Second accelerometer.
+        /// </summary>
+        /// <remarks>Values are in m/s^2</remarks>
+        SecondAccelerometer,
+
+        /// <summary>
+        /// Second gyroscope.
+        /// </summary>
+        /// <remarks>Values are in degrees</remarks>
+        SecondGyroscope
     }
 }

src/Ryujinx.SDL2.Common/SDL2Driver.cs

@@ -25,14 +25,17 @@ namespace Ryujinx.SDL2.Common
 
         public static Action<Action> MainThreadDispatcher { get; set; }
 
-        private const uint SdlInitFlags = SDL_INIT_EVENTS | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO | SDL_INIT_VIDEO;
+        private const uint SdlInitFlags = SDL_INIT_EVENTS | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK |
+                                          SDL_INIT_AUDIO | SDL_INIT_VIDEO;
 
         private bool _isRunning;
         private uint _refereceCount;
         private Thread _worker;
 
+        private const uint SDL_JOYBATTERYUPDATED = 1543;
         public event Action<int, int> OnJoyStickConnected;
         public event Action<int> OnJoystickDisconnected;
+        public event Action<int, SDL_JoystickPowerLevel> OnJoyBatteryUpdated;
 
         private ConcurrentDictionary<uint, Action<SDL_Event>> _registeredWindowHandlers;
 
@@ -78,12 +81,14 @@ namespace Ryujinx.SDL2.Common
                 // First ensure that we only enable joystick events (for connected/disconnected).
                 if (SDL_GameControllerEventState(SDL_IGNORE) != SDL_IGNORE)
                 {
-                    Logger.Error?.PrintMsg(LogClass.Application, "Couldn't change the state of game controller events.");
+                    Logger.Error?.PrintMsg(LogClass.Application,
+                        "Couldn't change the state of game controller events.");
                 }
 
                 if (SDL_JoystickEventState(SDL_ENABLE) < 0)
                 {
-                    Logger.Error?.PrintMsg(LogClass.Application, $"Failed to enable joystick event polling: {SDL_GetError()}");
+                    Logger.Error?.PrintMsg(LogClass.Application,
+                        $"Failed to enable joystick event polling: {SDL_GetError()}");
                 }
 
                 // Disable all joysticks information, we don't need them no need to flood the event queue for that.
@@ -143,7 +148,12 @@ namespace Ryujinx.SDL2.Common
 
                 OnJoystickDisconnected?.Invoke(evnt.cbutton.which);
             }
-            else if (evnt.type is SDL_EventType.SDL_WINDOWEVENT or SDL_EventType.SDL_MOUSEBUTTONDOWN or SDL_EventType.SDL_MOUSEBUTTONUP)
+            else if ((uint)evnt.type == SDL_JOYBATTERYUPDATED)
+            {
+                OnJoyBatteryUpdated?.Invoke(evnt.cbutton.which, (SDL_JoystickPowerLevel)evnt.user.code);
+            }
+            else if (evnt.type is SDL_EventType.SDL_WINDOWEVENT or SDL_EventType.SDL_MOUSEBUTTONDOWN
+                     or SDL_EventType.SDL_MOUSEBUTTONUP)
             {
                 if (_registeredWindowHandlers.TryGetValue(evnt.window.windowID, out Action<SDL_Event> handler))
                 {

src/Ryujinx/AppHost.cs

@@ -902,53 +902,19 @@ namespace Ryujinx.Ava
                 _ => new OpenGLRenderer()
             };
 
-            BackendThreading threadingMode = ConfigurationState.Instance.Graphics.BackendThreading;
-
-            bool isGALThreaded = threadingMode == BackendThreading.On || (threadingMode == BackendThreading.Auto && renderer.PreferThreading);
-            if (isGALThreaded)
-            {
-                renderer = new ThreadedRenderer(renderer);
-            }
-
-            Logger.Info?.PrintMsg(LogClass.Gpu, $"Backend Threading ({threadingMode}): {isGALThreaded}");
-
             // Initialize Configuration.
-            MemoryConfiguration memoryConfiguration = ConfigurationState.Instance.System.DramSize.Value;
+            Device = new Switch(ConfigurationState.Instance.CreateHleConfiguration()
-
+                .Configure(
-            Device = new Switch(new HLEConfiguration(
+                    VirtualFileSystem,
-                VirtualFileSystem,
+                    _viewModel.LibHacHorizonManager,
-                _viewModel.LibHacHorizonManager,
+                    ContentManager,
-                ContentManager,
+                    _accountManager,
-                _accountManager,
+                    _userChannelPersistence,
-                _userChannelPersistence,
+                    renderer.TryMakeThreaded(ConfigurationState.Instance.Graphics.BackendThreading),
-                renderer,
+                    InitializeAudio(),
-                InitializeAudio(),
+                    _viewModel.UiHandler
-                memoryConfiguration,
+                )
-                _viewModel.UiHandler,
+            );
-                (SystemLanguage)ConfigurationState.Instance.System.Language.Value,
-                (RegionCode)ConfigurationState.Instance.System.Region.Value,
-                ConfigurationState.Instance.Graphics.VSyncMode,
-                ConfigurationState.Instance.System.EnableDockedMode,
-                ConfigurationState.Instance.System.EnablePtc,
-                ConfigurationState.Instance.System.EnableInternetAccess,
-                ConfigurationState.Instance.System.EnableFsIntegrityChecks ? IntegrityCheckLevel.ErrorOnInvalid : IntegrityCheckLevel.None,
-                ConfigurationState.Instance.System.FsGlobalAccessLogMode,
-                ConfigurationState.Instance.System.MatchSystemTime 
-                    ? 0 
-                    : ConfigurationState.Instance.System.SystemTimeOffset,
-                ConfigurationState.Instance.System.TimeZone,
-                ConfigurationState.Instance.System.MemoryManagerMode,
-                ConfigurationState.Instance.System.IgnoreMissingServices,
-                ConfigurationState.Instance.Graphics.AspectRatio,
-                ConfigurationState.Instance.System.AudioVolume,
-                ConfigurationState.Instance.System.UseHypervisor,
-                ConfigurationState.Instance.Multiplayer.LanInterfaceId.Value,
-                ConfigurationState.Instance.Multiplayer.Mode,
-                ConfigurationState.Instance.Multiplayer.DisableP2p,
-                ConfigurationState.Instance.Multiplayer.LdnPassphrase,
-                ConfigurationState.Instance.Multiplayer.GetLdnServer(),
-                ConfigurationState.Instance.Graphics.CustomVSyncInterval.Value,
-                ConfigurationState.Instance.Hacks.ShowDirtyHacks ? ConfigurationState.Instance.Hacks.EnabledHacks : null));
         }
 
         private static IHardwareDeviceDriver InitializeAudio()
@@ -1182,6 +1148,9 @@ namespace Ryujinx.Ava
 
         private void UpdateShaderCount()
         {
+            if (_displayCount is 0 && _renderer.ProgramCount is 0)
+                return;
+            
             // If there is a mismatch between total program compile and previous count
             // this means new shaders have been compiled and should be displayed.
             if (_renderer.ProgramCount != _previousCount)
@@ -1255,12 +1224,10 @@ namespace Ryujinx.Ava
                             VSyncModeToggle();
                             break;
                         case KeyboardHotkeyState.CustomVSyncIntervalDecrement:
-                            Device.DecrementCustomVSyncInterval();
+                            _viewModel.CustomVSyncInterval = Device.DecrementCustomVSyncInterval();
-                            _viewModel.CustomVSyncInterval -= 1;
                             break;
                         case KeyboardHotkeyState.CustomVSyncIntervalIncrement:
-                            Device.IncrementCustomVSyncInterval();
+                            _viewModel.CustomVSyncInterval = Device.IncrementCustomVSyncInterval();
-                            _viewModel.CustomVSyncInterval += 1;
                             break;
                         case KeyboardHotkeyState.Screenshot:
                             ScreenshotRequested = true;

src/Ryujinx/Common/ApplicationHelper.cs

@@ -13,7 +13,7 @@ using LibHac.Tools.Fs;
 using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
 using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Ava.UI.Controls;
+using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.Utilities;
 using Ryujinx.Ava.Utilities.Configuration;

src/Ryujinx/Headless/HeadlessRyujinx.Init.cs

@@ -312,49 +312,42 @@ namespace Ryujinx.Headless
             return new OpenGLRenderer();
         }
 
-        private static Switch InitializeEmulationContext(WindowBase window, IRenderer renderer, Options options)
+        private static Switch InitializeEmulationContext(WindowBase window, IRenderer renderer, Options options) =>
-        {
+            new(
-            BackendThreading threadingMode = options.BackendThreading;
+                new HleConfiguration(
-
+                        options.DramSize,
-            bool threadedGAL = threadingMode == BackendThreading.On || (threadingMode == BackendThreading.Auto && renderer.PreferThreading);
+                        options.SystemLanguage,
-
+                        options.SystemRegion,
-            if (threadedGAL)
+                        options.VSyncMode,
-            {
+                        !options.DisableDockedMode,
-                renderer = new ThreadedRenderer(renderer);
+                        !options.DisablePTC,
-            }
+                        options.EnableInternetAccess,
-
+                        !options.DisableFsIntegrityChecks ? IntegrityCheckLevel.ErrorOnInvalid : IntegrityCheckLevel.None,
-            HLEConfiguration configuration = new(_virtualFileSystem,
+                        options.FsGlobalAccessLogMode,
-                _libHacHorizonManager,
+                        options.SystemTimeOffset,
-                _contentManager,
+                        options.SystemTimeZone,
-                _accountManager,
+                        options.MemoryManagerMode,
-                _userChannelPersistence,
+                        options.IgnoreMissingServices,
-                renderer,
+                        options.AspectRatio,
-                new SDL2HardwareDeviceDriver(),
+                        options.AudioVolume,
-                options.DramSize,
+                        options.UseHypervisor ?? true,
-                window,
+                        options.MultiplayerLanInterfaceId,
-                options.SystemLanguage,
+                        Common.Configuration.Multiplayer.MultiplayerMode.Disabled,
-                options.SystemRegion,
+                        false,
-                options.VSyncMode,
+                        string.Empty,
-                !options.DisableDockedMode,
+                        string.Empty,
-                !options.DisablePTC,
+                        options.CustomVSyncInterval
-                options.EnableInternetAccess,
+                    )
-                !options.DisableFsIntegrityChecks ? IntegrityCheckLevel.ErrorOnInvalid : IntegrityCheckLevel.None,
+                    .Configure(
-                options.FsGlobalAccessLogMode,
+                        _virtualFileSystem,
-                options.SystemTimeOffset,
+                        _libHacHorizonManager,
-                options.SystemTimeZone,
+                        _contentManager,
-                options.MemoryManagerMode,
+                        _accountManager,
-                options.IgnoreMissingServices,
+                        _userChannelPersistence,
-                options.AspectRatio,
+                        renderer.TryMakeThreaded(options.BackendThreading),
-                options.AudioVolume,
+                        new SDL2HardwareDeviceDriver(),
-                options.UseHypervisor ?? true,
+                        window
-                options.MultiplayerLanInterfaceId,
+                    )
-                Common.Configuration.Multiplayer.MultiplayerMode.Disabled,
+            );
-                false,
-                string.Empty,
-                string.Empty,
-                options.CustomVSyncInterval);
-
-            return new Switch(configuration);
-        }
     }
 }

src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml.cs

@@ -9,6 +9,7 @@ using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Common.Models;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
+using Ryujinx.Ava.UI.Views.Misc;
 using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Ava.Utilities;
 using Ryujinx.Ava.Utilities.AppLibrary;

src/Ryujinx/UI/Controls/RyujinxControl.cs

@@ -9,9 +9,15 @@ namespace Ryujinx.Ava.UI.Controls
     {
         public TViewModel ViewModel
         {
-            get => (TViewModel)DataContext ?? throw new InvalidOperationException(
+            get
-                $"Underlying DataContext is not of type {typeof(TViewModel).AsPrettyString()}; " +
+            {
-                $"Actual type is {DataContext?.GetType().AsPrettyString()}");
+                if (DataContext is not TViewModel viewModel)
+                    throw new InvalidOperationException(
+                        $"Underlying DataContext is not of type {typeof(TViewModel).AsPrettyString()}; " +
+                        $"Actual type is {DataContext?.GetType().AsPrettyString()}");
+
+                return viewModel;
+            }
             set => DataContext = value;
         }
     }

src/Ryujinx/UI/Helpers/ContentDialogHelper.cs

@@ -4,6 +4,7 @@ using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Input;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Styling;
 using Avalonia.Threading;
 using FluentAvalonia.Core;
 using FluentAvalonia.UI.Controls;
@@ -21,6 +22,23 @@ namespace Ryujinx.Ava.UI.Helpers
         private static bool _isChoiceDialogOpen;
         private static ContentDialogOverlayWindow _contentDialogOverlayWindow;
 
+        public static ContentDialog ApplyStyles(
+            this ContentDialog contentDialog, 
+            double closeButtonWidth = 80, 
+            HorizontalAlignment buttonSpaceAlignment = HorizontalAlignment.Right)
+        {
+            Style closeButton = new(x => x.Name("CloseButton"));
+            closeButton.Setters.Add(new Setter(Layoutable.WidthProperty, closeButtonWidth));
+            
+            Style closeButtonParent = new(x => x.Name("CommandSpace"));
+            closeButtonParent.Setters.Add(new Setter(Layoutable.HorizontalAlignmentProperty, buttonSpaceAlignment));
+
+            contentDialog.Styles.Add(closeButton);
+            contentDialog.Styles.Add(closeButtonParent);
+
+            return contentDialog;
+        }
+
         private async static Task<UserResult> ShowContentDialog(
              string title,
              object content,
@@ -40,19 +58,19 @@ namespace Ryujinx.Ava.UI.Helpers
                 SecondaryButtonText = secondaryButton,
                 CloseButtonText = closeButton,
                 Content = content,
-                PrimaryButtonCommand = MiniCommand.Create(() =>
+                PrimaryButtonCommand = Commands.Create(() =>
                 {
                     result = primaryButtonResult;
                 })
             };
 
-            contentDialog.SecondaryButtonCommand = MiniCommand.Create(() =>
+            contentDialog.SecondaryButtonCommand = Commands.Create(() =>
             {
                 result = UserResult.No;
                 contentDialog.PrimaryButtonClick -= deferCloseAction;
             });
 
-            contentDialog.CloseButtonCommand = MiniCommand.Create(() =>
+            contentDialog.CloseButtonCommand = Commands.Create(() =>
             {
                 result = UserResult.Cancel;
                 contentDialog.PrimaryButtonClick -= deferCloseAction;

src/Ryujinx/UI/Helpers/MiniCommand.cs

@@ -1,72 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using System.Windows.Input;
-
-namespace Ryujinx.Ava.UI.Helpers
-{
-    public sealed class MiniCommand<T> : MiniCommand, ICommand
-    {
-        private readonly Action<T> _callback;
-        private bool _busy;
-        private readonly Func<T, Task> _asyncCallback;
-
-        public MiniCommand(Action<T> callback)
-        {
-            _callback = callback;
-        }
-
-        public MiniCommand(Func<T, Task> callback)
-        {
-            _asyncCallback = callback;
-        }
-
-        private bool Busy
-        {
-            get => _busy;
-            set
-            {
-                _busy = value;
-                CanExecuteChanged?.Invoke(this, EventArgs.Empty);
-            }
-        }
-
-        public override event EventHandler CanExecuteChanged;
-        public override bool CanExecute(object parameter) => !_busy;
-
-        public override async void Execute(object parameter)
-        {
-            if (Busy)
-            {
-                return;
-            }
-            try
-            {
-                Busy = true;
-                if (_callback != null)
-                {
-                    _callback((T)parameter);
-                }
-                else
-                {
-                    await _asyncCallback((T)parameter);
-                }
-            }
-            finally
-            {
-                Busy = false;
-            }
-        }
-    }
-
-    public abstract class MiniCommand : ICommand
-    {
-        public static MiniCommand Create(Action callback) => new MiniCommand<object>(_ => callback());
-        public static MiniCommand Create<TArg>(Action<TArg> callback) => new MiniCommand<TArg>(callback);
-        public static MiniCommand CreateFromTask(Func<Task> callback) => new MiniCommand<object>(_ => callback());
-        public static MiniCommand CreateFromTask<TArg>(Func<TArg, Task> callback) => new MiniCommand<TArg>(callback);
-
-        public abstract bool CanExecute(object parameter);
-        public abstract void Execute(object parameter);
-        public abstract event EventHandler CanExecuteChanged;
-    }
-}

src/Ryujinx/UI/Views/Main/MainMenuBarView.axaml.cs

@@ -73,7 +73,7 @@ namespace Ryujinx.Ava.UI.Views.Main
                     {
                         Content = $".{it.FileName}",
                         IsChecked = it.FileType.GetConfigValue(ConfigurationState.Instance.UI.ShownFileTypes),
-                        Command = MiniCommand.Create(() => Window.ToggleFileType(it.FileName))
+                        Command = Commands.Create(() => Window.ToggleFileType(it.FileName))
                     }
                 );
 
@@ -108,7 +108,7 @@ namespace Ryujinx.Ava.UI.Views.Main
                     Margin = new Thickness(3, 0, 3, 0),
                     HorizontalAlignment = HorizontalAlignment.Stretch,
                     Header = languageName,
-                    Command = MiniCommand.Create(() => MainWindowViewModel.ChangeLanguage(language))
+                    Command = Commands.Create(() => MainWindowViewModel.ChangeLanguage(language))
                 };
 
                 yield return menuItem;

src/Ryujinx/UI/Views/Misc/ApplicationDataView.axaml

@@ -7,7 +7,7 @@
              xmlns:ui="using:FluentAvalonia.UI.Controls"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
-             x:Class="Ryujinx.Ava.UI.Controls.ApplicationDataView"
+             x:Class="Ryujinx.Ava.UI.Views.Misc.ApplicationDataView"
              x:DataType="viewModels:ApplicationDataViewModel">
     <StackPanel Orientation="Horizontal">
         <Image Margin="0"

src/Ryujinx/UI/Views/Misc/ApplicationDataView.axaml.cs

@@ -1,9 +1,11 @@
 using Avalonia.Controls;
 using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
+using Avalonia.Layout;
 using Avalonia.Styling;
 using FluentAvalonia.UI.Controls;
 using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.UI.Controls;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.UI.Windows;
@@ -12,7 +14,7 @@ using Ryujinx.Ava.Utilities.Compat;
 using System.Linq;
 using System.Threading.Tasks;
 
-namespace Ryujinx.Ava.UI.Controls
+namespace Ryujinx.Ava.UI.Views.Misc
 {
     public partial class ApplicationDataView : RyujinxControl<ApplicationDataViewModel>
     {
@@ -28,17 +30,7 @@ namespace Ryujinx.Ava.UI.Controls
                 Content = new ApplicationDataView { ViewModel = new ApplicationDataViewModel(appData) }
             };
 
-            Style closeButton = new(x => x.Name("CloseButton"));
+            await ContentDialogHelper.ShowAsync(contentDialog.ApplyStyles(160, HorizontalAlignment.Center));
-            closeButton.Setters.Add(new Setter(WidthProperty, 160d));
-
-            Style closeButtonParent = new(x => x.Name("CommandSpace"));
-            closeButtonParent.Setters.Add(new Setter(HorizontalAlignmentProperty,
-                Avalonia.Layout.HorizontalAlignment.Center));
-
-            contentDialog.Styles.Add(closeButton);
-            contentDialog.Styles.Add(closeButtonParent);
-
-            await ContentDialogHelper.ShowAsync(contentDialog);
         }
         
         public ApplicationDataView()

src/Ryujinx/UI/Views/Misc/ApplicationGridView.axaml

@@ -1,5 +1,5 @@
 <UserControl
-    x:Class="Ryujinx.Ava.UI.Controls.ApplicationGridView"
+    x:Class="Ryujinx.Ava.UI.Views.Misc.ApplicationGridView"
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:controls="clr-namespace:Ryujinx.Ava.UI.Controls"

src/Ryujinx/UI/Views/Misc/ApplicationGridView.axaml.cs

@@ -1,12 +1,13 @@
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Interactivity;
+using Ryujinx.Ava.UI.Controls;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.Utilities.AppLibrary;
 using System;
 
-namespace Ryujinx.Ava.UI.Controls
+namespace Ryujinx.Ava.UI.Views.Misc
 {
     public partial class ApplicationGridView : RyujinxControl<MainWindowViewModel>
     {

src/Ryujinx/UI/Views/Misc/ApplicationListView.axaml

@@ -1,5 +1,5 @@
 <UserControl
-    x:Class="Ryujinx.Ava.UI.Controls.ApplicationListView"
+    x:Class="Ryujinx.Ava.UI.Views.Misc.ApplicationListView"
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

src/Ryujinx/UI/Views/Misc/ApplicationListView.axaml.cs

@@ -2,6 +2,7 @@ using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
+using Ryujinx.Ava.UI.Controls;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.Utilities.AppLibrary;
@@ -9,7 +10,7 @@ using Ryujinx.Ava.Utilities.Compat;
 using System;
 using System.Linq;
 
-namespace Ryujinx.Ava.UI.Controls
+namespace Ryujinx.Ava.UI.Views.Misc
 {
     public partial class ApplicationListView : RyujinxControl<MainWindowViewModel>
     {

src/Ryujinx/UI/Views/Misc/DlcSelectView.axaml

@@ -7,7 +7,7 @@
              xmlns:models="using:Ryujinx.Ava.Common.Models"
              xmlns:viewModels="using:Ryujinx.Ava.UI.ViewModels"
              mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
-             x:Class="Ryujinx.Ava.UI.Controls.DlcSelectView"
+             x:Class="Ryujinx.Ava.UI.Views.Misc.DlcSelectView"
              x:DataType="viewModels:DlcSelectViewModel">
     <Grid RowDefinitions="*,Auto,*">
         <TextBlock

src/Ryujinx/UI/Views/Misc/DlcSelectView.axaml.cs

@@ -3,12 +3,13 @@ using Avalonia.Styling;
 using FluentAvalonia.UI.Controls;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Common.Models;
+using Ryujinx.Ava.UI.Controls;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.Utilities.AppLibrary;
 using System.Threading.Tasks;
 
-namespace Ryujinx.Ava.UI.Controls
+namespace Ryujinx.Ava.UI.Views.Misc
 {
     public partial class DlcSelectView : RyujinxControl<DlcSelectViewModel>
     {
@@ -31,17 +32,7 @@ namespace Ryujinx.Ava.UI.Controls
                 Content = new DlcSelectView { ViewModel = viewModel }
             };
 
-            Style closeButton = new(x => x.Name("CloseButton"));
+            await ContentDialogHelper.ShowAsync(contentDialog.ApplyStyles());
-            closeButton.Setters.Add(new Setter(WidthProperty, 80d));
-
-            Style closeButtonParent = new(x => x.Name("CommandSpace"));
-            closeButtonParent.Setters.Add(new Setter(HorizontalAlignmentProperty,
-                Avalonia.Layout.HorizontalAlignment.Right));
-
-            contentDialog.Styles.Add(closeButton);
-            contentDialog.Styles.Add(closeButtonParent);
-
-            await ContentDialogHelper.ShowAsync(contentDialog);
 
             return viewModel.SelectedDlc;
         }

src/Ryujinx/UI/Windows/AboutWindow.axaml.cs

@@ -5,6 +5,7 @@ using Avalonia.Layout;
 using Avalonia.Styling;
 using FluentAvalonia.UI.Controls;
 using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.UI.Controls;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Common;
@@ -14,7 +15,7 @@ using Button = Avalonia.Controls.Button;
 
 namespace Ryujinx.Ava.UI.Windows
 {
-    public partial class AboutWindow : UserControl
+    public partial class AboutWindow : RyujinxControl<AboutWindowViewModel>
     {
         public AboutWindow()
         {
@@ -33,19 +34,10 @@ namespace Ryujinx.Ava.UI.Windows
                 PrimaryButtonText = string.Empty,
                 SecondaryButtonText = string.Empty,
                 CloseButtonText = LocaleManager.Instance[LocaleKeys.UserProfilesClose],
-                Content = new AboutWindow { DataContext = viewModel }
+                Content = new AboutWindow { ViewModel = viewModel }
             };
 
-            Style closeButton = new(x => x.Name("CloseButton"));
+            await ContentDialogHelper.ShowAsync(contentDialog.ApplyStyles());
-            closeButton.Setters.Add(new Setter(WidthProperty, 80d));
-
-            Style closeButtonParent = new(x => x.Name("CommandSpace"));
-            closeButtonParent.Setters.Add(new Setter(HorizontalAlignmentProperty, HorizontalAlignment.Right));
-
-            contentDialog.Styles.Add(closeButton);
-            contentDialog.Styles.Add(closeButtonParent);
-
-            await ContentDialogHelper.ShowAsync(contentDialog);
         }
 
         private void Button_OnClick(object sender, RoutedEventArgs e)

src/Ryujinx/UI/Windows/MainWindow.axaml

@@ -9,6 +9,7 @@
     xmlns:helpers="clr-namespace:Ryujinx.Ava.UI.Helpers"
     xmlns:controls="clr-namespace:Ryujinx.Ava.UI.Controls"
     xmlns:main="clr-namespace:Ryujinx.Ava.UI.Views.Main"
+    xmlns:viewsMisc="clr-namespace:Ryujinx.Ava.UI.Views.Misc"
     Cursor="{Binding Cursor}"
     Title="{Binding Title}"
     WindowState="{Binding WindowState}"
@@ -73,7 +74,7 @@
                     <main:MainViewControls
                         Name="ViewControls"
                         Grid.Row="0"/>
-                    <controls:ApplicationListView
+                    <viewsMisc:ApplicationListView
                         x:Name="ApplicationList"
                         Grid.Row="1"
                         HorizontalAlignment="Stretch"
@@ -81,7 +82,7 @@
                         HorizontalContentAlignment="Stretch"
                         VerticalContentAlignment="Stretch"
                         IsVisible="{Binding IsList}" />
-                    <controls:ApplicationGridView
+                    <viewsMisc:ApplicationGridView
                         x:Name="ApplicationGrid"
                         Grid.Row="1"
                         HorizontalAlignment="Stretch"

src/Ryujinx/UI/Windows/UpdateWaitWindow.axaml

@@ -1,5 +1,5 @@
 <Window
-    x:Class="Ryujinx.Ava.UI.Controls.UpdateWaitWindow"
+    x:Class="Ryujinx.Ava.UI.Windows.UpdateWaitWindow"
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

src/Ryujinx/UI/Windows/UpdateWaitWindow.axaml.cs

@@ -1,8 +1,7 @@
 using Avalonia.Controls;
-using Ryujinx.Ava.UI.Windows;
 using System.Threading;
 
-namespace Ryujinx.Ava.UI.Controls
+namespace Ryujinx.Ava.UI.Windows
 {
     public partial class UpdateWaitWindow : StyleableWindow
     {

src/Ryujinx/Utilities/Compat/CompatibilityList.axaml.cs

@@ -25,16 +25,7 @@ namespace Ryujinx.Ava.Utilities.Compat
                 }
             };
 
-            Style closeButton = new(x => x.Name("CloseButton"));
+            await ContentDialogHelper.ShowAsync(contentDialog.ApplyStyles());
-            closeButton.Setters.Add(new Setter(WidthProperty, 80d));
-            
-            Style closeButtonParent = new(x => x.Name("CommandSpace"));
-            closeButtonParent.Setters.Add(new Setter(HorizontalAlignmentProperty, Avalonia.Layout.HorizontalAlignment.Right));
-
-            contentDialog.Styles.Add(closeButton);
-            contentDialog.Styles.Add(closeButtonParent);
-
-            await ContentDialogHelper.ShowAsync(contentDialog);
         }
         
         public CompatibilityList()

src/Ryujinx/Utilities/Configuration/ConfigurationState.Model.cs

@@ -1,6 +1,6 @@
 using ARMeilleure;
 using Gommon;
-using Ryujinx.Ava.Utilities.AppLibrary;
+using LibHac.Tools.FsSystem;
 using Ryujinx.Ava.Utilities.Configuration.System;
 using Ryujinx.Ava.Utilities.Configuration.UI;
 using Ryujinx.Common;
@@ -11,6 +11,7 @@ using Ryujinx.Common.Helper;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.Utilities;
 using Ryujinx.HLE;
+using Ryujinx.HLE.HOS.SystemState;
 using System.Collections.Generic;
 using System.Linq;
 using RyuLogger = Ryujinx.Common.Logging.Logger;
@@ -19,7 +20,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
 {
     public partial class ConfigurationState
     {
-                /// <summary>
+        /// <summary>
         /// UI configuration section
         /// </summary>
         public class UISection
@@ -838,5 +839,35 @@ namespace Ryujinx.Ava.Utilities.Configuration
             EnableHardwareAcceleration = new ReactiveObject<bool>();
             HideCursor = new ReactiveObject<HideCursorMode>();
         }
+
+        public HleConfiguration CreateHleConfiguration() =>
+            new(
+                System.DramSize,
+                (SystemLanguage)System.Language.Value,
+                (RegionCode)System.Region.Value,
+                Graphics.VSyncMode,
+                System.EnableDockedMode,
+                System.EnablePtc,
+                System.EnableInternetAccess,
+                System.EnableFsIntegrityChecks 
+                    ? IntegrityCheckLevel.ErrorOnInvalid 
+                    : IntegrityCheckLevel.None,
+                System.FsGlobalAccessLogMode,
+                System.MatchSystemTime
+                    ? 0
+                    : System.SystemTimeOffset,
+                System.TimeZone,
+                System.MemoryManagerMode,
+                System.IgnoreMissingServices,
+                Graphics.AspectRatio,
+                System.AudioVolume,
+                System.UseHypervisor,
+                Multiplayer.LanInterfaceId,
+                Multiplayer.Mode,
+                Multiplayer.DisableP2p,
+                Multiplayer.LdnPassphrase,
+                Instance.Multiplayer.GetLdnServer(),
+                Instance.Graphics.CustomVSyncInterval,
+                Instance.Hacks.ShowDirtyHacks ? Instance.Hacks.EnabledHacks : null);
     }
 }

src/Ryujinx/Utilities/Configuration/ConfigurationState.cs

@@ -327,5 +327,5 @@ namespace Ryujinx.Ava.Utilities.Configuration
 
             return GraphicsBackend.OpenGl;
         }
-            }
+    }
-        }
+}