Fix bugs with premature usage of OpenGL and Vulkan functions (#484)

Author: Perksey

src/Lab/InputTest/Program.cs

@@ -197,7 +197,7 @@ public static unsafe void DoConnect(IInputDevice device, bool isConnected)
                     mouse.MouseMove -= MouseOnMouseMove;
                 }
 
-                mouse.Cursor.IsConfined = true;
+                // mouse.Cursor.IsConfined = true;
 
                 Console.Write("    Buttons: ");
                 Console.WriteLine(string.Join(", ", mouse.SupportedButtons.Select(x => x)));

src/Lab/Triangle/Program.cs

@@ -1,4 +1,4 @@
-#define MINIMAL
+#define REOPEN_EXPERIMENT
 
 using System;
 using System.Drawing;
@@ -24,39 +24,50 @@ public static class Program
         private static uint _vertexBufferObject;
         private static uint _vertexArrayObject;
         private static GL _gl;
-#if MINIMAL
         private static IView _window;
-#else
-        private static IWindow _window;
-#endif
         private static Shader _shader;
 
         public static GraphicsAPI API { get; set; } = GraphicsAPI.Default;
 
         public static void Main(string[] args)
         {
+            //Silk.NET.Windowing.Sdl.SdlWindowing.Use();
             //SdlProvider.SetMainReady = true;
-#if MINIMAL
             var opts = ViewOptions.Default;
             opts.FramesPerSecond = 90;
             opts.UpdatesPerSecond = 90;
             opts.API = API;
             opts.VSync = false;
-            _window = Window.GetView(opts);
-#else
-            var opts = WindowOptions.Default;
-            opts.FramesPerSecond = 90;
-            opts.API = API;
-            opts.UpdatesPerSecond = 90;
-            _window = Window.Create(opts);
-#endif
+            if (Window.IsViewOnly)
+            {
+                _window = Window.GetView(opts);
+            }
+            else
+            {
+                _window = Window.Create(new(opts));
+            }
+
             _window.Load += Load;
             _window.Load += InputTest.Program.OnLoad(_window);
             _window.Render += RenderFrame;
             _window.Update += UpdateFrame;
             _window.FramebufferResize += Resize;
             _window.Closing += End;
             _window.Run();
+#if REOPEN_EXPERIMENT
+            // Experiment notes:
+            // - This is something we're meant to support, but we've never tested it!
+            // - GLFW worked fine, bar input which for some reason didn't work when the window reloaded.
+            // - SDL worked flawlessly.
+            // - Right now the Closing event can actually cancel window closure using IsClosing.
+            //     - We need to test this too.
+            //     - We need to add an Unload event that is only called once the window is guaranteed to be terminated.
+            // - TODO for 3.0 (to add the Unload event, by all means fix bugs before then)
+            if (_window is IWindow)
+            {
+                _window.Run();
+            }
+#endif
         }
 
         private static unsafe void Load()

src/Windowing/Silk.NET.Windowing.Common/Internals/ViewImplementationBase.cs

@@ -55,14 +55,14 @@ protected ViewImplementationBase(ViewOptions opts)
         protected abstract Vector2D<int> CoreSize { get; }
         protected abstract nint CoreHandle { get; }
         protected abstract bool CoreIsClosing { get; }
+        protected abstract IGLContext? CoreGLContext { get; }
+        protected abstract IVkSurface? CoreVkSurface { get; }
 
         // Function bases - again extra functionality on top
         protected abstract void CoreInitialize(ViewOptions opts);
         protected abstract void CoreReset();
 
         // Other APIs implemented abstractly
-        public abstract IGLContext? GLContext { get; }
-        public abstract IVkSurface? VkSurface { get; }
         public abstract VideoMode VideoMode { get; }
         public abstract bool IsEventDriven { get; set; }
         public abstract Vector2D<int> FramebufferSize { get; }
@@ -213,6 +213,52 @@ public bool VSync
             }
         }
 
