[input] replaced per-platform pad readers with sdl gamepad input

src/SharpEmu.Libs/Gpu/Metal/MetalHostInput.cs

@@ -1,182 +0,0 @@
-// Copyright (C) 2026 SharpEmu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-using SharpEmu.HLE.Host;
-using SharpEmu.HLE.Host.Posix;
-
-namespace SharpEmu.Libs.Gpu.Metal;
-
-/// <summary>
-/// Keyboard state sampled from the Metal presenter's window, feeding the POSIX
-/// host input seam so pad emulation works like the Vulkan presenter's
-/// HostWindowInput. Key events arrive on the AppKit main thread as macOS
-/// virtual key codes; pad reads happen on guest threads, so state is guarded.
-/// Window gamepads are not surfaced by AppKit — controller support would go
-/// through GameController.framework and is out of scope here.
-/// </summary>
-internal static class MetalHostInput
-{
-    private static readonly object Gate = new();
-    private static readonly HashSet<ushort> Pressed = new();
-    private static volatile bool _connected;
-
-    /// <summary>Registers this window's keyboard as the host input source.</summary>
-    public static void Attach()
-    {
-        _connected = true;
-        PosixHostInput.SetSource(new MetalWindowInputSource());
-        Console.Error.WriteLine("[LOADER][INFO] Window keyboard input attached for pad emulation.");
-    }
-
-    // Debug automation: SHARPEMU_METAL_AUTOKEY="12:0x24,15:0x24" presses the
-    // macOS key code at each elapsed-seconds mark for a few frames, letting
-    // headless test runs navigate menus without a human at the keyboard.
-    private static readonly List<(double At, ushort Key, bool[] State)> _autoKeys = ParseAutoKeys();
-    private static readonly System.Diagnostics.Stopwatch _autoKeyClock =
-        System.Diagnostics.Stopwatch.StartNew();
-
-    private static List<(double, ushort, bool[])> ParseAutoKeys()
-    {
-        var keys = new List<(double, ushort, bool[])>();
-        var spec = Environment.GetEnvironmentVariable("SHARPEMU_METAL_AUTOKEY");
-        if (string.IsNullOrWhiteSpace(spec))
-        {
-            return keys;
-        }
-
-        foreach (var entry in spec.Split(',', StringSplitOptions.RemoveEmptyEntries))
-        {
-            var parts = entry.Split(':');
-            if (parts.Length == 2 &&
-                double.TryParse(parts[0], out var at) &&
-                TryParseKeyCode(parts[1], out var key))
-            {
-                keys.Add((at, key, new bool[2]));
-            }
-        }
-
-        return keys;
-    }
-
-    private static bool TryParseKeyCode(string text, out ushort key)
-    {
-        return text.StartsWith("0x", StringComparison.OrdinalIgnoreCase)
-            ? ushort.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, null, out key)
-            : ushort.TryParse(text, out key);
-    }
-
-    /// <summary>Called once per render frame; fires and releases scripted keys.</summary>
-    public static void PumpAutoKeys()
-    {
-        if (_autoKeys.Count == 0)
-        {
-            return;
-        }
-
-        var elapsed = _autoKeyClock.Elapsed.TotalSeconds;
-        foreach (var (at, key, state) in _autoKeys)
-        {
-            if (!state[0] && elapsed >= at)
-            {
-                state[0] = true;
-                KeyDown(key, isRepeat: false);
-                Console.Error.WriteLine($"[LOADER][INFO] Metal autokey press 0x{key:X} at {elapsed:F1}s");
-            }
-            else if (state[0] && !state[1] && elapsed >= at + 0.2)
-            {
-                state[1] = true;
-                KeyUp(key);
-            }
-        }
-    }
-
-    public static void KeyDown(ushort keyCode, bool isRepeat)
-    {
-        // kVK_F1: parity with the Vulkan window's perf-overlay toggle.
-        if (keyCode == 0x7A && !isRepeat)
-        {
-            VideoOut.PerfOverlay.Toggle();
-        }
-
-        lock (Gate)
-        {
-            Pressed.Add(keyCode);
-        }
-    }
-
-    public static void KeyUp(ushort keyCode)
-    {
-        lock (Gate)
-        {
-            Pressed.Remove(keyCode);
-        }
-    }
-
-    private static bool IsKeyCodeDown(ushort keyCode)
-    {
-        lock (Gate)
-        {
-            return Pressed.Contains(keyCode);
-        }
-    }
-
-    private sealed class MetalWindowInputSource : IPosixWindowInputSource
-    {
-        public bool HasKeyboardFocus => _connected;
-
-        public bool IsKeyDown(int virtualKey) =>
-            TryMapVirtualKey(virtualKey, out var keyCode) && IsKeyCodeDown(keyCode);
-
-        public int GetGamepadStates(Span<HostGamepadState> destination) => 0;
-
-        public string? DescribeConnectedGamepad() => null;
-    }
-
-    /// <summary>Windows virtual-key semantics (the seam's contract) to macOS
-    /// kVK virtual key codes, covering the keys pad emulation polls.</summary>
-    private static bool TryMapVirtualKey(int vk, out ushort keyCode)
-    {
-        keyCode = vk switch
-        {
-            0x08 => 0x33, // Backspace -> kVK_Delete
-            0x09 => 0x30, // Tab
-            0x0D => 0x24, // Enter -> kVK_Return
-            0x1B => 0x35, // Escape
-            0x20 => 0x31, // Space
-            0x25 => 0x7B, // Left
-            0x26 => 0x7E, // Up
-            0x27 => 0x7C, // Right
-            0x28 => 0x7D, // Down
-            // Letters: macOS ANSI key codes are layout-position based and
-            // non-contiguous, so map each polled letter explicitly.
-            0x41 => 0x00, // A
-            0x42 => 0x0B, // B
-            0x43 => 0x08, // C
-            0x44 => 0x02, // D
-            0x45 => 0x0E, // E
-            0x46 => 0x03, // F
-            0x47 => 0x05, // G
-            0x48 => 0x04, // H
-            0x49 => 0x22, // I
-            0x4A => 0x26, // J
-            0x4B => 0x28, // K
-            0x4C => 0x25, // L
-            0x4D => 0x2E, // M
-            0x4E => 0x2D, // N
-            0x4F => 0x1F, // O
-            0x50 => 0x23, // P
-            0x51 => 0x0C, // Q
-            0x52 => 0x0F, // R
-            0x53 => 0x01, // S
-            0x54 => 0x11, // T
-            0x55 => 0x20, // U
-            0x56 => 0x09, // V
-            0x57 => 0x0D, // W
-            0x58 => 0x07, // X
-            0x59 => 0x10, // Y
-            0x5A => 0x06, // Z
-            _ => ushort.MaxValue,
-        };
-        return keyCode != ushort.MaxValue;
-    }
-}

