Start of windowing implementation

Silk.NET.sln

@@ -20,6 +20,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "libraries", "libraries", "{
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Maths", "src\libraries\Silk.NET.Maths\Silk.NET.Maths.csproj", "{7A2A3176-DBA1-4026-AF65-8E36B4F09B01}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Silk.NET.Windowing", "src\libraries\Silk.NET.Windowing\Silk.NET.Windowing.csproj", "{7A2A3176-DBA1-4026-AF65-8E36B4F09B02}"
+EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks", "{FD15E196-1C63-47D6-8AD5-64F015120B4B}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "infrastructure", "infrastructure", "{F07CABFC-DC6A-4B5B-BC56-B10EEC2C0BFA}"
@@ -361,6 +363,7 @@ Global
 		{5329AC43-7177-4953-AFAB-A9FA7B9A4C7C} = {94D5D1E1-B998-4CB1-9D04-DA138A2B0F3C}
 		{66FE736C-C407-44C3-A94E-4345E22AA95E} = {94D5D1E1-B998-4CB1-9D04-DA138A2B0F3C}
 		{381D1039-3259-488F-BB25-D90EE63A3E82} = {94D5D1E1-B998-4CB1-9D04-DA138A2B0F3C}
+		{7A2A3176-DBA1-4026-AF65-8E36B4F09B02} = {C9718C94-2F21-4E8D-B55D-8F0B1A131346}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {F5273D7F-3334-48DF-94E3-41AE6816CD4D}

src/libraries/Silk.Net.Windowing/Abstract/ContextFlags.cs

