GLFW cleanup (#14)

* Start of GLFW libraries

* Add libs

* Add anti-gitignore for the libraries

* Use included libs

* Remove debug print from GlfwWindow

* Organize variables, cleanup documentation

* Add the ability to change update/render rate post-window creation

* Revert change, it ended up being messier than expected

* Replace int with KeyModifiers

* Replace dispatcher null check with proper constructor

* Document GlfwWindow constructor

* Add documentation to the RaiseFrame functions

* Change way libs are included

* Fix errors in csproj

* Better targets file

* Fix indents

Author: devvoid

build/native/.gitignore

@@ -0,0 +1,3 @@
+!**/*.dll
+!**/*.so
+!**/*.dylib

build/native/glfw/glfw3-x64.dll

@@ -105,7 +105,7 @@ public delegate void KeyCallback(WindowHandle* window, Keys key, int scanCode, I
         /// <seealso cref="IGlfw.SetMouseButtonCallback" />
         public delegate void
             MouseButtonCallback(WindowHandle* window, int button, InputAction action,
-                int mods); // TODO: Make enums for int params in callback
+                KeyModifiers mods);
 
         /// <summary>
         /// The function signature for scroll callback functions.

build/native/glfw/glfw3-x86.dll

@@ -13,6 +13,30 @@ namespace Silk.NET.GLFW
     /// </summary>
     public static class GlfwProvider
     {
+        /// <summary>
+        /// Creates a new instance of the GlfwProvider class.
+        /// </summary>
+        static GlfwProvider()
+        {
+            ThreadDispatcher = new Dispatcher();
+            GLFW = new Lazy<Glfw>(() =>
+            {
+                if (ThreadDispatcher == null) {
+                    ThreadDispatcher = new Dispatcher();
+                }
+
+                var glfw = Glfw.GetAPI();
+
+                ThreadDispatcher.Invoke(() =>
+                {
+                    glfw.Init();
+                    glfw.SetErrorCallback(Glfw.ErrorCallback);
+                });
+
+                return glfw;
+            });
+        }
+        
         /// <summary>
         /// Gets a dispatcher to the main GLFW thread.
         /// </summary>
@@ -26,22 +50,7 @@ public static class GlfwProvider
         /// <summary>
         /// Gets a GLFW interface implementation lazily.
         /// </summary>
-        public static Lazy<Glfw> GLFW { get; internal set; } = new Lazy<Glfw>(() =>
-        {
-            if (ThreadDispatcher == null) {
-                ThreadDispatcher = new Dispatcher();
-            }
-
-            var glfw = Glfw.GetAPI();
-
-            ThreadDispatcher.Invoke(() =>
-            {
-                glfw.Init();
-                glfw.SetErrorCallback(Glfw.ErrorCallback);
-            });
-
-            return glfw;
-        });
+        public static Lazy<Glfw> GLFW { get; internal set; }
 
         /// <summary>
         /// Unloads the loaded <see cref="GLFW" /> interface implementation.

build/native/glfw/libglfw.so.3.3

@@ -8,11 +8,29 @@
 
     <ItemGroup>
       <PackageReference Include="AdvancedDLSupport" Version="3.0.0" />
-      <PackageReference Include="opentoolkit.redist.glfw" Version="3.3.0-pre20190424184726" />
       <PackageReference Include="Ultz.Dispatcher" Version="1.1.0" />
     </ItemGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\..\Silk.NET.Core\Silk.NET.Core.csproj" />
     </ItemGroup>
+
+    <ItemGroup>
+      <Content Include="..\..\..\build\native\glfw\glfw3-x64.dll"
+               Link="runtimes/win-x64/native/glfw3-x64.dll"
+               PackagePath="runtimes/win-x64/native"
+               InProject="false" />
+
+      <Content Include="..\..\..\build\native\glfw\glfw3-x86.dll"
+               Link="runtimes/win-x86/native/glfw3-x86.dll"
+               PackagePath="runtimes/win-x86/native"
+               InProject="false" />
+
+      <Content Include="..\..\..\build\native\glfw\libglfw.so.3.3"
+               Link="runtimes/linux-x64/native/libglfw.so.3.3"
+               PackagePath="runtimes/linux-x64/native"
+               InProject="false" />
+
+      <Content Include="Silk.NET.GLFW.targets" PackagePath="build/" />
+    </ItemGroup>
 </Project>

src/Windowing/Silk.NET.GLFW/GlfwCallbacks.cs

@@ -0,0 +1,38 @@
+<Project>
+  <PropertyGroup>
+    <glfw_Platform Condition="'$(RuntimeIdentifier)' == 'win-x64'">win64</glfw_Platform>
+    <glfw_Platform Condition="'$(RuntimeIdentifier)' == 'win-x86'">win86</glfw_Platform>
+    <glfw_Platform Condition="'$(RuntimeIdentifier)' == 'linux-x64'">linux</glfw_Platform>
+    <glfw_Platform Condition="'$(glfw_Platform)' == ''">any</glfw_Platform>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
+    <None Include="$(MSBuildThisFileDirectory)\..\runtimes\win-x64\native\glfw3-x64.dll">
+      <Link>glfw3-x64.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>false</Visible>
+    </None>
+    <None Include="$(MSBuildThisFileDirectory)\..\runtimes\win-x86\native\glfw3-x86.dll">
+      <Link>glfw3-x86.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>false</Visible>
+    </None>
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETFramework'">
+    <None Include="$(MSBuildThisFileDirectory)\..\runtimes\win-x64\native\glfw3-x64.dll" Condition="'$(glfw_Platform)' == 'win64' Or '$(glfw_Platform)' == 'any'">
+      <Link>glfw3-x64.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>false</Visible>
+    </None>
+    <None Include="$(MSBuildThisFileDirectory)\..\runtimes\win-x86\native\glfw3-x86.dll" Condition="'$(glfw_Platform)' == 'win86' Or '$(glfw_Platform)' == 'any'">
+      <Link>glfw3-x86.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>false</Visible>
+    </None>
+    <None Include="$(MSBuildThisFileDirectory)\..\runtimes\linux-x64\native\libglfw.so.3.3" Condition="'$(glfw_Platform)' == 'linux' Or '$(glfw_Platform)' == 'any'">
+      <Link>libglfw.so.3.3</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>false</Visible>
+    </None>
+    <!-- TODO: Add Mac support -->
+  </ItemGroup>
+</Project>

src/Windowing/Silk.NET.GLFW/GlfwProvider.cs

@@ -47,12 +47,12 @@ public interface IWindowProperties
         /// <summary>
         /// The number of rendering operations to run every second.
         /// </summary>
-        double FramesPerSecond { get; }
+        double FramesPerSecond { get; set; }
 
         /// <summary>
         /// The number of update operations to run every second.
         /// </summary>
-        double UpdatesPerSecond { get; }
+        double UpdatesPerSecond { get; set; }
 
         /// <summary>
         /// Gets the graphics API the window will use.

src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj

@@ -22,47 +22,49 @@ public class GlfwWindow : IWindow
         // The number of frames that the window has been running slowly for.
         private int _isRunningSlowlyTries;
 
+        // Cache variables
         private Point _position;
-
         private Size _size;
-
         private string _title;
-
         private VSyncMode _vSync;
-
         private WindowBorder _windowBorder;
-
         private WindowState _windowState;
 
         // Glfw stuff
         private Glfw glfw = GlfwProvider.GLFW.Value;
         private Dispatcher glfwThread = GlfwProvider.ThreadDispatcher;
+        private unsafe WindowHandle* WindowPtr;
+
+        // Callbacks
         private GlfwCallbacks.WindowCloseCallback onClosing;
         private GlfwCallbacks.DropCallback onFileDrop;
         private GlfwCallbacks.WindowFocusCallback onFocusChanged;
         private GlfwCallbacks.WindowMaximizeCallback onMaximized;
         private GlfwCallbacks.WindowIconifyCallback onMinimized;
-
-        // Callbacks
-
         private GlfwCallbacks.WindowPosCallback onMove;
         private GlfwCallbacks.WindowSizeCallback onResize;
-        private Dispatcher RenderDispatcher;
-
-        // The period for rendering and updating. In essence, the delay between events being fired off.
-        private double renderPeriod;
 
+        // Main loop-related things
+        
         // The stopwatches. Used to calculate delta.
         private Stopwatch renderStopwatch;
-
-        // Main loop-related things
+        private Stopwatch updateStopwatch;
 
         // Dispatcher for the update and render threads
         private Dispatcher UpdateDispatcher;
+        private Dispatcher RenderDispatcher;
+        
+        // Update and render period. Represents the time in seconds that each frame should take.
         private double updatePeriod;
-        private Stopwatch updateStopwatch;
-        private unsafe WindowHandle* WindowPtr;
+        private double renderPeriod;
+
+        private double updatesPerSecond;
+        private double framesPerSecond;
 
+        /// <summary>
+        /// Create and open a new GlfwWindow.
+        /// </summary>
+        /// <param name="options">The options to use for this window.</param>
         public GlfwWindow(WindowOptions options)
         {
             unsafe {
@@ -217,10 +219,36 @@ public Size Size
         }
 
         /// <inheritdoc />
-        public double FramesPerSecond { get; }
+        public double FramesPerSecond {
+            get => framesPerSecond;
+            set
+            {
+                framesPerSecond = value;
+
+                if (value <= double.Epsilon) {
+                    renderPeriod = 0.0;
+                    return;
+                }
+                
+                renderPeriod = 1.0 / value;
+            }
+        }
 
         /// <inheritdoc />
-        public double UpdatesPerSecond { get; }
+        public double UpdatesPerSecond
+        {
+            get => updatesPerSecond;
+            set
+            {
+                updatesPerSecond = value;
+                
+                if (value <= double.Epsilon) {
+                    updatePeriod = 0.0;
+                    return;
+                }
+                updatePeriod = 1.0 / value;
+            }
+        }
 
         /// <inheritdoc />
         public GraphicsAPI API { get; }
@@ -280,7 +308,7 @@ public WindowBorder WindowBorder
         {
             get => _windowBorder;
             set
-            {
+            {   
                 glfwThread.Invoke(() =>
                 {
                     unsafe {
@@ -351,25 +379,10 @@ public void Run()
 
             // Initialize some variables
             _isRunningSlowlyTries = 0;
+            
             renderStopwatch = new Stopwatch();
             updateStopwatch = new Stopwatch();
-
-            // Calculate the update speed.
-            if (UpdatesPerSecond <= double.Epsilon) {
-                updatePeriod = 0.0;
-            }
-            else {
-                updatePeriod = 1.0 / UpdatesPerSecond;
-            }
-
-            // Calculate the render speed.
-            if (FramesPerSecond <= double.Epsilon) {
-                renderPeriod = 0.0;
-            }
-            else {
-                renderPeriod = 1.0 / FramesPerSecond;
-            }
-
+            
             UpdateDispatcher = new Dispatcher();
             RenderDispatcher = new Dispatcher();
 
@@ -467,10 +480,13 @@ public Point PointToScreen(Point point)
         /// <inheritdoc />
         public event Action<double> OnRender;
 
+        /// <summary>
+        /// Run an OnUpdate event.
+        /// </summary>
         private void RaiseUpdateFrame()
         {
-            // If using a capped framerate, we have to do some synchronization-related things before rendering.
-            // This is only necessary if VSync is disabled.
+            // If using a capped framerate without vsync, we have to do some synchronization-related things
+            // before rendering.
             if (UpdatesPerSecond > double.Epsilon
                 && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly)) {
                 // Calculate the amount of time to sleep.
@@ -493,27 +509,21 @@ private void RaiseUpdateFrame()
             updateStopwatch.Restart();
         }
 
+        /// <summary>
+        /// Run an OnRender event.
+        /// </summary>
         private void RaiseRenderFrame()
         {
-            // If using a capped framerate, we have to do some synchronization-related things before rendering.
+            // Identical to RaiseUpdateFrame.
             if (FramesPerSecond > double.Epsilon
                 && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly)) {
-                // Calculate the amount of time to sleep.
                 var sleepTime = renderPeriod - renderStopwatch.Elapsed.TotalSeconds;
 
-                // If the result is negative, that means the frame is running slowly, so don't sleep.
                 if (sleepTime > 0.0) {
-                    // Else, sleep for that amount of time.
-                    var timeBefore = renderStopwatch.Elapsed.TotalSeconds;
                     Thread.Sleep((int) (1000 * sleepTime));
-                    var timeAfter = renderStopwatch.Elapsed.TotalSeconds;
-
-                    Console.WriteLine($"Tried sleeping for {sleepTime}, slept for {timeAfter - timeBefore}," +
-                                      $"variance of {timeAfter - timeBefore - sleepTime}\n");
                 }
             }
 
-            // Calculate delta and run frame.
             var delta = renderStopwatch.Elapsed.TotalSeconds;
             OnRender?.Invoke(delta);
             renderStopwatch.Restart();