src/SharpEmu.Libs/Pad/HostWindowInput.cs

@@ -2,138 +2,135 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 using SharpEmu.HLE.Host;
-using SharpEmu.HLE.Host.Posix;
-using Silk.NET.Input;
 
 namespace SharpEmu.Libs.Pad;
 
-/// <summary>
-/// Keyboard and gamepad state sampled from the presenter's window, feeding
-/// the POSIX host input seam (macOS/Linux have no user32/XInput/raw-HID
-/// readers). The presenter attaches the window's input context once the
-/// window exists; input events arrive on the window thread and pad reads
-/// happen on guest threads, so all state is guarded.
-/// </summary>
+/// <summary>Cross-platform input state supplied by the SDL game window.</summary>
 public static class HostWindowInput
 {
     private static readonly object Gate = new();
-    private static readonly HashSet<Key> Pressed = new();
-    private static volatile bool _connected;
-
-    // Latest window-gamepad snapshot in the host seam's conventions.
+    private static readonly HashSet<int> PressedKeys = new();
+    private static bool _focused;
     private static bool _gamepadConnected;
     private static string? _gamepadName;
-    private static HostGamepadButtons _gamepadButtons;
-    private static byte _gamepadLeftX = 128;
-    private static byte _gamepadLeftY = 128;
-    private static byte _gamepadRightX = 128;
-    private static byte _gamepadRightY = 128;
-    private static byte _gamepadL2;
-    private static byte _gamepadR2;
+    private static HostGamepadState _gamepadState;
+    private static IHostGamepadOutput? _gamepadOutput;
+    private static readonly WindowInputSource Source = new();
 
-    /// <summary>True once a window keyboard is delivering events.</summary>
-    public static bool IsConnected => _connected;
-
-    public static void Attach(IInputContext input)
-    {
-        foreach (var keyboard in input.Keyboards)
-        {
-            keyboard.KeyDown += (_, key, _) =>
-            {
-                if (key == Key.F1)
-                {
-                    VideoOut.PerfOverlay.Toggle();
-                }
-
-                lock (Gate)
-                {
-                    Pressed.Add(key);
-                }
-            };
-            keyboard.KeyUp += (_, key, _) =>
-            {
-                lock (Gate)
-                {
-                    Pressed.Remove(key);
-                }
-            };
-        }
-
-        if (input.Keyboards.Count > 0)
-        {
-            _connected = true;
-        }
-
-        foreach (var gamepad in input.Gamepads)
-        {
-            AttachGamepad(gamepad);
-        }
-
-        input.ConnectionChanged += (device, connected) =>
-        {
-            if (device is not IGamepad gamepad)
-            {
-                return;
-            }
-
-            if (connected)
-            {
-                AttachGamepad(gamepad);
-                return;
-            }
-
-            lock (Gate)
-            {
-                _gamepadConnected = false;
-                _gamepadName = null;
-                _gamepadButtons = HostGamepadButtons.None;
-                _gamepadLeftX = 128;
-                _gamepadLeftY = 128;
-                _gamepadRightX = 128;
-                _gamepadRightY = 128;
-                _gamepadL2 = 0;
-                _gamepadR2 = 0;
-            }
-        };
-
-        PosixHostInput.SetSource(new WindowInputSource());
-    }
-
-    public static bool IsKeyDown(Key key)
+    public static void Connect(IHostGamepadOutput? gamepadOutput = null)
     {
         lock (Gate)
         {
-            return Pressed.Contains(key);
+            _focused = true;
+            _gamepadOutput = gamepadOutput;
+            PressedKeys.Clear();
+        }
+
+        HostWindowInputSource.Set(Source);
+    }
+
+    public static void Disconnect()
+    {
+        lock (Gate)
+        {
+            _focused = false;
+            _gamepadConnected = false;
+            _gamepadName = null;
+            _gamepadState = default;
+            _gamepadOutput = null;
+            PressedKeys.Clear();
+        }
+
+        HostWindowInputSource.Clear(Source);
+    }
+
+    public static void SetFocused(bool focused)
+    {
+        lock (Gate)
+        {
+            _focused = focused;
+            if (!focused)
+            {
+                PressedKeys.Clear();
+            }
         }
     }
 
-    private sealed class WindowInputSource : IPosixWindowInputSource
+    public static void SetKey(int virtualKey, bool down)
     {
-        public bool HasKeyboardFocus => _connected;
+        lock (Gate)
+        {
+            if (down)
+            {
+                PressedKeys.Add(virtualKey);
+            }
+            else
+            {
+                PressedKeys.Remove(virtualKey);
+            }
+        }
+    }
+
+    public static void SetGamepad(string? name, HostGamepadState state)
+    {
+        lock (Gate)
+        {
+            _gamepadConnected = state.Connected;
+            _gamepadName = name;
+            _gamepadState = state;
+        }
+    }
+
+    public static void ClearGamepad()
+    {
+        lock (Gate)
+        {
+            _gamepadConnected = false;
+            _gamepadName = null;
+            _gamepadState = default;
+        }
+    }
+
+    internal static byte ToStickByte(short value)
+    {
+        var normalized = value + 32768;
+        return (byte)Math.Clamp((normalized * 255 + 32767) / 65535, 0, 255);
+    }
+
+    internal static byte ToTriggerByte(short value) =>
+        (byte)Math.Clamp(value * 255 / 32767, 0, 255);
+
+    private sealed class WindowInputSource : IHostWindowInputSource
+    {
+        public bool HasKeyboardFocus
+        {
+            get
+            {
+                lock (Gate)
+                {
+                    return _focused;
+                }
+            }
+        }
 
         public bool IsKeyDown(int virtualKey)
         {
-            return TryMapVirtualKey(virtualKey, out var key) && HostWindowInput.IsKeyDown(key);
+            lock (Gate)
+            {
+                return PressedKeys.Contains(virtualKey);
+            }
         }
 
         public int GetGamepadStates(Span<HostGamepadState> destination)
         {
             lock (Gate)
             {
-                if (!_gamepadConnected || destination.Length == 0)
+                if (!_gamepadConnected || destination.IsEmpty)
                 {
                     return 0;
                 }
 
-                destination[0] = new HostGamepadState(
-                    Connected: true,
-                    Buttons: _gamepadButtons,
-                    LeftX: _gamepadLeftX,
-                    LeftY: _gamepadLeftY,
-                    RightX: _gamepadRightX,
-                    RightY: _gamepadRightY,
-                    LeftTrigger: _gamepadL2,
-                    RightTrigger: _gamepadR2);
+                destination[0] = _gamepadState;
                 return 1;
             }
         }
@@ -142,139 +139,80 @@ public static class HostWindowInput
         {
             lock (Gate)
             {
-                return _gamepadConnected ? _gamepadName ?? "GLFW gamepad" : null;
+                return _gamepadConnected ? _gamepadName ?? "SDL gamepad" : null;
             }
         }
-    }
 
-    private static bool TryMapVirtualKey(int vk, out Key key)
-    {
-        key = vk switch
+        public void SetRumble(byte largeMotor, byte smallMotor)
         {
-            0x08 => Key.Backspace,
-            0x09 => Key.Tab,
-            0x0D => Key.Enter,
-            0x1B => Key.Escape,
-            0x25 => Key.Left,
-            0x26 => Key.Up,
-            0x27 => Key.Right,
-            0x28 => Key.Down,
-            >= 0x41 and <= 0x5A => Key.A + (vk - 0x41),
-            _ => Key.Unknown,
-        };
-        return key != Key.Unknown;
-    }
+            IHostGamepadOutput? output;
+            lock (Gate)
+            {
+                output = _gamepadOutput;
+            }
 
-    private static void AttachGamepad(IGamepad gamepad)
-    {
-        lock (Gate)
-        {
-            _gamepadConnected = true;
-            _gamepadName = gamepad.Name;
+            output?.SetRumble(largeMotor, smallMotor);
         }
 
-        gamepad.ButtonDown += (_, button) =>
+        public void SetTriggerRumble(byte? leftTrigger, byte? rightTrigger)
         {
-            var bit = MapButton(button.Name);
-            if (bit == HostGamepadButtons.None)
+            IHostGamepadOutput? output;
+            lock (Gate)
             {
-                return;
+                output = _gamepadOutput;
             }
 
+            output?.SetTriggerRumble(leftTrigger, rightTrigger);
+        }
+
+        public void SetAdaptiveTriggerEffect(
+            HostAdaptiveTriggerEffect? leftTrigger,
+            HostAdaptiveTriggerEffect? rightTrigger)
+        {
+            IHostGamepadOutput? output;
             lock (Gate)
             {
-                _gamepadButtons |= bit;
-            }
-        };
-        gamepad.ButtonUp += (_, button) =>
-        {
-            var bit = MapButton(button.Name);
-            if (bit == HostGamepadButtons.None)
-            {
-                return;
+                output = _gamepadOutput;
             }
 
-            lock (Gate)
-            {
-                _gamepadButtons &= ~bit;
-            }
-        };
-        gamepad.ThumbstickMoved += (_, thumbstick) =>
+            output?.SetAdaptiveTriggerEffect(leftTrigger, rightTrigger);
+        }
+
+        public void SetLightbar(byte red, byte green, byte blue)
         {
-            // Silk's GLFW backend reports sticks -1..1 with +Y pointing down,
-            // matching the seam's 0..255 down-growing convention after biasing.
-            var x = ToStickByte(thumbstick.X);
-            var y = ToStickByte(thumbstick.Y);
+            IHostGamepadOutput? output;
             lock (Gate)
             {
-                if (thumbstick.Index == 0)
-                {
-                    _gamepadLeftX = x;
-                    _gamepadLeftY = y;
-                }
-                else
-                {
-                    _gamepadRightX = x;
-                    _gamepadRightY = y;
-                }
+                output = _gamepadOutput;
             }
-        };
-        gamepad.TriggerMoved += (_, trigger) =>
+
+            output?.SetLightbar(red, green, blue);
+        }
+
+        public void ResetLightbar()
         {
-            // GLFW gamepad triggers rest at -1 and saturate at +1.
-            var value = (byte)Math.Clamp((int)((trigger.Position + 1.0f) * 0.5f * 255.0f), 0, 255);
+            IHostGamepadOutput? output;
             lock (Gate)
             {
-                if (trigger.Index == 0)
-                {
-                    _gamepadL2 = value;
-                    if (value > 64)
-                    {
-                        _gamepadButtons |= HostGamepadButtons.L2;
-                    }
-                    else
-                    {
-                        _gamepadButtons &= ~HostGamepadButtons.L2;
-                    }
-                }
-                else
-                {
-                    _gamepadR2 = value;
-                    if (value > 64)
-                    {
-                        _gamepadButtons |= HostGamepadButtons.R2;
-                    }
-                    else
-                    {
-                        _gamepadButtons &= ~HostGamepadButtons.R2;
-                    }
-                }
+                output = _gamepadOutput;
             }
-        };
+
+            output?.ResetLightbar();
+        }
     }
