Merge pull request #284 from winnerspiros/copilot/check-vulkan-black-screen-issue

Fix S Pen / tablet cursor stuck at top-left + upstream merge (ranked play duels, beatmap strip)

Author: winnerspiros

osu.Android.props

@@ -99,7 +99,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.428.4" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.501.1" />
     <!-- `ppy.osu.Framework.NativeLibs` is a transitive dependency of `ppy.osu.Framework`
          that ships desktop-only natives (Linux/macOS/Windows) under `runtimes/<rid>/native/`
          — including a bare Linux `libbass.so`/`libbass_fx.so`/`libbassmix.so` for linux-arm64.

osu.Android/Input/AndroidStylusHandler.cs

@@ -137,8 +137,37 @@ public override bool Initialize(GameHost host)
 
             AreaSize.BindValueChanged(_ => updateCachedTransform());
             AreaOffset.BindValueChanged(_ => updateCachedTransform());
-            OutputAreaSize.BindValueChanged(_ => updateCachedTransform());
-            OutputAreaOffset.BindValueChanged(_ => updateCachedTransform());
+
+            // OutputAreaSize and OutputAreaOffset need a guard against ScalingContainer's
+            // normalised-coordinate writes. ScalingContainer assumes desktop tablet handlers
+            // use a [0..1] normalised output space and writes Vector2.One / (0.5, 0.5) when
+            // game scaling mode is not "Everything". AndroidStylusHandler works in *pixel*
+            // space, so (1, 1) means a 1×1 pixel output area — which collapses every mapped
+            // cursor position to ≈(0, 0) and keeps the pointer stuck at the top-left corner
+            // regardless of where the S Pen physically is. When we detect a sub-pixel write
+            // (both components ≤ 2) and we already know the real screen size (> 10 px), we
+            // restore the pixel-space output area immediately.
+            OutputAreaSize.BindValueChanged(e =>
+            {
+                if (e.NewValue.X <= 2f && e.NewValue.Y <= 2f && cachedTabletSizeX > 10f)
+                {
+                    restorePixelOutputArea();
+                    return;
+                }
+
+                updateCachedTransform();
+            });
+            OutputAreaOffset.BindValueChanged(e =>
+            {
+                if (e.NewValue.X <= 1f && e.NewValue.Y <= 1f && cachedTabletSizeX > 10f)
+                {
+                    restorePixelOutputArea();
+                    return;
+                }
+
+                updateCachedTransform();
+            });
+
             Rotation.BindValueChanged(_ => updateCachedTransform());
             PressureThreshold.BindValueChanged(v => cachedPressureThreshold = v.NewValue, true);
 
@@ -150,6 +179,23 @@ public override bool Initialize(GameHost host)
             return base.Initialize(host);
         }
 
+        /// <summary>
+        /// Restores <see cref="OutputAreaSize"/> and <see cref="OutputAreaOffset"/> to the
+        /// actual pixel dimensions of the screen. Called when we detect that
+        /// <see cref="osu.Game.Graphics.Containers.ScalingContainer"/> has overwritten the
+        /// pixel-space output area with its normalised-coordinate sentinel values.
+        /// </summary>
+        private void restorePixelOutputArea()
+        {
+            float w = cachedTabletSizeX;
+            float h = cachedTabletSizeY;
+
+            if (w <= 10f || h <= 10f) return;
+
+            OutputAreaSize.Value = new Vector2(w, h);
+            OutputAreaOffset.Value = new Vector2(w / 2f, h / 2f);
+        }
+
         /// <summary>
         /// Sets the digitizer/display dimensions. Must be called after the display is known,
         /// and re-called from <see cref="OsuGameAndroid.RefreshStylusDisplaySize"/> on each
@@ -185,14 +231,18 @@ public void SetDisplaySize(int width, int height)
             // legacy 1920x1080 ctor default seeded in Initialize, or still at the
             // auto-default we installed on a previous SetDisplaySize call (so a phone
             // rotation re-syncs the area mapping rather than leaving the user pinned to
-            // the previous orientation's bounds).
+            // the previous orientation's bounds). Also reset if ScalingContainer has
+            // previously written its normalised-space sentinel (≤ 2 px) — those are
+            // not user-configured values and must not be preserved.
             if (AreaSize.Value == default || AreaSize.Value == legacy_default_size || AreaSize.Value == previousAuto)
             {
                 AreaSize.Value = size;
                 AreaOffset.Value = size / 2;
             }
 
