Merge branch 'Ryubing:master' into master

add ?

Directory.Packages.props

@@ -44,7 +44,7 @@
     <PackageVersion Include="Gommon" Version="2.6.8" />
     <PackageVersion Include="securifybv.ShellLink" Version="0.1.0" />
     <PackageVersion Include="shaderc.net" Version="0.1.0" />
-    <PackageVersion Include="SharpMetal" Version="1.0.0-preview21" />
+    <PackageVersion Include="SharpMetal" Version="1.0.0-preview20" />
     <PackageVersion Include="SharpZipLib" Version="1.4.2" />
     <PackageVersion Include="Silk.NET.Vulkan" Version="2.21.0" />
     <PackageVersion Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.21.0" />

src/Ryujinx.Graphics.Metal.SharpMetalExtensions/CAMetalLayerExtensions.cs

@@ -1,5 +1,4 @@
 using SharpMetal;
-using SharpMetal.Foundation;
 using SharpMetal.ObjectiveCCore;
 using SharpMetal.QuartzCore;
 using System.Runtime.Versioning;
@@ -10,13 +9,22 @@ namespace Ryujinx.Graphics.Metal.SharpMetalExtensions
     [SupportedOSPlatform("macOS")]
     public static class CAMetalLayerExtensions
     {
+        private static readonly Selector sel_displaySyncEnabled = "displaySyncEnabled";
+        private static readonly Selector sel_setDisplaySyncEnabled = "setDisplaySyncEnabled:";
+        
         private static readonly Selector sel_developerHUDProperties = "developerHUDProperties";
         private static readonly Selector sel_setDeveloperHUDProperties = "setDeveloperHUDProperties:";
+        
+        public static bool IsDisplaySyncEnabled(this CAMetalLayer metalLayer) 
+            => ObjectiveCRuntime.bool_objc_msgSend(metalLayer.NativePtr, sel_displaySyncEnabled);
 
-        public static NSDictionary GetDeveloperHudProperties(this CAMetalLayer metalLayer)
-            => new(ObjectiveCRuntime.IntPtr_objc_msgSend(metalLayer.NativePtr, sel_developerHUDProperties));
+        public static void SetDisplaySyncEnabled(this CAMetalLayer metalLayer, bool enabled) 
+            => ObjectiveCRuntime.objc_msgSend(metalLayer.NativePtr, sel_setDisplaySyncEnabled, enabled);
 
-        public static void SetDeveloperHudProperties(this CAMetalLayer metalLayer, NSDictionary dictionary) 
-            => ObjectiveCRuntime.objc_msgSend(metalLayer.NativePtr, sel_setDeveloperHUDProperties, dictionary);
+        public static nint GetDeveloperHudProperties(this CAMetalLayer metalLayer)
+            => ObjectiveCRuntime.IntPtr_objc_msgSend(metalLayer.NativePtr, sel_developerHUDProperties);
+
+        public static void SetDeveloperHudProperties(this CAMetalLayer metalLayer, nint dictionaryPointer) 
+            => ObjectiveCRuntime.objc_msgSend(metalLayer.NativePtr, sel_setDeveloperHUDProperties, dictionaryPointer);
     }
 }

src/Ryujinx.Graphics.Metal.SharpMetalExtensions/NSHelper.cs

@@ -1,28 +0,0 @@
-using SharpMetal.Foundation;
-using SharpMetal.ObjectiveCCore;
-using System.Runtime.Versioning;
-
-namespace Ryujinx.Graphics.Metal.SharpMetalExtensions
-{
-    [SupportedOSPlatform("macOS")]
-    public static class NSHelper
-    {
-        public static unsafe string ToDotNetString(this NSString source)
-        {
-            char[] sourceBuffer = new char[source.Length];
-            fixed (char* pSourceBuffer = sourceBuffer)
-            {
-                ObjectiveC.bool_objc_msgSend(source,
-                    "getCString:maxLength:encoding:",
-                    pSourceBuffer,
-                    source.MaximumLengthOfBytes(NSStringEncoding.UTF16) + 1,
-                    (ulong)NSStringEncoding.UTF16);
-            }
-
-            return new string(sourceBuffer);
-        }
-        
-        public static NSString ToNSString(this string source) 
-            => new(ObjectiveC.IntPtr_objc_msgSend(new ObjectiveCClass("NSString"), "stringWithUTF8String:", source));
-    }
-}