+        public IGLContext? GLContext
+        {
+            get
+            {
+                if (!IsInitialized && (API.API == ContextAPI.OpenGL || API.API == ContextAPI.OpenGLES))
+                {
+                    static void Throw() => throw new InvalidOperationException
+                    (
+                        "OpenGL functions can only be used after initialization (just before the Load callback is " +
+                        "executed)"
+                    );
+
+                    Throw();
+                }
+                else if (API.API != ContextAPI.OpenGL && API.API != ContextAPI.OpenGLES)
+                {
+                    return null;
+                }
+
+                return CoreGLContext;
+            }
+        }
+
+        public IVkSurface? VkSurface
+        {
+            get
+            {
+                if (!IsInitialized && API.API == ContextAPI.Vulkan)
+                {
+                    static void Throw() => throw new InvalidOperationException
+                    (
+                        "Vulkan functions can only be used after initialization (just before the Load callback is " +
+                        "executed)"
+                    );
+
+                    Throw();
+                }
+                else if (API.API != ContextAPI.Vulkan)
+                {
+                    return null;
+                }
+
+                return CoreVkSurface;
+            }
+        }
+
         // Misc implementations
         [MethodImpl(MethodImplOptions.AggressiveInlining | (MethodImplOptions) 512)]
         public Vector2D<int> PointToFramebuffer(Vector2D<int> point)

src/Windowing/Silk.NET.Windowing.Glfw/GlfwWindow.cs

@@ -77,21 +77,35 @@ protected override void CoreReset()
             {
                 _glfw.DestroyWindow(_glfwWindow);
                 GLFW.Glfw.ThrowExceptions();
-                _glfwWindow = null;
             }
             catch (GlfwException)
             {
                 // If the window is already destroyed, it throws an exception,
                 // but we want the window destroyed anyways, so just ignore it
             }
+            finally
+            {
+                _glfwWindow = null;
+                _glContext = null;
+            }
         }
 
-        public override IGLContext? GLContext
-            => API.API == ContextAPI.OpenGL || API.API == ContextAPI.OpenGLES
-                ? _glContext ??= new(_glfw, _glfwWindow, this)
-                : null;
+        protected override IGLContext? CoreGLContext => _glContext ??= new(_glfw, _glfwWindow, this);
 
-        public override IVkSurface? VkSurface => API.API == ContextAPI.Vulkan && _glfw.VulkanSupported() ? this : null;
+        protected override IVkSurface? CoreVkSurface
+        {
+            get
+            {
+                if (!_glfw.VulkanSupported())
+                {
+                    static void Throw()
+                        => throw new PlatformNotSupportedException("GLFW does not support Vulkan on this platform.");
+                    Throw();
+                }
+                
+                return this;
+            }
+        }
 
         protected override bool CoreIsVisible
         {

src/Windowing/Silk.NET.Windowing.Sdl/SdlView.cs

@@ -53,11 +53,8 @@ public SdlView(void* nativeHandle, IGLContext? ctx, SdlPlatform platform) : base
         public override event Action<bool>? FocusChanged;
 
         // Properties
-        public override IGLContext? GLContext => _ctx ??= API.API == ContextAPI.OpenGL || API.API == ContextAPI.OpenGLES
-            ? new SdlContext(Sdl, SdlWindow, this)
-            : null;
-
-        public override IVkSurface? VkSurface => _vk ??= API.API == ContextAPI.Vulkan ? new SdlVkSurface(this) : null;
+        protected override IGLContext? CoreGLContext => _ctx ??= new SdlContext(Sdl, SdlWindow, this);
+        protected override IVkSurface? CoreVkSurface => _vk ??= new SdlVkSurface(this);
         protected override nint CoreHandle => (nint) SdlWindow;
         internal SDL.Sdl Sdl { get; }
         internal SDL.Window* SdlWindow { get; private set; }
@@ -160,7 +157,7 @@ protected void CoreInitialize
             }
 
             sharedContext?.MakeCurrent();
-            (GLContext as SdlContext)?.Create
+            (CoreGLContext as SdlContext)?.Create
             (
                 (GLattr.GLContextMajorVersion, opts.API.Version.MajorVersion),
                 (GLattr.GLContextMinorVersion, opts.API.Version.MinorVersion),
@@ -244,8 +241,12 @@ protected override void CoreReset()
                 return;
             }
 
-            GLContext?.Dispose();
+            CoreGLContext?.Dispose();
             Sdl.DestroyWindow(SdlWindow);
+
+            SdlWindow = null;
+            _ctx = null;
+            _vk = null;
         }
 
         public override void DoEvents()