-
-    internal static byte ToStickByte(float value)
-    {
-        return (byte)Math.Clamp((int)MathF.Round((value + 1.0f) * 127.5f), 0, 255);
-    }
-
-    private static HostGamepadButtons MapButton(ButtonName name) => name switch
-    {
-        // GLFW reports the Xbox layout: A=Cross, B=Circle, X=Square, Y=Triangle.
-        ButtonName.A => HostGamepadButtons.Cross,
-        ButtonName.B => HostGamepadButtons.Circle,
-        ButtonName.X => HostGamepadButtons.Square,
-        ButtonName.Y => HostGamepadButtons.Triangle,
-        ButtonName.LeftBumper => HostGamepadButtons.L1,
-        ButtonName.RightBumper => HostGamepadButtons.R1,
-        ButtonName.Back => HostGamepadButtons.TouchPad,
-        ButtonName.Start => HostGamepadButtons.Options,
-        ButtonName.LeftStick => HostGamepadButtons.L3,
-        ButtonName.RightStick => HostGamepadButtons.R3,
-        ButtonName.DPadUp => HostGamepadButtons.Up,
-        ButtonName.DPadRight => HostGamepadButtons.Right,
-        ButtonName.DPadDown => HostGamepadButtons.Down,
-        ButtonName.DPadLeft => HostGamepadButtons.Left,
-        _ => HostGamepadButtons.None,
-    };
+}
+
+public interface IHostGamepadOutput
+{
+    void SetRumble(byte largeMotor, byte smallMotor);
+
+    void SetTriggerRumble(byte? leftTrigger, byte? rightTrigger);
+
+    void SetAdaptiveTriggerEffect(
+        HostAdaptiveTriggerEffect? leftTrigger,
+        HostAdaptiveTriggerEffect? rightTrigger);
+
+    void SetLightbar(byte red, byte green, byte blue);
+
+    void ResetLightbar();
 }

