Add IsRunningSlowlyThreshold

src/Windowing/Silk.NET.Windowing.Common/Enums/WindowBorder.cs

@@ -11,7 +11,7 @@ namespace Silk.NET.Windowing.Common
     public enum WindowBorder
     {
         /// <summary>
-        /// The window can be resized by grabbing its border.
+        /// The window can be resized by clicking and dragging its border.
         /// </summary>
         Resizable = 0,
 

src/Windowing/Silk.NET.Windowing.Common/Interfaces/ISilkPlatform.cs

@@ -5,10 +5,22 @@
 
 namespace Silk.NET.Windowing.Common
 {
+    /// <summary>
+    /// An interface that provides windowing for its respective native backend.
+    /// </summary>
     public interface ISilkPlatform
     {
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="ISilkPlatform"/> should be used, based on the
+        /// current runtime/environment.
+        /// </summary>
         bool IsApplicable { get; }
 
+        /// <summary>
+        /// Creates a window with the given options.
+        /// </summary>
+        /// <param name="options">The initial settings this window should open with.</param>
+        /// <returns>An implementation of <see cref="IWindow"/></returns>
         IWindow GetWindow(WindowOptions options);
     }
-}
+}

src/Windowing/Silk.NET.Windowing.Common/Interfaces/IWindow.cs

@@ -18,8 +18,9 @@ public interface IWindow : IWindowProperties, IWindowFunctions, IWindowEvents
         IntPtr Handle { get; }
 
         /// <summary>
-        /// If true, the window has failed to reach the target framerate for five consecutive frames. You can use this
-        /// to do things such as lowering visual fidelity to increase framerates on lower-end machines.
+        /// If true, the window has failed to reach the target framerate for multiple consecutive frames, as defined
+        /// in <see cref="IWindowProperties.RunningSlowTolerance"/>. You can use this to do things such as lowering
+        /// visual fidelity to increase framerates on lower-end machines.
         /// </summary>
         bool IsRunningSlowly { get; }
     }

src/Windowing/Silk.NET.Windowing.Common/Interfaces/IWindowProperties.cs

@@ -13,19 +13,18 @@ namespace Silk.NET.Windowing.Common
     public interface IWindowProperties
     {
         /// <summary>
-        /// Gets or sets whether or not the window is visible.
+        /// Whether or not the window is visible.
         /// </summary>
         bool IsVisible { get; set; }
 
         /// <summary>
         /// If true, both updates and rendering will happen on the same thread. If false, both updating and rendering
-        /// will be run on their own threads. Default is true.
+        /// will be run on their own threads.
         /// </summary>
         bool UseSingleThreadedWindow { get; }
 
         /// <summary>
-        /// The position of the window. Integer vector. If set to -1, use the backend default.
-        /// Default is -1 for both components.
+        /// The position of the window. If set to -1, use the backend default.
         /// </summary>
         /// <remarks>
         /// <para>
@@ -35,7 +34,7 @@ public interface IWindowProperties
         Point Position { get; set; }
 
         /// <summary>
-        /// Gets or sets the size of the window in pixels.
+        /// The size of the window in pixels.
         /// </summary>
         /// <remarks>
         /// <para>
@@ -55,7 +54,7 @@ public interface IWindowProperties
         double UpdatesPerSecond { get; set; }
 
         /// <summary>
-        /// Gets the graphics API the window will use.
+        /// The graphics API to use, and associated configurations.
         /// </summary>
         GraphicsAPI API { get; }
 
@@ -65,18 +64,24 @@ public interface IWindowProperties
         string Title { get; set; }
 
         /// <summary>
-        /// Gets or sets the window state.
+        /// The window state.
         /// </summary>
         WindowState WindowState { get; set; }
 
         /// <summary>
-        /// Gets or sets the window border.
+        /// The window border.
         /// </summary>
         WindowBorder WindowBorder { get; set; }
 
         /// <summary>
-        /// Gets or sets the VSync mode.
+        /// The VSync mode.
         /// </summary>
         VSyncMode VSync { get; set; }
+
+        /// <summary>
+        /// The number of frames the window needs to be running slowly for before <see cref="IWindow.IsRunningSlowly"/>
+        /// is set to true.
+        /// </summary>
+        int RunningSlowTolerance { get; set; }
     }
 }

src/Windowing/Silk.NET.Windowing.Common/WindowOptions.cs

@@ -44,14 +44,17 @@ public struct WindowOptions : IWindowProperties
 
         /// <inheritdoc />
         public VSyncMode VSync { get; set; }