@@ -0,0 +1,26 @@
+namespace Silk.NET.Windowing
+{
+    /// <summary>
+    /// Represents flags related to the OpenGL context.
+    /// </summary>
+    [Flags]
+    public enum ContextFlags
+    {
+        /// <summary>
+        /// No flags enabled.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// Enables debug context; debug contexts provide more debugging info, but can run slower.
+        /// </summary>
+        Debug = 1,
+
+        /// <summary>
+        /// Enables forward compatability; this context won't support anything marked as deprecated in the current
+        /// version.
+        /// </summary>
+        /// <remarks>On OpenGL contexts older than 3.0, this flag does nothing.</remarks>
+        ForwardCompatible = 2
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/ContextProfile.cs

@@ -0,0 +1,19 @@
+namespace Silk.NET.Windowing
+{
+    /// <summary>
+    /// Represents the context profile OpenGL should use.
+    /// </summary>
+    public enum ContextProfile
+    {
+        /// <summary>
+        /// Uses a core OpenGL context, which removes some deprecated functionality.
+        /// </summary>
+        Core = 0,
+
+        /// <summary>
+        /// Uses a compatability OpenGL context, allowing for some deprecated functionality. This should only ever be
+        /// used for maintaining legacy code; no newly-written software should use this.
+        /// </summary>
+        Compatability
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/Delegates.cs

@@ -0,0 +1,8 @@
+using Silk.NET.Maths;
+using Silk.NET.Windowing;
+
+public delegate void Vector2DAction(Vector2D<int> newValue);
+public delegate void DeltaAction(double deltaTime);
+public delegate void WindowStateAction(WindowState newState);
+public delegate void FilePathsAction(string[] filePaths);
+public delegate void ToggleAction(bool newValue);

src/libraries/Silk.Net.Windowing/Abstract/IDesktopSurface.cs

@@ -0,0 +1,150 @@
+using Silk.NET.Core;
+using Silk.NET.Maths;
+
+namespace Silk.NET.Windowing
+{
+    /// <summary>
+    /// A surface which wraps a Desktop Window.
+    /// </summary>
+    public interface IDesktopSurface : ISurface
+    {
+        /// <summary>
+        /// Whether or not the window is visible.
+        /// </summary>
+        bool IsVisible { get; set; }
+
+        /// <summary>
+        /// The position of the window. If set to -1, use the backend default.
+        /// </summary>
+        Vector2D<int> Position { get; set; }
+
+        /// <summary>
+        /// The size of the window in pixels.
+        /// </summary>
+        new Vector2D<int> Size { get; set; }
+
+        /// <summary>
+        /// The window title.
+        /// </summary>
+        string Title { get; set; }
+
+        /// <summary>
+        /// The window state.
+        /// </summary>
+        WindowState WindowState { get; set; }
+
+        /// <summary>
+        /// The window border.
+        /// </summary>
+        WindowBorder WindowBorder { get; set; }
+
+        /// <summary>
+        /// The video mode.
+        /// </summary>
+        VideoMode VideoMode { get; set; }
+
+        /// <summary>
+        /// Gets the screen on which this window is active.
+        /// </summary>
+        IScreen? CurrentScreen { get; set; }
+
+        /// <summary>
+        /// Gets the available screens for this surface.
+        /// </summary>
+        IEnumerable<IScreen>? AvailableScreens { get; }
+
+        /// <summary>
+        /// Gets or sets whether the window waits for an event to be posted before existing <see cref="DoEvents" />.
+        /// </summary>
+        bool IsEventDriven { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the window has been requested to close.
+        /// </summary>
+        bool IsCloseRequested { get; set; }
+
+        /// <summary>
+        /// Gets whether the window is focused or not.
+        /// </summary>
+        bool IsFocused { get; }
+
+        /// <summary>
+        /// Gets the distances in screen coordinates from the edges of the content area to the corresponding edges of
+        /// the full window.
+        /// </summary>
+        /// <remarks>
+        /// Because these are distances and not coordinates, they are always zero or positive.
+        /// </remarks>
+        /// <seealso cref="WindowExtensions.GetFullSize"/>
+        Rectangle<int> BorderSize { get; }
+
+        /// <summary>
+        /// Raised when the window has been requested to close.
+        /// </summary>
+        event Action CloseRequested;
+
+        /// <summary>
+        /// Raised when the window is moved.
+        /// </summary>
+        event Vector2DAction? Move;
+
+        /// <summary>
+        /// Raised when the window state is changed.
+        /// </summary>
+        event WindowStateAction? StateChanged;
+
+        /// <summary>
+        /// Raised when the user drops files onto the window.
+        /// </summary>
+        event FilePathsAction? FileDrop;
+
+        /// <summary>
+        /// Raised when the window focus changes.
+        /// </summary>
+        event ToggleAction? FocusChanged;
+
+        /// <summary>
+        /// Sets the window icons.
+        /// </summary>
+        /// <param name="icons">Either a collection of window icons, or null to set to the default icon.</param>
+        void SetWindowIcon(ReadOnlySpan<RawImage> icons)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// When using <see cref="WindowOptions.IsEventDriven"/> = true, wakes the main thread from
+        /// its blocking wait on incoming events.  Can be called from any thread.
+        /// </summary>
+        void ContinueEvents()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Converts this point to client coordinates.
+        /// </summary>
+        /// <param name="point">The point to transform.</param>
+        /// <returns>The transformed point.</returns>
+        /// <remarks>Expects screen coordinates as input.</remarks>
+        Vector2D<int> PointToClient(Vector2D<int> point)
+        {
+            return new Vector2D<int>(point.X - Position.X, point.Y - Position.Y);
+        }
+
+        /// <summary>
+        /// Converts this point to screen coordinates.
+        /// </summary>
+        /// <param name="point">The point to transform.</param>
+        /// <returns>The transformed point.</returns>
+        /// <remarks>Expects client coordinates as input.</remarks>
+        Vector2D<int> PointToScreen(Vector2D<int> point)
+        {
+            return new Vector2D<int>(point.X + Position.X, point.Y + Position.Y);
+        }
+        public Vector2D<int> PointToFramebuffer(Vector2D<int> point)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/IGLDesktopSurface.cs

@@ -0,0 +1,5 @@
+
+namespace Silk.NET.Windowing
+{
+    public interface IGLDesktopSurface : IDesktopSurface, IGLSurface { }
+}

src/libraries/Silk.Net.Windowing/Abstract/IGLSurface.cs

@@ -0,0 +1,17 @@
+namespace Silk.NET.Windowing
+{
+    public interface IGLSurface : INativeGLSurface
+    {
+        ContextFlags ContextFlags { get; set; }
+        ContextProfile ContextProfile { get; set; }
+        IGLSurface? SharedContext { get; set; }
+
+        /// <summary>
+        /// Enables OpenGL support for this surface. This will create a surface upon initialization.
+        /// </summary>
+        bool TryEnableOpenGL()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/IGLTransparentFramebufferSurface.cs

@@ -0,0 +1,8 @@
+
+namespace Silk.NET.Windowing
+{
+    public interface IGLTransparentFramebuffer : INativeGLSurface
+    {
+        bool TransparentFramebuffer { get; set; }
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/IGlesDesktopSurface.cs

@@ -0,0 +1,7 @@
+namespace Silk.NET.Windowing
+{
+    public interface IGlesDesktopSurface : IDesktopSurface, IGlesSurface
+    {
+
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/IGlesSurface.cs

@@ -0,0 +1,11 @@
+namespace Silk.NET.Windowing
+{
+    public interface IGlesSurface : INativeGLSurface
+    {
+        IGlesSurface? SharedContext { get; set; }
+        /// <summary>
+        /// Enables OpenGLES support for this surface. This will create a surface upon initialization.
+        /// </summary>
+        bool TryEnableOpenGLES();
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/INativeGLSurface.cs

@@ -0,0 +1,56 @@
+using Silk.NET.Core;
+using Silk.NET.Maths;
+
+namespace Silk.NET.Windowing
+{
+    public interface INativeGLSurface : ISurface
+    {
+        nint Handle { get; }
+        bool IsContextCurrent { get; set; }
+        bool ShouldSwapAutomatically { get; set; }
+
+        /// <summary>
+        /// Sets the number of vertical blanks to wait between calling <see cref="SwapBuffers" /> and presenting the image,
+        /// a.k.a vertical synchronization (V-Sync). Set to <c>1</c> to enable V-Sync.
+        /// </summary>
+        /// <remarks>
+        /// Due to platform restrictions, this value can only be set and not retrieved.
+        /// </remarks>
+        int SwapInterval { set; }
+
+        /// <summary>
+        /// Preferred depth buffer bits of the window's framebuffer.
+        /// </summary>
+        /// <remarks>
+        /// Pass <c>null</c> or <c>-1</c> to use the system default. 
+        /// </remarks>
+        int? PreferredDepthBufferBits { get; set; }
+
+        /// <summary>
+        /// Preferred stencil buffer bits of the window's framebuffer.
+        /// </summary>
+        /// <remarks>
+        /// Pass <c>null</c> or <c>-1</c> to use the system default. 
+        /// </remarks>
+        int? PreferredStencilBufferBits { get; set; }
+
+        /// <summary>
+        /// Preferred red, green, blue, and alpha bits of the window's framebuffer.
+        /// </summary>
+        /// <remarks>
+        /// Pass <c>null</c> or <c>-1</c> for any of the channels to use the system default. 
+        /// </remarks>
+        Vector4D<int>? PreferredBitDepth { get; set; }
+
+        /// <summary>
+        /// The API version to use.
+        /// </summary>
+        Version32? ApiVersion { get; set; }
+
+        nint? GetProcAddress(string proc);
+        void SwapBuffers()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/libraries/Silk.Net.Windowing/Abstract/IScreen.cs

@@ -0,0 +1,44 @@
+using Silk.NET.Maths;
+
+namespace Silk.NET.Windowing
+{
+    /// <summary>
+    /// An interface representing a screen.
+    /// </summary>
+    public interface IScreen
+    {
+        /// <summary>
+        /// The name of this screen.
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// The index of this screen.
+        /// </summary>
+        int Index { get; }
+
+        /// <summary>
+        /// The workarea of this screen.
+        /// </summary>
+        Rectangle<int> WorkArea { get; }
+
+        /// <summary>
+        /// The current video mode of this monitor.
+        /// </summary>
+        VideoMode VideoMode { get; }
+
+        /// <summary>
+        /// This screen's gamma correction.
+        /// </summary>
+        float Gamma { get; set; }
+
+        /// <summary>
+        /// Get all video modes that this screen supports.
+        /// </summary>
+        /// <returns>An array of all video modes.</returns>
+        IEnumerable<VideoMode> GetAllVideoModes()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}