OpenGL: GraphicsAdapter.Outputs is now properly populated

Author: ferafiks

sources/engine/Stride.Graphics/OpenGL/GraphicsAdapter.OpenGL.cs

@@ -21,15 +21,19 @@ public unsafe partial class GraphicsAdapter
 
         internal GraphicsAdapter()
         {
-            outputs = new [] { new GraphicsOutput() };
-
             // set default values
             int detectedVersion = 100;
 
             string renderer, vendor, version;
             int versionMajor, versionMinor;
 
             var SDL = Stride.Graphics.SDL.Window.SDL;
+
+            //Initialize outputs
+            outputs = new GraphicsOutput[SDL.GetNumVideoDisplays()];
+            for (int i = 0; i < outputs.Length; i++)
+                outputs[i] = new GraphicsOutput(this, i);
+
             // Some platforms (i.e. Android) can only have a single window
             var sdlWindow = DefaultWindow;
             if (sdlWindow == null)

sources/engine/Stride.Graphics/OpenGL/GraphicsOutput.OpenGL.cs

@@ -3,14 +3,66 @@
 #if STRIDE_GRAPHICS_API_OPENGL
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Stride.Graphics
 {
     public partial class GraphicsOutput
     {
+        /// <summary>
+        /// Initializes a new instance of <see cref="GraphicsOutput" />.
+        /// </summary>
+        /// <param name="adapter">The adapter.</param>
+        /// <param name="displayIndex">Index of the output.</param>
+        /// <exception cref="System.ArgumentNullException">output</exception>
+        public GraphicsOutput(GraphicsAdapter adapter, int displayIndex)
+        {
+            if (adapter == null) throw new ArgumentNullException("adapter");
+            
+            this.adapter = adapter;
+            this.displayIndex = displayIndex;
+
+            var SDL = Stride.Graphics.SDL.Window.SDL;
+
+            unsafe
+            {
+                var bounds = new Silk.NET.Maths.Rectangle<int>();
+                SDL.GetDisplayBounds(displayIndex, &bounds);
+                desktopBounds.Width = bounds.Size.X;
+                desktopBounds.Height = bounds.Size.Y;
+                desktopBounds.X = bounds.Origin.X;
+                desktopBounds.Y = bounds.Origin.Y;
+            }
+
+            DisplayName = SDL.GetDisplayNameS(displayIndex);
+        }
+
+        private readonly int displayIndex;
+
+        public string DisplayName { get; init; }
+
+        /// <summary>
+        /// Find the display mode that most closely matches the requested display mode.
+        /// </summary>
+        /// <param name="targetProfiles">The target profile, as available formats are different depending on the feature level..</param>
+        /// <param name="mode">The mode.</param>
+        /// <returns>Returns the closes display mode.</returns>
         public DisplayMode FindClosestMatchingDisplayMode(GraphicsProfile[] targetProfiles, DisplayMode mode)
         {
-            return mode;
+            var SDL = Stride.Graphics.SDL.Window.SDL;
+
+            DisplayMode closest;
+            unsafe
+            {
+                var modeSDL = new Silk.NET.SDL.DisplayMode(0, mode.Width, mode.Height, mode.RefreshRate.Denominator / mode.RefreshRate.Numerator);
+                var closestSDL = new Silk.NET.SDL.DisplayMode();
+
+                SDL.GetClosestDisplayMode(displayIndex, &modeSDL, &closestSDL);
+                closest = new DisplayMode(PixelFormat.None, closestSDL.W, closestSDL.H, new Rational(1, closestSDL.RefreshRate));
+            }
+
+            return closest;
         }
 
         public IntPtr MonitorHandle
@@ -20,11 +72,40 @@ public IntPtr MonitorHandle
 
         private void InitializeSupportedDisplayModes()
         {
+            var SDL = Stride.Graphics.SDL.Window.SDL;
+
+            var modesMap = new Dictionary<string, DisplayMode>();
+            var modeCount = SDL.GetNumDisplayModes(displayIndex);
+
+            unsafe
+            {
+                for (int i = 0; i < modeCount; i++)
+                {
+                    var sdlMode = new Silk.NET.SDL.DisplayMode();
+                    SDL.GetDisplayMode(displayIndex, i, &sdlMode);
+
+                    var key = $"{sdlMode.W};{sdlMode.H};{sdlMode.RefreshRate}";
+
+                    if (!modesMap.ContainsKey(key))
+                    {
+                        //We should probably convert the sdlMode format
+                        //to the engine's Pixel Format
+                        modesMap.Add(key, new DisplayMode(PixelFormat.None, sdlMode.W, sdlMode.H, new Rational(1, sdlMode.RefreshRate)));
+                    }
+                }
+            }
+
+            supportedDisplayModes = modesMap
+                .Select(x => x.Value)
+                .ToArray();
         }
 
         private void InitializeCurrentDisplayMode()
         {
-            currentDisplayMode = null;
+            var SDL = Stride.Graphics.SDL.Window.SDL;
+            var mode = new DisplayMode(PixelFormat.None, desktopBounds.Width, desktopBounds.Height, new Rational(1, 0));
+
+            currentDisplayMode = FindClosestMatchingDisplayMode([], mode);
         }
     }
 }