src/Ryujinx.Graphics.Metal.SharpMetalExtensions/Ryujinx.Graphics.Metal.SharpMetalExtensions.csproj

@@ -2,7 +2,6 @@
   <PropertyGroup>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   
   <ItemGroup>

src/Ryujinx.Graphics.Metal/Window.cs

@@ -18,7 +18,7 @@ namespace Ryujinx.Graphics.Metal
         public bool ScreenCaptureRequested { get; set; }
 
         private readonly MetalRenderer _renderer;
-        private CAMetalLayer _metalLayer;
+        private readonly CAMetalLayer _metalLayer;
 
         private int _width;
         private int _height;
@@ -146,11 +146,11 @@ namespace Ryujinx.Graphics.Metal
         {
             switch (vSyncMode)
             {
-                case VSyncMode.Unbounded:
-                    _metalLayer.DisplaySyncEnabled = false;
+                case VSyncMode.Unbounded: 
+                    _metalLayer.SetDisplaySyncEnabled(false);
                     break;
                 case VSyncMode.Switch:
-                    _metalLayer.DisplaySyncEnabled = true;
+                    _metalLayer.SetDisplaySyncEnabled(true);
                     break;
             }
         }

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,28 @@ 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 +185,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)
@@ -166,12 +202,7 @@ namespace Ryujinx.Input.SDL2
 
             nint gamepadHandle = SDL_GameControllerOpen(joystickIndex);
 
-            if (gamepadHandle == nint.Zero)
-            {
-                return null;
-            }
-
-            return new SDL2Gamepad(gamepadHandle, id);
+            return gamepadHandle == nint.Zero ? null : new SDL2Gamepad(gamepadHandle, id);
         }
     }
 }

src/Ryujinx.Input.SDL2/SDL2JoyConPair.cs