+
+        /// <inheritdoc />
+        public int RunningSlowTolerance { get; set; }
 
         /// <summary>
         /// Creates a new WindowOptions struct, with sensible defaults.
         /// </summary>
         public WindowOptions(bool isVisible, bool useSingleThreadedWindow, Point position, Size size,
             double framesPerSecond,
             double updatesPerSecond, GraphicsAPI api, string title, WindowState windowState, WindowBorder windowBorder,
-            VSyncMode vSync)
+            VSyncMode vSync, int isRunningSlowlyThreshold)
         {
             IsVisible = isVisible;
             UseSingleThreadedWindow = useSingleThreadedWindow;
@@ -64,13 +67,14 @@ public WindowOptions(bool isVisible, bool useSingleThreadedWindow, Point positio
             WindowState = windowState;
             WindowBorder = windowBorder;
             VSync = vSync;
+            RunningSlowTolerance = isRunningSlowlyThreshold;
         }
 
         /// <summary>
         /// Convinience wrapper around creating a new WindowProperties with the default values.
         /// </summary>
         public static WindowOptions Default { get; } = new WindowOptions(true, true, new Point(-1, -1),
             new Size(1280, 720), 0.0, 0.0, GraphicsAPI.Default,
-            "Silk.NET Window", WindowState.Normal, WindowBorder.Resizable, VSyncMode.On);
+            "Silk.NET Window", WindowState.Normal, WindowBorder.Resizable, VSyncMode.On, 5);
     }
 }

src/Windowing/Silk.NET.Windowing.Desktop/GlfwPlatform.cs

@@ -9,8 +9,12 @@
 
 namespace Silk.NET.Windowing.Desktop
 {
+    /// <summary>
+    /// A GLFW-based backend.
+    /// </summary>
     public class GlfwPlatform : ISilkPlatform
     {
+        /// <inheritdoc />
         public bool IsApplicable
         {
             get
@@ -26,6 +30,7 @@ public bool IsApplicable
             }
         }
 
+        /// <inheritdoc />
         public IWindow GetWindow(WindowOptions options)
         {
             return new GlfwWindow(options);

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

@@ -58,9 +58,6 @@ public class GlfwWindow : IWindow
         private double updatePeriod;
         private double renderPeriod;
 
-        private double updatesPerSecond;
-        private double framesPerSecond;
-
         /// <summary>
         /// Create and open a new GlfwWindow.
         /// </summary>
@@ -137,13 +134,17 @@ public GlfwWindow(WindowOptions options)
                 WindowState = options.WindowState;
                 Position = options.Position;
                 VSync = options.VSync;
+                RunningSlowTolerance = options.RunningSlowTolerance;
 
                 InitializeCallbacks();
             }
         }
+
+        /// <inheritdoc />
+        public int RunningSlowTolerance { get; set; }
 
         /// <inheritdoc />
-        public bool IsRunningSlowly => _isRunningSlowlyTries > 5;
+        public bool IsRunningSlowly => _isRunningSlowlyTries > RunningSlowTolerance;
 
         /// <inheritdoc />
         public bool IsVisible
@@ -219,12 +220,11 @@ public Size Size
         }
 
         /// <inheritdoc />
-        public double FramesPerSecond {
-            get => framesPerSecond;
+        public double FramesPerSecond
+        {
+            get => 1.0 / renderPeriod;
             set
             {
-                framesPerSecond = value;
-
                 if (value <= double.Epsilon) {
                     renderPeriod = 0.0;
                     return;
@@ -237,11 +237,9 @@ public double FramesPerSecond {
         /// <inheritdoc />
         public double UpdatesPerSecond
         {
-            get => updatesPerSecond;
+            get => 1.0 / updatePeriod;
             set
             {
-                updatesPerSecond = value;
-
                 if (value <= double.Epsilon) {
                     updatePeriod = 0.0;
                     return;

src/Windowing/Silk.NET.Windowing/Silk.cs

@@ -22,7 +22,9 @@ public static class Silk
         /// <summary>
         /// Reflects over the current AppDomain in an attempt to resolve an <see cref="ISilkPlatform" />.
         /// </summary>
-        /// <exception cref="NotSupportedException">Thrown f no applicable <see cref="ISilkPlatform" /> was found.</exception>
+        /// <exception cref="NotSupportedException">
+        /// Thrown if no applicable <see cref="ISilkPlatform" /> was found.
+        /// </exception>
         public static void Init()
         {
             var glfwPlatform = new GlfwPlatform();

src/Windowing/Silk.NET.Windowing/Window.cs

@@ -7,8 +7,16 @@
 
 namespace Silk.NET.Windowing
 {
+    /// <summary>
+    /// Convenience wrapper for easily creating a Silk.NET window.
+    /// </summary>
     public static class Window
     {
+        /// <summary>
+        /// Create a window on the current platform.
+        /// </summary>
+        /// <param name="options">The window to use.</param>
+        /// <returns>A Silk.NET window using the current platform.</returns>
         public static IWindow Create(WindowOptions options)
         {
             if (Silk.CurrentPlatform == null) {