src/SharpEmu.Libs/Pad/PadExports.cs

@@ -37,6 +37,7 @@ public static class PadExports
     private static PadState _cachedInputState;
 
     private static bool _initialized;
+    private static int _motionSensorEnabled;
     private static int _controlsAnnouncementLogged;
 
     [SysAbiExport(
@@ -151,9 +152,13 @@ public static class PadExports
     public static int PadSetMotionSensorState(CpuContext ctx)
     {
         var handle = unchecked((int)ctx[CpuRegister.Rdi]);
-        return IsPrimaryPadHandle(handle)
-            ? ctx.SetReturn(0)
-            : ctx.SetReturn(OrbisPadErrorInvalidHandle);
+        if (!IsPrimaryPadHandle(handle))
+        {
+            return ctx.SetReturn(OrbisPadErrorInvalidHandle);
+        }
+
+        Volatile.Write(ref _motionSensorEnabled, ctx[CpuRegister.Rsi] != 0 ? 1 : 0);
+        return ctx.SetReturn(0);
     }
 
     [SysAbiExport(
@@ -362,24 +367,170 @@ public static class PadExports
         }
 
         var triggerMask = parameter[0];
-        HostPlatform.Current.Input.SetTriggerRumble(
-            (triggerMask & 0x01) != 0 ? DecodeTriggerVibration(parameter[8..64]) : null,
-            (triggerMask & 0x02) != 0 ? DecodeTriggerVibration(parameter[64..120]) : null);
+        HostPlatform.Current.Input.SetAdaptiveTriggerEffect(
+            (triggerMask & 0x01) != 0 ? DecodeTriggerEffect(parameter[8..64]) : null,
+            (triggerMask & 0x02) != 0 ? DecodeTriggerEffect(parameter[64..120]) : null);
         return ctx.SetReturn((int)OrbisGen2Result.ORBIS_GEN2_OK);
     }
 
-    private static byte DecodeTriggerVibration(ReadOnlySpan<byte> command)
+    private static HostAdaptiveTriggerEffect DecodeTriggerEffect(ReadOnlySpan<byte> command)
     {
         var mode = BinaryPrimitives.ReadUInt32LittleEndian(command);
-        var amplitude = mode switch
+        var parameters = command[8..];
+        Span<byte> native = stackalloc byte[11];
+        native.Clear();
+        byte fallbackStrength = 0;
+        switch (mode)
         {
-            3 when command[10] != 0 => command[9],
-            6 when command[8] != 0 => command[9..19].ToArray().Max(),
-            _ => (byte)0,
-        };
-        return (byte)(Math.Min(amplitude, (byte)8) * 255 / 8);
+            case 1:
+                EncodeFeedback(native, parameters[0], parameters[1]);
+                fallbackStrength = ScaleTriggerStrength(parameters[1]);
+                break;
+            case 2:
+                EncodeWeapon(native, parameters[0], parameters[1], parameters[2]);
+                fallbackStrength = ScaleTriggerStrength(parameters[2]);
+                break;
+            case 3:
+                EncodeZonedEffect(native, 0x26, parameters[0], parameters[1], parameters[2]);
+                fallbackStrength = ScaleTriggerStrength(parameters[1]);
+                break;
+            case 4:
+                EncodeZonedStrengths(native, 0x21, parameters[..10], 0);
+                fallbackStrength = ScaleTriggerStrength(Max(parameters[..10]));
+                break;
+            case 5:
+                EncodeSlope(native, parameters[0], parameters[1], parameters[2], parameters[3]);
+                fallbackStrength = ScaleTriggerStrength(Math.Max(parameters[2], parameters[3]));
+                break;
+            case 6:
+                EncodeZonedStrengths(native, 0x26, parameters[1..11], parameters[0]);
+                fallbackStrength = parameters[0] == 0 ? (byte)0 : ScaleTriggerStrength(Max(parameters[1..11]));
+                break;
+            default:
+                native[0] = 0x05;
+                break;
+        }
+
+        return HostAdaptiveTriggerEffect.FromBytes(native, fallbackStrength);
     }
 
+    private static void EncodeFeedback(Span<byte> destination, byte position, byte strength)
+    {
+        if (position > 9 || strength is 0 or > 8)
+        {
+            destination[0] = 0x05;
+            return;
+        }
+
+        Span<byte> strengths = stackalloc byte[10];
+        strengths[position..].Fill(strength);
+        EncodeZonedStrengths(destination, 0x21, strengths, 0);
+    }
+
+    private static void EncodeWeapon(Span<byte> destination, byte start, byte end, byte strength)
+    {
+        if (start is < 2 or > 7 || end <= start || end > 8 || strength is 0 or > 8)
+        {
+            destination[0] = 0x05;
+            return;
+        }
+
+        var zones = (ushort)((1 << start) | (1 << end));
+        destination[0] = 0x25;
+        BinaryPrimitives.WriteUInt16LittleEndian(destination[1..], zones);
+        destination[3] = (byte)(strength - 1);
+    }
+
+    private static void EncodeZonedEffect(
+        Span<byte> destination,
+        byte nativeMode,
+        byte position,
+        byte strength,
+        byte frequency)
+    {
+        if (position > 9 || strength is 0 or > 8 || frequency == 0)
+        {
+            destination[0] = 0x05;
+            return;
+        }
+
+        Span<byte> strengths = stackalloc byte[10];
+        strengths[position..].Fill(strength);
+        EncodeZonedStrengths(destination, nativeMode, strengths, frequency);
+    }
+
+    private static void EncodeSlope(
+        Span<byte> destination,
+        byte startPosition,
+        byte endPosition,
+        byte startStrength,
+        byte endStrength)
+    {
+        if (startPosition > 8 || endPosition <= startPosition || endPosition > 9 ||
+            startStrength is 0 or > 8 || endStrength is 0 or > 8)
+        {
+            destination[0] = 0x05;
+            return;
+        }
+
+        Span<byte> strengths = stackalloc byte[10];
+        var distance = endPosition - startPosition;
+        for (var index = startPosition; index < strengths.Length; index++)
+        {
+            strengths[index] = index <= endPosition
+                ? (byte)Math.Round(startStrength + ((endStrength - startStrength) * (index - startPosition) / (double)distance))
+                : endStrength;
+        }
+
+        EncodeZonedStrengths(destination, 0x21, strengths, 0);
+    }
+
+    private static void EncodeZonedStrengths(
+        Span<byte> destination,
+        byte nativeMode,
+        ReadOnlySpan<byte> strengths,
+        byte frequency)
+    {
+        ushort activeZones = 0;
+        uint packedStrengths = 0;
+        for (var index = 0; index < Math.Min(strengths.Length, 10); index++)
+        {
+            var strength = strengths[index];
+            if (strength is 0 or > 8)
+            {
+                continue;
+            }
+
+            activeZones |= (ushort)(1 << index);
+            packedStrengths |= (uint)(strength - 1) << (index * 3);
+        }
+
+        if (activeZones == 0 || (nativeMode == 0x26 && frequency == 0))
+        {
+            destination[0] = 0x05;
+            return;
+        }
+
+        destination[0] = nativeMode;
+        BinaryPrimitives.WriteUInt16LittleEndian(destination[1..], activeZones);
+        BinaryPrimitives.WriteUInt32LittleEndian(destination[3..], packedStrengths);
+        destination[9] = frequency;
+    }
+
+    private static byte Max(ReadOnlySpan<byte> values)
+    {
+        byte result = 0;
+        foreach (var value in values)
+        {
+            result = Math.Max(result, value);
+        }
+
+        return result;
+    }
+
+    private static byte ScaleTriggerStrength(byte strength) =>
+        (byte)(Math.Min(strength, (byte)8) * 255 / 8);
+
     [SysAbiExport(
         Nid = "yFVnOdGxvZY",
         ExportName = "scePadSetVibration",
@@ -478,6 +629,17 @@ public static class PadExports
         data[0x08] = l2;
         data[0x09] = r2;
         BinaryPrimitives.WriteSingleLittleEndian(data[0x18..], 1.0f);
+        if (Volatile.Read(ref _motionSensorEnabled) != 0 && input.Motion.Available)
+        {
+            BinaryPrimitives.WriteSingleLittleEndian(data[0x1C..], input.Motion.AccelerationX);
+            BinaryPrimitives.WriteSingleLittleEndian(data[0x20..], input.Motion.AccelerationY);
+            BinaryPrimitives.WriteSingleLittleEndian(data[0x24..], input.Motion.AccelerationZ);
+            BinaryPrimitives.WriteSingleLittleEndian(data[0x28..], input.Motion.AngularVelocityX);
+            BinaryPrimitives.WriteSingleLittleEndian(data[0x2C..], input.Motion.AngularVelocityY);
+            BinaryPrimitives.WriteSingleLittleEndian(data[0x30..], input.Motion.AngularVelocityZ);
+        }
+
+        WriteTouchData(data, input.Touch);
         data[0x4C] = 1;
         var timestampTicks = Stopwatch.GetTimestamp();
         var timestampMicroseconds =
@@ -508,6 +670,10 @@ public static class PadExports
         var rightY = acceptsKeyboardInput ? ReadAnalogStick(input.IsKeyDown(0x49), input.IsKeyDown(0x4B)) : (byte)128;
         var l2 = acceptsKeyboardInput && input.IsKeyDown(0x52) ? (byte)255 : (byte)0;
         var r2 = acceptsKeyboardInput && input.IsKeyDown(0x46) ? (byte)255 : (byte)0;
+        var gamepadType = HostGamepadType.Generic;
+        var connection = HostGamepadConnection.Unknown;
+        var motion = default(HostMotionState);
+        var touch = default(HostTouchState);
 
         Span<HostGamepadState> gamepads = stackalloc HostGamepadState[2];
         var gamepadCount = input.GetGamepadStates(gamepads);
@@ -523,6 +689,13 @@ public static class PadExports
             rightY = MergeAxis(pad.RightY, rightY);
             l2 = Math.Max(l2, pad.LeftTrigger);
             r2 = Math.Max(r2, pad.RightTrigger);
+            if (index == 0)
+            {
+                gamepadType = pad.Type;
+                connection = pad.Connection;
+                motion = pad.Motion;
+                touch = pad.Touch;
+            }
         }
 
         if (IsAutoCrossActive())
@@ -538,7 +711,11 @@ public static class PadExports
             RightX: rightX,
             RightY: rightY,
             L2: l2,
-            R2: r2);
+            R2: r2,
+            Type: gamepadType,
+            Connection: connection,
+            Motion: motion,
+            Touch: touch);
         _lastInputSampleTicks = now;
         return _cachedInputState;
     }
