Fix minimized window raw client size handling

sources/engine/Stride.Games/Desktop/GameForm.cs

@@ -313,6 +313,13 @@ private void OnDisableFullScreen(EventArgs e)
         protected override void OnClientSizeChanged(EventArgs e)
         {
             base.OnClientSizeChanged(e);
+
+            if (ClientSize.Width <= 0 || ClientSize.Height <= 0)
+            {
+                isSizeChangedWithoutResizeBegin = true;
+                return;
+            }
+
             if (!isUserResizing && (isSizeChangedWithoutResizeBegin || cachedSize != Size))
             {
                 isSizeChangedWithoutResizeBegin = false;
@@ -344,7 +351,7 @@ protected override void WndProc(ref Message m)
                         Rectangle rect;
 
                         GetClientRect(m.HWnd, out rect);
-                        if (rect.Bottom - rect.Top == 0)
+                        if (rect.Right - rect.Left <= 0 || rect.Bottom - rect.Top <= 0)
                         {
                             // Rapidly clicking the task bar to minimize and restore a window
                             // can cause a WM_SIZE message with SIZE_RESTORED when 

sources/engine/Stride.Games/Desktop/GameWindowWinforms.cs

@@ -105,7 +105,12 @@ public override void EndScreenDeviceChange(int clientWidth, int clientHeight)
             if (deviceChangeChangedVisible)
                 Visible = oldVisible;
 
-            if (form != null)
+            if (form != null
+                && form.WindowState != FormWindowState.Minimized
+                && form.ClientSize.Width > 0
+                && form.ClientSize.Height > 0
+                && clientWidth > 0
+                && clientHeight > 0)
             {
                 form.ClientSize = new Size(clientWidth, clientHeight);
             }
@@ -376,6 +381,20 @@ public override Stride.Core.Mathematics.Rectangle ClientBounds
             }
         }
 
+        /// <inheritdoc />
+        internal override Int2 RawClientSize
+        {
+            get
+            {
+                if (IsMinimized)
+                    return new Int2(0, 0);
+
+                return Control != null
+                    ? new Int2(Control.ClientSize.Width, Control.ClientSize.Height)
+                    : new Int2(0, 0);
+            }
+        }
+
         public override DisplayOrientation CurrentOrientation
         {
             get

sources/engine/Stride.Games/GameWindow.cs

@@ -92,6 +92,17 @@ public abstract class GameWindow : ComponentBase
         /// <value>The client bounds.</value>
         public abstract Rectangle ClientBounds { get; }
 
+        /// <summary>
+        /// Gets the unclamped client size reported by the native window.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="ClientBounds"/> can clamp its dimensions to keep rendering code away from zero-sized viewports.
+        /// Device and swap-chain resize decisions need the native size instead, otherwise minimized windows can be
+        /// mistaken for valid 1x1 render targets.
+        /// Platform implementations that can observe the native client size should override this property.
+        /// </remarks>
+        internal virtual Int2 RawClientSize => new Int2(ClientBounds.Width, ClientBounds.Height);
+
         /// <summary>
         /// Gets the current orientation.
         /// </summary>
@@ -282,11 +293,16 @@ protected void OnActivated(object source, EventArgs e)
 
         protected void OnClientSizeChanged(object source, EventArgs e)
         {
+            var resizeSize = RawClientSize;
+            if (resizeSize.X <= 0 || resizeSize.Y <= 0)
+            {
+                return;
+            }
+
             if (!isFullscreen)
             {
                 // Update preferred windowed size in windowed mode 
-                var resizeSize = ClientBounds.Size;
-                PreferredWindowedSize = new Int2(resizeSize.Width, resizeSize.Height); 
+                PreferredWindowedSize = resizeSize;
             }
             var handler = ClientSizeChanged;
             handler?.Invoke(this, e);

sources/engine/Stride.Games/GameWindowRenderer.cs

@@ -196,25 +196,28 @@ protected override void Destroy()
         /// <summary>
         ///   Determines the requested size for the Back-Buffer based on the current window bounds and user preferences.
         /// </summary>
+        /// <param name="size">
+        ///   When this method returns, contains the requested size for the Back-Buffer.
+        /// </param>
         /// <param name="format">
         ///   When this method returns, contains the pixel format to be used for the Back-Buffer.
         ///   This will be the preferred Back-Buffer format if specified;
         ///   otherwise, it defaults to <see cref="PixelFormat.R8G8B8A8_UNorm"/>.
         /// </param>
         /// <returns>
-        ///   An <see cref="Int2"/> structure representing the width and height of the requested Back-Buffer size.
-        ///   If the preferred Back-Buffer dimensions are not set or the window has been resized by the user,
-        ///   the current window dimensions are used.
+        ///   <see langword="true"/> when a valid requested size could be determined; otherwise, <see langword="false"/>.
         /// </returns>
-        private Int2 GetRequestedSize(out PixelFormat format)
+        private bool TryGetRequestedSize(out Int2 size, out PixelFormat format)
         {
-            var bounds = Window.ClientBounds;
+            var rawClientSize = Window.RawClientSize;
 
             format = PreferredBackBufferFormat == PixelFormat.None ? PixelFormat.R8G8B8A8_UNorm : PreferredBackBufferFormat;
 
-            return new Int2(
-                PreferredBackBufferWidth == 0 || windowUserResized ? bounds.Width : PreferredBackBufferWidth,
-                PreferredBackBufferHeight == 0 || windowUserResized ? bounds.Height : PreferredBackBufferHeight);
+            size = new Int2(
+                PreferredBackBufferWidth == 0 || windowUserResized ? rawClientSize.X : PreferredBackBufferWidth,
+                PreferredBackBufferHeight == 0 || windowUserResized ? rawClientSize.Y : PreferredBackBufferHeight);
+
+            return size.X > 0 && size.Y > 0;
         }
 
         /// <summary>
@@ -225,11 +228,18 @@ private Int2 GetRequestedSize(out PixelFormat format)
         ///   using the requested size and format. It configures the presentation parameters,
         ///   including Depth-Stencil format and presentation interval.
         /// </remarks>
-        protected virtual void CreateOrUpdatePresenter()
+        /// <returns>
+        ///   <see langword="true"/> when the presenter exists or could be created; otherwise, <see langword="false"/>.
+        /// </returns>
+        protected virtual bool CreateOrUpdatePresenter()
         {
             if (Presenter is null || isColorSpaceToChange)
             {
-                var size = GetRequestedSize(out PixelFormat resizeFormat);
+                if (!TryGetRequestedSize(out var size, out PixelFormat resizeFormat))
+                {
+                    return false;
+                }
+
                 var presentationParameters = new PresentationParameters(size.X, size.Y, Window.NativeWindow, resizeFormat)
                 {
                     DepthStencilFormat = PreferredDepthStencilFormat,
@@ -251,6 +261,8 @@ protected virtual void CreateOrUpdatePresenter()
                 isBackBufferToResize = false;
                 isColorSpaceToChange = false;
             }
+
+            return true;
         }
 
         /// <inheritdoc/>
@@ -260,11 +272,20 @@ public override bool BeginDraw()
             {
                 savedPresenter = GraphicsDevice.Presenter;
 
-                CreateOrUpdatePresenter();
+                if (!CreateOrUpdatePresenter())
+                {
+                    beginDrawOk = false;
+                    return false;
+                }
 
                 if (isBackBufferToResize || windowUserResized)
                 {
-                    var size = GetRequestedSize(out PixelFormat resizeFormat);
+                    if (!TryGetRequestedSize(out var size, out PixelFormat resizeFormat))
+                    {
+                        beginDrawOk = false;
+                        return false;
+                    }
+
                     Presenter.Resize(size.X, size.Y, resizeFormat);
 
                     isBackBufferToResize = false;

sources/engine/Stride.Games/GraphicsDeviceManager.cs

@@ -1004,10 +1004,11 @@ private bool ProcessClientSizeChanged()
         {
             // The client size can be zero in some cases (minimized window...)
             // We only process it when we have a valid size
-            if (game.Window.ClientBounds.Height != 0 || game.Window.ClientBounds.Width != 0)
+            var clientSize = game.Window.RawClientSize;
+            if (clientSize.X > 0 && clientSize.Y > 0)
             {
-                resizedBackBufferWidth = game.Window.ClientBounds.Width;
-                resizedBackBufferHeight = game.Window.ClientBounds.Height;
+                resizedBackBufferWidth = clientSize.X;
+                resizedBackBufferHeight = clientSize.Y;
                 isBackBufferToResize = true;
                 deviceSettingsChanged = true;
 
@@ -1049,11 +1050,12 @@ private bool ProcessOrientationChanged()
         {
             // The client size can be zero in some cases (minimized window...)
             // We only process it when we have a valid size, and the orientation actually changed
-            if ((game.Window.ClientBounds.Height != 0 || game.Window.ClientBounds.Width != 0) &&
+            var clientSize = game.Window.RawClientSize;
+            if ((clientSize.X > 0 && clientSize.Y > 0) &&
                 game.Window.CurrentOrientation != currentWindowOrientation)
             {
-                if ((game.Window.ClientBounds.Height > game.Window.ClientBounds.Width && preferredBackBufferWidth > preferredBackBufferHeight) ||
-                    (game.Window.ClientBounds.Width > game.Window.ClientBounds.Height && preferredBackBufferHeight > preferredBackBufferWidth))
+                if ((clientSize.Y > clientSize.X && preferredBackBufferWidth > preferredBackBufferHeight) ||
+                    (clientSize.X > clientSize.Y && preferredBackBufferHeight > preferredBackBufferWidth))
                 {
                     // Client size and Back-Buffer size are different things
                     // In this case all we care is if orientation changed, if so we swap width and height
@@ -1167,15 +1169,16 @@ void ChangeOrCreateDevice()
                 game.ConfirmRenderingSettings(GraphicsDevice is null); // If no device we assume we are still at game creation phase
 
                 isChangingDevice = true;
-                var width = game.Window.ClientBounds.Width;
-                var height = game.Window.ClientBounds.Height;
+                var clientSize = game.Window.RawClientSize;
+                var width = clientSize.X > 0 ? clientSize.X : game.Window.ClientBounds.Width;
+                var height = clientSize.Y > 0 ? clientSize.Y : game.Window.ClientBounds.Height;
 
                 // If the orientation is free to be changed from portrait to landscape we actually need this check now,
                 // it is mostly useful only at initialization because `Window_OrientationChanged` does the same logic on runtime change
                 if (game.Window.CurrentOrientation != currentWindowOrientation)
                 {
-                    if ((game.Window.ClientBounds.Height > game.Window.ClientBounds.Width && preferredBackBufferWidth > preferredBackBufferHeight) ||
-                        (game.Window.ClientBounds.Width > game.Window.ClientBounds.Height && preferredBackBufferHeight > preferredBackBufferWidth))
+                    if ((clientSize.Y > 0 && clientSize.X > 0 && clientSize.Y > clientSize.X && preferredBackBufferWidth > preferredBackBufferHeight) ||
+                        (clientSize.X > 0 && clientSize.Y > 0 && clientSize.X > clientSize.Y && preferredBackBufferHeight > preferredBackBufferWidth))
                     {
                         // Client size and Back-Buffer size are different things
                         // In this case all we care is if orientation changed, if so we swap width and height

sources/engine/Stride.Games/SDL/GameWindowSDL.cs

@@ -347,6 +347,17 @@ public override Rectangle ClientBounds
             }
         }
 
+        /// <inheritdoc />
+        internal override Int2 RawClientSize
+        {
+            get
+            {
+                return window != null
+                    ? new Int2(window.ClientSize.Width, window.ClientSize.Height)
+                    : new Int2(0, 0);
+            }
+        }
+
         public override DisplayOrientation CurrentOrientation
         {
             get