Apply initial configuration, surprisingly little code...

Author: Perksey

sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Children.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Silk.NET.SDL;
+
 namespace Silk.NET.Windowing.SDL3;
 
 internal partial class SdlSurfaceComponents : ISurfaceChildren
@@ -10,6 +12,14 @@ internal partial class SdlSurfaceComponents : ISurfaceChildren
     public void Spawn<T>()
         where T : ISurfaceApplication
     {
+        if (!IsSurfaceInitialized)
+        {
+            throw new InvalidOperationException(
+                "Children cannot be spawned until ISurfaceApplication.Initialize<TSurface>(TSurface) has finished "
+                    + "executing, consider using the Surface.Created callback instead."
+            );
+        }
+
         _children ??= new List<SdlSurface>(1);
         var child = SdlSurfaceLifecycle.CoreInit<T>(surface);
         child.Terminating += _ =>
@@ -48,4 +58,15 @@ public void TerminateChildren()
             child.Terminate();
         }
     }
+
+    private unsafe void InitializeChildren(uint createProps)
+    {
+        if (
+            surface.Parent is { Impl.Handle.Handle: not null and var handle }
+            && !Sdl.SetPointerProperty(createProps, Sdl.PropWindowCreateParentPointer, handle)
+        )
+        {
+            Sdl.ThrowError();
+        }
+    }
 }

sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Display.cs

@@ -1,26 +1,57 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Diagnostics.CodeAnalysis;
+using Silk.NET.Maths;
 using Silk.NET.SDL;
 
 namespace Silk.NET.Windowing.SDL3;
 
 internal partial class SdlSurfaceComponents : ISurfaceDisplay
 {
     private SdlDisplay? _display;
+    private bool CanPositionDetermineDisplay =>
+        IsWindowEnabled
+        && _state is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen);
+
+    private bool IsDisplayDeterminedByPosition =>
+        CanPositionDetermineDisplay && ClientArea is not ({ Origin.X: -1 } or { Origin.Y: -1 });
+
     public IDisplay Current
     {
         get
         {
-            if (!IsSurfaceInitialized && _display is { } ret)
+            // If Window decoration is not supported, then the display field is the exclusive determinant of the
+            // display. Note that if the surface is initialized we defer to SDL to get the most accurate result.
+            if (!IsSurfaceInitialized && !IsDisplayDeterminedByPosition && _display is { } ret)
             {
                 return ret;
             }
 
-            var current = IsSurfaceInitialized
-                ? Sdl.GetDisplayForWindow(Handle)
-                : Sdl.GetPrimaryDisplay();
+            uint current;
+            if (IsSurfaceInitialized)
+            {
+                // Get the most up-to-date value.
+                current = Sdl.GetDisplayForWindow(Handle);
+            }
+            else if (IsDisplayDeterminedByPosition)
+            {
+                // Determine the display from the requested position. -1 indicates "don't care" for which _display is
+                // the determinant.
+                var ca = ClientArea;
+                var rect = new Rect
+                {
+                    X = (int)ca.Origin.X,
+                    Y = (int)ca.Origin.Y,
+                    W = (int)ca.Size.X,
+                    H = (int)ca.Size.Y,
+                };
+                current = Sdl.GetDisplayForRect(rect.AsRef());
+            }
+            else
+            {
+                current = Sdl.GetPrimaryDisplay();
+            }
+
             if (current == 0)
             {
                 Sdl.ThrowError();
@@ -41,7 +72,8 @@ public IDisplay Current
         }
         set
         {
-            if (value.Equals(_display))
+            var current = Current;
+            if (value.Equals(current))
             {
                 return;
             }
@@ -67,36 +99,28 @@ public IDisplay Current
             }
 
             var videoMode = VideoMode;
-            if (!IsSurfaceInitialized)
+            if (!IsSurfaceInitialized && !IsDisplayDeterminedByPosition)
             {
                 Return(sdlDisplay, videoMode);
                 return;
             }
 
             if (videoMode == default) // not fullscreen
             {
-                var x = 0;
-                var y = 0;
-                if (!Sdl.GetWindowPosition(Handle, x.AsRef(), y.AsRef()))
-                {
-                    Sdl.ThrowError();
-                }
-
-                var currentDisplayWorkArea = Current.WorkArea;
+                GetPosition(out var x, out var y);
+                var currentDisplayWorkArea = current.WorkArea;
                 var newDisplayWorkArea = sdlDisplay.WorkArea;
-                if (
-                    !Sdl.SetWindowPosition(
-                        Handle,
-                        (int)(x - currentDisplayWorkArea.Origin.X + newDisplayWorkArea.Origin.X),
-                        (int)(y - currentDisplayWorkArea.Origin.Y + newDisplayWorkArea.Origin.Y)
-                    )
-                )
-                {
-                    Sdl.ThrowError();
-                }
+                SetPosition(
+                    (int)(x - currentDisplayWorkArea.Origin.X + newDisplayWorkArea.Origin.X),
+                    (int)(y - currentDisplayWorkArea.Origin.Y + newDisplayWorkArea.Origin.Y)
+                );
             }
             else if (
-                !Sdl.SetWindowFullscreenMode(Handle, (Ref<DisplayMode>)sdlDisplay.DisplayModes[0])
+                IsSurfaceInitialized
+                && !Sdl.SetWindowFullscreenMode(
+                    Handle,
+                    (Ref<DisplayMode>)sdlDisplay.DisplayModes[0]
+                )
             )
             {
                 Sdl.ThrowError();
@@ -134,6 +158,36 @@ is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen)
                     new DisplayVideoModeAvailabilityChangeEvent(surface, display)
                 );
             }