@@ -592,6 +769,7 @@ public static class PadExports
     private static uint ToOrbisButtons(HostGamepadButtons buttons)
     {
         uint result = 0;
+        if ((buttons & HostGamepadButtons.Create) != 0) result |= OrbisPadButton.Share;
         if ((buttons & HostGamepadButtons.Up) != 0) result |= OrbisPadButton.Up;
         if ((buttons & HostGamepadButtons.Down) != 0) result |= OrbisPadButton.Down;
         if ((buttons & HostGamepadButtons.Left) != 0) result |= OrbisPadButton.Left;
@@ -611,6 +789,34 @@ public static class PadExports
         return result;
     }
 
+    private static void WriteTouchData(Span<byte> data, HostTouchState touch)
+    {
+        Span<HostTouchPoint> active = stackalloc HostTouchPoint[2];
+        var count = 0;
+        if (touch.First.Active)
+        {
+            active[count++] = touch.First;
+        }
+        if (touch.Second.Active)
+        {
+            active[count++] = touch.Second;
+        }
+
+        data[0x34] = (byte)count;
+        for (var index = 0; index < count; index++)
+        {
+            var offset = 0x3C + (index * 8);
+            var point = active[index];
+            BinaryPrimitives.WriteUInt16LittleEndian(
+                data[offset..],
+                (ushort)Math.Round(Math.Clamp(point.X, 0, 1) * 1919));
+            BinaryPrimitives.WriteUInt16LittleEndian(
+                data[(offset + 2)..],
+                (ushort)Math.Round(Math.Clamp(point.Y, 0, 1) * 942));
+            data[offset + 4] = point.Id;
+        }
+    }
+
     private static uint ReadKeyboardButtons(IHostInput input)
     {
         uint buttons = 0;

src/SharpEmu.Libs/Pad/PadState.cs

@@ -1,6 +1,8 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+using SharpEmu.HLE.Host;
+
 namespace SharpEmu.Libs.Pad;
 
 /// <summary>
@@ -16,11 +18,16 @@ internal readonly record struct PadState(
     byte RightX,
     byte RightY,
     byte L2,
-    byte R2);
+    byte R2,
+    HostGamepadType Type = HostGamepadType.Generic,
+    HostGamepadConnection Connection = HostGamepadConnection.Unknown,
+    HostMotionState Motion = default,
+    HostTouchState Touch = default);
 
 /// <summary>SCE_PAD_BUTTON bit values.</summary>
 internal static class OrbisPadButton
 {
+    internal const uint Share = 0x0001;
     internal const uint L3 = 0x0002;
     internal const uint R3 = 0x0004;
     internal const uint Options = 0x0008;

src/SharpEmu.Libs/Pad/SdlGamepadStateReader.cs

@@ -0,0 +1,121 @@
+// Copyright (C) 2026 SharpEmu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+using SharpEmu.HLE.Host;
+using SDL;
+using static SDL.SDL3;
+
+namespace SharpEmu.Libs.Pad;
+
+internal static unsafe class SdlGamepadStateReader
+{
+    public static void EnableSonyHidApi()
+    {
+        fixed (byte* enabled = "1"u8)
+        fixed (byte* ps4 = SDL_HINT_JOYSTICK_HIDAPI_PS4)
+        fixed (byte* ps5 = SDL_HINT_JOYSTICK_HIDAPI_PS5)
+        {
+            SDL_SetHint(ps4, enabled);
+            SDL_SetHint(ps5, enabled);
+        }
+    }
+
+    public static SDL_Gamepad* OpenPreferredGamepad()
+    {
+        using var gamepads = SDL_GetGamepads();
+        if (gamepads is null || gamepads.Count == 0)
+        {
+            return null;
+        }
+
+        var selected = gamepads[0];
+        for (var index = 0; index < gamepads.Count; index++)
+        {
+            var type = SDL_GetRealGamepadTypeForID(gamepads[index]);
+            if (type is SDL_GamepadType.SDL_GAMEPAD_TYPE_PS5 or SDL_GamepadType.SDL_GAMEPAD_TYPE_PS4)
+            {
+                selected = gamepads[index];
+                break;
+            }
+        }
+
+        return SDL_OpenGamepad(selected);
+    }
+
+    public static HostGamepadState Read(SDL_Gamepad* gamepad)
+    {
+        var buttons = HostGamepadButtons.None;
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_SOUTH, HostGamepadButtons.Cross, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_EAST, HostGamepadButtons.Circle, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_WEST, HostGamepadButtons.Square, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_NORTH, HostGamepadButtons.Triangle, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, HostGamepadButtons.L1, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, HostGamepadButtons.R1, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_LEFT_STICK, HostGamepadButtons.L3, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_RIGHT_STICK, HostGamepadButtons.R3, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_BACK, HostGamepadButtons.Create, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_GUIDE, HostGamepadButtons.Ps, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_START, HostGamepadButtons.Options, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_MISC1, HostGamepadButtons.Mic, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_TOUCHPAD, HostGamepadButtons.TouchPad, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_DPAD_UP, HostGamepadButtons.Up, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_DPAD_RIGHT, HostGamepadButtons.Right, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_DPAD_DOWN, HostGamepadButtons.Down, ref buttons);
+        AddButton(gamepad, SDL_GamepadButton.SDL_GAMEPAD_BUTTON_DPAD_LEFT, HostGamepadButtons.Left, ref buttons);
+
+        var leftTrigger = HostWindowInput.ToTriggerByte(
+            SDL_GetGamepadAxis(gamepad, SDL_GamepadAxis.SDL_GAMEPAD_AXIS_LEFT_TRIGGER));
+        var rightTrigger = HostWindowInput.ToTriggerByte(
+            SDL_GetGamepadAxis(gamepad, SDL_GamepadAxis.SDL_GAMEPAD_AXIS_RIGHT_TRIGGER));
+        if (leftTrigger > 64)
+        {
+            buttons |= HostGamepadButtons.L2;
+        }
+        if (rightTrigger > 64)
+        {
+            buttons |= HostGamepadButtons.R2;
+        }
+
+        var battery = 0;
+        SDL_GetGamepadPowerInfo(gamepad, &battery);
+        return new HostGamepadState(
+            Connected: true,
+            Buttons: buttons,
+            LeftX: HostWindowInput.ToStickByte(SDL_GetGamepadAxis(gamepad, SDL_GamepadAxis.SDL_GAMEPAD_AXIS_LEFTX)),
+            LeftY: HostWindowInput.ToStickByte(SDL_GetGamepadAxis(gamepad, SDL_GamepadAxis.SDL_GAMEPAD_AXIS_LEFTY)),
+            RightX: HostWindowInput.ToStickByte(SDL_GetGamepadAxis(gamepad, SDL_GamepadAxis.SDL_GAMEPAD_AXIS_RIGHTX)),
+            RightY: HostWindowInput.ToStickByte(SDL_GetGamepadAxis(gamepad, SDL_GamepadAxis.SDL_GAMEPAD_AXIS_RIGHTY)),
+            LeftTrigger: leftTrigger,
+            RightTrigger: rightTrigger,
+            Type: MapGamepadType(SDL_GetRealGamepadType(gamepad)),
+            Connection: GetConnection(gamepad),
+            BatteryPercent: (byte)Math.Clamp(battery, 0, 100));
+    }
+
+    public static HostGamepadType MapGamepadType(SDL_GamepadType type) => type switch
+    {
+        SDL_GamepadType.SDL_GAMEPAD_TYPE_PS4 => HostGamepadType.DualShock4,
+        SDL_GamepadType.SDL_GAMEPAD_TYPE_PS5 => HostGamepadType.DualSense,
+        _ => HostGamepadType.Generic,
+    };
+
+    public static HostGamepadConnection GetConnection(SDL_Gamepad* gamepad) =>
+        SDL_GetGamepadConnectionState(gamepad) switch
+        {
+            SDL_JoystickConnectionState.SDL_JOYSTICK_CONNECTION_WIRED => HostGamepadConnection.Wired,
+            SDL_JoystickConnectionState.SDL_JOYSTICK_CONNECTION_WIRELESS => HostGamepadConnection.Wireless,
+            _ => HostGamepadConnection.Unknown,
+        };
+
+    private static void AddButton(
+        SDL_Gamepad* gamepad,
+        SDL_GamepadButton source,
+        HostGamepadButtons target,
+        ref HostGamepadButtons buttons)
+    {
+        if (SDL_GetGamepadButton(gamepad, source))
+        {
+            buttons |= target;
+        }
+    }
+}