@@ -0,0 +1,284 @@
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Hid.Controller;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Threading;
+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
+        ];
+
+        private readonly record struct ButtonMappingEntry(GamepadButtonInputId To, GamepadButtonInputId From)
+        {
+            public bool IsValid => To is not GamepadButtonInputId.Unbound && From is not GamepadButtonInputId.Unbound;
+        }
+
+        private readonly List<ButtonMappingEntry> _buttonsUserMapping = new(20);
+
+        private readonly Lock _userMappingLock = new();
+
+        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)";
+        private const string LeftName = "Nintendo Switch Joy-Con (L)";
+        private const string RightName = "Nintendo Switch Joy-Con (R)";
+        public bool IsConnected => left is { IsConnected: true } && right is { IsConnected: true };
+
+        public void Dispose()
+        {
+            left?.Dispose();
+            right?.Dispose();
+        }
+
+        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;
+        }
+
+        public Vector3 GetMotionData(MotionInputId inputId)
+        {
+            Vector3 motionData;
+            switch (inputId)
+            {
+                case MotionInputId.Accelerometer:
+                case MotionInputId.Gyroscope:
+                     motionData = left.GetMotionData(inputId);
+                     return new Vector3(-motionData.Z, motionData.Y, motionData.X);
+                case MotionInputId.SecondAccelerometer:
+                     motionData = right.GetMotionData(MotionInputId.Accelerometer);
+                     return new Vector3(motionData.Z, motionData.Y, -motionData.X);
+                case MotionInputId.SecondGyroscope:
+                     motionData = right.GetMotionData(MotionInputId.Gyroscope);
+                     return new Vector3(motionData.Z, motionData.Y, -motionData.X);
+                case MotionInputId.Invalid:
+                default:
+                    return Vector3.Zero;
+            }
+        }
+
+        public GamepadStateSnapshot GetStateSnapshot()
+        {
+            return IGamepad.GetStateSnapshot(this);
+        }
+
+        public (float, float) GetStick(StickInputId inputId)
+        {
+            switch (inputId)
+            {
+                case StickInputId.Left:
+                    {
+                        (float x, float y) = left.GetStick(StickInputId.Left);
+                        return (y, -x);
+                    }
+                case StickInputId.Right:
+                    {
+                        (float x, float y) = right.GetStick(StickInputId.Left);
+                        return (-y, x);
+                    }
+                case StickInputId.Unbound:
+                case StickInputId.Count:
+                default:
+                    return (0, 0);
+            }
+        }
+
+        public bool IsPressed(GamepadButtonInputId inputId)
+        {
+            return inputId switch
+            {
+                GamepadButtonInputId.LeftStick => left.IsPressed(GamepadButtonInputId.LeftStick),
+                GamepadButtonInputId.DpadUp => left.IsPressed(GamepadButtonInputId.Y),
+                GamepadButtonInputId.DpadDown => left.IsPressed(GamepadButtonInputId.A),
+                GamepadButtonInputId.DpadLeft => left.IsPressed(GamepadButtonInputId.B),
+                GamepadButtonInputId.DpadRight => left.IsPressed(GamepadButtonInputId.X),
+                GamepadButtonInputId.Minus => left.IsPressed(GamepadButtonInputId.Start),
+                GamepadButtonInputId.LeftShoulder => left.IsPressed(GamepadButtonInputId.Paddle2),
+                GamepadButtonInputId.LeftTrigger => left.IsPressed(GamepadButtonInputId.Paddle4),
+                GamepadButtonInputId.SingleRightTrigger0 => left.IsPressed(GamepadButtonInputId.LeftShoulder),
+                GamepadButtonInputId.SingleLeftTrigger0 => left.IsPressed(GamepadButtonInputId.RightShoulder),
+
+                GamepadButtonInputId.RightStick => right.IsPressed(GamepadButtonInputId.LeftStick),
+                GamepadButtonInputId.A => right.IsPressed(GamepadButtonInputId.B),
+                GamepadButtonInputId.B => right.IsPressed(GamepadButtonInputId.Y),
+                GamepadButtonInputId.X => right.IsPressed(GamepadButtonInputId.A),
+                GamepadButtonInputId.Y => right.IsPressed(GamepadButtonInputId.X),
+                GamepadButtonInputId.Plus => right.IsPressed(GamepadButtonInputId.Start),
+                GamepadButtonInputId.RightShoulder => right.IsPressed(GamepadButtonInputId.Paddle1),
+                GamepadButtonInputId.RightTrigger => right.IsPressed(GamepadButtonInputId.Paddle3),
+                GamepadButtonInputId.SingleRightTrigger1 => right.IsPressed(GamepadButtonInputId.LeftShoulder),
+                GamepadButtonInputId.SingleLeftTrigger1 => right.IsPressed(GamepadButtonInputId.RightShoulder),
+
+                _ => false
+            };
+        }
+
+        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)
+        {
+            lock (_userMappingLock)
+            {
+                _configuration = (StandardControllerInputConfig)configuration;
+                left.SetConfiguration(configuration);
+                right.SetConfiguration(configuration);
+
+                _buttonsUserMapping.Clear();
+
+                // First update sticks
+                _stickUserMapping[(int)StickInputId.Left] = (StickInputId)_configuration.LeftJoyconStick.Joystick;
+                _stickUserMapping[(int)StickInputId.Right] = (StickInputId)_configuration.RightJoyconStick.Joystick;
+
+                // Then left joycon
+                _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));
+
+                // Finally right joycon
+                _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));
+
+                SetTriggerThreshold(_configuration.TriggerThreshold);
+            }
+        }
+
+        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(LeftName);
+            int rightIndex = gamepadNames.IndexOf(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 SDL2Gamepad(leftGamepadHandle, gamepadsIds[leftIndex]),
+                new SDL2Gamepad(rightGamepadHandle, gamepadsIds[rightIndex]));
+        }
+    }
+}

src/Ryujinx.Input/HLE/NpadController.cs

@@ -266,6 +266,7 @@ namespace Ryujinx.Input.HLE
             if (motionConfig.MotionBackend != MotionInputBackendType.CemuHook)
             {
                 _leftMotionInput = new MotionInput();
+                _rightMotionInput = new MotionInput();
             }
             else
             {
@@ -298,7 +299,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;
+                                }
                             }
                         }
                     }
@@ -333,6 +347,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 SQL_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 == SQL_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))
                 {