+
+            void GetPosition(out int x, out int y)
+            {
+                (x, y) = (0, 0);
+                if (!IsSurfaceInitialized)
+                {
+                    var ca = ClientArea;
+                    (x, y) = ((int)ca.Origin.X, (int)ca.Origin.Y);
+                    return;
+                }
+
+                if (!Sdl.GetWindowPosition(Handle, x.AsRef(), y.AsRef()))
+                {
+                    Sdl.ThrowError();
+                }
+            }
+
+            void SetPosition(int x, int y)
+            {
+                if (!IsSurfaceInitialized)
+                {
+                    ClientArea = ClientArea with { Origin = new Vector2D<float>(x, y) };
+                    return;
+                }
+
+                if (!Sdl.SetWindowPosition(Handle, x, y))
+                {
+                    Sdl.ThrowError();
+                }
+            }
         }
     }
 
@@ -208,7 +262,7 @@ is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen)
             {
                 if (value != default)
                 {
-                    Throw();
+                    ThrowBadVideoMode(nameof(value));
                 }
 
                 return;
@@ -220,42 +274,48 @@ is not (WindowState.ExclusiveFullscreen or WindowState.WindowedFullscreen)
             }
 
             var display = (SdlDisplay)Current;
-            Ptr<DisplayMode> displayMode = nullptr;
-            var found = false;
-            for (var i = 0; i < display.KnownVideoModes?.Count; i++)
-            {
-                if (display.KnownVideoModes[i] != value)
-                {
-                    continue;
-                }
+            var displayMode = GetDisplayMode(display, in value);
+            SetState(
+                currentState,
+                value == default ? WindowState.WindowedFullscreen : WindowState.ExclusiveFullscreen,
+                (value, displayMode),
+                display
+            );
+        }
+    }
 
-                if (i > 0)
-                {
-                    displayMode = display.DisplayModes[i - 1];
-                }
+    private static void ThrowBadVideoMode(string? arg) =>
+        throw new ArgumentException(
+            "The given video mode is not one of the AvailableVideoModes.",
+            arg
+        );
 
-                found = true;
-                break;
+    private Ptr<DisplayMode> GetDisplayMode(SdlDisplay display, in VideoMode value)
+    {
+        Ptr<DisplayMode> displayMode = nullptr;
+        var found = false;
+        for (var i = 0; i < display.KnownVideoModes?.Count; i++)
+        {
+            if (display.KnownVideoModes[i] != value)
+            {
+                continue;
             }
 
-            if (!found)
+            if (i > 0)
             {
-                Throw();
+                displayMode = display.DisplayModes[i - 1];
             }
 
-            SetState(
-                currentState,
-                value == default ? WindowState.WindowedFullscreen : WindowState.ExclusiveFullscreen,
-                (value, displayMode),
-                display
-            );
-            return;
-            static void Throw() =>
-                throw new ArgumentException(
-                    "The given video mode is not one of the AvailableVideoModes.",
-                    nameof(value)
-                );
+            found = true;
+            break;
+        }
+
+        if (!found)
+        {
+            ThrowBadVideoMode(nameof(value));
         }
+
+        return displayMode;
     }
 
     public IReadOnlyList<VideoMode> AvailableVideoModes =>
@@ -341,8 +401,6 @@ internal void OnPotentialVideoModeChanges(uint id, out bool isCurrent, uint curr
         }
     }
 
-    private void InitializeDisplay(uint props) { }
-
     public void OnVideoModeChanged()
     {
         var oldVideoMode = _videoMode;
@@ -356,4 +414,18 @@ public void OnVideoModeChanged()
 
     public void OnCurrentDisplayChanged() =>
         CurrentDisplayChanged?.Invoke(new DisplayChangeEvent(surface, Current));
+
+    private void PostInitializeDisplay()
+    {
+        if (
+            _state == WindowState.ExclusiveFullscreen
+            && !Sdl.SetWindowFullscreenMode(
+                Handle,
+                (Ref<DisplayMode>)GetDisplayMode((SdlDisplay)Current, in _videoMode)
+            )
+        )
+        {
+            Sdl.ThrowError();
+        }
+    }
 }

sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.OpenGL.cs

@@ -417,7 +417,7 @@ private void InitializeOpenGL(uint props)
             return;
         }
 
-        AddWindowCreateFlag(props, Sdl.WindowOpengl);
+        AddWindowCreateFlags(props, Sdl.WindowOpengl);
     }
 
     private void PostInitializeOpenGL()

sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Scale.cs

@@ -101,4 +101,6 @@ private void InitializeScale(uint createProps)
             Sdl.ThrowError();
         }
     }
+
+    private void PostInitializeScale() => OnPotentialScaleChanges();
 }

sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.Vulkan.cs

@@ -68,6 +68,6 @@ private void InitializeVulkan(uint props)
             return;
         }
 
-        AddWindowCreateFlag(props, Sdl.WindowVulkan);
+        AddWindowCreateFlags(props, Sdl.WindowVulkan);
     }
 }