src/SharpEmu.Libs/Pad/SdlLauncherGamepad.cs

@@ -0,0 +1,85 @@
+// Copyright (C) 2026 SharpEmu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+using SharpEmu.HLE.Host;
+using SDL;
+using static SDL.SDL3;
+
+namespace SharpEmu.Libs.Pad;
+
+/// <summary>Cross-platform SDL gamepad polling for launcher navigation.</summary>
+public static unsafe class SdlLauncherGamepad
+{
+    private const SDL_InitFlags InitFlags = SDL_InitFlags.SDL_INIT_GAMEPAD;
+    private static SDL_Gamepad* _gamepad;
+    private static bool _initialized;
+
+    public static void EnsureStarted()
+    {
+        if (_initialized)
+        {
+            return;
+        }
+
+        SdlGamepadStateReader.EnableSonyHidApi();
+        if (!SDL_InitSubSystem(InitFlags))
+        {
+            Console.Error.WriteLine("[GUI][WARN] SDL gamepad initialization failed.");
+            return;
+        }
+
+        _initialized = true;
+        OpenFirstGamepad();
+    }
+
+    public static bool TryGetState(out HostGamepadState state)
+    {
+        state = default;
+        if (!_initialized)
+        {
+            return false;
+        }
+
+        SDL_UpdateGamepads();
+        if (_gamepad is not null && !SDL_GamepadConnected(_gamepad))
+        {
+            SDL_CloseGamepad(_gamepad);
+            _gamepad = null;
+        }
+
+        if (_gamepad is null)
+        {
+            OpenFirstGamepad();
+        }
+
+        if (_gamepad is null)
+        {
+            return false;
+        }
+
+        state = SdlGamepadStateReader.Read(_gamepad);
+        return true;
+    }
+
+    public static void Shutdown()
+    {
+        if (!_initialized)
+        {
+            return;
+        }
+
+        if (_gamepad is not null)
+        {
+            SDL_CloseGamepad(_gamepad);
+            _gamepad = null;
+        }
+
+        SDL_QuitSubSystem(InitFlags);
+        _initialized = false;
+    }
+
+    private static void OpenFirstGamepad()
+    {
+        _gamepad = SdlGamepadStateReader.OpenPreferredGamepad();
+    }
+}