-            if (OutputAreaSize.Value == default || OutputAreaSize.Value == legacy_default_size || OutputAreaSize.Value == previousAuto)
+            bool outputIsNormalisedSentinel = OutputAreaSize.Value.X <= 2f && OutputAreaSize.Value.Y <= 2f;
+
+            if (OutputAreaSize.Value == default || OutputAreaSize.Value == legacy_default_size || OutputAreaSize.Value == previousAuto || outputIsNormalisedSentinel)
             {
                 OutputAreaSize.Value = size;
                 OutputAreaOffset.Value = size / 2;

osu.Android/OsuGameAndroid.cs

@@ -2000,13 +2000,19 @@ private void registerAndroidInputHandlers(GameHost host)
                 gameActivity.MouseHandler = mouseHandler;
                 gameActivity.KeyboardHandler = keyboardHandler;
 
-                // Match the screen / digitiser dimensions for tablet area mapping.
-                applyStylusDisplaySize(stylusHandler);
-
                 // Initialize each handler the same way the framework would in
                 // CreateAvailableInputHandlers — sets the protected Host field on the base
                 // class and runs handler-specific bindable wiring. Skip-on-failure: a single
                 // misbehaving handler must not knock out the other two.
+                //
+                // NOTE: applyStylusDisplaySize is called AFTER Initialize so that:
+                // 1. base.Initialize(host) has finished setting up the Host field and any
+                //    framework config bindings, avoiding a race where config-loaded values
+                //    overwrite the display size we push in SetDisplaySize.
+                // 2. The OutputAreaSize BindValueChanged guard installed in Initialize is
+                //    already in place before SetDisplaySize fires the first write, ensuring
+                //    the normalised-sentinel detector can intercept subsequent ScalingContainer
+                //    writes on the very first updateSize() call.
                 var newHandlers = new osu.Framework.Input.Handlers.InputHandler[] { stylusHandler, mouseHandler, keyboardHandler };
 
                 foreach (var h in newHandlers)
@@ -2022,6 +2028,11 @@ private void registerAndroidInputHandlers(GameHost host)
                     }
                 }
 
+                // Match the screen / digitiser dimensions for tablet area mapping.
+                // Called after Initialize so the display-size write lands on top of any
+                // framework config-restore and the OutputAreaSize guard is already armed.
+                applyStylusDisplaySize(stylusHandler);
+
                 // Reflectively replace AvailableInputHandlers with the union of the host's
                 // existing immutable array and our three handlers. The property has a private
                 // setter; we use reflection because the framework does not expose a public
@@ -2105,10 +2116,13 @@ private void registerAndroidInputHandlers(GameHost host)
         /// </para>
         ///
         /// <para>
-        /// As a final defensive guard the resolved bounds are normalised to landscape
-        /// (<c>max(W,H) × min(W,H)</c>) since the activity is landscape-locked on phones —
+        /// As a final defensive guard on phones, the resolved bounds are normalised to landscape
+        /// (<c>max(W,H) × min(W,H)</c>) since the activity is landscape-locked there —
         /// this neutralises the residual case where an OEM still hands back portrait
-        /// bounds for the current metrics on certain Android skins.
+        /// bounds for the current metrics on certain Android skins. Tablets and DeX are
+        /// excluded because they run in <see cref="ScreenOrientation.FullUser"/> / external
+        /// display orientation, where forcing landscape makes portrait tablet S Pen
+        /// coordinates divide by the wrong axis and pins the pointer near the origin.
         /// </para>
         /// </summary>
         private void applyStylusDisplaySize(AndroidStylusHandler handler)
@@ -2178,13 +2192,18 @@ private void applyStylusDisplaySize(AndroidStylusHandler handler)
                 if (width <= 0 || height <= 0)
                     return;
 
-                // Canonicalise to landscape since the phone activity is landscape-locked
+                // Canonicalise to landscape only when the activity is actually landscape-locked
                 // (see [Activity(ScreenOrientation = ScreenOrientation.Landscape)] on
-                // OsuGameActivity). Tablets / DeX run in FullUser orientation so the
-                // canonicalisation is harmless — we still get a (W, H) pair whose major
-                // axis matches MotionEvent.GetX's range.
-                int w = Math.Max(width, height);
-                int h = Math.Min(width, height);
+                // OsuGameActivity). Tablets / DeX run in FullUser / external-display
+                // orientation, so preserve the current window metrics exactly there.
+                int w = width;
+                int h = height;
+
+                if (!gameActivity.IsTablet && !gameActivity.IsDeX)
+                {
+                    w = Math.Max(width, height);
+                    h = Math.Min(width, height);
+                }
 
                 handler.SetDisplaySize(w, h);
             }

osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs

@@ -170,7 +170,8 @@ private void updateState()
 
             // By limiting the width we avoid this box showing up as an outline around the drawables that are on top of it.
             background.ResizeWidthTo(buttonAreaWidth + BeatmapCard.CORNER_RADIUS, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
-            background.FadeTo(ShowDetails.Value ? 1 : 0, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
+            if (ButtonsCollapsedWidth == 0)
+                background.FadeTo(ShowDetails.Value ? 1 : 0, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
 
             background.FadeColour(downloadTracker.State.Value == DownloadState.LocallyAvailable ? colours.Lime0 : colourProvider.Background3, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
             buttons.FadeTo(ShowDetails.Value ? 1 : 0, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);

osu.Game/Online/Matchmaking/IMatchmakingClient.cs

@@ -38,6 +38,12 @@ public interface IMatchmakingClient : IStatefulUserHubClient
         /// </summary>
         Task MatchmakingRoomInvitedWithParams(MatchmakingRoomInvitationParams invitation);
 
+        /// <summary>
+        /// Signals that the user has been issued a duel by another user.
+        /// </summary>
+        /// <param name="issue">Contains the parameters for the duel.</param>
+        Task MatchmakingDuelIssued(MatchmakingDuelIssuedParams issue);
+
         /// <summary>
         /// Signals that the matchmaking room is ready to be opened.
         /// </summary>

osu.Game/Online/Matchmaking/IMatchmakingServer.cs

@@ -40,6 +40,18 @@ public interface IMatchmakingServer
         /// </summary>
         Task MatchmakingAcceptInvitation();
 
+        /// <summary>
+        /// Issues a matchmaking duel.
+        /// </summary>
+        /// <param name="request">Describes the duel.</param>
+        Task<MatchmakingIssueDuelResponse> MatchmakingIssueDuel(MatchmakingIssueDuelRequest request);
+
+        /// <summary>
+        /// Accepts a matchmaking duel invitation.
+        /// </summary>
+        /// <param name="request">Describes the duel.</param>
+        Task<MatchmakingAcceptDuelResponse> MatchmakingAcceptDuel(MatchmakingAcceptDuelRequest request);
+
         /// <summary>
         /// Declines a matchmaking room invitation.
         /// </summary>

osu.Game/Online/Matchmaking/MatchmakingDuelIssuedParams.cs

@@ -0,0 +1,22 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [MessagePackObject]
+    [Serializable]
+    public class MatchmakingDuelIssuedParams
+    {
+        [Key(0)]
+        public Guid Id { get; set; }
+
+        [Key(1)]
+        public int UserId { get; set; }
+
+        [Key(2)]
+        public MatchmakingPool Pool { get; set; } = new MatchmakingPool();
+    }
+}

osu.Game/Online/Matchmaking/MatchmakingPool.cs

@@ -26,6 +26,31 @@ public class MatchmakingPool : IEquatable<MatchmakingPool>
         [Key(4)]
         public MatchmakingPoolType Type { get; set; } = MatchmakingPoolType.QuickPlay;
 
+        [IgnoreMember]
+        public string DisplayName
+        {
+            get
+            {
+                switch (RulesetId)
+                {
+                    case 0:
+                        return $"osu! ({Name})";
+
+                    case 1:
+                        return $"osu!taiko ({Name})";
+
+                    case 2:
+                        return $"osu!catch ({Name})";
+
+                    case 3:
+                        return $"osu!mania {Variant}K ({Name})";
+
+                    default:
+                        return Name;
+                }
+            }
+        }
+
         public bool Equals(MatchmakingPool? other)
             => other != null
                && Id == other.Id

osu.Game/Online/Matchmaking/Requests/MatchmakingAcceptDuelRequest.cs

@@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+
+namespace osu.Game.Online.Matchmaking.Requests
+{
+    [MessagePackObject]
+    [Serializable]
+    public class MatchmakingAcceptDuelRequest
+    {
+        [Key(0)]
+        public Guid Id { get; set; }
+    }
+}

osu.Game/Online/Matchmaking/Requests/MatchmakingIssueDuelRequest.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+
+namespace osu.Game.Online.Matchmaking.Requests
+{
+    [MessagePackObject]
+    [Serializable]
+    public class MatchmakingIssueDuelRequest
+    {
+        [Key(0)]
+        public int UserId { get; set; }
+
+        [Key(1)]
+        public int PoolId { get; set; }
+    }
+}