From 179f457cfc53f934d53983415ef029dd7e8b9303 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Sun, 14 Jul 2019 20:13:36 +0100
Subject: [PATCH 01/46] Start of the GLFW Input implementation


From ec588a7f249b224aa411e756de7d0b2410a79d9f Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Mon, 15 Jul 2019 21:50:59 +0100
Subject: [PATCH 02/46] A start I guess, it's messy and all over the place

---
 Silk.NET.sln                                  |  30 +++++
 documentation/proposals/Proposal - Input.md   |  28 ++--
 .../InputWindowExtensions.cs                  |  28 ----
 .../Interfaces/IGamepad.cs                    |   6 +-
 .../Interfaces/IInputContext.cs               |  24 +++-
 .../Interfaces/IJoystick.cs                   | 124 +++++++++---------
 .../Interfaces/IKeyboard.cs                   |   2 +-
 .../Interfaces/IMouse.cs                      |   4 +-
 .../Collections/GlfwAxisCollection.cs         |  90 +++++++++++++
 .../Collections/GlfwGamepadCollection.cs      |  84 ++++++++++++
 .../Collections/GlfwJoystickCollection.cs     |  98 ++++++++++++++
 .../Collections/GlfwKeyboardCollection.cs     |  70 ++++++++++
 .../Collections/GlfwMouseCollection.cs        |  70 ++++++++++
 .../GlfwInputContext.cs                       |  61 +++++++++
 .../GlfwInputPlatform.cs                      |  21 +++
 .../Implementations/GlfwGamepad.cs            |  32 +++++
 .../Implementations/GlfwJoystick.cs           |  41 ++++++
 .../Implementations/GlfwKeyboard.cs           |  40 ++++++
 .../Implementations/GlfwMouse.cs              |  29 ++++
 .../Silk.NET.Input.Desktop/InputHandler.cs    |  31 +++++
 .../Silk.NET.Input.Desktop.csproj             |  21 +++
 src/Input/Silk.NET.Input.Desktop/Util.cs      |  82 ++++++++++++
 .../Silk.NET.Input/InputWindowExtensions.cs   |  38 ++++++
 .../Silk.NET.Input/Silk.NET.Input.csproj      |  12 ++
 src/Windowing/Silk.NET.GLFW/Glfw.cs           |   2 +-
 .../Silk.NET.GLFW/Interfaces/IGlfw.cs         |   2 +-
 26 files changed, 952 insertions(+), 118 deletions(-)
 delete mode 100644 src/Input/Silk.NET.Input.Common/InputWindowExtensions.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwKeyboardCollection.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwMouseCollection.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/GlfwInputPlatform.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/InputHandler.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Util.cs
 create mode 100644 src/Input/Silk.NET.Input/InputWindowExtensions.cs
 create mode 100644 src/Input/Silk.NET.Input/Silk.NET.Input.csproj

diff --git a/Silk.NET.sln b/Silk.NET.sln
index bb44d31f6d..9f5d188048 100644
--- a/Silk.NET.sln
+++ b/Silk.NET.sln
@@ -165,6 +165,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.OpenGLES.Extension
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{0651C5EF-50AA-4598-8D9C-8F210ADD8490}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Input.Desktop", "src\Input\Silk.NET.Input.Desktop\Silk.NET.Input.Desktop.csproj", "{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Input", "src\Input\Silk.NET.Input\Silk.NET.Input.csproj", "{020A8E88-B607-4281-BA0D-5ED03484A201}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1030,6 +1034,30 @@ Global
 		{8D534FE1-6113-457A-97DD-FD42782580A5}.Release|x64.Build.0 = Release|Any CPU
 		{8D534FE1-6113-457A-97DD-FD42782580A5}.Release|x86.ActiveCfg = Release|Any CPU
 		{8D534FE1-6113-457A-97DD-FD42782580A5}.Release|x86.Build.0 = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x64.Build.0 = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Debug|x86.Build.0 = Debug|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x64.ActiveCfg = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x64.Build.0 = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x86.ActiveCfg = Release|Any CPU
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4}.Release|x86.Build.0 = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x64.Build.0 = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Debug|x86.Build.0 = Debug|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|Any CPU.Build.0 = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x64.ActiveCfg = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x64.Build.0 = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x86.ActiveCfg = Release|Any CPU
+		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{BFE429EB-4C2E-4BF3-A302-C9C5A2FDA6D7} = {23324041-2076-477C-A4BF-B385B8066C6C}
@@ -1104,5 +1132,7 @@ Global
 		{8D534FE1-6113-457A-97DD-FD42782580A5} = {CF69D5C3-4ACE-4458-BA5A-0E9A3B294CDC}
 		{FD24E9FF-1097-4777-A418-F2D88C558665} = {0651C5EF-50AA-4598-8D9C-8F210ADD8490}
 		{136C6154-D300-4B82-80D3-17B637841A2B} = {0651C5EF-50AA-4598-8D9C-8F210ADD8490}
+		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4} = {FA9D1C95-5585-4DEC-B226-1447A486C376}
+		{020A8E88-B607-4281-BA0D-5ED03484A201} = {FA9D1C95-5585-4DEC-B226-1447A486C376}
 	EndGlobalSection
 EndGlobal
diff --git a/documentation/proposals/Proposal - Input.md b/documentation/proposals/Proposal - Input.md
index 5cdb00bbe5..93cc39a948 100644
--- a/documentation/proposals/Proposal - Input.md	
+++ b/documentation/proposals/Proposal - Input.md	
@@ -27,9 +27,9 @@ Proposal API for Input via keyboards, mice, and controllers.
 ```cs
 public interface IJoystick : IInputDevice
 {
-    IReadOnlyCollection<Axis> Axes { get; }
-    IReadOnlyCollection<Button> Buttons { get; }
-    IReadOnlyCollection<Hat> Hats { get; }
+    IReadOnlyList<Axis> Axes { get; }
+    IReadOnlyList<Button> Buttons { get; }
+    IReadOnlyList<Hat> Hats { get; }
     Deadzone Deadzone { get; set; }
     event Action<IJoystick, Button> ButtonDown;
     event Action<IJoystick, Button> ButtonUp;
@@ -42,9 +42,9 @@ public interface IJoystick : IInputDevice
 ```cs
 public interface IGamepad : IInputDevice
 {
-    IReadOnlyCollection<Button> Buttons { get; }
-    IReadOnlyCollection<Thumbstick> Thumbsticks { get; }
-    IReadOnlyCollection<Trigger> Triggers { get; }
+    IReadOnlyList<Button> Buttons { get; }
+    IReadOnlyList<Thumbstick> Thumbsticks { get; }
+    IReadOnlyList<Trigger> Triggers { get; }
     Deadzone Deadzone { get; set; }
     event Action<IGamepad, Button> ButtonDown;
     event Action<IGamepad, Button> ButtonUp;
@@ -57,7 +57,7 @@ public interface IGamepad : IInputDevice
 ```cs
 public interface IKeyboard : IInputDevice
 {
-    IReadOnlyCollection<Key> SupportedKeys { get; }
+    IReadOnlyList<Key> SupportedKeys { get; }
     bool IsKeyPressed(Key key);
     bool IsKeyPressed(uint scancode);
     event Action<IKeyboard, Key> KeyDown;
@@ -69,8 +69,8 @@ public interface IKeyboard : IInputDevice
 ```cs
 public interface IMouse : IInputDevice
 {
-    IReadOnlyCollection<MouseButton> SupportedButtons { get; }
-    IReadOnlyCollection<ScrollWheel> ScrollWheels { get; }
+    IReadOnlyList<MouseButton> SupportedButtons { get; }
+    IReadOnlyList<ScrollWheel> ScrollWheels { get; }
     bool IsButtonPressed(MouseButton btn);
     event Action<IMouse, MouseButton> MouseDown;
     event Action<IMouse, MouseButton> MouseUp;
@@ -94,11 +94,11 @@ public interface IInputDevice
 public interface IInputContext : IDisposable
 {
     IntPtr Handle { get; }
-    IReadOnlyCollection<IGamepad> Gamepads { get; }
-    IReadOnlyCollection<IJoystick> Joysticks { get; }
-    IReadOnlyCollection<IKeyboard> Keyboards { get; }
-    IReadOnlyCollection<IMouse> Mice { get; }
-    IReadOnlyCollection<IInputDevice> OtherDevices { get; }
+    IReadOnlyList<IGamepad> Gamepads { get; }
+    IReadOnlyList<IJoystick> Joysticks { get; }
+    IReadOnlyList<IKeyboard> Keyboards { get; }
+    IReadOnlyList<IMouse> Mice { get; }
+    IReadOnlyList<IInputDevice> OtherDevices { get; }
 }
 ```
 
diff --git a/src/Input/Silk.NET.Input.Common/InputWindowExtensions.cs b/src/Input/Silk.NET.Input.Common/InputWindowExtensions.cs
deleted file mode 100644
index c8514c5697..0000000000
--- a/src/Input/Silk.NET.Input.Common/InputWindowExtensions.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-using System;
-using Silk.NET.Windowing.Common;
-
-namespace Silk.NET.Input.Common
-{
-    public static class InputWindowExtensions
-    {
-        public static void RegisterInputPlatform(IInputPlatform platform)
-        {
-            throw new NotImplementedException();
-        }
-
-        public static void UnregisterInputPlatform(IInputPlatform platform)
-        {
-            throw new NotImplementedException();
-        }
-
-        public static IInputContext GetInput(this IWindow window)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs
index e546fc4171..b6538687de 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IGamepad.cs
@@ -16,17 +16,17 @@ public interface IGamepad : IInputDevice
         /// <summary>
         /// A list of all available buttons.
         /// </summary>
-        IReadOnlyCollection<Button> Buttons { get; }
+        IReadOnlyList<Button> Buttons { get; }
         
         /// <summary>
         /// A list of all available thumbsticks.
         /// </summary>
-        IReadOnlyCollection<Thumbstick> Thumbsticks { get; }
+        IReadOnlyList<Thumbstick> Thumbsticks { get; }
         
         /// <summary>
         /// A list of all available triggers.
         /// </summary>
-        IReadOnlyCollection<Trigger> Triggers { get; }
+        IReadOnlyList<Trigger> Triggers { get; }
         
         /// <summary>
         /// The deadzone for this gamepad.
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
index 21fbda8ff2..3a68187dba 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
@@ -11,7 +11,7 @@ namespace Silk.NET.Input.Common
     /// <summary>
     /// An interface representing the input context.
     /// </summary>
-    public interface IInputContext
+    public interface IInputContext : IDisposable
     {
         /// <summary>
         /// A handle to the underlying window.
@@ -21,26 +21,38 @@ public interface IInputContext
         /// <summary>
         /// A list of all available gamepads.
         /// </summary>
-        IReadOnlyCollection<IGamepad> Gamepads { get; }
+        IReadOnlyList<IGamepad> Gamepads { get; }
         
         /// <summary>
         /// A list of all available joysticks.
         /// </summary>
-        IReadOnlyCollection<IJoystick> Joysticks { get; }
+        IReadOnlyList<IJoystick> Joysticks { get; }
         
         /// <summary>
         /// A list of all available keyboards.
+        /// <remarks>
+        /// On some backends, this list may only contain 1 item. This is most likely because the underlying API doesn't
+        /// support multiple keyboards.
+        /// </remarks>
         /// </summary>
-        IReadOnlyCollection<IKeyboard> Keyboards { get; }
+        IReadOnlyList<IKeyboard> Keyboards { get; }
         
         /// <summary>
         /// A list of all available mice.
         /// </summary>
-        IReadOnlyCollection<IMouse> Mice { get; }
+        /// <remarks>
+        /// On some backends, this list may only contain 1 item. This is most likely because the underlying API doesn't
+        /// support multiple mice.
+        /// </remarks>
+        IReadOnlyList<IMouse> Mice { get; }
         
         /// <summary>
         /// A list of all other available input devices.
         /// </summary>
-        IReadOnlyCollection<IInputDevice> OtherDevices { get; }
+        /// <remarks>
+        /// On some backends, this list might be empty. This is most likely because the underlying API doesn't
+        /// support other devices.
+        /// </remarks>
+        IReadOnlyList<IInputDevice> OtherDevices { get; }
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs
index 456452a51c..e0f590ded6 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IJoystick.cs
@@ -1,62 +1,62 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-using System;
-using System.Collections.Generic;
-
-namespace Silk.NET.Input.Common
-{
-    /// <summary>
-    /// Represents a joystick device with a set amount of axes, buttons, and hats.
-    /// </summary>
-    public interface IJoystick : IInputDevice
-    {
-        /// <summary>
-        /// A list of all axes reported by this joystick.
-        /// </summary>
-        IReadOnlyCollection<Axis> Axes { get; }
-        
-        /// <summary>
-        /// A list of all buttons reported by this joystick.
-        /// </summary>
-        IReadOnlyCollection<Button> Buttons { get; }
-        
-        /// <summary>
-        /// A list of all hats reported by this joystick.
-        /// </summary>
-        IReadOnlyCollection<Hat> Hats { get; }
-        
-        /// <summary>
-        /// The deadzone to use for this joystick's axes.
-        /// </summary>
-        Deadzone Deadzone { get; set; }
-        
-        /// <summary>
-        /// Called when a button on this joystick is pressed.
-        /// </summary>
-        /// <remarks>
-        /// This event is only called when the button is first pressed, and not every frame where the button is still pressed.
-        /// </remarks>
-        event Action<IJoystick, Button> ButtonDown;
-        
-        /// <summary>
-        /// Called when a button on this joystick is released.
-        /// </summary>
-        /// <remarks>
-        /// This event is only called when the button is first released, and not every frame where the button is still released.
-        /// </remarks>
-        event Action<IJoystick, Button> ButtonUp;
-        
-        /// <summary>
-        /// Called when an axis on this joystick is moved.
-        /// </summary>
-        event Action<IJoystick, Axis> AxisMoved;
-        
-        /// <summary>
-        /// Called when a hat on this joystick is moved.
-        /// </summary>
-        event Action<IJoystick, Hat> HatMoved;
-    }
-}
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+
+namespace Silk.NET.Input.Common
+{
+    /// <summary>
+    /// Represents a joystick device with a set amount of axes, buttons, and hats.
+    /// </summary>
+    public interface IJoystick : IInputDevice
+    {
+        /// <summary>
+        /// A list of all axes reported by this joystick.
+        /// </summary>
+        IReadOnlyList<Axis> Axes { get; }
+        
+        /// <summary>
+        /// A list of all buttons reported by this joystick.
+        /// </summary>
+        IReadOnlyList<Button> Buttons { get; }
+        
+        /// <summary>
+        /// A list of all hats reported by this joystick.
+        /// </summary>
+        IReadOnlyList<Hat> Hats { get; }
+        
+        /// <summary>
+        /// The deadzone to use for this joystick's axes.
+        /// </summary>
+        Deadzone Deadzone { get; set; }
+        
+        /// <summary>
+        /// Called when a button on this joystick is pressed.
+        /// </summary>
+        /// <remarks>
+        /// This event is only called when the button is first pressed, and not every frame where the button is still pressed.
+        /// </remarks>
+        event Action<IJoystick, Button> ButtonDown;
+        
+        /// <summary>
+        /// Called when a button on this joystick is released.
+        /// </summary>
+        /// <remarks>
+        /// This event is only called when the button is first released, and not every frame where the button is still released.
+        /// </remarks>
+        event Action<IJoystick, Button> ButtonUp;
+        
+        /// <summary>
+        /// Called when an axis on this joystick is moved.
+        /// </summary>
+        event Action<IJoystick, Axis> AxisMoved;
+        
+        /// <summary>
+        /// Called when a hat on this joystick is moved.
+        /// </summary>
+        event Action<IJoystick, Hat> HatMoved;
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs
index 3b139b722c..e396af73d0 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IKeyboard.cs
@@ -16,7 +16,7 @@ public interface IKeyboard : IInputDevice
         /// <summary>
         /// The keys this keyboard has available.
         /// </summary>
-        IReadOnlyCollection<Key> SupportedKeys { get; }
+        IReadOnlyList<Key> SupportedKeys { get; }
         
         /// <summary>
         /// Checks if a specific key is pressed.
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs
index d512765cea..3b6f2486ee 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IMouse.cs
@@ -16,12 +16,12 @@ public interface IMouse : IInputDevice
         /// <summary>
         /// The buttons this mouse has available.
         /// </summary>
-        IReadOnlyCollection<MouseButton> SupportedButtons { get; }
+        IReadOnlyList<MouseButton> SupportedButtons { get; }
         
         /// <summary>
         /// The scroll wheels this mouse has available.
         /// </summary>
-        IReadOnlyCollection<ScrollWheel> ScrollWheels { get; }
+        IReadOnlyList<ScrollWheel> ScrollWheels { get; }
         
         /// <summary>
         /// Checks if a specific button is currently pressed.
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
new file mode 100644
index 0000000000..8776abfd44
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
@@ -0,0 +1,90 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwAxisCollection : IReadOnlyList<Axis>
+    {
+        private float* _floats;
+        private int _count;
+        private readonly GlfwJoystick _joystick;
+
+        public GlfwAxisCollection(float* floats, int count, GlfwJoystick joystick)
+        {
+            _floats = floats;
+            _count = count;
+            _joystick = joystick;
+        }
+        public IEnumerator<Axis> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public int Count => _count;
+
+        public Axis this[int index] => index < _count
+            ? new Axis(index, Get(_floats, index))
+            : throw new ArgumentOutOfRangeException();
+
+        public static float Get(float* floats, int index)
+        {
+            return (float) Marshal.PtrToStructure
+            (
+                Marshal.ReadIntPtr((IntPtr) floats, index * IntPtr.Size),
+                typeof(float)
+            );
+        }
+        
+        private struct Enumerator : IEnumerator<Axis>
+        {
+            private GlfwAxisCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwAxisCollection col)
+            {
+                _col = col;
+                _current = 0;
+            }
+            
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Axis(_current, Get(_col._floats, _current));
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Axis Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
new file mode 100644
index 0000000000..07e63f2f54
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
@@ -0,0 +1,84 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwGamepadCollection : IReadOnlyList<IGamepad>
+    {
+        private GlfwInputContext _ctx;
+
+        public GlfwGamepadCollection(GlfwInputContext ctx)
+        {
+            _ctx = ctx;
+        }
+        
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        IEnumerator<IGamepad> IEnumerable<IGamepad>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        public IEnumerator<IGamepad> GetEnumerator()
+        {
+            return new Enumerator();
+        }
+
+        public int Count { get; }
+        
+        public struct Enumerator : IEnumerator<IGamepad>, IEnumerator
+        {
+            private int _current;
+            private GlfwInputContext _c;
+
+            public Enumerator(GlfwInputContext c)
+            {
+                _c = c;
+                _current = 0;
+                Current = null;
+            }
+            
+            public bool MoveNext()
+            {
+                if (_current == 16)
+                {
+                    return false;
+                }
+
+                for (; _current < 16; _current++)
+                {
+                    if (_c._gamepads[_current].IsConnected)
+                    {
+                        Current = _c._gamepads[_current];
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            public void Reset()
+            {
+                Current = null;
+                _current = 0;
+            }
+
+            public IGamepad Current { get; private set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+
+        public IGamepad this[int i] => _ctx._gamepads[i];
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
new file mode 100644
index 0000000000..1266ae2d94
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
@@ -0,0 +1,98 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwJoystickCollection : IReadOnlyList<IJoystick>
+    {
+        private readonly GlfwInputContext _glfwInputContext;
+
+        public GlfwJoystickCollection(GlfwInputContext glfwInputContext)
+        {
+            _glfwInputContext = glfwInputContext;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        IEnumerator<IJoystick> IEnumerable<IJoystick>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        public IEnumerator<IJoystick> GetEnumerator()
+        {
+            return new Enumerator();
+        }
+
+        public int Count
+        {
+            get
+            {
+                var c = 0;
+                foreach (var j in this)
+                {
+                    if (j.IsConnected)
+                    {
+                        c++;
+                    }
+                }
+
+                return c;
+            }
+        }
+        
+        public struct Enumerator : IEnumerator<IJoystick>
+        {
+            private int _current;
+            private GlfwInputContext _ctx;
+
+            public Enumerator(GlfwInputContext ctx)
+            {
+                _ctx = ctx;
+                _current = 0;
+                Current = null;
+            }
+            public bool MoveNext()
+            {
+                if (_current == 16)
+                {
+                    return false;
+                }
+
+                for (; _current < 16; _current++)
+                {
+                    if (_ctx._joysticks[_current].IsConnected)
+                    {
+                        Current = _ctx._joysticks[_current];
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            public void Reset()
+            {
+                Current = null;
+                _current = 0;
+            }
+
+            public IJoystick Current { get; private set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+
+        public IJoystick this[int index] => _glfwInputContext._joysticks[index];
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwKeyboardCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwKeyboardCollection.cs
new file mode 100644
index 0000000000..5856362434
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwKeyboardCollection.cs
@@ -0,0 +1,70 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwKeyboardCollection : IReadOnlyList<IKeyboard>
+    {
+        private readonly GlfwInputContext _ctx;
+
+        public GlfwKeyboardCollection(GlfwInputContext ctx)
+        {
+            _ctx = ctx;
+        }
+        public IEnumerator<IKeyboard> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public int Count { get; } = 1;
+
+        public IKeyboard this[int index] => index == 0 ? _ctx._keyboard : throw new ArgumentOutOfRangeException();
+        
+        public struct Enumerator : IEnumerator<IKeyboard>
+        {
+            private readonly GlfwKeyboardCollection _col;
+            private bool _done;
+
+            public Enumerator(GlfwKeyboardCollection col)
+            {
+                _col = col;
+                _done = false;
+                Current = null;
+            }
+            
+            public bool MoveNext()
+            {
+                Current = _done ? null : _col._ctx._keyboard;
+                var ret = !_done;
+                _done = true;
+                return ret;
+            }
+
+            public void Reset()
+            {
+                _done = false;
+                Current = null;
+            }
+
+            public IKeyboard Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwMouseCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwMouseCollection.cs
new file mode 100644
index 0000000000..caacd166bd
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwMouseCollection.cs
@@ -0,0 +1,70 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwMouseCollection : IReadOnlyList<IMouse>
+    {
+        private readonly GlfwInputContext _ctx;
+
+        public GlfwMouseCollection(GlfwInputContext ctx)
+        {
+            _ctx = ctx;
+        }
+        public IEnumerator<IMouse> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public int Count { get; } = 1;
+
+        public IMouse this[int index] => index == 0 ? _ctx._mouse : throw new ArgumentOutOfRangeException();
+        
+        public struct Enumerator : IEnumerator<IMouse>
+        {
+            private readonly GlfwMouseCollection _col;
+            private bool _done;
+
+            public Enumerator(GlfwMouseCollection col)
+            {
+                _col = col;
+                _done = false;
+                Current = null;
+            }
+            
+            public bool MoveNext()
+            {
+                Current = _done ? null : _col._ctx._mouse;
+                var ret = !_done;
+                _done = true;
+                return ret;
+            }
+
+            public void Reset()
+            {
+                _done = false;
+                Current = null;
+            }
+
+            public IMouse Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
new file mode 100644
index 0000000000..bf8314507f
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -0,0 +1,61 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Silk.NET.Windowing.Common;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwInputContext : IInputContext
+    {
+        internal List<GlfwGamepad> _gamepads;
+        internal List<GlfwJoystick> _joysticks;
+        internal IKeyboard _keyboard;
+        internal IMouse _mouse;
+        internal IWindow _window;
+
+        public GlfwInputContext(IWindow window)
+        {
+            Handle = window.Handle;
+            _window = window;
+            InputHandler.RegisterContext(this);
+            
+            // initialize auto-properties
+            Gamepads = new GlfwGamepadCollection(this);
+            Joysticks = new GlfwJoystickCollection(this);
+            
+            // initialize joysticks
+            _joysticks = new List<GlfwJoystick>(Enumerable.Range(0, 16).Select(i => new GlfwJoystick(i)));
+            _gamepads = new List<GlfwGamepad>(Enumerable.Range(0, 16).Select(i => new GlfwGamepad(i)));
+        }
+
+        public IntPtr Handle { get; }
+        public IReadOnlyList<IGamepad> Gamepads { get; }
+        public IReadOnlyList<IJoystick> Joysticks { get; }
+        public IReadOnlyList<IKeyboard> Keyboards { get; } // TODO
+        public IReadOnlyList<IMouse> Mice { get; } // TODO
+        public IReadOnlyList<IInputDevice> OtherDevices { get; } = Array.Empty<IInputDevice>(); // not supported in GLFW
+
+        public void Dispose()
+        {
+            InputHandler.UnregisterContext(this);
+        }
+
+        ~GlfwInputContext()
+        {
+            Dispose();
+        }
+
+        public void WindowUpdate(double obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputPlatform.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputPlatform.cs
new file mode 100644
index 0000000000..ebcb6d1e61
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputPlatform.cs
@@ -0,0 +1,21 @@
+using System;
+using Silk.NET.Input.Common;
+using Silk.NET.Windowing.Common;
+using Silk.NET.Windowing.Desktop;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwInputPlatform : IInputPlatform
+    {
+        public bool IsApplicable(IWindow window)
+        {
+            return window is GlfwWindow;
+        }
+
+        public IInputContext GetInput(IWindow window)
+        {
+            // the cast isn't needed, but is used to make sure that what we've got is actually a GlfwWindow
+            return new GlfwInputContext((GlfwWindow)window);
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
new file mode 100644
index 0000000000..b387e154f0
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -0,0 +1,32 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwGamepad : IGamepad
+    {
+        public GlfwGamepad(int i)
+        {
+            Index = i;
+        }
+
+        public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
+        public int Index { get; }
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index));
+        public event Action<IInputDevice, bool> ConnectionChanged;
+        public IReadOnlyList<Button> Buttons { get; }
+        public IReadOnlyList<Thumbstick> Thumbsticks { get; }
+        public IReadOnlyList<Trigger> Triggers { get; }
+        public Deadzone Deadzone { get; set; }
+        public event Action<IGamepad, Button> ButtonDown;
+        public event Action<IGamepad, Button> ButtonUp;
+        public event Action<IGamepad, Thumbstick> ThumbstickMoved;
+        public event Action<IGamepad, Trigger> TriggerMoved;
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
new file mode 100644
index 0000000000..e2ee6206c9
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -0,0 +1,41 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Ultz.Dispatcher.Unsafe;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwJoystick : IJoystick
+    {
+        public GlfwJoystick(int i)
+        {
+            Index = i;
+        }
+
+        public string Name => Util.Do(() => Util.Glfw.GetJoystickName(Index));
+        public int Index { get; }
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index));
+        public event Action<IInputDevice, bool> ConnectionChanged;
+        public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
+        public IReadOnlyList<Button> Buttons { get; }
+        public IReadOnlyList<Hat> Hats { get; }
+        public Deadzone Deadzone { get; set; }
+        public event Action<IJoystick, Button> ButtonDown;
+        public event Action<IJoystick, Button> ButtonUp;
+        public event Action<IJoystick, Axis> AxisMoved;
+        public event Action<IJoystick, Hat> HatMoved;
+
+        private static unsafe IReadOnlyList<Axis> GetAxes(int i, GlfwJoystick joystick)
+        {
+            var count = 0;
+            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            return new GlfwAxisCollection(floats, count, joystick);
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
new file mode 100644
index 0000000000..5ba8cb0e2f
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
@@ -0,0 +1,40 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwKeyboard : IKeyboard
+    {
+        private GlfwInputContext _gic;
+
+        public GlfwKeyboard(GlfwInputContext gic)
+        {
+            _gic = gic;
+        }
+        public string Name { get; } = $"Silk.NET Keyboard (GLFW)";
+        public int Index { get; } = 0;
+        public bool IsConnected { get; } = true;
+        public event Action<IInputDevice, bool> ConnectionChanged;
+        public IReadOnlyList<Key> SupportedKeys { get; } = Util.SupportedKeys;
+        public unsafe bool IsKeyPressed(Key key)
+        {
+            return Util.Do(() => Util.Glfw.GetKey((WindowHandle*)_gic._window.Handle, Util.SilkKeyToGlfwKey(key))) == 1;
+        }
+
+        public unsafe bool IsKeyPressed(uint scancode)
+        {
+            return Util.Do(() => Util.Glfw.GetKey((WindowHandle*)_gic._window.Handle, (Keys)scancode)) == 1;
+        }
+
+        public event Action<IKeyboard, Key> KeyDown;
+        public event Action<IKeyboard, Key> KeyUp;
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
new file mode 100644
index 0000000000..465def03b5
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
@@ -0,0 +1,29 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwMouse : IMouse
+    {
+        public string Name { get; } = "Silk.NET Mouse (GLFW)";
+        public int Index { get; } = 0;
+        public bool IsConnected { get; } = true;
+        public event Action<IInputDevice, bool> ConnectionChanged;
+        public IReadOnlyList<MouseButton> SupportedButtons { get; }
+        public IReadOnlyList<ScrollWheel> ScrollWheels { get; }
+        public bool IsButtonPressed(MouseButton btn)
+        {
+            throw new NotImplementedException();
+        }
+
+        public event Action<IMouse, MouseButton> MouseDown;
+        public event Action<IMouse, MouseButton> MouseUp;
+        public event Action<IMouse, ScrollWheel> Scroll;
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
new file mode 100644
index 0000000000..850ab57d65
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
@@ -0,0 +1,31 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System.Collections.Generic;
+
+namespace Silk.NET.Input.Desktop
+{
+    internal class InputHandler
+    {
+        public static List<GlfwInputContext> Contexts { get; }
+        
+        static InputHandler()
+        {
+            Contexts = new List<GlfwInputContext>();
+        }
+
+        public static void RegisterContext(GlfwInputContext ctx)
+        {
+            Contexts.Add(ctx);
+            ctx._window.OnUpdate += ctx.WindowUpdate;
+        }
+
+        public static void UnregisterContext(GlfwInputContext ctx)
+        {
+            Contexts.Remove(ctx);
+            ctx._window.OnUpdate -= ctx.WindowUpdate;
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj b/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
new file mode 100644
index 0000000000..8cf80aab22
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\Windowing\Silk.NET.Windowing.Desktop\Silk.NET.Windowing.Desktop.csproj" />
+      <ProjectReference Include="..\Silk.NET.Input.Common\Silk.NET.Input.Common.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Reference Include="System.Memory, Version=4.0.1.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51">
+        <HintPath>..\..\..\..\..\..\.nuget\packages\system.memory\4.5.2\lib\netstandard2.0\System.Memory.dll</HintPath>
+      </Reference>
+    </ItemGroup>
+    
+    <Import Project="..\..\..\build\props\common.props" />
+
+</Project>
diff --git a/src/Input/Silk.NET.Input.Desktop/Util.cs b/src/Input/Silk.NET.Input.Desktop/Util.cs
new file mode 100644
index 0000000000..68c5a08dd5
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Util.cs
@@ -0,0 +1,82 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Linq;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using Ultz.Dispatcher.Unsafe;
+
+namespace Silk.NET.Input.Desktop
+{
+    internal static class Util
+    {
+        private static string[] _glfwKeys = Enum.GetNames(typeof(Keys));
+        public static object Do(Delegate @delegate)
+        {
+            return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+        
+        public static void Do(Action @delegate)
+        {
+            GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+
+        public static T Do<T>(Func<T> @delegate)
+        {
+            return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+
+        public static unsafe T* Do<T>(Func<UnsafeDispatch<T>> @delegate)
+            where T:unmanaged
+        {
+            return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
+        }
+
+        public static float ApplyDeadzone(Deadzone deadzone, float val)
+        {
+            switch (deadzone.Method)
+            {
+                case DeadzoneMethod.Traditional:
+                    return Math.Abs(val) < deadzone.Value ? 0 : val;
+                case DeadzoneMethod.AdaptiveGradient:
+                    return (1 - deadzone.Value) * val + deadzone.Value * Math.Sign(val);
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public static Glfw Glfw => GlfwProvider.GLFW.Value;
+        public static Key[] SupportedKeys { get; } // this is expensive, but only runs once.
+            = Enum.GetNames(typeof(Key)).Where(_glfwKeys.Contains).Select(StringToSilkKey).ToArray();
+
+        public static Key StringToSilkKey(string s)
+        {
+            if (Enum.TryParse<Key>(s, out var k))
+            {
+                return k;
+            }
+            throw new ArgumentOutOfRangeException(nameof(s), $"Key name mismatch (couldn't find a Key value for {s}");
+        }
+
+        public static Keys SilkKeyToGlfwKey(Key k)
+        {
+            if (Enum.TryParse<Keys>(k.ToString(), out var gk))
+            {
+                return gk;
+            }
+            throw new ArgumentOutOfRangeException(nameof(k));
+        }
+
+        public static Key GlfwKeyToSilkKey(Keys k)
+        {
+            if (Enum.TryParse<Key>(k.ToString(), out var sk))
+            {
+                return sk;
+            }
+            throw new ArgumentOutOfRangeException(nameof(k));
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input/InputWindowExtensions.cs b/src/Input/Silk.NET.Input/InputWindowExtensions.cs
new file mode 100644
index 0000000000..6adf5f8569
--- /dev/null
+++ b/src/Input/Silk.NET.Input/InputWindowExtensions.cs
@@ -0,0 +1,38 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop;
+using Silk.NET.Windowing.Common;
+
+namespace Silk.NET.Input
+{
+    public static class InputWindowExtensions
+    {
+        private static List<IInputPlatform> _platforms = new List<IInputPlatform>();
+        static InputWindowExtensions()
+        {
+            RegisterInputPlatform(new GlfwInputPlatform());
+        }
+        public static void RegisterInputPlatform(IInputPlatform platform)
+        {
+            _platforms.Add(platform);
+        }
+
+        public static void UnregisterInputPlatform(IInputPlatform platform)
+        {
+            _platforms.Remove(platform);
+        }
+
+        public static IInputContext GetInput(this IWindow window)
+        {
+            return _platforms.FirstOrDefault(x => x.IsApplicable(window))?.GetInput(window) 
+                ?? throw new NotSupportedException("Couldn't find a suitable input platform for this window.");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input/Silk.NET.Input.csproj b/src/Input/Silk.NET.Input/Silk.NET.Input.csproj
new file mode 100644
index 0000000000..d4d8837c01
--- /dev/null
+++ b/src/Input/Silk.NET.Input/Silk.NET.Input.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Silk.NET.Input.Common\Silk.NET.Input.Common.csproj" />
+      <ProjectReference Include="..\Silk.NET.Input.Desktop\Silk.NET.Input.Desktop.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/src/Windowing/Silk.NET.GLFW/Glfw.cs b/src/Windowing/Silk.NET.GLFW/Glfw.cs
index 9d4495d032..d75b7f56c7 100644
--- a/src/Windowing/Silk.NET.GLFW/Glfw.cs
+++ b/src/Windowing/Silk.NET.GLFW/Glfw.cs
@@ -125,7 +125,7 @@ public abstract unsafe void GetWindowFrameSize(WindowHandle* window, out int lef
         public abstract int GetKeyScancode(int key);
 
         /// <inheritdoc />
-        public abstract unsafe int GetKey(WindowHandle* window, int key);
+        public abstract unsafe int GetKey(WindowHandle* window, Keys key);
 
         /// <inheritdoc />
         public abstract unsafe int GetMouseButton(WindowHandle* window, int button);
diff --git a/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs b/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
index 6da83af415..2ebf9b31d5 100644
--- a/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
+++ b/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
@@ -981,7 +981,7 @@ public interface IGlfw
         /// Possible errors include <see cref="ErrorCode.NotInitialized" /> and <see cref="ErrorCode.InvalidEnum" />.
         /// </para>
         /// </remarks>
-        unsafe int GetKey(WindowHandle* window, int key);
+        unsafe int GetKey(WindowHandle* window, Keys key);
 
         /// <summary>
         /// <para>

From e633f3652644eba65fb118565182d87ecbdcbaa8 Mon Sep 17 00:00:00 2001
From: Void <33298798+devvoid@users.noreply.github.com>
Date: Fri, 19 Jul 2019 09:50:31 -0500
Subject: [PATCH 03/46] Additional work on GLFW input (#26)

* Move ApplyDeadzone to Deadzone struct

* Add test program, move ConnectionChanged to IInputContext

* Add functionality to test program
---
 Silk.NET.sln                                  | 15 +++++++++++
 examples/InputTest/InputTest.csproj           | 12 +++++++++
 examples/InputTest/Program.cs                 | 26 +++++++++++++++++++
 src/Input/Silk.NET.Input.Common/Deadzone.cs   | 22 ++++++++++++++++
 .../Interfaces/IInputContext.cs               |  5 ++++
 .../Interfaces/IInputDevice.cs                |  7 -----
 .../GlfwInputContext.cs                       |  3 +++
 .../Implementations/GlfwGamepad.cs            |  1 -
 .../Implementations/GlfwJoystick.cs           |  1 -
 .../Implementations/GlfwKeyboard.cs           |  1 -
 .../Implementations/GlfwMouse.cs              |  1 -
 src/Input/Silk.NET.Input.Desktop/Util.cs      | 13 ----------
 12 files changed, 83 insertions(+), 24 deletions(-)
 create mode 100644 examples/InputTest/InputTest.csproj
 create mode 100644 examples/InputTest/Program.cs

diff --git a/Silk.NET.sln b/Silk.NET.sln
index 9f5d188048..1f26bbb3a4 100644
--- a/Silk.NET.sln
+++ b/Silk.NET.sln
@@ -169,6 +169,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Input.Desktop", "s
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Input", "src\Input\Silk.NET.Input\Silk.NET.Input.csproj", "{020A8E88-B607-4281-BA0D-5ED03484A201}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "InputTest", "examples\InputTest\InputTest.csproj", "{3E744E54-F450-4051-8919-04D9B591688E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1058,6 +1060,18 @@ Global
 		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x64.Build.0 = Release|Any CPU
 		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x86.ActiveCfg = Release|Any CPU
 		{020A8E88-B607-4281-BA0D-5ED03484A201}.Release|x86.Build.0 = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x64.Build.0 = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Debug|x86.Build.0 = Debug|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x64.ActiveCfg = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x64.Build.0 = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x86.ActiveCfg = Release|Any CPU
+		{3E744E54-F450-4051-8919-04D9B591688E}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{BFE429EB-4C2E-4BF3-A302-C9C5A2FDA6D7} = {23324041-2076-477C-A4BF-B385B8066C6C}
@@ -1134,5 +1148,6 @@ Global
 		{136C6154-D300-4B82-80D3-17B637841A2B} = {0651C5EF-50AA-4598-8D9C-8F210ADD8490}
 		{3908DEF6-7403-49F5-B8EC-5B3B12C325D4} = {FA9D1C95-5585-4DEC-B226-1447A486C376}
 		{020A8E88-B607-4281-BA0D-5ED03484A201} = {FA9D1C95-5585-4DEC-B226-1447A486C376}
+		{3E744E54-F450-4051-8919-04D9B591688E} = {E1F91563-7277-4E9B-A3B7-8D5FD9802A4A}
 	EndGlobalSection
 EndGlobal
diff --git a/examples/InputTest/InputTest.csproj b/examples/InputTest/InputTest.csproj
new file mode 100644
index 0000000000..ef123cd998
--- /dev/null
+++ b/examples/InputTest/InputTest.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>netcoreapp2.1</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\src\Input\Silk.NET.Input.Desktop\Silk.NET.Input.Desktop.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
new file mode 100644
index 0000000000..6415f986da
--- /dev/null
+++ b/examples/InputTest/Program.cs
@@ -0,0 +1,26 @@
+using System;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop;
+using Silk.NET.Windowing.Common;
+using Silk.NET.Windowing.Desktop;
+
+namespace InputTest
+{
+    internal class Program
+    {
+        private static void Main()
+        {
+            var window = new GlfwWindow(WindowOptions.Default);
+
+            var inputContext = new GlfwInputContext(window);
+            inputContext.ConnectionChanged += ControllerConnected;
+        }
+
+        public static void ControllerConnected(IInputDevice device, bool isConnected)
+        {
+            Console.WriteLine(isConnected
+                ? $"Controller {device.Name} connected"
+                : $"Controller {device.Name} disconnected");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Deadzone.cs b/src/Input/Silk.NET.Input.Common/Deadzone.cs
index e7b0fc39cf..ac32532cd4 100644
--- a/src/Input/Silk.NET.Input.Common/Deadzone.cs
+++ b/src/Input/Silk.NET.Input.Common/Deadzone.cs
@@ -3,6 +3,8 @@
 // You may modify and distribute Silk.NET under the terms
 // of the MIT license. See the LICENSE file for details.
 
+using System;
+
 namespace Silk.NET.Input.Common
 {
     /// <summary>
@@ -30,5 +32,25 @@ public Deadzone(float value, DeadzoneMethod method)
             Value = value;
             Method = method;
         }
+
+        /// <summary>
+        /// Applies this deadzone to a raw input value.
+        /// </summary>
+        /// <param name="raw">The raw input value to apply the deadzone to.</param>
+        /// <returns>The input with deadzone applied.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">If the deadzone method isn't part of
+        /// <see cref="DeadzoneMethod"/></exception>
+        public float Apply(float raw)
+        {
+            switch (Method)
+            {
+                case DeadzoneMethod.Traditional:
+                    return Math.Abs(raw) < Value ? 0 : raw;
+                case DeadzoneMethod.AdaptiveGradient:
+                    return (1 - Value) * raw + Value * Math.Sign(raw);
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
index 3a68187dba..72d41f491e 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IInputContext.cs
@@ -54,5 +54,10 @@ public interface IInputContext : IDisposable
         /// support other devices.
         /// </remarks>
         IReadOnlyList<IInputDevice> OtherDevices { get; }
+        
+        /// <summary>
+        /// Called when the connection status of a device changes.
+        /// </summary>
+        event Action<IInputDevice, bool> ConnectionChanged;
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs b/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs
index d466bc2128..b5d5b929f3 100644
--- a/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs
+++ b/src/Input/Silk.NET.Input.Common/Interfaces/IInputDevice.cs
@@ -3,8 +3,6 @@
 // You may modify and distribute Silk.NET under the terms
 // of the MIT license. See the LICENSE file for details.
 
-using System;
-
 namespace Silk.NET.Input.Common
 {
     /// <summary>
@@ -26,10 +24,5 @@ public interface IInputDevice
         /// Whether or not this device is currently connected.
         /// </summary>
         bool IsConnected { get; }
-        
-        /// <summary>
-        /// Called when the connection of this device changes.
-        /// </summary>
-        event Action<IInputDevice, bool> ConnectionChanged;
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index bf8314507f..eeeae42127 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -57,5 +57,8 @@ public void WindowUpdate(double obj)
         {
             throw new NotImplementedException();
         }
+        
+        /// <inheritdoc />
+        public event Action<IInputDevice, bool> ConnectionChanged;
     }
 }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index b387e154f0..b785ced56c 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -19,7 +19,6 @@ public GlfwGamepad(int i)
         public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index));
-        public event Action<IInputDevice, bool> ConnectionChanged;
         public IReadOnlyList<Button> Buttons { get; }
         public IReadOnlyList<Thumbstick> Thumbsticks { get; }
         public IReadOnlyList<Trigger> Triggers { get; }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index e2ee6206c9..15aed12ab0 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -21,7 +21,6 @@ public GlfwJoystick(int i)
         public string Name => Util.Do(() => Util.Glfw.GetJoystickName(Index));
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index));
-        public event Action<IInputDevice, bool> ConnectionChanged;
         public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
         public IReadOnlyList<Button> Buttons { get; }
         public IReadOnlyList<Hat> Hats { get; }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
index 5ba8cb0e2f..0f014f69cb 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
@@ -22,7 +22,6 @@ public GlfwKeyboard(GlfwInputContext gic)
         public string Name { get; } = $"Silk.NET Keyboard (GLFW)";
         public int Index { get; } = 0;
         public bool IsConnected { get; } = true;
-        public event Action<IInputDevice, bool> ConnectionChanged;
         public IReadOnlyList<Key> SupportedKeys { get; } = Util.SupportedKeys;
         public unsafe bool IsKeyPressed(Key key)
         {
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
index 465def03b5..e7862a6ac3 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
@@ -14,7 +14,6 @@ public class GlfwMouse : IMouse
         public string Name { get; } = "Silk.NET Mouse (GLFW)";
         public int Index { get; } = 0;
         public bool IsConnected { get; } = true;
-        public event Action<IInputDevice, bool> ConnectionChanged;
         public IReadOnlyList<MouseButton> SupportedButtons { get; }
         public IReadOnlyList<ScrollWheel> ScrollWheels { get; }
         public bool IsButtonPressed(MouseButton btn)
diff --git a/src/Input/Silk.NET.Input.Desktop/Util.cs b/src/Input/Silk.NET.Input.Desktop/Util.cs
index 68c5a08dd5..605ccd937b 100644
--- a/src/Input/Silk.NET.Input.Desktop/Util.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Util.cs
@@ -35,19 +35,6 @@ public static T Do<T>(Func<T> @delegate)
             return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
         }
 
-        public static float ApplyDeadzone(Deadzone deadzone, float val)
-        {
-            switch (deadzone.Method)
-            {
-                case DeadzoneMethod.Traditional:
-                    return Math.Abs(val) < deadzone.Value ? 0 : val;
-                case DeadzoneMethod.AdaptiveGradient:
-                    return (1 - deadzone.Value) * val + deadzone.Value * Math.Sign(val);
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-
         public static Glfw Glfw => GlfwProvider.GLFW.Value;
         public static Key[] SupportedKeys { get; } // this is expensive, but only runs once.
             = Enum.GetNames(typeof(Key)).Where(_glfwKeys.Contains).Select(StringToSilkKey).ToArray();

From f80cba25d2f9f38df943eddff09ba0ec9fc68dfc Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Tue, 23 Jul 2019 21:30:00 +0100
Subject: [PATCH 04/46] More input work

---
 .../GlfwInputContext.cs                       | 25 +++++--
 .../Implementations/GlfwKeyboard.cs           | 10 +++
 .../Implementations/GlfwMouse.cs              | 19 +++++
 .../Silk.NET.Input.Desktop/InputHandler.cs    | 70 ++++++++++++++++++-
 src/Input/Silk.NET.Input.Desktop/Util.cs      | 10 +++
 .../Silk.NET.OpenGL.Legacy.csproj             |  2 +-
 .../Silk.NET.OpenGL/Silk.NET.OpenGL.csproj    |  2 +-
 .../Silk.NET.GLFW/Enums/MouseButton.cs        | 24 +++----
 8 files changed, 143 insertions(+), 19 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index eeeae42127..f3c4afacf5 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -30,17 +30,21 @@ public GlfwInputContext(IWindow window)
             // initialize auto-properties
             Gamepads = new GlfwGamepadCollection(this);
             Joysticks = new GlfwJoystickCollection(this);
-            
+            Keyboards = new GlfwKeyboardCollection(this);
+            Mice = new GlfwMouseCollection(this);
+
             // initialize joysticks
             _joysticks = new List<GlfwJoystick>(Enumerable.Range(0, 16).Select(i => new GlfwJoystick(i)));
             _gamepads = new List<GlfwGamepad>(Enumerable.Range(0, 16).Select(i => new GlfwGamepad(i)));
+            _keyboard = new GlfwKeyboard(this);
+            _mouse = new GlfwMouse(this);
         }
 
         public IntPtr Handle { get; }
         public IReadOnlyList<IGamepad> Gamepads { get; }
         public IReadOnlyList<IJoystick> Joysticks { get; }
-        public IReadOnlyList<IKeyboard> Keyboards { get; } // TODO
-        public IReadOnlyList<IMouse> Mice { get; } // TODO
+        public IReadOnlyList<IKeyboard> Keyboards { get; }
+        public IReadOnlyList<IMouse> Mice { get; }
         public IReadOnlyList<IInputDevice> OtherDevices { get; } = Array.Empty<IInputDevice>(); // not supported in GLFW
 
         public void Dispose()
@@ -55,10 +59,23 @@ public void Dispose()
 
         public void WindowUpdate(double obj)
         {
-            throw new NotImplementedException();
+            // TODO:
+            // foreach joystick in this.Joysticks
+            //   foreach axis in joystick.Axes
+            //     if (axis.Position != someCachedValue)
+            //       joystick.RaiseAxisMove(axis)
+            //   foreach button in joystick.Buttons
+            //     if (button.Pressed != someCachedValue)
+            //       joystick.RaiseButtonDown(button)
+            // etc. etc.
         }
         
         /// <inheritdoc />
         public event Action<IInputDevice, bool> ConnectionChanged;
+
+        public void RaiseConnectionChange(int joystick, ConnectedState state)
+        {
+            ConnectionChanged?.Invoke(Joysticks[joystick], state == ConnectedState.Connected);
+        }
     }
 }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
index 0f014f69cb..a71fd17d41 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwKeyboard.cs
@@ -35,5 +35,15 @@ public unsafe bool IsKeyPressed(uint scancode)
 
         public event Action<IKeyboard, Key> KeyDown;
         public event Action<IKeyboard, Key> KeyUp;
+
+        internal void RaisePressEvent(Keys key, int scancode, KeyModifiers mods)
+        {
+            KeyDown?.Invoke(this, Util.GlfwKeyToSilkKey(key));
+        }
+
+        internal void RaiseReleaseEvent(Keys key, int scancode, KeyModifiers mods)
+        {
+            KeyUp?.Invoke(this, Util.GlfwKeyToSilkKey(key));
+        }
     }
 }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
index e7862a6ac3..ad04041655 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
@@ -11,6 +11,10 @@ namespace Silk.NET.Input.Desktop
 {
     public class GlfwMouse : IMouse
     {
+        public GlfwMouse(GlfwInputContext inputContext)
+        {
+        }
+
         public string Name { get; } = "Silk.NET Mouse (GLFW)";
         public int Index { get; } = 0;
         public bool IsConnected { get; } = true;
@@ -24,5 +28,20 @@ public bool IsButtonPressed(MouseButton btn)
         public event Action<IMouse, MouseButton> MouseDown;
         public event Action<IMouse, MouseButton> MouseUp;
         public event Action<IMouse, ScrollWheel> Scroll;
+
+        internal void RaiseMouseDown(MouseButton btn)
+        {
+            MouseDown?.Invoke(this, btn);
+        }
+
+        internal void RaiseMouseUp(MouseButton btn)
+        {
+            MouseUp?.Invoke(this, btn);
+        }
+
+        internal void RaiseScroll(ScrollWheel wheel)
+        {
+            Scroll?.Invoke(this, wheel);
+        }
     }
 }
diff --git a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
index 850ab57d65..16f0d496d1 100644
--- a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
+++ b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
@@ -3,7 +3,12 @@
 // You may modify and distribute Silk.NET under the terms
 // of the MIT license. See the LICENSE file for details.
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using MouseButton = Silk.NET.GLFW.MouseButton;
 
 namespace Silk.NET.Input.Desktop
 {
@@ -14,14 +19,77 @@ internal class InputHandler
         static InputHandler()
         {
             Contexts = new List<GlfwInputContext>();
+            Util.Do(() => Util.Glfw.SetJoystickCallback(JoystickCallback));
         }
 
-        public static void RegisterContext(GlfwInputContext ctx)
+        public static unsafe void RegisterContext(GlfwInputContext ctx)
         {
             Contexts.Add(ctx);
+
+            if (Contexts.Any(x => x._window == ctx._window))
+            {
+                return;
+            }
+            
+            // register callbacks
+            Util.Do(() => Util.Glfw.SetKeyCallback((WindowHandle*) ctx._window.Handle, KeyCallback));
+            Util.Do(() => Util.Glfw.SetMouseButtonCallback((WindowHandle*)ctx._window.Handle, MouseCallback));
+            Util.Do(() => Util.Glfw.SetScrollCallback((WindowHandle*)ctx._window.Handle, ScrollCallback));
             ctx._window.OnUpdate += ctx.WindowUpdate;
         }
 
+        private static unsafe void ScrollCallback(WindowHandle* window, double offsetx, double offsety)
+        {
+            // multiple contexts for one window should be allowed, but frowned upon
+            var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+            foreach (var context in allContexts)
+            {
+                ((GlfwMouse)context._mouse).RaiseScroll(new ScrollWheel((float) offsetx, (float) offsety));
+            }
+        }
+
+        private static void JoystickCallback(int joystick, ConnectedState state)
+        {
+            Contexts.ForEach(x => x.RaiseConnectionChange(joystick, state));
+        }
+
+        private static unsafe void MouseCallback(WindowHandle* window, MouseButton button, InputAction action, KeyModifiers mods)
+        {
+            // multiple contexts for one window should be allowed, but frowned upon
+            var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+            foreach (var context in allContexts)
+            {
+                if (action == InputAction.Press)
+                {
+                    ((GlfwMouse)context._mouse).RaiseMouseDown(Util.GlfwButtonToSilkButton(button));
+                } 
+                else if (action == InputAction.Release)
+                {
+                    ((GlfwMouse)context._mouse).RaiseMouseUp(Util.GlfwButtonToSilkButton(button));
+                }
+            }
+        }
+
+        private static unsafe void KeyCallback(WindowHandle* window, Keys key, int scancode, InputAction action, KeyModifiers mods)
+        {
+            // multiple contexts for one window should be allowed, but frowned upon
+            var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+            foreach (var context in allContexts)
+            {
+                if (action == InputAction.Press)
+                {
+                    ((GlfwKeyboard) context._keyboard).RaisePressEvent(key, scancode, mods);
+                } 
+                else if (action == InputAction.Release)
+                {
+                    ((GlfwKeyboard) context._keyboard).RaiseReleaseEvent(key, scancode, mods);
+                }
+            }
+        }
+
         public static void UnregisterContext(GlfwInputContext ctx)
         {
             Contexts.Remove(ctx);
diff --git a/src/Input/Silk.NET.Input.Desktop/Util.cs b/src/Input/Silk.NET.Input.Desktop/Util.cs
index 605ccd937b..033f39e677 100644
--- a/src/Input/Silk.NET.Input.Desktop/Util.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Util.cs
@@ -8,6 +8,7 @@
 using Silk.NET.GLFW;
 using Silk.NET.Input.Common;
 using Ultz.Dispatcher.Unsafe;
+using MouseButton = Silk.NET.Input.Common.MouseButton;
 
 namespace Silk.NET.Input.Desktop
 {
@@ -65,5 +66,14 @@ public static Key GlfwKeyToSilkKey(Keys k)
             }
             throw new ArgumentOutOfRangeException(nameof(k));
         }
+
+        public static MouseButton GlfwButtonToSilkButton(GLFW.MouseButton k)
+        {
+            if (Enum.TryParse<MouseButton>(k.ToString(), out var sk))
+            {
+                return sk;
+            }
+            throw new ArgumentOutOfRangeException(nameof(k));
+        }
     }
 }
diff --git a/src/OpenGL/Silk.NET.OpenGL.Legacy/Silk.NET.OpenGL.Legacy.csproj b/src/OpenGL/Silk.NET.OpenGL.Legacy/Silk.NET.OpenGL.Legacy.csproj
index 37f54e5fde..783d2b22f5 100644
--- a/src/OpenGL/Silk.NET.OpenGL.Legacy/Silk.NET.OpenGL.Legacy.csproj
+++ b/src/OpenGL/Silk.NET.OpenGL.Legacy/Silk.NET.OpenGL.Legacy.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
diff --git a/src/OpenGL/Silk.NET.OpenGL/Silk.NET.OpenGL.csproj b/src/OpenGL/Silk.NET.OpenGL/Silk.NET.OpenGL.csproj
index 37f54e5fde..783d2b22f5 100644
--- a/src/OpenGL/Silk.NET.OpenGL/Silk.NET.OpenGL.csproj
+++ b/src/OpenGL/Silk.NET.OpenGL/Silk.NET.OpenGL.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
diff --git a/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs b/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
index 3d4e3d8756..d93369d463 100644
--- a/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
+++ b/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
@@ -10,17 +10,17 @@ namespace Silk.NET.GLFW
     /// </summary>
     public enum MouseButton
     {
-        MouseButton1 = 0,
-        MouseButton2,
-        MouseButton3,
-        MouseButton4,
-        MouseButton5,
-        MouseButton6,
-        MouseButton7,
-        MouseButton8,
-        MouseButtonLast = MouseButton8,
-        MouseButtonLeft = MouseButton1,
-        MouseButtonRight = MouseButton2,
-        MouseButtonMiddle = MouseButton3
+        Button1 = 0,
+        Button2,
+        Button3,
+        Button4,
+        Button5,
+        Button6,
+        Button7,
+        Button8,
+        ButtonLast = Button8,
+        ButtonLeft = Button1,
+        ButtonRight = Button2,
+        ButtonMiddle = Button3
     }
 }
\ No newline at end of file

From a1f6a272043fd7ea898f321a1657dc0dd4f9fefd Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Tue, 23 Jul 2019 21:32:57 +0100
Subject: [PATCH 05/46] Add an .editorconfig

---
 .editorconfig | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 .editorconfig

diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000000..755550fdfc
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,53 @@
+
+[*]
+charset=utf-8
+end_of_line=crlf
+trim_trailing_whitespace=false
+insert_final_newline=false
+indent_style=space
+indent_size=4
+
+# Microsoft .NET properties
+csharp_new_line_before_members_in_object_initializers=false
+csharp_preferred_modifier_order=public, private, protected, internal, new, abstract, virtual, sealed, override, static, readonly, extern, unsafe, volatile, async:suggestion
+csharp_style_var_elsewhere=true:hint
+csharp_style_var_for_built_in_types=true:hint
+csharp_style_var_when_type_is_apparent=true:hint
+dotnet_style_predefined_type_for_locals_parameters_members=true:hint
+dotnet_style_predefined_type_for_member_access=true:hint
+dotnet_style_qualification_for_event=false:warning
+dotnet_style_qualification_for_field=false:warning
+dotnet_style_qualification_for_method=false:warning
+dotnet_style_qualification_for_property=false:warning
+dotnet_style_require_accessibility_modifiers=for_non_interface_members:hint
+
+# ReSharper properties
+resharper_autodetect_indent_settings=true
+resharper_braces_for_for=required
+resharper_braces_for_foreach=required
+resharper_braces_for_ifelse=required
+resharper_braces_for_while=required
+resharper_csharp_insert_final_newline=true
+resharper_csharp_wrap_before_declaration_lpar=true
+resharper_csharp_wrap_before_invocation_lpar=true
+resharper_csharp_wrap_extends_list_style=chop_if_long
+resharper_csharp_wrap_parameters_style=chop_if_long
+resharper_use_indent_from_vs=false
+resharper_wrap_after_declaration_lpar=true
+resharper_wrap_after_invocation_lpar=true
+resharper_wrap_before_declaration_rpar=true
+resharper_wrap_before_invocation_rpar=true
+resharper_wrap_chained_method_calls=chop_if_long
+resharper_xmldoc_indent_child_elements=DoNotTouch
+resharper_xmldoc_indent_text=DoNotTouch
+
+# ReSharper inspection severities
+resharper_invert_if_highlighting=none
+resharper_web_config_module_not_resolved_highlighting=warning
+resharper_web_config_type_not_resolved_highlighting=warning
+resharper_web_config_wrong_module_highlighting=warning
+
+[*.{appxmanifest,asax,ascx,aspx,build,config,cs,cshtml,csproj,dbml,discomap,dtd,fs,fsi,fsscript,fsx,htm,html,jsproj,lsproj,master,ml,mli,njsproj,nuspec,proj,props,razor,resw,resx,skin,StyleCop,targets,tasks,vb,vbproj,xaml,xamlx,xml,xoml,xsd}]
+indent_style=space
+indent_size=4
+tab_width=4

From 8dcc3f13c22b75bab2eaa6cd286a650d17455ddb Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Wed, 24 Jul 2019 17:07:24 +0200
Subject: [PATCH 06/46] ThumbstickCollection

---
 .../Collections/GlfwThumbstickCollection.cs   | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
new file mode 100644
index 0000000000..a118c3d14e
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
@@ -0,0 +1,79 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwThumbstickCollection : IReadOnlyList<Thumbstick>
+    {
+        private float* _positions, _directions;
+        private int _count;
+
+        public int Count => _count;
+
+        public Thumbstick this[int index] => index < _count
+            ? new Thumbstick(index, Get(_positions, index), Get(_directions, index))
+            : throw new ArgumentOutOfRangeException();
+
+        public static float Get(float* floats, int index)
+        {
+            return (float)Marshal.PtrToStructure
+            (
+                Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
+                typeof(float)
+            );
+        }
+
+        public IEnumerator<Thumbstick> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private struct Enumerator : IEnumerator<Thumbstick>
+        {
+            private GlfwThumbstickCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwThumbstickCollection col)
+            {
+                _col = col;
+                _current = 0;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Thumbstick(_current, Get(_col._positions, _current), Get(_col._directions, _current));
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Thumbstick Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}

From 92f9f68286a83f51d04d1188781511afc8cb9c99 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Wed, 24 Jul 2019 17:33:56 +0200
Subject: [PATCH 07/46] ButtonCollection

---
 .../Collections/GlfwButtonCollection.cs       | 87 +++++++++++++++++++
 .../Collections/GlfwThumbstickCollection.cs   |  8 ++
 2 files changed, 95 insertions(+)
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
new file mode 100644
index 0000000000..ab93204ebb
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -0,0 +1,87 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwButtonCollection : IReadOnlyList<Button>
+    {
+        private bool* _bools;
+        private int _count;
+        private readonly GlfwKeyboard _keyboard;
+
+        public GlfwButtonCollection(bool* bools, int count, GlfwKeyboard keyboard)
+        {
+            _bools = bools;
+            _count = count;
+            _keyboard = keyboard;
+        }
+
+        public int Count => _count;
+
+        public Button this[int index] => index < _count
+            ? new Button ((ButtonName)index, index, Get(_bools, index))
+            : throw new ArgumentOutOfRangeException();
+
+        public IEnumerator<Button> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public static bool Get(bool* bools, int index)
+        {
+            return (bool)Marshal.PtrToStructure
+            (
+                Marshal.ReadIntPtr((IntPtr)bools, index * IntPtr.Size),
+                typeof(float)
+            );
+        }
+        private struct Enumerator : IEnumerator<Button>
+        {
+            private GlfwButtonCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwButtonCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Button((ButtonName)_current, _current, Get(_col._bools, _current));
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Button Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
index a118c3d14e..a972e39e5c 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
@@ -12,6 +12,13 @@ public unsafe class GlfwThumbstickCollection : IReadOnlyList<Thumbstick>
         private float* _positions, _directions;
         private int _count;
 
+        public GlfwThumbstickCollection(float* positions, float* directions, int count)
+        {
+            _positions = positions;
+            _directions = directions;
+            _count = count;
+        }
+
         public int Count => _count;
 
         public Thumbstick this[int index] => index < _count
@@ -46,6 +53,7 @@ public Enumerator(GlfwThumbstickCollection col)
             {
                 _col = col;
                 _current = 0;
+                Current = default;
             }
 
             public bool MoveNext()

From 4503a9719f71514634a83dc13e31e5f893f34628 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 11:29:14 +0200
Subject: [PATCH 08/46] Hat and Trigger collection

---
 .../Collections/GlfwButtonCollection.cs       | 86 +++++++++----------
 .../Collections/GlfwHatCollection.cs          | 79 +++++++++++++++++
 .../Collections/GlfwThumbstickCollection.cs   | 76 ++++++++--------
 .../Collections/GlfwTriggerCollection.cs      | 86 +++++++++++++++++++
 4 files changed, 246 insertions(+), 81 deletions(-)
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
index ab93204ebb..b81ab99db4 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -36,52 +36,52 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public static bool Get(bool* bools, int index)
-        {
-            return (bool)Marshal.PtrToStructure
-            (
-                Marshal.ReadIntPtr((IntPtr)bools, index * IntPtr.Size),
-                typeof(float)
-            );
+        public static bool Get(bool* bools, int index)
+        {
+            return (bool)Marshal.PtrToStructure
+            (
+                Marshal.ReadIntPtr((IntPtr)bools, index * IntPtr.Size),
+                typeof(float)
+            );
         }
-        private struct Enumerator : IEnumerator<Button>
-        {
-            private GlfwButtonCollection _col;
-            private int _current;
-
-            public Enumerator(GlfwButtonCollection col)
-            {
-                _col = col;
-                _current = 0;
-                Current = default;
+        private struct Enumerator : IEnumerator<Button>
+        {
+            private GlfwButtonCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwButtonCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Button((ButtonName)_current, _current, Get(_col._bools, _current));
+                _current++;
+                return true;
             }
 
-            public bool MoveNext()
-            {
-                if (_current == _col._count)
-                {
-                    Current = default;
-                    return false;
-                }
-
-                Current = new Button((ButtonName)_current, _current, Get(_col._bools, _current));
-                _current++;
-                return true;
-            }
-
-            public void Reset()
-            {
-                Current = default;
-                _current = 0;
-            }
-
-            public Button Current { get; set; }
-
-            object IEnumerator.Current => Current;
-
-            public void Dispose()
-            {
-            }
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Button Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
         }
     }
 }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
new file mode 100644
index 0000000000..75bc60f2c5
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
@@ -0,0 +1,79 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwHatCollection : IReadOnlyList<Hat>
+    {
+        public Position2D* _positions;
+        public int _count;
+
+        public Hat this[int index] => index < _count
+            ? new Hat(index, Get(_positions, index))
+            : throw new ArgumentOutOfRangeException();
+
+        public int Count => _count;
+
+        public IEnumerator<Hat> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        public static Position2D Get(Position2D* positions, int index)
+        {
+            return (Position2D)Marshal.PtrToStructure
+            (
+                Marshal.ReadIntPtr((IntPtr)positions, index * IntPtr.Size),
+                typeof(float)
+            );
+        }
+
+        private struct Enumerator : IEnumerator<Hat>
+        {
+            private GlfwHatCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwHatCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Hat(_current, Get(_col._positions, _current));
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Hat Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
index a972e39e5c..9dd3520e49 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
@@ -25,13 +25,13 @@ public GlfwThumbstickCollection(float* positions, float* directions, int count)
             ? new Thumbstick(index, Get(_positions, index), Get(_directions, index))
             : throw new ArgumentOutOfRangeException();
 
-        public static float Get(float* floats, int index)
-        {
-            return (float)Marshal.PtrToStructure
-            (
-                Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
-                typeof(float)
-            );
+        public static float Get(float* floats, int index)
+        {
+            return (float)Marshal.PtrToStructure
+            (
+                Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
+                typeof(float)
+            );
         }
 
         public IEnumerator<Thumbstick> GetEnumerator()
@@ -48,39 +48,39 @@ private struct Enumerator : IEnumerator<Thumbstick>
         {
             private GlfwThumbstickCollection _col;
             private int _current;
-
-            public Enumerator(GlfwThumbstickCollection col)
-            {
-                _col = col;
-                _current = 0;
-                Current = default;
+
+            public Enumerator(GlfwThumbstickCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Thumbstick(_current, Get(_col._positions, _current), Get(_col._directions, _current));
+                _current++;
+                return true;
             }
 
-            public bool MoveNext()
-            {
-                if (_current == _col._count)
-                {
-                    Current = default;
-                    return false;
-                }
-
-                Current = new Thumbstick(_current, Get(_col._positions, _current), Get(_col._directions, _current));
-                _current++;
-                return true;
-            }
-
-            public void Reset()
-            {
-                Current = default;
-                _current = 0;
-            }
-
-            public Thumbstick Current { get; set; }
-
-            object IEnumerator.Current => Current;
-
-            public void Dispose()
-            {
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Thumbstick Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
             }
         }
     }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
new file mode 100644
index 0000000000..503cb73089
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
@@ -0,0 +1,86 @@
+using Silk.NET.Input.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public unsafe class GlfwTriggerCollection : IReadOnlyList<Trigger>
+    {
+        private float* _floats;
+        private int _count;
+
+        public GlfwTriggerCollection(float* floats, int count)
+        {
+            _count = count;
+            _floats = floats;
+        }
+
+        public Trigger this[int index] => index < Count
+            ? new Trigger(index, Get(_floats, index))
+            : throw new ArgumentOutOfRangeException();
+
+        public int Count => _count;
+
+        public IEnumerator<Trigger> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public static float Get(float* floats, int index)
+        {
+            return (float)Marshal.PtrToStructure
+            (
+                Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
+                typeof(float)
+            );
+        }
+
+        private struct Enumerator : IEnumerator<Trigger>
+        {
+            private GlfwTriggerCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwTriggerCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Trigger(_current, Get(_col._floats, _current));
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Trigger Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}

From 2859bdf5255c1f52030c39e216b6ede105645883 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 11:44:53 +0200
Subject: [PATCH 09/46] Update collections

---
 .../Collections/GlfwButtonCollection.cs       |  6 +-
 .../Collections/GlfwHatCollection.cs          | 78 ++++++++++---------
 2 files changed, 45 insertions(+), 39 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
index b81ab99db4..a4c675418b 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -11,13 +11,13 @@ public unsafe class GlfwButtonCollection : IReadOnlyList<Button>
     {
         private bool* _bools;
         private int _count;
-        private readonly GlfwKeyboard _keyboard;
+        private readonly GlfwJoystick joystick;
 
-        public GlfwButtonCollection(bool* bools, int count, GlfwKeyboard keyboard)
+        public GlfwButtonCollection(bool* bools, int count, GlfwJoystick _joystick)
         {
             _bools = bools;
             _count = count;
-            _keyboard = keyboard;
+            joystick = _joystick;
         }
 
         public int Count => _count;
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
index 75bc60f2c5..b54515783f 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
@@ -12,6 +12,12 @@ public unsafe class GlfwHatCollection : IReadOnlyList<Hat>
         public Position2D* _positions;
         public int _count;
 
+        public GlfwHatCollection(Position2D* positions, int count)
+        {
+            _positions = positions;
+            _count = count;
+        }
+
         public Hat this[int index] => index < _count
             ? new Hat(index, Get(_positions, index))
             : throw new ArgumentOutOfRangeException();
@@ -36,44 +42,44 @@ public static Position2D Get(Position2D* positions, int index)
             );
         }
 
-        private struct Enumerator : IEnumerator<Hat>
-        {
-            private GlfwHatCollection _col;
-            private int _current;
-
-            public Enumerator(GlfwHatCollection col)
-            {
-                _col = col;
-                _current = 0;
-                Current = default;
+        private struct Enumerator : IEnumerator<Hat>
+        {
+            private GlfwHatCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwHatCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
             }
 
-            public bool MoveNext()
-            {
-                if (_current == _col._count)
-                {
-                    Current = default;
-                    return false;
-                }
-
-                Current = new Hat(_current, Get(_col._positions, _current));
-                _current++;
-                return true;
-            }
-
-            public void Reset()
-            {
-                Current = default;
-                _current = 0;
-            }
-
-            public Hat Current { get; set; }
-
-            object IEnumerator.Current => Current;
-
-            public void Dispose()
-            {
-            }
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Hat(_current, Get(_col._positions, _current));
+                _current++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Hat Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
         }
     }
 }

From 422c2f406d56e7bbbf13c46ddb847cee797c22ad Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 21:35:22 +0200
Subject: [PATCH 10/46] joystick axis cache

---
 .../GlfwInputContext.cs                       | 166 +++++++++---------
 .../Implementations/GlfwJoystick.cs           |  13 ++
 2 files changed, 98 insertions(+), 81 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index f3c4afacf5..8b49ab2118 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -1,81 +1,85 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Silk.NET.GLFW;
-using Silk.NET.Input.Common;
-using Silk.NET.Input.Desktop.Collections;
-using Silk.NET.Windowing.Common;
-
-namespace Silk.NET.Input.Desktop
-{
-    public class GlfwInputContext : IInputContext
-    {
-        internal List<GlfwGamepad> _gamepads;
-        internal List<GlfwJoystick> _joysticks;
-        internal IKeyboard _keyboard;
-        internal IMouse _mouse;
-        internal IWindow _window;
-
-        public GlfwInputContext(IWindow window)
-        {
-            Handle = window.Handle;
-            _window = window;
-            InputHandler.RegisterContext(this);
-            
-            // initialize auto-properties
-            Gamepads = new GlfwGamepadCollection(this);
-            Joysticks = new GlfwJoystickCollection(this);
-            Keyboards = new GlfwKeyboardCollection(this);
-            Mice = new GlfwMouseCollection(this);
-
-            // initialize joysticks
-            _joysticks = new List<GlfwJoystick>(Enumerable.Range(0, 16).Select(i => new GlfwJoystick(i)));
-            _gamepads = new List<GlfwGamepad>(Enumerable.Range(0, 16).Select(i => new GlfwGamepad(i)));
-            _keyboard = new GlfwKeyboard(this);
-            _mouse = new GlfwMouse(this);
-        }
-
-        public IntPtr Handle { get; }
-        public IReadOnlyList<IGamepad> Gamepads { get; }
-        public IReadOnlyList<IJoystick> Joysticks { get; }
-        public IReadOnlyList<IKeyboard> Keyboards { get; }
-        public IReadOnlyList<IMouse> Mice { get; }
-        public IReadOnlyList<IInputDevice> OtherDevices { get; } = Array.Empty<IInputDevice>(); // not supported in GLFW
-
-        public void Dispose()
-        {
-            InputHandler.UnregisterContext(this);
-        }
-
-        ~GlfwInputContext()
-        {
-            Dispose();
-        }
-
-        public void WindowUpdate(double obj)
-        {
-            // TODO:
-            // foreach joystick in this.Joysticks
-            //   foreach axis in joystick.Axes
-            //     if (axis.Position != someCachedValue)
-            //       joystick.RaiseAxisMove(axis)
-            //   foreach button in joystick.Buttons
-            //     if (button.Pressed != someCachedValue)
-            //       joystick.RaiseButtonDown(button)
-            // etc. etc.
-        }
-        
-        /// <inheritdoc />
-        public event Action<IInputDevice, bool> ConnectionChanged;
-
-        public void RaiseConnectionChange(int joystick, ConnectedState state)
-        {
-            ConnectionChanged?.Invoke(Joysticks[joystick], state == ConnectedState.Connected);
-        }
-    }
-}
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Silk.NET.GLFW;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Silk.NET.Windowing.Common;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwInputContext : IInputContext
+    {
+        internal List<GlfwGamepad> _gamepads;
+        internal List<GlfwJoystick> _joysticks;
+        internal IKeyboard _keyboard;
+        internal IMouse _mouse;
+        internal IWindow _window;
+
+        public GlfwInputContext(IWindow window)
+        {
+            Handle = window.Handle;
+            _window = window;
+            InputHandler.RegisterContext(this);
+            
+            // initialize auto-properties
+            Gamepads = new GlfwGamepadCollection(this);
+            Joysticks = new GlfwJoystickCollection(this);
+            Keyboards = new GlfwKeyboardCollection(this);
+            Mice = new GlfwMouseCollection(this);
+
+            // initialize joysticks
+            _joysticks = new List<GlfwJoystick>(Enumerable.Range(0, 16).Select(i => new GlfwJoystick(i)));
+            _gamepads = new List<GlfwGamepad>(Enumerable.Range(0, 16).Select(i => new GlfwGamepad(i)));
+            _keyboard = new GlfwKeyboard(this);
+            _mouse = new GlfwMouse(this);
+        }
+
+        public IntPtr Handle { get; }
+        public IReadOnlyList<IGamepad> Gamepads { get; }
+        public IReadOnlyList<IJoystick> Joysticks { get; }
+        public IReadOnlyList<IKeyboard> Keyboards { get; }
+        public IReadOnlyList<IMouse> Mice { get; }
+        public IReadOnlyList<IInputDevice> OtherDevices { get; } = Array.Empty<IInputDevice>(); // not supported in GLFW
+
+        public void Dispose()
+        {
+            InputHandler.UnregisterContext(this);
+        }
+
+        ~GlfwInputContext()
+        {
+            Dispose();
+        }
+
+        public void WindowUpdate(double obj)
+        {
+            for (int i = 0; i < _joysticks.Count; i++)
+            {
+                _joysticks[i].Update();
+            }
+            // TODO:
+            // foreach joystick in this.Joysticks
+            //   foreach axis in joystick.Axes
+            //     if (axis.Position != someCachedValue)
+            //       joystick.RaiseAxisMove(axis)
+            //   foreach button in joystick.Buttons
+            //     if (button.Pressed != someCachedValue)
+            //       joystick.RaiseButtonDown(button)
+            // etc. etc.
+        }
+        
+        /// <inheritdoc />
+        public event Action<IInputDevice, bool> ConnectionChanged;
+
+        public void RaiseConnectionChange(int joystick, ConnectedState state)
+        {
+            ConnectionChanged?.Invoke(Joysticks[joystick], state == ConnectedState.Connected);
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 15aed12ab0..e7c168ccb4 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -22,6 +22,7 @@ public GlfwJoystick(int i)
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index));
         public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
+        private List<Axis> _cachedAxes => new List<Axis>();
         public IReadOnlyList<Button> Buttons { get; }
         public IReadOnlyList<Hat> Hats { get; }
         public Deadzone Deadzone { get; set; }
@@ -30,6 +31,18 @@ public GlfwJoystick(int i)
         public event Action<IJoystick, Axis> AxisMoved;
         public event Action<IJoystick, Hat> HatMoved;
 
+        public void Update()
+        {
+            IReadOnlyList<Axis> axes = Axes;
+            for (int i = 0; i < axes.Count; i++)
+            {
+                if (!axes[i].Equals(_cachedAxes.Count > i ? _cachedAxes[i] : axes[i]))
+                {
+                    AxisMoved?.Invoke(this, axes[i]);
+                }
+            }
+        }
+
         private static unsafe IReadOnlyList<Axis> GetAxes(int i, GlfwJoystick joystick)
         {
             var count = 0;

From 3cdcc407ee4f1fa66ac568e84a48f38551826947 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 21:37:13 +0200
Subject: [PATCH 11/46] Update cached axis

---
 src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index e7c168ccb4..7c5bfdfffb 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -38,6 +38,7 @@ public void Update()
             {
                 if (!axes[i].Equals(_cachedAxes.Count > i ? _cachedAxes[i] : axes[i]))
                 {
+                    _cachedAxes[i] = axes[i];
                     AxisMoved?.Invoke(this, axes[i]);
                 }
             }

From 0046628874f909e3409778b949cf79e98be14b1c Mon Sep 17 00:00:00 2001
From: Dylan Perks <dylanperks23@gmail.com>
Date: Thu, 25 Jul 2019 20:46:23 +0100
Subject: [PATCH 12/46] Update GlfwJoystick.cs

---
 .../Implementations/GlfwJoystick.cs           | 86 +++++++++----------
 1 file changed, 43 insertions(+), 43 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 7c5bfdfffb..8414d97800 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -1,36 +1,36 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-using System;
-using System.Collections.Generic;
-using Silk.NET.Input.Common;
-using Silk.NET.Input.Desktop.Collections;
-using Ultz.Dispatcher.Unsafe;
-
-namespace Silk.NET.Input.Desktop
-{
-    public class GlfwJoystick : IJoystick
-    {
-        public GlfwJoystick(int i)
-        {
-            Index = i;
-        }
-
-        public string Name => Util.Do(() => Util.Glfw.GetJoystickName(Index));
-        public int Index { get; }
-        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index));
-        public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
-        private List<Axis> _cachedAxes => new List<Axis>();
-        public IReadOnlyList<Button> Buttons { get; }
-        public IReadOnlyList<Hat> Hats { get; }
-        public Deadzone Deadzone { get; set; }
-        public event Action<IJoystick, Button> ButtonDown;
-        public event Action<IJoystick, Button> ButtonUp;
-        public event Action<IJoystick, Axis> AxisMoved;
-        public event Action<IJoystick, Hat> HatMoved;
-
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Ultz.Dispatcher.Unsafe;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwJoystick : IJoystick
+    {
+        public GlfwJoystick(int i)
+        {
+            Index = i;
+        }
+
+        public string Name => Util.Do(() => Util.Glfw.GetJoystickName(Index));
+        public int Index { get; }
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index) && !Util.Glfw.JoystickIsGamepad(Index));
+        public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
+        private List<Axis> _cachedAxes => new List<Axis>();
+        public IReadOnlyList<Button> Buttons { get; }
+        public IReadOnlyList<Hat> Hats { get; }
+        public Deadzone Deadzone { get; set; }
+        public event Action<IJoystick, Button> ButtonDown;
+        public event Action<IJoystick, Button> ButtonUp;
+        public event Action<IJoystick, Axis> AxisMoved;
+        public event Action<IJoystick, Hat> HatMoved;
+
         public void Update()
         {
             IReadOnlyList<Axis> axes = Axes;
@@ -42,13 +42,13 @@ public void Update()
                     AxisMoved?.Invoke(this, axes[i]);
                 }
             }
-        }
-
-        private static unsafe IReadOnlyList<Axis> GetAxes(int i, GlfwJoystick joystick)
-        {
-            var count = 0;
-            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
-            return new GlfwAxisCollection(floats, count, joystick);
-        }
-    }
-}
+        }
+
+        private static unsafe IReadOnlyList<Axis> GetAxes(int i, GlfwJoystick joystick)
+        {
+            var count = 0;
+            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            return new GlfwAxisCollection(floats, count, joystick);
+        }
+    }
+}

From e0702c0229a249a1e68b59ce8005278f080e0d16 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 22:37:22 +0200
Subject: [PATCH 13/46] Joystick cache

---
 .../Implementations/GlfwJoystick.cs           | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 7c5bfdfffb..e7520ba249 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -24,7 +24,9 @@ public GlfwJoystick(int i)
         public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
         private List<Axis> _cachedAxes => new List<Axis>();
         public IReadOnlyList<Button> Buttons { get; }
+        private List<Button> _cachedButtons => new List<Button>();
         public IReadOnlyList<Hat> Hats { get; }
+        private List<Hat> _cachedHats => new List<Hat>();
         public Deadzone Deadzone { get; set; }
         public event Action<IJoystick, Button> ButtonDown;
         public event Action<IJoystick, Button> ButtonUp;
@@ -33,6 +35,11 @@ public GlfwJoystick(int i)
 
         public void Update()
         {
+            if (Util.Glfw.JoystickIsGamepad(Index))
+            {
+                return;
+            }
+
             IReadOnlyList<Axis> axes = Axes;
             for (int i = 0; i < axes.Count; i++)
             {
@@ -42,6 +49,24 @@ public void Update()
                     AxisMoved?.Invoke(this, axes[i]);
                 }
             }
+            IReadOnlyList<Button> buttons = Buttons;
+            for (int i = 0; i < buttons.Count; i++)
+            {
+                if (!buttons[i].Equals(_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]))
+                {
+                    _cachedButtons[i] = buttons[i];
+                    (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
+                }
+            }
+            IReadOnlyList<Hat> hats = Hats;
+            for (int i = 0; i < hats.Count; i++)
+            {
+                if (!hats[i].Equals(_cachedHats.Count > i ? _cachedHats[i] : hats[i]))
+                {
+                    _cachedHats[i] = hats[i];
+                    HatMoved?.Invoke(this, hats[i]);
+                }
+            }
         }
 
         private static unsafe IReadOnlyList<Axis> GetAxes(int i, GlfwJoystick joystick)

From 958818b5e398ccde0b3d8df530786e5f7ceda653 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 22:56:24 +0200
Subject: [PATCH 14/46] AxisCollection

---
 .../Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs     | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
index 8776abfd44..fb5a2e2f00 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
@@ -57,6 +57,7 @@ public Enumerator(GlfwAxisCollection col)
             {
                 _col = col;
                 _current = 0;
+                Current = default;
             }
             
             public bool MoveNext()

From dcb02c67c528bb155e07539d12f5b79776fe8310 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 22:57:04 +0200
Subject: [PATCH 15/46] GamePad and Joystick cache

---
 .../Implementations/GlfwGamepad.cs            | 43 ++++++++++++++++++-
 .../Implementations/GlfwJoystick.cs           |  8 ++--
 2 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index b785ced56c..97955b993f 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -19,13 +19,52 @@ public GlfwGamepad(int i)
         public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index));
-        public IReadOnlyList<Button> Buttons { get; }
+        public IReadOnlyList<Button> Buttons { get; }
+        private List<Button> _cachedButtons = new List<Button>();
         public IReadOnlyList<Thumbstick> Thumbsticks { get; }
+        private List<Thumbstick> _cachedThumbsticks = new List<Thumbstick>();
         public IReadOnlyList<Trigger> Triggers { get; }
+        private List<Trigger> _cachedTriggers = new List<Trigger>();
         public Deadzone Deadzone { get; set; }
         public event Action<IGamepad, Button> ButtonDown;
         public event Action<IGamepad, Button> ButtonUp;
         public event Action<IGamepad, Thumbstick> ThumbstickMoved;
         public event Action<IGamepad, Trigger> TriggerMoved;
+
+        public void Update()
+        {
+            if (Util.Glfw.JoystickIsGamepad(Index))
+            {
+                return;
+            }
+
+            IReadOnlyList<Button> buttons = Buttons;
+            for (int i = 0; i < buttons.Count; i++)
+            {
+                if (!buttons[i].Equals(_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]))
+                {
+                    _cachedButtons[i] = buttons[i];
+                    (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
+                }
+            }
+            IReadOnlyList<Thumbstick> thumbsticks = Thumbsticks;
+            for (int i = 0; i < thumbsticks.Count; i++)
+            {
+                if (!thumbsticks[i].Equals(_cachedThumbsticks.Count > i ? _cachedThumbsticks[i] : thumbsticks[i]))
+                {
+                    _cachedThumbsticks[i] = thumbsticks[i];
+                    ThumbstickMoved?.Invoke(this, thumbsticks[i]);
+                }
+            }
+            IReadOnlyList<Trigger> triggers = Triggers;
+            for (int i = 0; i < triggers.Count; i++)
+            {
+                if (!triggers[i].Equals(_cachedTriggers.Count > i ? _cachedTriggers[i] : triggers[i]))
+                {
+                    _cachedTriggers[i] = triggers[i];
+                    TriggerMoved?.Invoke(this, triggers[i]);
+                }
+            }
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index e102518e9b..01b4284643 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -22,11 +22,11 @@ public GlfwJoystick(int i)
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index)) && !Util.Glfw.JoystickIsGamepad(Index);
         public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
-        private List<Axis> _cachedAxes => new List<Axis>();
+        private List<Axis> _cachedAxes = new List<Axis>();
         public IReadOnlyList<Button> Buttons { get; }
-        private List<Button> _cachedButtons => new List<Button>();
+        private List<Button> _cachedButtons = new List<Button>();
         public IReadOnlyList<Hat> Hats { get; }
-        private List<Hat> _cachedHats => new List<Hat>();
+        private List<Hat> _cachedHats = new List<Hat>();
         public Deadzone Deadzone { get; set; }
         public event Action<IJoystick, Button> ButtonDown;
         public event Action<IJoystick, Button> ButtonUp;
@@ -35,7 +35,7 @@ public GlfwJoystick(int i)
 
         public void Update()
         {
-            if (Util.Glfw.JoystickIsGamepad(Index))
+            if (!Util.Glfw.JoystickIsGamepad(Index))
             {
                 return;
             }

From f159b8c466bbce11790bde3e060a26fb520c9dc0 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 22:58:16 +0200
Subject: [PATCH 16/46] GamepadFix

---
 src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index 97955b993f..1e5eb520e1 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -18,7 +18,7 @@ public GlfwGamepad(int i)
 
         public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
         public int Index { get; }
-        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index));
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index)) && Util.Glfw.JoystickIsGamepad(Index);
         public IReadOnlyList<Button> Buttons { get; }
         private List<Button> _cachedButtons = new List<Button>();
         public IReadOnlyList<Thumbstick> Thumbsticks { get; }

From 213c760abcd031ec7db3a2ffd66c2e283af9f439 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 23:02:16 +0200
Subject: [PATCH 17/46] GamePad Updates

---
 .../Silk.NET.Input.Desktop/GlfwInputContext.cs      | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index 8b49ab2118..77ccc9ab5f 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -63,15 +63,10 @@ public void WindowUpdate(double obj)
             {
                 _joysticks[i].Update();
             }
-            // TODO:
-            // foreach joystick in this.Joysticks
-            //   foreach axis in joystick.Axes
-            //     if (axis.Position != someCachedValue)
-            //       joystick.RaiseAxisMove(axis)
-            //   foreach button in joystick.Buttons
-            //     if (button.Pressed != someCachedValue)
-            //       joystick.RaiseButtonDown(button)
-            // etc. etc.
+            for (int i = 0; i < _gamepads.Count; i++)
+            {
+                _gamepads[i].Update();
+            }
         }
         
         /// <inheritdoc />

From a946ba27b1688dfc1a4d524f9671bf928528f661 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 25 Jul 2019 23:05:01 +0200
Subject: [PATCH 18/46] Bracket fix

---
 src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs | 2 +-
 .../Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index 1e5eb520e1..c10223f97b 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -18,7 +18,7 @@ public GlfwGamepad(int i)
 
         public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
         public int Index { get; }
-        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index)) && Util.Glfw.JoystickIsGamepad(Index);
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index) && Util.Glfw.JoystickIsGamepad(Index));
         public IReadOnlyList<Button> Buttons { get; }
         private List<Button> _cachedButtons = new List<Button>();
         public IReadOnlyList<Thumbstick> Thumbsticks { get; }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 01b4284643..6175da825b 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -20,7 +20,7 @@ public GlfwJoystick(int i)
 
         public string Name => Util.Do(() => Util.Glfw.GetJoystickName(Index));
         public int Index { get; }
-        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index)) && !Util.Glfw.JoystickIsGamepad(Index);
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index) && !Util.Glfw.JoystickIsGamepad(Index));
         public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
         private List<Axis> _cachedAxes = new List<Axis>();
         public IReadOnlyList<Button> Buttons { get; }

From d9d0cae69234b27a625726c46484e5d9ee625027 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Fri, 26 Jul 2019 14:36:26 +0100
Subject: [PATCH 19/46] work

---
 examples/InputTest/InputTest.csproj           |  2 +
 examples/InputTest/Program.cs                 | 32 ++++++++-
 .../Silk.NET.Input.Common/Enums/Position2D.cs |  1 +
 .../Collections/GlfwButtonCollection.cs       | 22 +++---
 .../Collections/GlfwHatCollection.cs          |  6 +-
 .../Implementations/GlfwGamepad.cs            | 68 +++++++++----------
 .../Implementations/GlfwJoystick.cs           | 39 +++++++----
 7 files changed, 105 insertions(+), 65 deletions(-)

diff --git a/examples/InputTest/InputTest.csproj b/examples/InputTest/InputTest.csproj
index ef123cd998..ba1d328a81 100644
--- a/examples/InputTest/InputTest.csproj
+++ b/examples/InputTest/InputTest.csproj
@@ -7,6 +7,8 @@
 
     <ItemGroup>
       <ProjectReference Include="..\..\src\Input\Silk.NET.Input.Desktop\Silk.NET.Input.Desktop.csproj" />
+      <ProjectReference Include="..\..\src\Input\Silk.NET.Input\Silk.NET.Input.csproj" />
+      <ProjectReference Include="..\..\src\Windowing\Silk.NET.Windowing\Silk.NET.Windowing.csproj" />
     </ItemGroup>
 
 </Project>
diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
index 6415f986da..beab9a1cc9 100644
--- a/examples/InputTest/Program.cs
+++ b/examples/InputTest/Program.cs
@@ -1,6 +1,9 @@
 using System;
+using System.Threading.Tasks;
+using Silk.NET.Input;
 using Silk.NET.Input.Common;
 using Silk.NET.Input.Desktop;
+using Silk.NET.Windowing;
 using Silk.NET.Windowing.Common;
 using Silk.NET.Windowing.Desktop;
 
@@ -10,10 +13,33 @@ internal class Program
     {
         private static void Main()
         {
-            var window = new GlfwWindow(WindowOptions.Default);
 
-            var inputContext = new GlfwInputContext(window);
-            inputContext.ConnectionChanged += ControllerConnected;
+            var window = Window.Create(WindowOptions.Default);
+            Task.Run(() => window.Run());
+            Console.Write("Connect your controller(s) and press ENTER (in the console window).");
+            Console.ReadLine();
+            var input = window.GetInput();
+            input.ConnectionChanged += ControllerConnected;
+            foreach (var inputGamepad in input.Gamepads)
+            {
+                Console.WriteLine("Discovered controller " + inputGamepad.Index);
+                inputGamepad.ButtonDown += InputGamepadOnButtonDown;
+                inputGamepad.ButtonUp += InputGamepadOnButtonUp;
+                foreach (var inputGamepadButton in inputGamepad.Buttons)
+                {
+                    Console.WriteLine("Controller ");
+                }
+            }
+        }
+
+        private static void InputGamepadOnButtonDown(IGamepad arg1, Button arg2)
+        {
+            Console.WriteLine(arg1.Index + "> " + arg2.Name + " down.");
+        }
+
+        private static void InputGamepadOnButtonUp(IGamepad arg1, Button arg2)
+        {
+            Console.WriteLine(arg1.Index + "> " + arg2.Name + " up.");
         }
 
         public static void ControllerConnected(IInputDevice device, bool isConnected)
diff --git a/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs b/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs
index 2e82a5ea99..d9fff157eb 100644
--- a/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs
+++ b/src/Input/Silk.NET.Input.Common/Enums/Position2D.cs
@@ -13,6 +13,7 @@ namespace Silk.NET.Input.Common
     [Flags]
     public enum Position2D
     {
+        Centered = 0,
         Up = 1,
         Down = 2,
         Left = 4,
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
index a4c675418b..28cca21931 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -9,21 +9,21 @@ namespace Silk.NET.Input.Desktop.Collections
 {
     public unsafe class GlfwButtonCollection : IReadOnlyList<Button>
     {
-        private bool* _bools;
+        private byte* _bytes;
         private int _count;
-        private readonly GlfwJoystick joystick;
+        private readonly GlfwJoystick _joystick;
 
-        public GlfwButtonCollection(bool* bools, int count, GlfwJoystick _joystick)
+        public GlfwButtonCollection(byte* bytes, int count, GlfwJoystick joystick)
         {
-            _bools = bools;
+            _bytes = bytes;
             _count = count;
-            joystick = _joystick;
+            _joystick = joystick;
         }
 
         public int Count => _count;
 
         public Button this[int index] => index < _count
-            ? new Button ((ButtonName)index, index, Get(_bools, index))
+            ? new Button ((ButtonName)index, index, Get(_bytes, index) != 0)
             : throw new ArgumentOutOfRangeException();
 
         public IEnumerator<Button> GetEnumerator()
@@ -36,12 +36,12 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public static bool Get(bool* bools, int index)
+        public static byte Get(byte* bytes, int index)
         {
-            return (bool)Marshal.PtrToStructure
+            return (byte)Marshal.PtrToStructure
             (
-                Marshal.ReadIntPtr((IntPtr)bools, index * IntPtr.Size),
-                typeof(float)
+                Marshal.ReadIntPtr((IntPtr)bytes, index * IntPtr.Size),
+                typeof(byte)
             );
         }
         private struct Enumerator : IEnumerator<Button>
@@ -64,7 +64,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Button((ButtonName)_current, _current, Get(_col._bools, _current));
+                Current = new Button((ButtonName)_current, _current, Get(_col._bytes, _current) != 0);
                 _current++;
                 return true;
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
index b54515783f..8f98a52535 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
@@ -35,11 +35,7 @@ IEnumerator IEnumerable.GetEnumerator()
         }
         public static Position2D Get(Position2D* positions, int index)
         {
-            return (Position2D)Marshal.PtrToStructure
-            (
-                Marshal.ReadIntPtr((IntPtr)positions, index * IntPtr.Size),
-                typeof(float)
-            );
+            return (Position2D) Marshal.ReadInt32((IntPtr) positions, index * IntPtr.Size);
         }
 
         private struct Enumerator : IEnumerator<Hat>
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index c10223f97b..31a1581e28 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -1,36 +1,36 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
-using System;
-using System.Collections.Generic;
-using Silk.NET.Input.Common;
-
-namespace Silk.NET.Input.Desktop
-{
-    public class GlfwGamepad : IGamepad
-    {
-        public GlfwGamepad(int i)
-        {
-            Index = i;
-        }
-
-        public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
-        public int Index { get; }
-        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index) && Util.Glfw.JoystickIsGamepad(Index));
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop
+{
+    public class GlfwGamepad : IGamepad
+    {
+        private List<Button> _cachedButtons = new List<Button>();
+        private List<Thumbstick> _cachedThumbsticks = new List<Thumbstick>();
+        private List<Trigger> _cachedTriggers = new List<Trigger>();
+        public GlfwGamepad(int i)
+        {
+            Index = i;
+        }
+
+        public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
+        public int Index { get; }
+        public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index) && Util.Glfw.JoystickIsGamepad(Index));
         public IReadOnlyList<Button> Buttons { get; }
-        private List<Button> _cachedButtons = new List<Button>();
-        public IReadOnlyList<Thumbstick> Thumbsticks { get; }
-        private List<Thumbstick> _cachedThumbsticks = new List<Thumbstick>();
-        public IReadOnlyList<Trigger> Triggers { get; }
-        private List<Trigger> _cachedTriggers = new List<Trigger>();
-        public Deadzone Deadzone { get; set; }
-        public event Action<IGamepad, Button> ButtonDown;
-        public event Action<IGamepad, Button> ButtonUp;
-        public event Action<IGamepad, Thumbstick> ThumbstickMoved;
-        public event Action<IGamepad, Trigger> TriggerMoved;
-
+        public IReadOnlyList<Thumbstick> Thumbsticks { get; }
+        public IReadOnlyList<Trigger> Triggers { get; }
+        public Deadzone Deadzone { get; set; }
+        public event Action<IGamepad, Button> ButtonDown;
+        public event Action<IGamepad, Button> ButtonUp;
+        public event Action<IGamepad, Thumbstick> ThumbstickMoved;
+        public event Action<IGamepad, Trigger> TriggerMoved;
+
         public void Update()
         {
             if (Util.Glfw.JoystickIsGamepad(Index))
@@ -65,6 +65,6 @@ public void Update()
                     TriggerMoved?.Invoke(this, triggers[i]);
                 }
             }
-        }
-    }
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 6175da825b..722c59864c 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using Silk.NET.GLFW;
 using Silk.NET.Input.Common;
 using Silk.NET.Input.Desktop.Collections;
 using Ultz.Dispatcher.Unsafe;
@@ -13,6 +14,9 @@ namespace Silk.NET.Input.Desktop
 {
     public class GlfwJoystick : IJoystick
     {
+        private List<Axis> _cachedAxes = new List<Axis>();
+        private List<Button> _cachedButtons = new List<Button>();
+        private List<Hat> _cachedHats = new List<Hat>();
         public GlfwJoystick(int i)
         {
             Index = i;
@@ -22,11 +26,8 @@ public GlfwJoystick(int i)
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index) && !Util.Glfw.JoystickIsGamepad(Index));
         public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
-        private List<Axis> _cachedAxes = new List<Axis>();
-        public IReadOnlyList<Button> Buttons { get; }
-        private List<Button> _cachedButtons = new List<Button>();
-        public IReadOnlyList<Hat> Hats { get; }
-        private List<Hat> _cachedHats = new List<Hat>();
+        public IReadOnlyList<Button> Buttons => GetButtons(Index, this);
+        public IReadOnlyList<Hat> Hats => GetHats(Index, this);
         public Deadzone Deadzone { get; set; }
         public event Action<IJoystick, Button> ButtonDown;
         public event Action<IJoystick, Button> ButtonUp;
@@ -35,13 +36,13 @@ public GlfwJoystick(int i)
 
         public void Update()
         {
-            if (!Util.Glfw.JoystickIsGamepad(Index))
+            if (Util.Glfw.JoystickIsGamepad(Index))
             {
                 return;
             }
 
-            IReadOnlyList<Axis> axes = Axes;
-            for (int i = 0; i < axes.Count; i++)
+            var axes = Axes;
+            for (var i = 0; i < axes.Count; i++)
             {
                 if (!axes[i].Equals(_cachedAxes.Count > i ? _cachedAxes[i] : axes[i]))
                 {
@@ -49,8 +50,8 @@ public void Update()
                     AxisMoved?.Invoke(this, axes[i]);
                 }
             }
-            IReadOnlyList<Button> buttons = Buttons;
-            for (int i = 0; i < buttons.Count; i++)
+            var buttons = Buttons;
+            for (var i = 0; i < buttons.Count; i++)
             {
                 if (!buttons[i].Equals(_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]))
                 {
@@ -58,8 +59,8 @@ public void Update()
                     (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
                 }
             }
-            IReadOnlyList<Hat> hats = Hats;
-            for (int i = 0; i < hats.Count; i++)
+            var hats = Hats;
+            for (var i = 0; i < hats.Count; i++)
             {
                 if (!hats[i].Equals(_cachedHats.Count > i ? _cachedHats[i] : hats[i]))
                 {
@@ -75,5 +76,19 @@ private static unsafe IReadOnlyList<Axis> GetAxes(int i, GlfwJoystick joystick)
             var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
             return new GlfwAxisCollection(floats, count, joystick);
         }
+
+        private static unsafe IReadOnlyList<Button> GetButtons(int i, GlfwJoystick joystick)
+        {
+            var count = 0;
+            var bytes = Util.Do(() => (UnsafeDispatch<byte>)Util.Glfw.GetJoystickButtons(i, out count));
+            return new GlfwButtonCollection(bytes, count, joystick);
+        }
+
+        private static unsafe IReadOnlyList<Hat> GetHats(int i, GlfwJoystick joystick)
+        {
+            var count = 0;
+            var hats = Util.Do(() => (UnsafeDispatch<JoystickHats>)Util.Glfw.GetJoystickHats(i, out count));
+            return new GlfwHatCollection((Position2D*)hats, count);
+        }
     }
 }

From 85042ab3b72af2b9f17434cf0097ae4a10a62e8c Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Fri, 26 Jul 2019 20:25:37 +0200
Subject: [PATCH 20/46] Thumbstick update

---
 documentation/proposals/Proposal - Input.md   |  6 +++--
 src/Input/Silk.NET.Input.Common/Thumbstick.cs | 26 ++++++++++++++-----
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/documentation/proposals/Proposal - Input.md b/documentation/proposals/Proposal - Input.md
index 93cc39a948..c7c248144e 100644
--- a/documentation/proposals/Proposal - Input.md	
+++ b/documentation/proposals/Proposal - Input.md	
@@ -1,4 +1,4 @@
-# Summary    
+# Summary    
 Proposal API for Input via keyboards, mice, and controllers.
 
 # Contributors
@@ -162,7 +162,9 @@ public struct Axis
 ```cs
 public struct Thumbstick
 {
-    public int Index { get; }
+    public int Index { get; }
+    public float X { get; }
+    public float Y { get; }
     public float Position { get; }
     public float Direction { get; }
     
diff --git a/src/Input/Silk.NET.Input.Common/Thumbstick.cs b/src/Input/Silk.NET.Input.Common/Thumbstick.cs
index c164f0018b..36b03778cc 100644
--- a/src/Input/Silk.NET.Input.Common/Thumbstick.cs
+++ b/src/Input/Silk.NET.Input.Common/Thumbstick.cs
@@ -3,6 +3,8 @@
 // You may modify and distribute Silk.NET under the terms
 // of the MIT license. See the LICENSE file for details.
 
+using System;
+
 namespace Silk.NET.Input.Common
 {
     /// <summary>
@@ -13,17 +15,27 @@ public struct Thumbstick
         /// <summary>
         /// The index of this stick.
         /// </summary>
-        public int Index { get; }
+        public int Index { get; }
+
+        /// <summary>
+        /// The x-axis of the stick, from -1.0 to 1.0
+        /// </summary>
+        public float X { get; }
+
+        /// <summary>
+        /// The y-axis of the stick, from -1.0 to 1.0
+        /// </summary>
+        public float Y { get; }
         
         /// <summary>
         /// The current position of the stick, from 0.0 to 1.0.
         /// </summary>
-        public float Position { get; }
+        public float Position { get { return (float)Math.Sqrt(X * X + Y *Y); } }
         
         /// <summary>
         /// The current direction of the stick, from 0.0 to 360.0.
         /// </summary>
-        public float Direction { get; }
+        public float Direction { get { return (float)Math.Atan2(Y, X); } }
 
         /// <summary>
         /// Creates a new instance of the Thumbstick struct.
@@ -31,11 +43,11 @@ public struct Thumbstick
         /// <param name="index">The index of the stick.</param>
         /// <param name="position">The position of the stick.</param>
         /// <param name="direction">The direction of the stick.</param>
-        public Thumbstick(int index, float position, float direction)
+        public Thumbstick(int index, float x, float y)
         {
-            Index = index;
-            Position = position;
-            Direction = direction;
+            Index = index;
+            X = x;
+            Y = y;
         }
     }
 }
\ No newline at end of file

From 4cb7095d0de2ab8be7629d10916d37b10c8da770 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Fri, 26 Jul 2019 20:32:14 +0200
Subject: [PATCH 21/46] Gamepad implementation

---
 .../Collections/GlfwAxisCollection.cs         |  4 +-
 .../Collections/GlfwButtonCollection.cs       |  6 +-
 .../Collections/GlfwThumbstickCollection.cs   | 14 ++--
 .../Collections/GlfwTriggerCollection.cs      | 74 +++++++++----------
 .../Implementations/GlfwGamepad.cs            | 32 +++++++-
 .../Implementations/GlfwJoystick.cs           | 16 ++--
 6 files changed, 84 insertions(+), 62 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
index fb5a2e2f00..8fbf104834 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
@@ -15,13 +15,11 @@ public unsafe class GlfwAxisCollection : IReadOnlyList<Axis>
     {
         private float* _floats;
         private int _count;
-        private readonly GlfwJoystick _joystick;
 
-        public GlfwAxisCollection(float* floats, int count, GlfwJoystick joystick)
+        public GlfwAxisCollection(float* floats, int count)
         {
             _floats = floats;
             _count = count;
-            _joystick = joystick;
         }
         public IEnumerator<Axis> GetEnumerator()
         {
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
index 28cca21931..2c1c5ae675 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -1,4 +1,4 @@
-using Silk.NET.Input.Common;
+using Silk.NET.Input.Common;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -11,13 +11,11 @@ public unsafe class GlfwButtonCollection : IReadOnlyList<Button>
     {
         private byte* _bytes;
         private int _count;
-        private readonly GlfwJoystick _joystick;
 
-        public GlfwButtonCollection(byte* bytes, int count, GlfwJoystick joystick)
+        public GlfwButtonCollection(byte* bytes, int count)
         {
             _bytes = bytes;
             _count = count;
-            _joystick = joystick;
         }
 
         public int Count => _count;
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
index 9dd3520e49..b2cdaf6122 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
@@ -1,4 +1,4 @@
-using Silk.NET.Input.Common;
+using Silk.NET.Input.Common;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -9,20 +9,20 @@ namespace Silk.NET.Input.Desktop.Collections
 {
     public unsafe class GlfwThumbstickCollection : IReadOnlyList<Thumbstick>
     {
-        private float* _positions, _directions;
+        private float* _x, _y;
         private int _count;
 
-        public GlfwThumbstickCollection(float* positions, float* directions, int count)
+        public GlfwThumbstickCollection(float* x, float* y, int count)
         {
-            _positions = positions;
-            _directions = directions;
+            _x = x;
+            _y = y;
             _count = count;
         }
 
         public int Count => _count;
 
         public Thumbstick this[int index] => index < _count
-            ? new Thumbstick(index, Get(_positions, index), Get(_directions, index))
+            ? new Thumbstick(index, Get(_x, index), Get(_y, index))
             : throw new ArgumentOutOfRangeException();
 
         public static float Get(float* floats, int index)
@@ -64,7 +64,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Thumbstick(_current, Get(_col._positions, _current), Get(_col._directions, _current));
+                Current = new Thumbstick(_current, Get(_col._x, _current), Get(_col._y, _current));
                 _current++;
                 return true;
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
index 503cb73089..c5f4931680 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
@@ -1,4 +1,4 @@
-using Silk.NET.Input.Common;
+using Silk.NET.Input.Common;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -43,44 +43,44 @@ public static float Get(float* floats, int index)
             );
         }
 
-        private struct Enumerator : IEnumerator<Trigger>
-        {
-            private GlfwTriggerCollection _col;
-            private int _current;
-
-            public Enumerator(GlfwTriggerCollection col)
-            {
-                _col = col;
-                _current = 0;
-                Current = default;
+        private struct Enumerator : IEnumerator<Trigger>
+        {
+            private GlfwTriggerCollection _col;
+            private int _current;
+
+            public Enumerator(GlfwTriggerCollection col)
+            {
+                _col = col;
+                _current = 0;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (_current == _col._count)
+                {
+                    Current = default;
+                    return false;
+                }
+
+                Current = new Trigger(_current, Get(_col._floats, _current));
+                _current++;
+                return true;
             }
 
-            public bool MoveNext()
-            {
-                if (_current == _col._count)
-                {
-                    Current = default;
-                    return false;
-                }
-
-                Current = new Trigger(_current, Get(_col._floats, _current));
-                _current++;
-                return true;
-            }
-
-            public void Reset()
-            {
-                Current = default;
-                _current = 0;
-            }
-
-            public Trigger Current { get; set; }
-
-            object IEnumerator.Current => Current;
-
-            public void Dispose()
-            {
-            }
+            public void Reset()
+            {
+                Current = default;
+                _current = 0;
+            }
+
+            public Trigger Current { get; set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
         }
     }
 }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index 31a1581e28..42d0eb92ca 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -6,6 +6,8 @@
 using System;
 using System.Collections.Generic;
 using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
+using Ultz.Dispatcher.Unsafe;
 
 namespace Silk.NET.Input.Desktop
 {
@@ -22,9 +24,9 @@ public GlfwGamepad(int i)
         public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index) && Util.Glfw.JoystickIsGamepad(Index));
-        public IReadOnlyList<Button> Buttons { get; }
-        public IReadOnlyList<Thumbstick> Thumbsticks { get; }
-        public IReadOnlyList<Trigger> Triggers { get; }
+        public IReadOnlyList<Button> Buttons => GetButtons(Index);
+        public IReadOnlyList<Thumbstick> Thumbsticks => GetThumbsticks(Index);
+        public IReadOnlyList<Trigger> Triggers => GetTriggers(Index);
         public Deadzone Deadzone { get; set; }
         public event Action<IGamepad, Button> ButtonDown;
         public event Action<IGamepad, Button> ButtonUp;
@@ -66,5 +68,29 @@ public void Update()
                 }
             }
         }
+        private static unsafe IReadOnlyList<Button> GetButtons(int i)
+        {
+            var count = 0;
+            var bytes = Util.Do(() => (UnsafeDispatch<byte>)Util.Glfw.GetJoystickButtons(i, out count));
+            return new GlfwButtonCollection(bytes, count);
+        }
+        private static unsafe IReadOnlyList<Thumbstick> GetThumbsticks(int i)
+        {
+            var count = 0;
+            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            fixed(float* x = new float[] { floats[0], floats[2] }, y = new float[] { floats[1], floats[3] })
+            {
+                return new GlfwThumbstickCollection(x, y, count);
+            }
+        }
+        private static unsafe IReadOnlyList<Trigger> GetTriggers(int i)
+        {
+            var count = 0;
+            var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            fixed(float* triggers = new float[] { floats[4], floats[5] })
+            {
+                return new GlfwTriggerCollection(floats, count);
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 722c59864c..00c9aca3b8 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -25,9 +25,9 @@ public GlfwJoystick(int i)
         public string Name => Util.Do(() => Util.Glfw.GetJoystickName(Index));
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickPresent(Index) && !Util.Glfw.JoystickIsGamepad(Index));
-        public IReadOnlyList<Axis> Axes => GetAxes(Index, this);
-        public IReadOnlyList<Button> Buttons => GetButtons(Index, this);
-        public IReadOnlyList<Hat> Hats => GetHats(Index, this);
+        public IReadOnlyList<Axis> Axes => GetAxes(Index);
+        public IReadOnlyList<Button> Buttons => GetButtons(Index);
+        public IReadOnlyList<Hat> Hats => GetHats(Index);
         public Deadzone Deadzone { get; set; }
         public event Action<IJoystick, Button> ButtonDown;
         public event Action<IJoystick, Button> ButtonUp;
@@ -70,21 +70,21 @@ public void Update()
             }
         }
 
-        private static unsafe IReadOnlyList<Axis> GetAxes(int i, GlfwJoystick joystick)
+        private static unsafe IReadOnlyList<Axis> GetAxes(int i)
         {
             var count = 0;
             var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
-            return new GlfwAxisCollection(floats, count, joystick);
+            return new GlfwAxisCollection(floats, count);
         }
 
-        private static unsafe IReadOnlyList<Button> GetButtons(int i, GlfwJoystick joystick)
+        private static unsafe IReadOnlyList<Button> GetButtons(int i)
         {
             var count = 0;
             var bytes = Util.Do(() => (UnsafeDispatch<byte>)Util.Glfw.GetJoystickButtons(i, out count));
-            return new GlfwButtonCollection(bytes, count, joystick);
+            return new GlfwButtonCollection(bytes, count);
         }
 
-        private static unsafe IReadOnlyList<Hat> GetHats(int i, GlfwJoystick joystick)
+        private static unsafe IReadOnlyList<Hat> GetHats(int i)
         {
             var count = 0;
             var hats = Util.Do(() => (UnsafeDispatch<JoystickHats>)Util.Glfw.GetJoystickHats(i, out count));

From b4fe96187290dc664fd2f1f898974e547d4fecd6 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Wed, 31 Jul 2019 18:28:12 +0100
Subject: [PATCH 22/46] nitpick

---
 src/Input/Silk.NET.Input.Common/Thumbstick.cs | 76 +++++++++----------
 1 file changed, 38 insertions(+), 38 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Common/Thumbstick.cs b/src/Input/Silk.NET.Input.Common/Thumbstick.cs
index 36b03778cc..ccc9b8ea9d 100644
--- a/src/Input/Silk.NET.Input.Common/Thumbstick.cs
+++ b/src/Input/Silk.NET.Input.Common/Thumbstick.cs
@@ -1,20 +1,20 @@
-// This file is part of Silk.NET.
-// 
-// You may modify and distribute Silk.NET under the terms
-// of the MIT license. See the LICENSE file for details.
-
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
 using System;
 
-namespace Silk.NET.Input.Common
-{
-    /// <summary>
-    /// A thumbstick on an <see cref="IGamepad"/>
-    /// </summary>
-    public struct Thumbstick
-    {
-        /// <summary>
-        /// The index of this stick.
-        /// </summary>
+namespace Silk.NET.Input.Common
+{
+    /// <summary>
+    /// A thumbstick on an <see cref="IGamepad"/>
+    /// </summary>
+    public struct Thumbstick
+    {
+        /// <summary>
+        /// The index of this stick.
+        /// </summary>
         public int Index { get; }
 
         /// <summary>
@@ -25,29 +25,29 @@ public struct Thumbstick
         /// <summary>
         /// The y-axis of the stick, from -1.0 to 1.0
         /// </summary>
-        public float Y { get; }
-        
-        /// <summary>
-        /// The current position of the stick, from 0.0 to 1.0.
-        /// </summary>
-        public float Position { get { return (float)Math.Sqrt(X * X + Y *Y); } }
-        
-        /// <summary>
-        /// The current direction of the stick, from 0.0 to 360.0.
-        /// </summary>
-        public float Direction { get { return (float)Math.Atan2(Y, X); } }
-
-        /// <summary>
-        /// Creates a new instance of the Thumbstick struct.
-        /// </summary>
-        /// <param name="index">The index of the stick.</param>
-        /// <param name="position">The position of the stick.</param>
-        /// <param name="direction">The direction of the stick.</param>
-        public Thumbstick(int index, float x, float y)
-        {
+        public float Y { get; }
+        
+        /// <summary>
+        /// The current position of the stick, from 0.0 to 1.0.
+        /// </summary>
+        public float Position => (float)Math.Sqrt(X * X + Y * Y);
+
+        /// <summary>
+        /// The current direction of the stick, from 0.0 to 360.0.
+        /// </summary>
+        public float Direction => (float)Math.Atan2(Y, X);
+
+        /// <summary>
+        /// Creates a new instance of the Thumbstick struct.
+        /// </summary>
+        /// <param name="index">The index of the stick.</param>
+        /// <param name="position">The position of the stick.</param>
+        /// <param name="direction">The direction of the stick.</param>
+        public Thumbstick(int index, float x, float y)
+        {
             Index = index;
             X = x;
-            Y = y;
-        }
-    }
+            Y = y;
+        }
+    }
 }
\ No newline at end of file

From 652450edcd6a7c5c298ab278b9a05fb17d3e0d23 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Wed, 31 Jul 2019 20:29:48 +0100
Subject: [PATCH 23/46] update test program

---
 examples/InputTest/Program.cs | 167 +++++++++++++++++++++++++++++++---
 1 file changed, 155 insertions(+), 12 deletions(-)

diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
index beab9a1cc9..6fda6616e5 100644
--- a/examples/InputTest/Program.cs
+++ b/examples/InputTest/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using Silk.NET.Input;
 using Silk.NET.Input.Common;
@@ -20,33 +21,175 @@ private static void Main()
             Console.ReadLine();
             var input = window.GetInput();
             input.ConnectionChanged += ControllerConnected;
-            foreach (var inputGamepad in input.Gamepads)
+            Console.WriteLine("Now, go press buttons in the window and you'll see the feedback here.");
+            foreach (var gamepad in input.Gamepads)
             {
-                Console.WriteLine("Discovered controller " + inputGamepad.Index);
-                inputGamepad.ButtonDown += InputGamepadOnButtonDown;
-                inputGamepad.ButtonUp += InputGamepadOnButtonUp;
-                foreach (var inputGamepadButton in inputGamepad.Buttons)
-                {
-                    Console.WriteLine("Controller ");
-                }
+                ControllerConnected(gamepad, gamepad.IsConnected);
             }
+            
+            foreach (var joystick in input.Joysticks)
+            {
+                ControllerConnected(joystick, joystick.IsConnected);
+            }
+
+            foreach (var keyboard in input.Keyboards)
+            {
+                ControllerConnected(keyboard, keyboard.IsConnected);
+            }
+
+            Console.ReadLine();
+        }
+
+        private static void GamepadOnTriggerMoved(IGamepad g, Trigger t)
+        {
+            Console.WriteLine("G" + g.Index + "> " + t.Index + " trigger moved: " + t.Position);
+        }
+
+        private static void GamepadOnThumbstickMoved(IGamepad g, Thumbstick t)
+        {
+            Console.WriteLine("G" + g.Index + "> " + t.Index + " thumbstick moved: (" + t.X + ", " + t.Y + ")");
+        }
+
+        private static void JoystickOnHatMoved(IJoystick arg1, Hat arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Index + " hat moved: " + arg2.Position);
+        }
+
+        private static void JoystickOnAxisMoved(IJoystick arg1, Axis arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Index + " axis moved: " + arg2.Position);
+        }
+
+        private static void JoystickOnButtonUp(IJoystick arg1, Button arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Name + " down.");
+        }
+
+        private static void JoystickOnButtonDown(IJoystick arg1, Button arg2)
+        {
+            Console.WriteLine("J" + arg1.Index + "> " + arg2.Name + " down.");
         }
 
         private static void InputGamepadOnButtonDown(IGamepad arg1, Button arg2)
         {
-            Console.WriteLine(arg1.Index + "> " + arg2.Name + " down.");
+            Console.WriteLine("G" + arg1.Index + "> " + arg2.Name + " down.");
         }
 
         private static void InputGamepadOnButtonUp(IGamepad arg1, Button arg2)
         {
-            Console.WriteLine(arg1.Index + "> " + arg2.Name + " up.");
+            Console.WriteLine("G" + arg1.Index + "> " + arg2.Name + " up.");
         }
 
         public static void ControllerConnected(IInputDevice device, bool isConnected)
         {
             Console.WriteLine(isConnected
-                ? $"Controller {device.Name} connected"
-                : $"Controller {device.Name} disconnected");
+                ? $"Device {device.Name} connected"
+                : $"Device {device.Name} disconnected");
+            if (device is IGamepad gamepad)
+            {
+                Console.WriteLine("Discovered controller " + gamepad.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    gamepad.ButtonDown += InputGamepadOnButtonDown;
+                    gamepad.ButtonUp += InputGamepadOnButtonUp;
+                    gamepad.ThumbstickMoved += GamepadOnThumbstickMoved;
+                    gamepad.TriggerMoved += GamepadOnTriggerMoved;
+                }
+                else
+                {
+                    gamepad.ButtonDown -= InputGamepadOnButtonDown;
+                    gamepad.ButtonUp -= InputGamepadOnButtonUp;
+                    gamepad.ThumbstickMoved -= GamepadOnThumbstickMoved;
+                    gamepad.TriggerMoved -= GamepadOnTriggerMoved;
+                }
+
+                Console.Write("    Buttons: ");
+                const string s = "\n             ";
+                Console.WriteLine(string.Join(s, gamepad.Buttons.Select(x => x.Name + (x.Pressed ? "(1)" : "(0)"))));
+                Console.WriteLine("    " + gamepad.Thumbsticks.Count + " thumbsticks found.");
+                Console.WriteLine("    " + gamepad.Triggers.Count + " triggers found.");
+            }
+            else if (device is IJoystick joystick)
+            {
+                Console.WriteLine("Discovered joystick " + joystick.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    joystick.ButtonDown += JoystickOnButtonDown;
+                    joystick.ButtonUp += JoystickOnButtonUp;
+                    joystick.AxisMoved += JoystickOnAxisMoved;
+                    joystick.HatMoved += JoystickOnHatMoved;
+                }
+                else
+                {
+                    joystick.ButtonDown -= JoystickOnButtonDown;
+                    joystick.ButtonUp -= JoystickOnButtonUp;
+                    joystick.AxisMoved -= JoystickOnAxisMoved;
+                    joystick.HatMoved -= JoystickOnHatMoved;
+                }
+
+                Console.Write("    Buttons: ");
+                const string s = "\n             ";
+                Console.WriteLine(string.Join(s, joystick.Buttons.Select(x => x.Name + (x.Pressed ? "(1)" : "(0)"))));
+            }
+            else if (device is IKeyboard keyboard)
+            {
+                Console.WriteLine("Discovered keyboard " + keyboard.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    keyboard.KeyDown += KeyboardOnKeyDown;
+                    keyboard.KeyUp += KeyboardOnKeyUp;
+                }
+                else
+                {
+                    keyboard.KeyDown -= KeyboardOnKeyDown;
+                    keyboard.KeyUp -= KeyboardOnKeyUp;
+                }
+
+                Console.Write("    Buttons: ");
+                Console.WriteLine(string.Join(", ", keyboard.SupportedKeys.Select(x => x)));
+            }
+            else if (device is IMouse mouse)
+            {
+                Console.WriteLine("Discovered mouse " + mouse.Index + " (Connected: " + isConnected + ")");
+                if (isConnected)
+                {
+                    mouse.MouseUp += MouseOnMouseUp;
+                    mouse.MouseDown += MouseOnMouseDown;
+                    mouse.Scroll += MouseOnScroll;
+                }
+                else
+                {
+                }
+
+                Console.Write("    Buttons: ");
+                Console.WriteLine(string.Join(", ", mouse.SupportedButtons.Select(x => x)));
+                Console.WriteLine("    " + mouse.ScrollWheels.Count + " scroll wheels.");
+            }
+        }
+
+        private static void MouseOnScroll(IMouse arg1, ScrollWheel arg2)
+        {
+            Console.WriteLine("K" + arg1.Index + "> Scrolled: (" + arg2.X + ", " + arg2.Y + ")");
+        }
+
+        private static void MouseOnMouseDown(IMouse arg1, MouseButton arg2)
+        {
+            Console.WriteLine("M" + arg1.Index + "> " + arg2 + " down.");
+        }
+
+        private static void MouseOnMouseUp(IMouse arg1, MouseButton arg2)
+        {
+            Console.WriteLine("M" + arg1.Index + "> " + arg2 + " up.");
+        }
+
+        private static void KeyboardOnKeyUp(IKeyboard arg1, Key arg2)
+        {
+            Console.WriteLine("K" + arg1.Index + "> " + arg2 + " up.");
+        }
+
+        private static void KeyboardOnKeyDown(IKeyboard arg1, Key arg2)
+        {
+            Console.WriteLine("K" + arg1.Index + "> " + arg2 + " down.");
         }
     }
 }
\ No newline at end of file

From f8bef17b36807da81b36a7a8f051a7e54d2c1c00 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Wed, 31 Jul 2019 22:05:16 +0100
Subject: [PATCH 24/46] Update dispatcher

---
 .../Silk.NET.Windowing.Desktop.csproj                           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj b/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj
index e1d1d19f28..5eaadaf854 100644
--- a/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj
+++ b/src/Windowing/Silk.NET.Windowing.Desktop/Silk.NET.Windowing.Desktop.csproj
@@ -11,7 +11,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="Ultz.Dispatcher" Version="1.1.0" />
+      <PackageReference Include="Ultz.Dispatcher" Version="2.0.0" />
     </ItemGroup>
 
     <Import Project="..\..\..\build\props\common.props" />

From 436c4f10535c5109f1e0f01bbcd5b0ff6f7e6ae1 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 00:21:45 +0100
Subject: [PATCH 25/46] Only show window when running

---
 .../Silk.NET.Windowing.Desktop/GlfwWindow.cs  | 436 +++++++++++-------
 1 file changed, 261 insertions(+), 175 deletions(-)

diff --git a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
index 4b833767c5..caca0eb34b 100644
--- a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
+++ b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
@@ -47,7 +47,7 @@ public class GlfwWindow : IWindow
         private GlfwCallbacks.WindowSizeCallback onResize;
 
         // Main loop-related things
-        
+
         // The stopwatches. Used to calculate delta.
         private Stopwatch renderStopwatch;
         private Stopwatch updateStopwatch;
@@ -55,95 +55,38 @@ public class GlfwWindow : IWindow
         // Invoke method variables
         private ConcurrentQueue<Task> InvokeQueue;
         private int MainThread = -1;
-        
+
         // Update and render period. Represents the time in seconds that each frame should take.
         private double updatePeriod;
         private double renderPeriod;
 
+        private WindowOptions initialOptions;
+        private bool running;
+
         /// <summary>
         /// Create and open a new GlfwWindow.
         /// </summary>
         /// <param name="options">The options to use for this window.</param>
         public GlfwWindow(WindowOptions options)
         {
-            unsafe {
+            unsafe
+            {
                 // Title and Size must be set before the window is created.
                 _title = options.Title;
                 _size = options.Size;
 
                 _windowBorder = WindowBorder;
 
-                glfwThread.Invoke(() =>
-                {
-                    // Set window border.
-                    switch (options.WindowBorder) {
-                        case WindowBorder.Hidden:
-                            glfw.WindowHint(WindowHintBool.Decorated, false);
-                            glfw.WindowHint(WindowHintBool.Resizable, false);
-                            break;
-
-                        case WindowBorder.Resizable:
-                            glfw.WindowHint(WindowHintBool.Decorated, true);
-                            glfw.WindowHint(WindowHintBool.Resizable, true);
-                            break;
-
-                        case WindowBorder.Fixed:
-                            glfw.WindowHint(WindowHintBool.Decorated, true);
-                            glfw.WindowHint(WindowHintBool.Resizable, false);
-                            break;
-                    }
-
-                    // Set window API.
-                    switch (options.API.API) {
-                        case ContextAPI.None:
-                        case ContextAPI.Vulkan:
-                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.NoApi);
-                            break;
-                        case ContextAPI.OpenGL:
-                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGL);
-                            break;
-                        case ContextAPI.OpenGLES:
-                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGLES);
-                            break;
-                    }
-
-                    // Set API version.
-                    glfw.WindowHint(WindowHintInt.ContextVersionMajor, options.API.Version.MajorVersion);
-                    glfw.WindowHint(WindowHintInt.ContextVersionMinor, options.API.Version.MinorVersion);
-
-                    // Set API flags
-                    if (options.API.Flags.HasFlag(ContextFlags.ForwardCompatible)) {
-                        glfw.WindowHint(WindowHintBool.OpenGLForwardCompat, true);
-                    }
-
-                    if (options.API.Flags.HasFlag(ContextFlags.Debug)) {
-                        glfw.WindowHint(WindowHintBool.OpenGLDebugContext, true);
-                    }
-
-                    // Set API profile
-                    glfw.WindowHint(WindowHintOpenGlProfile.OpenGlProfile,
-                        options.API.Profile == ContextProfile.Core ? OpenGlProfile.Core : OpenGlProfile.Compat);
-
-                    // Create window
-                    WindowPtr = glfw.CreateWindow(_size.Width, _size.Height, _title, null, null);
-                });
-            
-                InvokeQueue = new ConcurrentQueue<Task>();
-                MainThread = Thread.CurrentThread.ManagedThreadId;
-
-                glfw.MakeContextCurrent(WindowPtr);
-
                 FramesPerSecond = options.FramesPerSecond;
                 UpdatesPerSecond = options.UpdatesPerSecond;
 
-                WindowState = options.WindowState;
-                Position = options.Position;
-                VSync = options.VSync;
                 RunningSlowTolerance = options.RunningSlowTolerance;
                 UseSingleThreadedWindow = options.UseSingleThreadedWindow;
+
+                initialOptions = options;
             }
         }
-        
+
         /// <inheritdoc />
         public int RunningSlowTolerance { get; set; }
 
@@ -155,23 +98,31 @@ public bool IsVisible
         {
             get
             {
-                unsafe {
+                unsafe
+                {
                     return glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Visible);
                 }
             }
             set
             {
-                glfwThread.Invoke(() =>
-                {
-                    unsafe {
-                        if (value) {
-                            glfw.ShowWindow(WindowPtr);
-                        }
-                        else {
-                            glfw.HideWindow(WindowPtr);
+                glfwThread.Invoke
+                (
+                    () =>
+                    {
+                        Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
+                        unsafe
+                        {
+                            if (value)
+                            {
+                                glfw.ShowWindow(WindowPtr);
+                            }
+                            else
+                            {
+                                glfw.HideWindow(WindowPtr);
+                            }
                         }
                     }
-                });
+                );
             }
         }
 
@@ -180,7 +131,8 @@ public IntPtr Handle
         {
             get
             {
-                unsafe {
+                unsafe
+                {
                     return (IntPtr) WindowPtr;
                 }
             }
@@ -195,12 +147,16 @@ public Point Position
             get => _position;
             set
             {
-                glfwThread.Invoke(() =>
-                {
-                    unsafe {
-                        glfw.SetWindowPos(WindowPtr, value.X, value.Y);
+                glfwThread.Invoke
+                (
+                    () =>
+                    {
+                        unsafe
+                        {
+                            glfw.SetWindowPos(WindowPtr, value.X, value.Y);
+                        }
                     }
-                });
+                );
 
                 _position = value;
             }
@@ -212,12 +168,16 @@ public Size Size
             get => _size;
             set
             {
-                glfwThread.Invoke(() =>
-                {
-                    unsafe {
-                        glfw.SetWindowSize(WindowPtr, value.Width, value.Height);
+                glfwThread.Invoke
+                (
+                    () =>
+                    {
+                        unsafe
+                        {
+                            glfw.SetWindowSize(WindowPtr, value.Width, value.Height);
+                        }
                     }
-                });
+                );
 
                 _size = value;
             }
@@ -229,11 +189,12 @@ public double FramesPerSecond
             get => 1.0 / renderPeriod;
             set
             {
-                if (value <= double.Epsilon) {
+                if (value <= double.Epsilon)
+                {
                     renderPeriod = 0.0;
                     return;
                 }
-                
+
                 renderPeriod = 1.0 / value;
             }
         }
@@ -244,10 +205,12 @@ public double UpdatesPerSecond
             get => 1.0 / updatePeriod;
             set
             {
-                if (value <= double.Epsilon) {
+                if (value <= double.Epsilon)
+                {
                     updatePeriod = 0.0;
                     return;
                 }
+
                 updatePeriod = 1.0 / value;
             }
         }
@@ -261,12 +224,16 @@ public string Title
             get => _title;
             set
             {
-                glfwThread.Invoke(() =>
-                {
-                    unsafe {
-                        glfw.SetWindowTitle(WindowPtr, value);
+                glfwThread.Invoke
+                (
+                    () =>
+                    {
+                        unsafe
+                        {
+                            glfw.SetWindowTitle(WindowPtr, value);
+                        }
                     }
-                });
+                );
 
                 _title = value;
             }
@@ -278,28 +245,36 @@ public WindowState WindowState
             get => _windowState;
             set
             {
-                glfwThread.Invoke(() =>
-                {
-                    unsafe {
-                        switch (value) {
-                            case WindowState.Normal:
-                                glfw.RestoreWindow(WindowPtr);
-                                break;
-                            case WindowState.Minimized:
-                                glfw.IconifyWindow(WindowPtr);
-                                break;
-                            case WindowState.Maximized:
-                                glfw.MaximizeWindow(WindowPtr);
-                                break;
-                            case WindowState.Fullscreen:
-                                var monitor = glfw.GetPrimaryMonitor();
-                                var mode = glfw.GetVideoMode(monitor);
-                                glfw.SetWindowMonitor(WindowPtr, monitor, 0, 0, mode->Width, mode->Height,
-                                    mode->RefreshRate);
-                                break;
+                glfwThread.Invoke
+                (
+                    () =>
+                    {
+                        unsafe
+                        {
+                            switch (value)
+                            {
+                                case WindowState.Normal:
+                                    glfw.RestoreWindow(WindowPtr);
+                                    break;
+                                case WindowState.Minimized:
+                                    glfw.IconifyWindow(WindowPtr);
+                                    break;
+                                case WindowState.Maximized:
+                                    glfw.MaximizeWindow(WindowPtr);
+                                    break;
+                                case WindowState.Fullscreen:
+                                    var monitor = glfw.GetPrimaryMonitor();
+                                    var mode = glfw.GetVideoMode(monitor);
+                                    glfw.SetWindowMonitor
+                                    (
+                                        WindowPtr, monitor, 0, 0, mode->Width, mode->Height,
+                                        mode->RefreshRate
+                                    );
+                                    break;
+                            }
                         }
                     }
-                });
+                );
 
                 _windowState = value;
             }
@@ -310,28 +285,33 @@ public WindowBorder WindowBorder
         {
             get => _windowBorder;
             set
-            {   
-                glfwThread.Invoke(() =>
-                {
-                    unsafe {
-                        switch (value) {
-                            case WindowBorder.Hidden:
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, false);
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
-                                break;
-
-                            case WindowBorder.Resizable:
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, true);
-                                break;
-
-                            case WindowBorder.Fixed:
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
-                                glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
-                                break;
+            {
+                glfwThread.Invoke
+                (
+                    () =>
+                    {
+                        unsafe
+                        {
+                            switch (value)
+                            {
+                                case WindowBorder.Hidden:
+                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, false);
+                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
+                                    break;
+
+                                case WindowBorder.Resizable:
+                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
+                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, true);
+                                    break;
+
+                                case WindowBorder.Fixed:
+                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
+                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
+                                    break;
+                            }
                         }
                     }
-                });
+                );
 
                 _windowBorder = value;
             }
@@ -377,11 +357,16 @@ public object Invoke(Delegate d)
         /// <inheritdoc />
         public object Invoke(Delegate d, params object[] args)
         {
-            if (UseSingleThreadedWindow || Thread.CurrentThread.ManagedThreadId == MainThread)
+            if (!running)
             {
-                return d.DynamicInvoke(args);
+                throw new InvalidOperationException("The window must be running to be able to invoke it.");
             }
             
+            if (Thread.CurrentThread.ManagedThreadId == MainThread)
+            {
+                return d.DynamicInvoke(args);
+            }
+
             var task = new Task<object>(() => d.DynamicInvoke(args));
             InvokeQueue.Enqueue(task);
             SpinWait.SpinUntil(() => task.IsCompleted);
@@ -391,6 +376,79 @@ public object Invoke(Delegate d, params object[] args)
         /// <inheritdoc />
         public unsafe void Run()
         {
+            running = true;
+            glfwThread.Invoke
+            (
+                () =>
+                {
+                    // Set window border.
+                    switch (initialOptions.WindowBorder)
+                    {
+                        case WindowBorder.Hidden:
+                            glfw.WindowHint(WindowHintBool.Decorated, false);
+                            glfw.WindowHint(WindowHintBool.Resizable, false);
+                            break;
+
+                        case WindowBorder.Resizable:
+                            glfw.WindowHint(WindowHintBool.Decorated, true);
+                            glfw.WindowHint(WindowHintBool.Resizable, true);
+                            break;
+
+                        case WindowBorder.Fixed:
+                            glfw.WindowHint(WindowHintBool.Decorated, true);
+                            glfw.WindowHint(WindowHintBool.Resizable, false);
+                            break;
+                    }
+
+                    // Set window API.
+                    switch (initialOptions.API.API)
+                    {
+                        case ContextAPI.None:
+                        case ContextAPI.Vulkan:
+                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.NoApi);
+                            break;
+                        case ContextAPI.OpenGL:
+                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGL);
+                            break;
+                        case ContextAPI.OpenGLES:
+                            glfw.WindowHint(WindowHintClientApi.ClientApi, ClientApi.OpenGLES);
+                            break;
+                    }
+
+                    // Set API version.
+                    glfw.WindowHint(WindowHintInt.ContextVersionMajor, initialOptions.API.Version.MajorVersion);
+                    glfw.WindowHint(WindowHintInt.ContextVersionMinor, initialOptions.API.Version.MinorVersion);
+
+                    // Set API flags
+                    if (initialOptions.API.Flags.HasFlag(ContextFlags.ForwardCompatible))
+                    {
+                        glfw.WindowHint(WindowHintBool.OpenGLForwardCompat, true);
+                    }
+
+                    if (initialOptions.API.Flags.HasFlag(ContextFlags.Debug))
+                    {
+                        glfw.WindowHint(WindowHintBool.OpenGLDebugContext, true);
+                    }
+
+                    // Set API profile
+                    glfw.WindowHint
+                    (
+                        WindowHintOpenGlProfile.OpenGlProfile,
+                        initialOptions.API.Profile == ContextProfile.Core ? OpenGlProfile.Core : OpenGlProfile.Compat
+                    );
+
+                    // Create window
+                    WindowPtr = glfw.CreateWindow(_size.Width, _size.Height, _title, null, null);
+                }
+            );
+
+            InvokeQueue = new ConcurrentQueue<Task>();
+            MainThread = Thread.CurrentThread.ManagedThreadId;
+
+            glfw.MakeContextCurrent(WindowPtr);
+            WindowState = initialOptions.WindowState;
+            Position = initialOptions.Position;
+            VSync = initialOptions.VSync;
             if (glfw.GetCurrentContext() != WindowPtr)
             {
                 glfw.MakeContextCurrent(WindowPtr);
@@ -403,10 +461,10 @@ public unsafe void Run()
 
             // Initialize some variables
             _isRunningSlowlyTries = 0;
-            
+
             renderStopwatch = new Stopwatch();
             updateStopwatch = new Stopwatch();
-            
+
             MainThread = Thread.CurrentThread.ManagedThreadId;
 
             // Start the update loop.
@@ -414,11 +472,13 @@ public unsafe void Run()
             {
                 ProcessEvents();
 
-                if (UseSingleThreadedWindow) {
+                if (UseSingleThreadedWindow)
+                {
                     RaiseUpdateFrame();
                     RaiseRenderFrame();
                 }
-                else {
+                else
+                {
                     // Raise UpdateFrame, but don't await it yet.
                     var task = Task.Run(RaiseUpdateFrame);
 
@@ -435,16 +495,20 @@ public unsafe void Run()
                     RaiseRenderFrame();
                 }
 
-                if (VSync == VSyncMode.Adaptive) {
+                if (VSync == VSyncMode.Adaptive)
+                {
                     glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
                 }
             }
+
+            running = false;
         }
 
         /// <inheritdoc />
         public void Close()
         {
-            unsafe {
+            unsafe
+            {
                 glfw.SetWindowShouldClose(WindowPtr, true);
             }
         }
@@ -458,7 +522,8 @@ public void ProcessEvents()
         /// <inheritdoc />
         public void SwapBuffers()
         {
-            unsafe {
+            unsafe
+            {
                 glfw.SwapBuffers(WindowPtr);
             }
         }
@@ -512,16 +577,19 @@ private void RaiseUpdateFrame()
             // 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)) {
+                && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly))
+            {
                 // Calculate the amount of time to sleep.
                 var sleepTime = updatePeriod - updateStopwatch.Elapsed.TotalSeconds;
 
                 // If the result is negative, that means the frame is running slowly. Mark as such and don't sleep.
-                if (sleepTime < 0.0) {
+                if (sleepTime < 0.0)
+                {
                     _isRunningSlowlyTries += 1;
                 }
                 // Else, sleep for that amount of time.
-                else {
+                else
+                {
                     _isRunningSlowlyTries = 0;
                     Thread.Sleep((int) (1000 * sleepTime));
                 }
@@ -540,10 +608,12 @@ private void RaiseRenderFrame()
         {
             // Identical to RaiseUpdateFrame.
             if (FramesPerSecond > double.Epsilon
-                && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly)) {
+                && (VSync == VSyncMode.Off || VSync == VSyncMode.Adaptive && IsRunningSlowly))
+            {
                 var sleepTime = renderPeriod - renderStopwatch.Elapsed.TotalSeconds;
 
-                if (sleepTime > 0.0) {
+                if (sleepTime > 0.0)
+                {
                     Thread.Sleep((int) (1000 * sleepTime));
                 }
             }
@@ -551,9 +621,10 @@ private void RaiseRenderFrame()
             var delta = renderStopwatch.Elapsed.TotalSeconds;
             OnRender?.Invoke(delta);
             renderStopwatch.Restart();
-            
+
             // This has to be called on the thread with the graphics context
-            if (VSync == VSyncMode.Adaptive) {
+            if (VSync == VSyncMode.Adaptive)
+            {
                 glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
             }
         }
@@ -585,18 +656,23 @@ private unsafe void InitializeCallbacks()
             {
                 WindowState state;
                 // If minimized, we immediately know what value the new WindowState is.
-                if (isMinimized) {
+                if (isMinimized)
+                {
                     state = WindowState.Minimized;
                 }
-                else {
+                else
+                {
                     // Otherwise, we have to querry a few things to figure out out.
-                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Maximized)) {
+                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Maximized))
+                    {
                         state = WindowState.Maximized;
                     }
-                    else if (glfw.GetWindowMonitor(WindowPtr) != null) {
+                    else if (glfw.GetWindowMonitor(WindowPtr) != null)
+                    {
                         state = WindowState.Fullscreen;
                     }
-                    else {
+                    else
+                    {
                         state = WindowState.Normal;
                     }
                 }
@@ -609,17 +685,22 @@ private unsafe void InitializeCallbacks()
             {
                 // Same here as in onMinimized.
                 WindowState state;
-                if (isMaximized) {
+                if (isMaximized)
+                {
                     state = WindowState.Maximized;
                 }
-                else {
-                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Iconified)) {
+                else
+                {
+                    if (glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Iconified))
+                    {
                         state = WindowState.Minimized;
                     }
-                    else if (glfw.GetWindowMonitor(WindowPtr) != null) {
+                    else if (glfw.GetWindowMonitor(WindowPtr) != null)
+                    {
                         state = WindowState.Fullscreen;
                     }
-                    else {
+                    else
+                    {
                         state = WindowState.Normal;
                     }
                 }
@@ -632,11 +713,13 @@ private unsafe void InitializeCallbacks()
             {
                 var arrayOfPaths = new string[count];
 
-                if (count == 0 || paths == IntPtr.Zero) {
+                if (count == 0 || paths == IntPtr.Zero)
+                {
                     return;
                 }
 
-                for (var i = 0; i < count; i++) {
+                for (var i = 0; i < count; i++)
+                {
                     var p = Marshal.ReadIntPtr(paths, i * IntPtr.Size);
                     arrayOfPaths[i] = Marshal.PtrToStringAnsi(p);
                 }
@@ -644,16 +727,19 @@ private unsafe void InitializeCallbacks()
                 OnFileDrop?.Invoke(arrayOfPaths);
             };
 
-            glfwThread.Invoke(() =>
-            {
-                glfw.SetWindowPosCallback(WindowPtr, onMove);
-                glfw.SetWindowSizeCallback(WindowPtr, onResize);
-                glfw.SetWindowCloseCallback(WindowPtr, onClosing);
-                glfw.SetWindowFocusCallback(WindowPtr, onFocusChanged);
-                glfw.SetWindowIconifyCallback(WindowPtr, onMinimized);
-                glfw.SetWindowMaximizeCallback(WindowPtr, onMaximized);
-                glfw.SetDropCallback(WindowPtr, onFileDrop);
-            });
+            glfwThread.Invoke
+            (
+                () =>
+                {
+                    glfw.SetWindowPosCallback(WindowPtr, onMove);
+                    glfw.SetWindowSizeCallback(WindowPtr, onResize);
+                    glfw.SetWindowCloseCallback(WindowPtr, onClosing);
+                    glfw.SetWindowFocusCallback(WindowPtr, onFocusChanged);
+                    glfw.SetWindowIconifyCallback(WindowPtr, onMinimized);
+                    glfw.SetWindowMaximizeCallback(WindowPtr, onMaximized);
+                    glfw.SetDropCallback(WindowPtr, onFileDrop);
+                }
+            );
         }
     }
-}
\ No newline at end of file
+}

From f130cda01fc0e870bbab1ec2f88994e0773333a5 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 00:22:04 +0100
Subject: [PATCH 26/46] Fix context not being passed to enumerator

---
 .../Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs | 2 +-
 .../Collections/GlfwJoystickCollection.cs                       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
index 07e63f2f54..db6b659c74 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
@@ -28,7 +28,7 @@ IEnumerator<IGamepad> IEnumerable<IGamepad>.GetEnumerator()
         }
         public IEnumerator<IGamepad> GetEnumerator()
         {
-            return new Enumerator();
+            return new Enumerator(_ctx);
         }
 
         public int Count { get; }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
index 1266ae2d94..e2ba5d0ef6 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
@@ -28,7 +28,7 @@ IEnumerator<IJoystick> IEnumerable<IJoystick>.GetEnumerator()
         }
         public IEnumerator<IJoystick> GetEnumerator()
         {
-            return new Enumerator();
+            return new Enumerator(_glfwInputContext);
         }
 
         public int Count

From 2ceb2f2fcc93f656df876de87507c91b3789705d Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 13:57:02 +0100
Subject: [PATCH 27/46] Fix a marshalling bug

---
 .../Collections/GlfwButtonCollection.cs                     | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
index 2c1c5ae675..5ec643c715 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -36,11 +36,7 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public static byte Get(byte* bytes, int index)
         {
-            return (byte)Marshal.PtrToStructure
-            (
-                Marshal.ReadIntPtr((IntPtr)bytes, index * IntPtr.Size),
-                typeof(byte)
-            );
+            return Marshal.ReadByte((IntPtr) bytes, index);
         }
         private struct Enumerator : IEnumerator<Button>
         {

From 013f4105cd070acf4f67500a2cabb43284355b00 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 17:16:31 +0100
Subject: [PATCH 28/46] Apply deadzone

---
 .../Implementations/GlfwGamepad.cs            | 22 +++++++++----------
 .../Implementations/GlfwJoystick.cs           |  2 +-
 src/Input/Silk.NET.Input.Desktop/Util.cs      | 10 +++++++++
 3 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index 42d0eb92ca..b34c381a2c 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -24,9 +24,9 @@ public GlfwGamepad(int i)
         public string Name => Util.Do(() => Util.Glfw.GetGamepadName(Index));
         public int Index { get; }
         public bool IsConnected => Util.Do(() => Util.Glfw.JoystickIsGamepad(Index) && Util.Glfw.JoystickIsGamepad(Index));
-        public IReadOnlyList<Button> Buttons => GetButtons(Index);
-        public IReadOnlyList<Thumbstick> Thumbsticks => GetThumbsticks(Index);
-        public IReadOnlyList<Trigger> Triggers => GetTriggers(Index);
+        public IReadOnlyList<Button> Buttons => IsConnected ? GetButtons(Index) : null;
+        public IReadOnlyList<Thumbstick> Thumbsticks => IsConnected ? GetThumbsticks(Index) : null;
+        public IReadOnlyList<Trigger> Triggers => IsConnected ? GetTriggers(Index) : null;
         public Deadzone Deadzone { get; set; }
         public event Action<IGamepad, Button> ButtonDown;
         public event Action<IGamepad, Button> ButtonUp;
@@ -40,8 +40,8 @@ public void Update()
                 return;
             }
 
-            IReadOnlyList<Button> buttons = Buttons;
-            for (int i = 0; i < buttons.Count; i++)
+            var buttons = Buttons;
+            for (var i = 0; i < buttons.Count; i++)
             {
                 if (!buttons[i].Equals(_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]))
                 {
@@ -49,17 +49,17 @@ public void Update()
                     (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
                 }
             }
-            IReadOnlyList<Thumbstick> thumbsticks = Thumbsticks;
-            for (int i = 0; i < thumbsticks.Count; i++)
+            var thumbsticks = Thumbsticks;
+            for (var i = 0; i < thumbsticks.Count; i++)
             {
                 if (!thumbsticks[i].Equals(_cachedThumbsticks.Count > i ? _cachedThumbsticks[i] : thumbsticks[i]))
                 {
                     _cachedThumbsticks[i] = thumbsticks[i];
-                    ThumbstickMoved?.Invoke(this, thumbsticks[i]);
+                    ThumbstickMoved?.Invoke(this, Util.ApplyDeadzone(thumbsticks[i], Deadzone));
                 }
             }
-            IReadOnlyList<Trigger> triggers = Triggers;
-            for (int i = 0; i < triggers.Count; i++)
+            var triggers = Triggers;
+            for (var i = 0; i < triggers.Count; i++)
             {
                 if (!triggers[i].Equals(_cachedTriggers.Count > i ? _cachedTriggers[i] : triggers[i]))
                 {
@@ -78,7 +78,7 @@ private static unsafe IReadOnlyList<Thumbstick> GetThumbsticks(int i)
         {
             var count = 0;
             var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
-            fixed(float* x = new float[] { floats[0], floats[2] }, y = new float[] { floats[1], floats[3] })
+            fixed(float* x = new[] { floats[0], floats[2] }, y = new[] { floats[1], floats[3] })
             {
                 return new GlfwThumbstickCollection(x, y, count);
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 00c9aca3b8..708469ba38 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -47,7 +47,7 @@ public void Update()
                 if (!axes[i].Equals(_cachedAxes.Count > i ? _cachedAxes[i] : axes[i]))
                 {
                     _cachedAxes[i] = axes[i];
-                    AxisMoved?.Invoke(this, axes[i]);
+                    AxisMoved?.Invoke(this, Util.ApplyDeadzone(axes[i], Deadzone));
                 }
             }
             var buttons = Buttons;
diff --git a/src/Input/Silk.NET.Input.Desktop/Util.cs b/src/Input/Silk.NET.Input.Desktop/Util.cs
index 033f39e677..93996afdaf 100644
--- a/src/Input/Silk.NET.Input.Desktop/Util.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Util.cs
@@ -75,5 +75,15 @@ public static MouseButton GlfwButtonToSilkButton(GLFW.MouseButton k)
             }
             throw new ArgumentOutOfRangeException(nameof(k));
         }
+
+        public static Thumbstick ApplyDeadzone(Thumbstick thumbstick, Deadzone deadzone)
+        {
+            return new Thumbstick(thumbstick.Index, deadzone.Apply(thumbstick.X), deadzone.Apply(thumbstick.Y));
+        }
+
+        public static Axis ApplyDeadzone(Axis axis, Deadzone deadzone)
+        {
+            return new Axis(axis.Index, deadzone.Apply(axis.Position));
+        }
     }
 }

From 1658f44035c5ad2b001b4df547d99060675bc203 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 17:16:56 +0100
Subject: [PATCH 29/46] Enumerate over the disconnected joysticks too.

---
 .../Collections/GlfwGamepadCollection.cs      | 50 +--------------
 .../Collections/GlfwJoystickCollection.cs     | 64 +------------------
 2 files changed, 4 insertions(+), 110 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
index db6b659c74..b7270b5b10 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwGamepadCollection.cs
@@ -28,56 +28,10 @@ IEnumerator<IGamepad> IEnumerable<IGamepad>.GetEnumerator()
         }
         public IEnumerator<IGamepad> GetEnumerator()
         {
-            return new Enumerator(_ctx);
+            return _ctx._gamepads.GetEnumerator();
         }
 
-        public int Count { get; }
-        
-        public struct Enumerator : IEnumerator<IGamepad>, IEnumerator
-        {
-            private int _current;
-            private GlfwInputContext _c;
-
-            public Enumerator(GlfwInputContext c)
-            {
-                _c = c;
-                _current = 0;
-                Current = null;
-            }
-            
-            public bool MoveNext()
-            {
-                if (_current == 16)
-                {
-                    return false;
-                }
-
-                for (; _current < 16; _current++)
-                {
-                    if (_c._gamepads[_current].IsConnected)
-                    {
-                        Current = _c._gamepads[_current];
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            public void Reset()
-            {
-                Current = null;
-                _current = 0;
-            }
-
-            public IGamepad Current { get; private set; }
-
-            object IEnumerator.Current => Current;
-
-            public void Dispose()
-            {
-            }
-        }
+        public int Count => 16;
 
         public IGamepad this[int i] => _ctx._gamepads[i];
     }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
index e2ba5d0ef6..95936f1807 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwJoystickCollection.cs
@@ -28,70 +28,10 @@ IEnumerator<IJoystick> IEnumerable<IJoystick>.GetEnumerator()
         }
         public IEnumerator<IJoystick> GetEnumerator()
         {
-            return new Enumerator(_glfwInputContext);
+            return _glfwInputContext._joysticks.GetEnumerator();
         }
 
-        public int Count
-        {
-            get
-            {
-                var c = 0;
-                foreach (var j in this)
-                {
-                    if (j.IsConnected)
-                    {
-                        c++;
-                    }
-                }
-
-                return c;
-            }
-        }
-        
-        public struct Enumerator : IEnumerator<IJoystick>
-        {
-            private int _current;
-            private GlfwInputContext _ctx;
-
-            public Enumerator(GlfwInputContext ctx)
-            {
-                _ctx = ctx;
-                _current = 0;
-                Current = null;
-            }
-            public bool MoveNext()
-            {
-                if (_current == 16)
-                {
-                    return false;
-                }
-
-                for (; _current < 16; _current++)
-                {
-                    if (_ctx._joysticks[_current].IsConnected)
-                    {
-                        Current = _ctx._joysticks[_current];
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            public void Reset()
-            {
-                Current = null;
-                _current = 0;
-            }
-
-            public IJoystick Current { get; private set; }
-
-            object IEnumerator.Current => Current;
-
-            public void Dispose()
-            {
-            }
-        }
+        public int Count => 16;
 
         public IJoystick this[int index] => _glfwInputContext._joysticks[index];
     }

From 8083807875e5237726fdaec7d325dc9994e2a095 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 17:17:03 +0100
Subject: [PATCH 30/46] Update the test app.

---
 examples/InputTest/Program.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
index 6fda6616e5..74361150eb 100644
--- a/examples/InputTest/Program.cs
+++ b/examples/InputTest/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 using Silk.NET.Input;
@@ -14,7 +15,6 @@ internal class Program
     {
         private static void Main()
         {
-
             var window = Window.Create(WindowOptions.Default);
             Task.Run(() => window.Run());
             Console.Write("Connect your controller(s) and press ENTER (in the console window).");
@@ -85,7 +85,7 @@ public static void ControllerConnected(IInputDevice device, bool isConnected)
             Console.WriteLine(isConnected
                 ? $"Device {device.Name} connected"
                 : $"Device {device.Name} disconnected");
-            if (device is IGamepad gamepad)
+            if (device is IGamepad gamepad && device.IsConnected)
             {
                 Console.WriteLine("Discovered controller " + gamepad.Index + " (Connected: " + isConnected + ")");
                 if (isConnected)

From bec0f336030953614145563161fc9a0dd233efe0 Mon Sep 17 00:00:00 2001
From: Frederik <fjaplv64@gmail.com>
Date: Thu, 1 Aug 2019 18:32:53 +0200
Subject: [PATCH 31/46] Controller events fix

---
 .../Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs  | 7 ++++---
 .../Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs | 6 +++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index b34c381a2c..8453a47535 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -43,7 +43,7 @@ public void Update()
             var buttons = Buttons;
             for (var i = 0; i < buttons.Count; i++)
             {
-                if (!buttons[i].Equals(_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]))
+                if (buttons[i].Pressed != (_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]).Pressed)
                 {
                     _cachedButtons[i] = buttons[i];
                     (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
@@ -52,7 +52,8 @@ public void Update()
             var thumbsticks = Thumbsticks;
             for (var i = 0; i < thumbsticks.Count; i++)
             {
-                if (!thumbsticks[i].Equals(_cachedThumbsticks.Count > i ? _cachedThumbsticks[i] : thumbsticks[i]))
+                if (thumbsticks[i].X != (_cachedThumbsticks.Count > i ? _cachedThumbsticks[i] : thumbsticks[i]).X ||
+                    thumbsticks[i].Y != (_cachedThumbsticks.Count > i ? _cachedThumbsticks[i] : thumbsticks[i]).Y)
                 {
                     _cachedThumbsticks[i] = thumbsticks[i];
                     ThumbstickMoved?.Invoke(this, Util.ApplyDeadzone(thumbsticks[i], Deadzone));
@@ -61,7 +62,7 @@ public void Update()
             var triggers = Triggers;
             for (var i = 0; i < triggers.Count; i++)
             {
-                if (!triggers[i].Equals(_cachedTriggers.Count > i ? _cachedTriggers[i] : triggers[i]))
+                if (triggers[i].Position != (_cachedTriggers.Count > i ? _cachedTriggers[i] : triggers[i]).Position)
                 {
                     _cachedTriggers[i] = triggers[i];
                     TriggerMoved?.Invoke(this, triggers[i]);
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
index 708469ba38..a2ef42522b 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwJoystick.cs
@@ -44,7 +44,7 @@ public void Update()
             var axes = Axes;
             for (var i = 0; i < axes.Count; i++)
             {
-                if (!axes[i].Equals(_cachedAxes.Count > i ? _cachedAxes[i] : axes[i]))
+                if (axes[i].Position != (_cachedAxes.Count > i ? _cachedAxes[i] : axes[i]).Position)
                 {
                     _cachedAxes[i] = axes[i];
                     AxisMoved?.Invoke(this, Util.ApplyDeadzone(axes[i], Deadzone));
@@ -53,7 +53,7 @@ public void Update()
             var buttons = Buttons;
             for (var i = 0; i < buttons.Count; i++)
             {
-                if (!buttons[i].Equals(_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]))
+                if (buttons[i].Pressed != (_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]).Pressed)
                 {
                     _cachedButtons[i] = buttons[i];
                     (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
@@ -62,7 +62,7 @@ public void Update()
             var hats = Hats;
             for (var i = 0; i < hats.Count; i++)
             {
-                if (!hats[i].Equals(_cachedHats.Count > i ? _cachedHats[i] : hats[i]))
+                if (hats[i].Position != (_cachedHats.Count > i ? _cachedHats[i] : hats[i]).Position)
                 {
                     _cachedHats[i] = hats[i];
                     HatMoved?.Invoke(this, hats[i]);

From fe823d691b6ad896e3ca5ef1497bbad564238f6d Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 18:43:37 +0100
Subject: [PATCH 32/46] wip

---
 examples/InputTest/Program.cs                 |  2 --
 src/Core/Silk.NET.Core/Silk.NET.Core.csproj   |  2 +-
 .../Collections/GlfwAxisCollection.cs         |  1 +
 .../Collections/GlfwThumbstickCollection.cs   |  1 +
 .../Collections/GlfwTriggerCollection.cs      |  1 +
 .../Implementations/GlfwGamepad.cs            |  2 +-
 .../Silk.NET.Input.Desktop/InputHandler.cs    |  4 +--
 ...k.NET.OpenAL.Extensions.Enumeration.csproj |  1 -
 .../Silk.NET.GLFW/Interfaces/IGlfw.cs         | 36 +++++++++----------
 .../Silk.NET.GLFW/Silk.NET.GLFW.csproj        |  1 -
 10 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
index 74361150eb..0fede009ee 100644
--- a/examples/InputTest/Program.cs
+++ b/examples/InputTest/Program.cs
@@ -17,8 +17,6 @@ private static void Main()
         {
             var window = Window.Create(WindowOptions.Default);
             Task.Run(() => window.Run());
-            Console.Write("Connect your controller(s) and press ENTER (in the console window).");
-            Console.ReadLine();
             var input = window.GetInput();
             input.ConnectionChanged += ControllerConnected;
             Console.WriteLine("Now, go press buttons in the window and you'll see the feedback here.");
diff --git a/src/Core/Silk.NET.Core/Silk.NET.Core.csproj b/src/Core/Silk.NET.Core/Silk.NET.Core.csproj
index fc74409eed..8032814d89 100644
--- a/src/Core/Silk.NET.Core/Silk.NET.Core.csproj
+++ b/src/Core/Silk.NET.Core/Silk.NET.Core.csproj
@@ -6,7 +6,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="AdvancedDLSupport" Version="3.0.0" />
+      <PackageReference Include="Ultz.Private.AdvancedDLSupport" Version="4.0.0" />
       <PackageReference Include="System.Numerics.Vectors" Version="4.6.0-preview5.19224.8" />
     </ItemGroup>
 
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
index 8fbf104834..dc3492cd82 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
@@ -39,6 +39,7 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public static float Get(float* floats, int index)
         {
+            Console.WriteLine("bing");
             return (float) Marshal.PtrToStructure
             (
                 Marshal.ReadIntPtr((IntPtr) floats, index * IntPtr.Size),
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
index b2cdaf6122..8669141414 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
@@ -27,6 +27,7 @@ public GlfwThumbstickCollection(float* x, float* y, int count)
 
         public static float Get(float* floats, int index)
         {
+            Console.WriteLine("bong ");
             return (float)Marshal.PtrToStructure
             (
                 Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
index c5f4931680..534057f5b8 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
@@ -36,6 +36,7 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public static float Get(float* floats, int index)
         {
+            Console.WriteLine("bang");
             return (float)Marshal.PtrToStructure
             (
                 Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index 8453a47535..aa48c96f20 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -35,7 +35,7 @@ public GlfwGamepad(int i)
 
         public void Update()
         {
-            if (Util.Glfw.JoystickIsGamepad(Index))
+            if (!Util.Glfw.JoystickIsGamepad(Index))
             {
                 return;
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
index 16f0d496d1..bdef4439d3 100644
--- a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
+++ b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
@@ -24,13 +24,13 @@ static InputHandler()
 
         public static unsafe void RegisterContext(GlfwInputContext ctx)
         {
-            Contexts.Add(ctx);
-
             if (Contexts.Any(x => x._window == ctx._window))
             {
                 return;
             }
             
+            Contexts.Add(ctx);
+
             // register callbacks
             Util.Do(() => Util.Glfw.SetKeyCallback((WindowHandle*) ctx._window.Handle, KeyCallback));
             Util.Do(() => Util.Glfw.SetMouseButtonCallback((WindowHandle*)ctx._window.Handle, MouseCallback));
diff --git a/src/OpenAL/Extensions/Silk.NET.OpenAL.Extensions.Enumeration/Silk.NET.OpenAL.Extensions.Enumeration.csproj b/src/OpenAL/Extensions/Silk.NET.OpenAL.Extensions.Enumeration/Silk.NET.OpenAL.Extensions.Enumeration.csproj
index a9ae45f96a..43023bba42 100644
--- a/src/OpenAL/Extensions/Silk.NET.OpenAL.Extensions.Enumeration/Silk.NET.OpenAL.Extensions.Enumeration.csproj
+++ b/src/OpenAL/Extensions/Silk.NET.OpenAL.Extensions.Enumeration/Silk.NET.OpenAL.Extensions.Enumeration.csproj
@@ -12,7 +12,6 @@
 
   <ItemGroup>
     <PackageReference Include="System.Buffers" Version="4.5.0" />
-    <PackageReference Include="System.Memory" Version="4.5.1" />
   </ItemGroup>
 
   <Import Project="..\..\..\..\build\props\bindings.props" />
diff --git a/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs b/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
index 2ebf9b31d5..82b78d55c8 100644
--- a/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
+++ b/src/Windowing/Silk.NET.GLFW/Interfaces/IGlfw.cs
@@ -2336,7 +2336,7 @@ public interface IGlfw
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        unsafe GlfwCallbacks.CharCallback SetCharCallback(WindowHandle* window, GlfwCallbacks.CharCallback callback);
+        unsafe GlfwCallbacks.CharCallback SetCharCallback(WindowHandle* window, [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CharCallback callback);
 
         /// <summary>
         /// <para>
@@ -2369,7 +2369,7 @@ public interface IGlfw
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.CharModsCallback SetCharModsCallback(WindowHandle* window,
-            GlfwCallbacks.CharModsCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CharModsCallback callback);
 
         /// <summary>
         /// <para>
@@ -2412,7 +2412,7 @@ unsafe GlfwCallbacks.CharModsCallback SetCharModsCallback(WindowHandle* window,
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.CursorEnterCallback SetCursorEnterCallback(WindowHandle* window,
-            GlfwCallbacks.CursorEnterCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CursorEnterCallback callback);
 
         /// <summary>
         /// <para>
@@ -2438,7 +2438,7 @@ unsafe GlfwCallbacks.CursorEnterCallback SetCursorEnterCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window,
-            GlfwCallbacks.CursorPosCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.CursorPosCallback callback);
 
         /// <summary>
         /// <para>
@@ -2464,7 +2464,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        unsafe GlfwCallbacks.DropCallback SetDropCallback(WindowHandle* window, GlfwCallbacks.DropCallback callback);
+        unsafe GlfwCallbacks.DropCallback SetDropCallback(WindowHandle* window, [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.DropCallback callback);
 
         /// <summary>
         /// <para>
@@ -2494,7 +2494,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// This function must only be called from the main thread.
         /// </para>
         /// </remarks>
-        GlfwCallbacks.ErrorCallback SetErrorCallback(GlfwCallbacks.ErrorCallback callback);
+        GlfwCallbacks.ErrorCallback SetErrorCallback([DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.ErrorCallback callback);
 
         /// <summary>
         /// <para>
@@ -2583,7 +2583,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        GlfwCallbacks.JoystickCallback SetJoystickCallback(GlfwCallbacks.JoystickCallback callback);
+        GlfwCallbacks.JoystickCallback SetJoystickCallback([DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.JoystickCallback callback);
 
         /// <summary>
         /// <para>
@@ -2624,7 +2624,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        unsafe GlfwCallbacks.KeyCallback SetKeyCallback(WindowHandle* window, GlfwCallbacks.KeyCallback callback);
+        unsafe GlfwCallbacks.KeyCallback SetKeyCallback(WindowHandle* window, [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.KeyCallback callback);
 
         /// <summary>
         /// <para>
@@ -2649,7 +2649,7 @@ unsafe GlfwCallbacks.CursorPosCallback SetCursorPosCallback(WindowHandle* window
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.ScrollCallback SetScrollCallback(WindowHandle* window,
-            GlfwCallbacks.ScrollCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.ScrollCallback callback);
 
         /// <summary>
         /// <para>
@@ -2669,7 +2669,7 @@ unsafe GlfwCallbacks.ScrollCallback SetScrollCallback(WindowHandle* window,
         /// Possible errors include <see cref="ErrorCode.NotInitialized" />.
         /// </para>
         /// </remarks>
-        GlfwCallbacks.MonitorCallback SetMonitorCallback(GlfwCallbacks.MonitorCallback callback);
+        GlfwCallbacks.MonitorCallback SetMonitorCallback([DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.MonitorCallback callback);
 
         /// <summary>
         /// <para>
@@ -2698,7 +2698,7 @@ unsafe GlfwCallbacks.ScrollCallback SetScrollCallback(WindowHandle* window,
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.MouseButtonCallback SetMouseButtonCallback(WindowHandle* window,
-            GlfwCallbacks.MouseButtonCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.MouseButtonCallback callback);
 
         /// <summary>
         /// <para>
@@ -2731,7 +2731,7 @@ unsafe GlfwCallbacks.MouseButtonCallback SetMouseButtonCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowCloseCallback SetWindowCloseCallback(WindowHandle* window,
-            GlfwCallbacks.WindowCloseCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowCloseCallback callback);
 
         /// <summary>
         /// <para>
@@ -2758,7 +2758,7 @@ unsafe GlfwCallbacks.WindowCloseCallback SetWindowCloseCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowFocusCallback SetWindowFocusCallback(WindowHandle* window,
-            GlfwCallbacks.WindowFocusCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowFocusCallback callback);
 
         /// <summary>
         /// <para>
@@ -2813,7 +2813,7 @@ unsafe GlfwCallbacks.WindowFocusCallback SetWindowFocusCallback(WindowHandle* wi
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowIconifyCallback SetWindowIconifyCallback(WindowHandle* window,
-            GlfwCallbacks.WindowIconifyCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowIconifyCallback callback);
 
         /// <summary>
         /// <para>
@@ -2835,7 +2835,7 @@ unsafe GlfwCallbacks.WindowIconifyCallback SetWindowIconifyCallback(WindowHandle
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowMaximizeCallback SetWindowMaximizeCallback(WindowHandle* window,
-            GlfwCallbacks.WindowMaximizeCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowMaximizeCallback callback);
 
         /// <summary>
         /// <para>
@@ -2936,7 +2936,7 @@ unsafe void SetWindowMonitor(WindowHandle* window, Monitor* monitor, int x, int
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowPosCallback SetWindowPosCallback(WindowHandle* window,
-            GlfwCallbacks.WindowPosCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowPosCallback callback);
 
         /// <summary>
         /// <para>
@@ -2967,7 +2967,7 @@ unsafe GlfwCallbacks.WindowPosCallback SetWindowPosCallback(WindowHandle* window
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowRefreshCallback SetWindowRefreshCallback(WindowHandle* window,
-            GlfwCallbacks.WindowRefreshCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowRefreshCallback callback);
 
         /// <summary>
         /// <para>
@@ -3026,7 +3026,7 @@ unsafe GlfwCallbacks.WindowRefreshCallback SetWindowRefreshCallback(WindowHandle
         /// </para>
         /// </remarks>
         unsafe GlfwCallbacks.WindowSizeCallback SetWindowSizeCallback(WindowHandle* window,
-            GlfwCallbacks.WindowSizeCallback callback);
+            [DelegateLifetime(DelegateLifetime.Persistent)]GlfwCallbacks.WindowSizeCallback callback);
 
         /// <summary>
         /// <para>
diff --git a/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj b/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj
index 5a756f42b1..1afec9161a 100644
--- a/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj
+++ b/src/Windowing/Silk.NET.GLFW/Silk.NET.GLFW.csproj
@@ -7,7 +7,6 @@
     </PropertyGroup>
     
     <ItemGroup>
-      <PackageReference Include="AdvancedDLSupport" Version="3.0.0" />
       <PackageReference Include="Ultz.Dispatcher" Version="1.1.0" />
     </ItemGroup>
 

From abdb81a82be3909b4fe2cd388a8736ef6d5d6301 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 19:04:53 +0100
Subject: [PATCH 33/46] Use indexers on the pointers

---
 .../Collections/GlfwAxisCollection.cs              | 14 ++------------
 .../Collections/GlfwThumbstickCollection.cs        | 14 ++------------
 .../Collections/GlfwTriggerCollection.cs           | 14 ++------------
 3 files changed, 6 insertions(+), 36 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
index dc3492cd82..08302940c6 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwAxisCollection.cs
@@ -34,18 +34,8 @@ IEnumerator IEnumerable.GetEnumerator()
         public int Count => _count;
 
         public Axis this[int index] => index < _count
-            ? new Axis(index, Get(_floats, index))
+            ? new Axis(index, _floats[index])
             : throw new ArgumentOutOfRangeException();
-
-        public static float Get(float* floats, int index)
-        {
-            Console.WriteLine("bing");
-            return (float) Marshal.PtrToStructure
-            (
-                Marshal.ReadIntPtr((IntPtr) floats, index * IntPtr.Size),
-                typeof(float)
-            );
-        }
         
         private struct Enumerator : IEnumerator<Axis>
         {
@@ -67,7 +57,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Axis(_current, Get(_col._floats, _current));
+                Current = new Axis(_current, _col._floats[_current]);
                 _current++;
                 return true;
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
index 8669141414..293ccc9d00 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwThumbstickCollection.cs
@@ -22,19 +22,9 @@ public GlfwThumbstickCollection(float* x, float* y, int count)
         public int Count => _count;
 
         public Thumbstick this[int index] => index < _count
-            ? new Thumbstick(index, Get(_x, index), Get(_y, index))
+            ? new Thumbstick(index, _x[index], _y[index])
             : throw new ArgumentOutOfRangeException();
 
-        public static float Get(float* floats, int index)
-        {
-            Console.WriteLine("bong ");
-            return (float)Marshal.PtrToStructure
-            (
-                Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
-                typeof(float)
-            );
-        }
-
         public IEnumerator<Thumbstick> GetEnumerator()
         {
             return new Enumerator(this);
@@ -65,7 +55,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Thumbstick(_current, Get(_col._x, _current), Get(_col._y, _current));
+                Current = new Thumbstick(_current, _col._x[_current], _col._y[_current]);
                 _current++;
                 return true;
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
index 534057f5b8..0381895bce 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwTriggerCollection.cs
@@ -19,7 +19,7 @@ public GlfwTriggerCollection(float* floats, int count)
         }
 
         public Trigger this[int index] => index < Count
-            ? new Trigger(index, Get(_floats, index))
+            ? new Trigger(index, _floats[index])
             : throw new ArgumentOutOfRangeException();
 
         public int Count => _count;
@@ -34,16 +34,6 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public static float Get(float* floats, int index)
-        {
-            Console.WriteLine("bang");
-            return (float)Marshal.PtrToStructure
-            (
-                Marshal.ReadIntPtr((IntPtr)floats, index * IntPtr.Size),
-                typeof(float)
-            );
-        }
-
         private struct Enumerator : IEnumerator<Trigger>
         {
             private GlfwTriggerCollection _col;
@@ -64,7 +54,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Trigger(_current, Get(_col._floats, _current));
+                Current = new Trigger(_current, _col._floats[_current]);
                 _current++;
                 return true;
             }

From 2220a7bc08e52cfe0f0ab7ca56114109205c9ec8 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 21:47:55 +0100
Subject: [PATCH 34/46] Fix mismatched enumerant names in GLFW

---
 src/Windowing/Silk.NET.GLFW/Enums/Keys.cs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs b/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs
index 8b2d8a7edf..66fe86819c 100644
--- a/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs
+++ b/src/Windowing/Silk.NET.GLFW/Enums/Keys.cs
@@ -573,42 +573,42 @@ public enum Keys
         /// <summary>
         /// The left shift key.
         /// </summary>
-        LeftShift = 340,
+        ShiftLeft = 340,
 
         /// <summary>
         /// The left control key.
         /// </summary>
-        LeftControl = 341,
+        ControlLeft = 341,
 
         /// <summary>
         /// The left alt key.
         /// </summary>
-        LeftAlt = 342,
+        AltLeft = 342,
 
         /// <summary>
         /// The left super key.
         /// </summary>
-        LeftSuper = 343,
+        SuperLeft = 343,
 
         /// <summary>
         /// The right shift key.
         /// </summary>
-        RightShift = 344,
+        ShiftRight = 344,
 
         /// <summary>
         /// The right control key.
         /// </summary>
-        RightControl = 345,
+        ControlRight = 345,
 
         /// <summary>
         /// The right alt key.
         /// </summary>
-        RightAlt = 346,
+        AltRight = 346,
 
         /// <summary>
         /// The right super key.
         /// </summary>
-        RightSuper = 347,
+        SuperRight = 347,
 
         /// <summary>
         /// The menu key.

From 3c83428cc5f94f79c4a9649c0f0a5614065bff8a Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 21:48:30 +0100
Subject: [PATCH 35/46] Destroy window when we're done

---
 src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
index caca0eb34b..487fe6daec 100644
--- a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
+++ b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
@@ -502,6 +502,7 @@ public unsafe void Run()
             }
 
             running = false;
+            glfwThread.Invoke(() => glfw.DestroyWindow(WindowPtr));
         }
 
         /// <inheritdoc />

From 32f385f8604fa219c0ab9440f7b01bf468e4090a Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 21:48:42 +0100
Subject: [PATCH 36/46] Fix wrong enum values in GLFW

---
 src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs b/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs
index 12678cb420..b2c74f74cc 100644
--- a/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs
+++ b/src/Windowing/Silk.NET.GLFW/Enums/InputAction.cs
@@ -14,12 +14,12 @@ public enum InputAction
         /// <summary>
         /// The key or mouse button was pressed.
         /// </summary>
-        Press = 0,
+        Press = 1,
 
         /// <summary>
         /// The key or mouse button was released.
         /// </summary>
-        Release = 1,
+        Release = 0,
 
         /// <summary>
         /// The key was held down until it repeated.

From 8ddba8192f5ae21bdd4a231d36dcb9cd34558c75 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 21:49:15 +0100
Subject: [PATCH 37/46] Make properties update initialOptions, and only invoke
 GLFW if running

---
 .../Silk.NET.Windowing.Desktop/GlfwWindow.cs  | 244 ++++++++++--------
 1 file changed, 138 insertions(+), 106 deletions(-)

diff --git a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
index 487fe6daec..093bd055fc 100644
--- a/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
+++ b/src/Windowing/Silk.NET.Windowing.Desktop/GlfwWindow.cs
@@ -100,29 +100,36 @@ public bool IsVisible
             {
                 unsafe
                 {
-                    return glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Visible);
+                    return running
+                        ? glfw.GetWindowAttrib(WindowPtr, WindowAttributeGetter.Visible)
+                        : initialOptions.IsVisible;
                 }
             }
             set
             {
-                glfwThread.Invoke
-                (
-                    () =>
-                    {
-                        Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
-                        unsafe
+                if (running)
+                {
+                    glfwThread.Invoke
+                    (
+                        () =>
                         {
-                            if (value)
-                            {
-                                glfw.ShowWindow(WindowPtr);
-                            }
-                            else
+                            Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
+                            unsafe
                             {
-                                glfw.HideWindow(WindowPtr);
+                                if (value)
+                                {
+                                    glfw.ShowWindow(WindowPtr);
+                                }
+                                else
+                                {
+                                    glfw.HideWindow(WindowPtr);
+                                }
                             }
                         }
-                    }
-                );
+                    );
+                }
+
+                initialOptions.IsVisible = value;
             }
         }
 
@@ -133,7 +140,7 @@ public IntPtr Handle
             {
                 unsafe
                 {
-                    return (IntPtr) WindowPtr;
+                    return running ? (IntPtr) WindowPtr : IntPtr.Zero;
                 }
             }
         }
@@ -147,18 +154,22 @@ public Point Position
             get => _position;
             set
             {
-                glfwThread.Invoke
-                (
-                    () =>
-                    {
-                        unsafe
+                if (running)
+                {
+                    glfwThread.Invoke
+                    (
+                        () =>
                         {
-                            glfw.SetWindowPos(WindowPtr, value.X, value.Y);
+                            unsafe
+                            {
+                                glfw.SetWindowPos(WindowPtr, value.X, value.Y);
+                            }
                         }
-                    }
-                );
+                    );
+                }
 
                 _position = value;
+                initialOptions.Position = value;
             }
         }
 
@@ -168,17 +179,21 @@ public Size Size
             get => _size;
             set
             {
-                glfwThread.Invoke
-                (
-                    () =>
-                    {
-                        unsafe
+                if (running)
+                {
+                    glfwThread.Invoke
+                    (
+                        () =>
                         {
-                            glfw.SetWindowSize(WindowPtr, value.Width, value.Height);
+                            unsafe
+                            {
+                                glfw.SetWindowSize(WindowPtr, value.Width, value.Height);
+                            }
                         }
-                    }
-                );
+                    );
+                }
 
+                initialOptions.Size = value;
                 _size = value;
             }
         }
@@ -224,17 +239,21 @@ public string Title
             get => _title;
             set
             {
-                glfwThread.Invoke
-                (
-                    () =>
-                    {
-                        unsafe
+                if (running)
+                {
+                    glfwThread.Invoke
+                    (
+                        () =>
                         {
-                            glfw.SetWindowTitle(WindowPtr, value);
+                            unsafe
+                            {
+                                glfw.SetWindowTitle(WindowPtr, value);
+                            }
                         }
-                    }
-                );
+                    );
+                }
 
+                initialOptions.Title = value;
                 _title = value;
             }
         }
@@ -245,37 +264,41 @@ public WindowState WindowState
             get => _windowState;
             set
             {
-                glfwThread.Invoke
-                (
-                    () =>
-                    {
-                        unsafe
+                if (running)
+                {
+                    glfwThread.Invoke
+                    (
+                        () =>
                         {
-                            switch (value)
+                            unsafe
                             {
-                                case WindowState.Normal:
-                                    glfw.RestoreWindow(WindowPtr);
-                                    break;
-                                case WindowState.Minimized:
-                                    glfw.IconifyWindow(WindowPtr);
-                                    break;
-                                case WindowState.Maximized:
-                                    glfw.MaximizeWindow(WindowPtr);
-                                    break;
-                                case WindowState.Fullscreen:
-                                    var monitor = glfw.GetPrimaryMonitor();
-                                    var mode = glfw.GetVideoMode(monitor);
-                                    glfw.SetWindowMonitor
-                                    (
-                                        WindowPtr, monitor, 0, 0, mode->Width, mode->Height,
-                                        mode->RefreshRate
-                                    );
-                                    break;
+                                switch (value)
+                                {
+                                    case WindowState.Normal:
+                                        glfw.RestoreWindow(WindowPtr);
+                                        break;
+                                    case WindowState.Minimized:
+                                        glfw.IconifyWindow(WindowPtr);
+                                        break;
+                                    case WindowState.Maximized:
+                                        glfw.MaximizeWindow(WindowPtr);
+                                        break;
+                                    case WindowState.Fullscreen:
+                                        var monitor = glfw.GetPrimaryMonitor();
+                                        var mode = glfw.GetVideoMode(monitor);
+                                        glfw.SetWindowMonitor
+                                        (
+                                            WindowPtr, monitor, 0, 0, mode->Width, mode->Height,
+                                            mode->RefreshRate
+                                        );
+                                        break;
+                                }
                             }
                         }
-                    }
-                );
+                    );
+                }
 
+                initialOptions.WindowState = value;
                 _windowState = value;
             }
         }
@@ -286,33 +309,37 @@ public WindowBorder WindowBorder
             get => _windowBorder;
             set
             {
-                glfwThread.Invoke
-                (
-                    () =>
-                    {
-                        unsafe
+                if (running)
+                {
+                    glfwThread.Invoke
+                    (
+                        () =>
                         {
-                            switch (value)
+                            unsafe
                             {
-                                case WindowBorder.Hidden:
-                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, false);
-                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
-                                    break;
-
-                                case WindowBorder.Resizable:
-                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
-                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, true);
-                                    break;
-
-                                case WindowBorder.Fixed:
-                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
-                                    glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
-                                    break;
+                                switch (value)
+                                {
+                                    case WindowBorder.Hidden:
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, false);
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
+                                        break;
+
+                                    case WindowBorder.Resizable:
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, true);
+                                        break;
+
+                                    case WindowBorder.Fixed:
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Decorated, true);
+                                        glfw.SetWindowAttrib(WindowPtr, WindowAttributeSetter.Resizable, false);
+                                        break;
+                                }
                             }
                         }
-                    }
-                );
+                    );
+                }
 
+                initialOptions.WindowBorder = value;
                 _windowBorder = value;
             }
         }
@@ -323,28 +350,33 @@ public VSyncMode VSync
             get => _vSync;
             set
             {
-                this.Invoke
-                (
-                    () =>
-                    {
-                        switch (value)
+                if (running)
+                {
+                    this.Invoke
+                    (
+                        () =>
                         {
-                            case VSyncMode.Off:
-                                glfw.SwapInterval(0);
-                                break;
+                            switch (value)
+                            {
+                                case VSyncMode.Off:
+                                    glfw.SwapInterval(0);
+                                    break;
 
-                            case VSyncMode.On:
-                                glfw.SwapInterval(1);
-                                break;
+                                case VSyncMode.On:
+                                    glfw.SwapInterval(1);
+                                    break;
 
-                            default:
-                                glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
-                                break;
-                        }
+                                default:
+                                    glfw.SwapInterval(IsRunningSlowly ? 0 : 1);
+                                    break;
+                            }
 
-                        _vSync = value;
-                    }
-                );
+                            _vSync = value;
+                        }
+                    );
+                }
+                initialOptions.VSync = value;
+                _vSync = value;
             }
         }
 

From 911d42cc72a5a3d34bc34f0d44c3a118a57b6135 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Thu, 1 Aug 2019 21:58:16 +0100
Subject: [PATCH 38/46] Window is immovable when only 1 thread is used,
 investigate WindowUpdate

---
 examples/InputTest/Program.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
index 0fede009ee..6ceadf48af 100644
--- a/examples/InputTest/Program.cs
+++ b/examples/InputTest/Program.cs
@@ -15,7 +15,9 @@ internal class Program
     {
         private static void Main()
         {
-            var window = Window.Create(WindowOptions.Default);
+            var opts = WindowOptions.Default;
+            opts.UseSingleThreadedWindow = false;
+            var window = Window.Create(opts);
             Task.Run(() => window.Run());
             var input = window.GetInput();
             input.ConnectionChanged += ControllerConnected;

From 5ae7fc115a841197bb40fde1dfe68f2c6a5fcb95 Mon Sep 17 00:00:00 2001
From: John <johnkellyoxford@gmail.com>
Date: Thu, 1 Aug 2019 22:18:17 +0100
Subject: [PATCH 39/46] Fix `Get` methods (#30)

* Fix the abominations that were `Get()` methods

* Remove Get methods entirely
---
 .../Collections/GlfwButtonCollection.cs                |  8 ++------
 .../Collections/GlfwHatCollection.cs                   | 10 +++-------
 2 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
index 5ec643c715..656827a224 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -21,7 +21,7 @@ public GlfwButtonCollection(byte* bytes, int count)
         public int Count => _count;
 
         public Button this[int index] => index < _count
-            ? new Button ((ButtonName)index, index, Get(_bytes, index) != 0)
+            ? new Button ((ButtonName)index, index, _bytes[index] != 0)
             : throw new ArgumentOutOfRangeException();
 
         public IEnumerator<Button> GetEnumerator()
@@ -34,10 +34,6 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public static byte Get(byte* bytes, int index)
-        {
-            return Marshal.ReadByte((IntPtr) bytes, index);
-        }
         private struct Enumerator : IEnumerator<Button>
         {
             private GlfwButtonCollection _col;
@@ -58,7 +54,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Button((ButtonName)_current, _current, Get(_col._bytes, _current) != 0);
+                Current = new Button((ButtonName)_current, _current, _col._bytes[_current] != 0);
                 _current++;
                 return true;
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
index 8f98a52535..a2db2e64fe 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwHatCollection.cs
@@ -1,4 +1,4 @@
-using Silk.NET.Input.Common;
+using Silk.NET.Input.Common;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -19,7 +19,7 @@ public GlfwHatCollection(Position2D* positions, int count)
         }
 
         public Hat this[int index] => index < _count
-            ? new Hat(index, Get(_positions, index))
+            ? new Hat(index, _positions[index])
             : throw new ArgumentOutOfRangeException();
 
         public int Count => _count;
@@ -33,10 +33,6 @@ IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();
         }
-        public static Position2D Get(Position2D* positions, int index)
-        {
-            return (Position2D) Marshal.ReadInt32((IntPtr) positions, index * IntPtr.Size);
-        }
 
         private struct Enumerator : IEnumerator<Hat>
         {
@@ -58,7 +54,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Hat(_current, Get(_col._positions, _current));
+                Current = new Hat(_current, _col._positions[_current]);
                 _current++;
                 return true;
             }

From 0b90dad91851eb25649bc31a2daedbb265567b52 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Sat, 3 Aug 2019 21:34:07 +0100
Subject: [PATCH 40/46] Fully implement mice, fix deadlock issues

---
 examples/InputTest/Program.cs                 | 22 +++--
 .../Collections/GlfwWheelCollection.cs        | 78 +++++++++++++++++
 .../Implementations/GlfwMouse.cs              | 11 ++-
 .../Silk.NET.Input.Desktop/InputHandler.cs    | 85 ++++++++++++-------
 4 files changed, 158 insertions(+), 38 deletions(-)
 create mode 100644 src/Input/Silk.NET.Input.Desktop/Collections/GlfwWheelCollection.cs

diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
index 6ceadf48af..8b044594ac 100644
--- a/examples/InputTest/Program.cs
+++ b/examples/InputTest/Program.cs
@@ -20,21 +20,30 @@ private static void Main()
             var window = Window.Create(opts);
             Task.Run(() => window.Run());
             var input = window.GetInput();
-            input.ConnectionChanged += ControllerConnected;
+            input.ConnectionChanged += DoConnect;
             Console.WriteLine("Now, go press buttons in the window and you'll see the feedback here.");
             foreach (var gamepad in input.Gamepads)
             {
-                ControllerConnected(gamepad, gamepad.IsConnected);
+                if (!gamepad.IsConnected) continue;
+                DoConnect(gamepad, gamepad.IsConnected);
             }
             
             foreach (var joystick in input.Joysticks)
             {
-                ControllerConnected(joystick, joystick.IsConnected);
+                if (!joystick.IsConnected) continue;
+                DoConnect(joystick, joystick.IsConnected);
             }
 
             foreach (var keyboard in input.Keyboards)
             {
-                ControllerConnected(keyboard, keyboard.IsConnected);
+                if (!keyboard.IsConnected) continue;
+                DoConnect(keyboard, keyboard.IsConnected);
+            }
+
+            foreach (var mouse in input.Mice)
+            {
+                if (!mouse.IsConnected) continue;
+                DoConnect(mouse, mouse.IsConnected);
             }
 
             Console.ReadLine();
@@ -80,7 +89,7 @@ private static void InputGamepadOnButtonUp(IGamepad arg1, Button arg2)
             Console.WriteLine("G" + arg1.Index + "> " + arg2.Name + " up.");
         }
 
-        public static void ControllerConnected(IInputDevice device, bool isConnected)
+        public static void DoConnect(IInputDevice device, bool isConnected)
         {
             Console.WriteLine(isConnected
                 ? $"Device {device.Name} connected"
@@ -159,6 +168,9 @@ public static void ControllerConnected(IInputDevice device, bool isConnected)
                 }
                 else
                 {
+                    mouse.MouseUp -= MouseOnMouseUp;
+                    mouse.MouseDown -= MouseOnMouseDown;
+                    mouse.Scroll -= MouseOnScroll;
                 }
 
                 Console.Write("    Buttons: ");
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwWheelCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwWheelCollection.cs
new file mode 100644
index 0000000000..224a8b7bd9
--- /dev/null
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwWheelCollection.cs
@@ -0,0 +1,78 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Silk.NET.Input.Common;
+
+namespace Silk.NET.Input.Desktop.Collections
+{
+    public class GlfwWheelCollection : IReadOnlyList<ScrollWheel>
+    {
+        private GlfwMouse _mouse;
+
+        public GlfwWheelCollection(GlfwMouse mouse)
+        {
+            _mouse = mouse;
+        }
+
+        public ScrollWheel this[int index] => index != 0
+            ? _mouse._wheel
+            : throw new ArgumentOutOfRangeException();
+
+        public int Count { get; } = 1;
+
+        public IEnumerator<ScrollWheel> GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private struct Enumerator : IEnumerator<ScrollWheel>
+        {
+            private GlfwWheelCollection _col;
+            private bool _done;
+
+            public Enumerator(GlfwWheelCollection col)
+            {
+                _col = col;
+                _done = false;
+                Current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (!_done)
+                {
+                    Current = _col._mouse._wheel;
+                    _done = true;
+                    return true;
+                }
+
+                Current = default;
+                return false;
+            }
+
+            public void Reset()
+            {
+                Current = default;
+                _done = false;
+            }
+
+            public ScrollWheel Current { get; private set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+            }
+        }
+    }
+}
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
index ad04041655..b256508e9c 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwMouse.cs
@@ -6,23 +6,27 @@
 using System;
 using System.Collections.Generic;
 using Silk.NET.Input.Common;
+using Silk.NET.Input.Desktop.Collections;
 
 namespace Silk.NET.Input.Desktop
 {
     public class GlfwMouse : IMouse
     {
+        private List<MouseButton> _down = new List<MouseButton>();
+        internal ScrollWheel _wheel;
         public GlfwMouse(GlfwInputContext inputContext)
         {
+            ScrollWheels = new GlfwWheelCollection(this);
         }
 
         public string Name { get; } = "Silk.NET Mouse (GLFW)";
         public int Index { get; } = 0;
         public bool IsConnected { get; } = true;
-        public IReadOnlyList<MouseButton> SupportedButtons { get; }
+        public IReadOnlyList<MouseButton> SupportedButtons { get; } = Util.SupportedButtons;
         public IReadOnlyList<ScrollWheel> ScrollWheels { get; }
         public bool IsButtonPressed(MouseButton btn)
         {
-            throw new NotImplementedException();
+            return _down.Contains(btn);
         }
 
         public event Action<IMouse, MouseButton> MouseDown;
@@ -31,16 +35,19 @@ public bool IsButtonPressed(MouseButton btn)
 
         internal void RaiseMouseDown(MouseButton btn)
         {
+            _down.Add(btn);
             MouseDown?.Invoke(this, btn);
         }
 
         internal void RaiseMouseUp(MouseButton btn)
         {
+            _down.Remove(btn);
             MouseUp?.Invoke(this, btn);
         }
 
         internal void RaiseScroll(ScrollWheel wheel)
         {
+            _wheel = wheel;
             Scroll?.Invoke(this, wheel);
         }
     }
diff --git a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
index bdef4439d3..2ea74504d8 100644
--- a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
+++ b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Silk.NET.GLFW;
 using Silk.NET.Input.Common;
 using MouseButton = Silk.NET.GLFW.MouseButton;
@@ -40,54 +41,76 @@ public static unsafe void RegisterContext(GlfwInputContext ctx)
 
         private static unsafe void ScrollCallback(WindowHandle* window, double offsetx, double offsety)
         {
-            // multiple contexts for one window should be allowed, but frowned upon
-            var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run
+            (
+                () =>
+                {
+                    // multiple contexts for one window should be allowed, but frowned upon
+                    var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
 
-            foreach (var context in allContexts)
-            {
-                ((GlfwMouse)context._mouse).RaiseScroll(new ScrollWheel((float) offsetx, (float) offsety));
-            }
+                    foreach (var context in allContexts)
+                    {
+                        ((GlfwMouse) context._mouse).RaiseScroll(new ScrollWheel((float) offsetx, (float) offsety));
+                    }
+                }
+            );
         }
 
         private static void JoystickCallback(int joystick, ConnectedState state)
         {
-            Contexts.ForEach(x => x.RaiseConnectionChange(joystick, state));
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run(() => Contexts.ForEach(x => x.RaiseConnectionChange(joystick, state)));
         }
 
         private static unsafe void MouseCallback(WindowHandle* window, MouseButton button, InputAction action, KeyModifiers mods)
         {
-            // multiple contexts for one window should be allowed, but frowned upon
-            var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
-
-            foreach (var context in allContexts)
-            {
-                if (action == InputAction.Press)
-                {
-                    ((GlfwMouse)context._mouse).RaiseMouseDown(Util.GlfwButtonToSilkButton(button));
-                } 
-                else if (action == InputAction.Release)
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run
+            (
+                () =>
                 {
-                    ((GlfwMouse)context._mouse).RaiseMouseUp(Util.GlfwButtonToSilkButton(button));
+                    // multiple contexts for one window should be allowed, but frowned upon
+                    var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+                    foreach (var context in allContexts)
+                    {
+                        if (action == InputAction.Press)
+                        {
+                            ((GlfwMouse) context._mouse).RaiseMouseDown(Util.GlfwButtonToSilkButton(button));
+                        }
+                        else if (action == InputAction.Release)
+                        {
+                            ((GlfwMouse) context._mouse).RaiseMouseUp(Util.GlfwButtonToSilkButton(button));
+                        }
+                    }
                 }
-            }
+            );
         }
 
         private static unsafe void KeyCallback(WindowHandle* window, Keys key, int scancode, InputAction action, KeyModifiers mods)
         {
-            // multiple contexts for one window should be allowed, but frowned upon
-            var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
-
-            foreach (var context in allContexts)
-            {
-                if (action == InputAction.Press)
+            // run on a separate thread to prevent deadlocks on single-threaded windows
+            Task.Run
+            (
+                () =>
                 {
-                    ((GlfwKeyboard) context._keyboard).RaisePressEvent(key, scancode, mods);
-                } 
-                else if (action == InputAction.Release)
-                {
-                    ((GlfwKeyboard) context._keyboard).RaiseReleaseEvent(key, scancode, mods);
+                    // multiple contexts for one window should be allowed, but frowned upon
+                    var allContexts = Contexts.Where(x => x._window.Handle == (IntPtr) window);
+
+                    foreach (var context in allContexts)
+                    {
+                        if (action == InputAction.Press)
+                        {
+                            ((GlfwKeyboard) context._keyboard).RaisePressEvent(key, scancode, mods);
+                        }
+                        else if (action == InputAction.Release)
+                        {
+                            ((GlfwKeyboard) context._keyboard).RaiseReleaseEvent(key, scancode, mods);
+                        }
+                    }
                 }
-            }
+            );
         }
 
         public static void UnregisterContext(GlfwInputContext ctx)

From b0c82f2c577747d9484d1f6e6c0b3790ccf22eb2 Mon Sep 17 00:00:00 2001
From: DMP9 <dmp9biz@gmail.com>
Date: Sat, 3 Aug 2019 22:57:11 +0100
Subject: [PATCH 41/46] This is GLFW input.

---
 examples/InputTest/Program.cs                 |  4 +-
 .../Silk.NET.Input.Common/Enums/ButtonName.cs |  2 -
 .../Collections/GlfwButtonCollection.cs       |  4 +-
 .../GlfwInputContext.cs                       |  1 +
 .../Implementations/GlfwGamepad.cs            | 48 +++++++++++++++----
 src/Input/Silk.NET.Input.Desktop/Util.cs      | 25 +++++++++-
 .../Silk.NET.GLFW/Enums/GamepadButton.cs      | 26 ++++++++++
 .../Silk.NET.GLFW/Enums/MouseButton.cs        | 12 ++---
 8 files changed, 100 insertions(+), 22 deletions(-)
 create mode 100644 src/Windowing/Silk.NET.GLFW/Enums/GamepadButton.cs

diff --git a/examples/InputTest/Program.cs b/examples/InputTest/Program.cs
index 8b044594ac..491d4cd66c 100644
--- a/examples/InputTest/Program.cs
+++ b/examples/InputTest/Program.cs
@@ -17,6 +17,8 @@ private static void Main()
         {
             var opts = WindowOptions.Default;
             opts.UseSingleThreadedWindow = false;
+            opts.FramesPerSecond = 60;
+            opts.UpdatesPerSecond = 60;
             var window = Window.Create(opts);
             Task.Run(() => window.Run());
             var input = window.GetInput();
@@ -81,7 +83,7 @@ private static void JoystickOnButtonDown(IJoystick arg1, Button arg2)
 
         private static void InputGamepadOnButtonDown(IGamepad arg1, Button arg2)
         {
-            Console.WriteLine("G" + arg1.Index + "> " + arg2.Name + " down.");
+            Console.WriteLine("G" + arg1.Index + "> " + arg2.Name + " down. " + (int)arg2.Name);
         }
 
         private static void InputGamepadOnButtonUp(IGamepad arg1, Button arg2)
diff --git a/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs b/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs
index 481dac440e..6aa0e1afd7 100644
--- a/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs
+++ b/src/Input/Silk.NET.Input.Common/Enums/ButtonName.cs
@@ -22,10 +22,8 @@ public enum ButtonName
         DPadRight,
         LeftBumper,
         LeftStick,
-        LeftTrigger,
         RightBumper,
         RightStick,
-        RightTrigger,
         Start
     }
 }
\ No newline at end of file
diff --git a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
index 656827a224..665cea6023 100644
--- a/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Collections/GlfwButtonCollection.cs
@@ -21,7 +21,7 @@ public GlfwButtonCollection(byte* bytes, int count)
         public int Count => _count;
 
         public Button this[int index] => index < _count
-            ? new Button ((ButtonName)index, index, _bytes[index] != 0)
+            ? new Button (Util.IntToSilkButton(index), index, _bytes[index] != 0)
             : throw new ArgumentOutOfRangeException();
 
         public IEnumerator<Button> GetEnumerator()
@@ -54,7 +54,7 @@ public bool MoveNext()
                     return false;
                 }
 
-                Current = new Button((ButtonName)_current, _current, _col._bytes[_current] != 0);
+                Current = new Button(Util.IntToSilkButton(_current), _current, _col._bytes[_current] != 0);
                 _current++;
                 return true;
             }
diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index 77ccc9ab5f..8715756bd5 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -74,6 +74,7 @@ public void WindowUpdate(double obj)
 
         public void RaiseConnectionChange(int joystick, ConnectedState state)
         {
+            Console.WriteLine("Connection Change " + joystick + ", " + state);
             ConnectionChanged?.Invoke(Joysticks[joystick], state == ConnectedState.Connected);
         }
     }
diff --git a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
index aa48c96f20..be6e2685ec 100644
--- a/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Implementations/GlfwGamepad.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Silk.NET.Input.Common;
 using Silk.NET.Input.Desktop.Collections;
 using Ultz.Dispatcher.Unsafe;
@@ -43,54 +44,85 @@ public void Update()
             var buttons = Buttons;
             for (var i = 0; i < buttons.Count; i++)
             {
-                if (buttons[i].Pressed != (_cachedButtons.Count > i ? _cachedButtons[i] : buttons[i]).Pressed)
+                if (_cachedButtons.Count <= i)
+                {
+                    _cachedButtons[i] = default;
+                }
+                
+                if (buttons[i].Pressed != _cachedButtons[i].Pressed)
                 {
                     _cachedButtons[i] = buttons[i];
                     (buttons[i].Pressed ? ButtonDown : ButtonUp)?.Invoke(this, buttons[i]);
                 }
             }
+            
             var thumbsticks = Thumbsticks;
             for (var i = 0; i < thumbsticks.Count; i++)
             {
-                if (thumbsticks[i].X != (_cachedThumbsticks.Count > i ? _cachedThumbsticks[i] : thumbsticks[i]).X ||
-                    thumbsticks[i].Y != (_cachedThumbsticks.Count > i ? _cachedThumbsticks[i] : thumbsticks[i]).Y)
+                if (_cachedThumbsticks.Count <= i)
+                {
+                    _cachedThumbsticks[i] = default;
+                }
+
+                if (thumbsticks[i].X != _cachedThumbsticks[i].X || thumbsticks[i].Y != _cachedThumbsticks[i].Y)
                 {
                     _cachedThumbsticks[i] = thumbsticks[i];
                     ThumbstickMoved?.Invoke(this, Util.ApplyDeadzone(thumbsticks[i], Deadzone));
                 }
             }
+            
             var triggers = Triggers;
             for (var i = 0; i < triggers.Count; i++)
             {
-                if (triggers[i].Position != (_cachedTriggers.Count > i ? _cachedTriggers[i] : triggers[i]).Position)
+                if (_cachedTriggers.Count <= i)
+                {
+                    _cachedTriggers[i] = default;
+                }
+
+                if (triggers[i].Position != _cachedTriggers[i].Position)
                 {
                     _cachedTriggers[i] = triggers[i];
                     TriggerMoved?.Invoke(this, triggers[i]);
                 }
             }
         }
-        private static unsafe IReadOnlyList<Button> GetButtons(int i)
+        private unsafe IReadOnlyList<Button> GetButtons(int i)
         {
             var count = 0;
             var bytes = Util.Do(() => (UnsafeDispatch<byte>)Util.Glfw.GetJoystickButtons(i, out count));
+            if (count != _cachedButtons.Count)
+            {
+                _cachedButtons = new List<Button>();
+                _cachedButtons.AddRange(Enumerable.Range(0, count).Select(_ => (Button)default));
+            }
             return new GlfwButtonCollection(bytes, count);
         }
-        private static unsafe IReadOnlyList<Thumbstick> GetThumbsticks(int i)
+        private unsafe IReadOnlyList<Thumbstick> GetThumbsticks(int i)
         {
             var count = 0;
             var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            if (count != _cachedThumbsticks.Count)
+            {
+                _cachedThumbsticks = new List<Thumbstick>();
+                _cachedThumbsticks.AddRange(Enumerable.Range(0, count).Select(_ => (Thumbstick)default));
+            }
             fixed(float* x = new[] { floats[0], floats[2] }, y = new[] { floats[1], floats[3] })
             {
                 return new GlfwThumbstickCollection(x, y, count);
             }
         }
-        private static unsafe IReadOnlyList<Trigger> GetTriggers(int i)
+        private unsafe IReadOnlyList<Trigger> GetTriggers(int i)
         {
             var count = 0;
             var floats = Util.Do(() => (UnsafeDispatch<float>)Util.Glfw.GetJoystickAxes(i, out count));
+            if (count != _cachedTriggers.Count)
+            {
+                _cachedTriggers = new List<Trigger>();
+                _cachedTriggers.AddRange(Enumerable.Range(0, count).Select(_ => (Trigger)default));
+            }
             fixed(float* triggers = new float[] { floats[4], floats[5] })
             {
-                return new GlfwTriggerCollection(floats, count);
+                return new GlfwTriggerCollection(triggers, count);
             }
         }
     }
diff --git a/src/Input/Silk.NET.Input.Desktop/Util.cs b/src/Input/Silk.NET.Input.Desktop/Util.cs
index 93996afdaf..6e7135e2d9 100644
--- a/src/Input/Silk.NET.Input.Desktop/Util.cs
+++ b/src/Input/Silk.NET.Input.Desktop/Util.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Linq;
+using System.Threading;
 using Silk.NET.GLFW;
 using Silk.NET.Input.Common;
 using Ultz.Dispatcher.Unsafe;
@@ -15,6 +16,7 @@ namespace Silk.NET.Input.Desktop
     internal static class Util
     {
         private static string[] _glfwKeys = Enum.GetNames(typeof(Keys));
+        private static string[] _glfwButtons = Enum.GetNames(typeof(GLFW.MouseButton));
         public static object Do(Delegate @delegate)
         {
             return GlfwProvider.ThreadDispatcher.Invoke(@delegate);
@@ -39,6 +41,8 @@ public static T Do<T>(Func<T> @delegate)
         public static Glfw Glfw => GlfwProvider.GLFW.Value;
         public static Key[] SupportedKeys { get; } // this is expensive, but only runs once.
             = Enum.GetNames(typeof(Key)).Where(_glfwKeys.Contains).Select(StringToSilkKey).ToArray();
+        public static MouseButton[] SupportedButtons { get; } // this is expensive, but only runs once.
+            = Enum.GetNames(typeof(MouseButton)).Where(_glfwButtons.Contains).Select(StringToSilkButton).ToArray();
 
         public static Key StringToSilkKey(string s)
         {
@@ -46,7 +50,17 @@ public static Key StringToSilkKey(string s)
             {
                 return k;
             }
-            throw new ArgumentOutOfRangeException(nameof(s), $"Key name mismatch (couldn't find a Key value for {s}");
+            throw new ArgumentOutOfRangeException(nameof(s), $"Key name mismatch (couldn't find a Key value for {s})");
+        }
+        
+        public static ButtonName IntToSilkButton(int i)
+        {
+            var s = ((GamepadButton) i).ToString();
+            if (Enum.TryParse<ButtonName>(s, out var k))
+            {
+                return k;
+            }
+            throw new ArgumentOutOfRangeException(nameof(s), $"Button name mismatch (couldn't find a ButtonName value for {s})");
         }
 
         public static Keys SilkKeyToGlfwKey(Key k)
@@ -67,6 +81,15 @@ public static Key GlfwKeyToSilkKey(Keys k)
             throw new ArgumentOutOfRangeException(nameof(k));
         }
 
+        public static MouseButton StringToSilkButton(string s)
+        {
+            if (Enum.TryParse<MouseButton>(s, out var k))
+            {
+                return k;
+            }
+            throw new ArgumentOutOfRangeException(nameof(s), $"Button name mismatch (couldn't find a MouseButton value for {s})");
+        }
+
         public static MouseButton GlfwButtonToSilkButton(GLFW.MouseButton k)
         {
             if (Enum.TryParse<MouseButton>(k.ToString(), out var sk))
diff --git a/src/Windowing/Silk.NET.GLFW/Enums/GamepadButton.cs b/src/Windowing/Silk.NET.GLFW/Enums/GamepadButton.cs
new file mode 100644
index 0000000000..d4e2390869
--- /dev/null
+++ b/src/Windowing/Silk.NET.GLFW/Enums/GamepadButton.cs
@@ -0,0 +1,26 @@
+// This file is part of Silk.NET.
+// 
+// You may modify and distribute Silk.NET under the terms
+// of the MIT license. See the LICENSE file for details.
+
+namespace Silk.NET.GLFW
+{
+    public enum GamepadButton
+    {
+        A,
+        B,
+        X,
+        Y,
+        LeftBumper,
+        RightBumper,
+        Back,
+        Start,
+        Home,
+        LeftStick,
+        RightStick,
+        DPadUp,
+        DPadRight,
+        DPadDown,
+        DPadLeft
+    }
+}
diff --git a/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs b/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
index d93369d463..11cbeb5742 100644
--- a/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
+++ b/src/Windowing/Silk.NET.GLFW/Enums/MouseButton.cs
@@ -10,17 +10,13 @@ namespace Silk.NET.GLFW
     /// </summary>
     public enum MouseButton
     {
-        Button1 = 0,
-        Button2,
-        Button3,
+        Left = 0,
+        Right,
+        Middle,
         Button4,
         Button5,
         Button6,
         Button7,
-        Button8,
-        ButtonLast = Button8,
-        ButtonLeft = Button1,
-        ButtonRight = Button2,
-        ButtonMiddle = Button3
+        Button8
     }
 }
\ No newline at end of file

From 8b7913fdef3761f1cbb60225e6b8306b9f849fec Mon Sep 17 00:00:00 2001
From: Dylan Perks <dylanperks23@gmail.com>
Date: Sun, 4 Aug 2019 16:53:24 +0100
Subject: [PATCH 42/46] Update GlfwInputContext.cs

---
 src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index 8715756bd5..d84cf4a2d1 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -17,8 +17,8 @@ public class GlfwInputContext : IInputContext
     {
         internal List<GlfwGamepad> _gamepads;
         internal List<GlfwJoystick> _joysticks;
-        internal IKeyboard _keyboard;
-        internal IMouse _mouse;
+        internal GlfwKeyboard _keyboard;
+        internal GlfwMouse _mouse;
         internal IWindow _window;
 
         public GlfwInputContext(IWindow window)
@@ -74,7 +74,6 @@ public void WindowUpdate(double obj)
 
         public void RaiseConnectionChange(int joystick, ConnectedState state)
         {
-            Console.WriteLine("Connection Change " + joystick + ", " + state);
             ConnectionChanged?.Invoke(Joysticks[joystick], state == ConnectedState.Connected);
         }
     }

From 066670443517abe30c6ffd59a685a1dcb00d7bed Mon Sep 17 00:00:00 2001
From: Dylan Perks <dylanperks23@gmail.com>
Date: Sun, 4 Aug 2019 16:57:38 +0100
Subject: [PATCH 43/46] Update Silk.NET.Input.Desktop.csproj

---
 .../Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj     | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj b/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
index 8cf80aab22..7b36b0dfae 100644
--- a/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
+++ b/src/Input/Silk.NET.Input.Desktop/Silk.NET.Input.Desktop.csproj
@@ -3,6 +3,7 @@
     <PropertyGroup>
         <TargetFramework>netstandard2.0</TargetFramework>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+        <LangVersion>latest</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
@@ -11,9 +12,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Reference Include="System.Memory, Version=4.0.1.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51">
-        <HintPath>..\..\..\..\..\..\.nuget\packages\system.memory\4.5.2\lib\netstandard2.0\System.Memory.dll</HintPath>
-      </Reference>
+      <PackageReference Include="System.Memory" Version="4.5.3" />
     </ItemGroup>
     
     <Import Project="..\..\..\build\props\common.props" />

From 1fd3852c3857b507daca06839f52b1d22c6f995f Mon Sep 17 00:00:00 2001
From: Dylan Perks <dylanperks23@gmail.com>
Date: Sun, 4 Aug 2019 17:08:23 +0100
Subject: [PATCH 44/46] Update GlfwInputContext.cs

---
 src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index d84cf4a2d1..ac5e61fc9e 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -19,9 +19,9 @@ public class GlfwInputContext : IInputContext
         internal List<GlfwJoystick> _joysticks;
         internal GlfwKeyboard _keyboard;
         internal GlfwMouse _mouse;
-        internal IWindow _window;
+        internal GlfwWindow _window;
 
-        public GlfwInputContext(IWindow window)
+        public GlfwInputContext(GlfwWindow window)
         {
             Handle = window.Handle;
             _window = window;

From 4c404b39091e84420676ba622b08cc61cab3dd7b Mon Sep 17 00:00:00 2001
From: Dylan Perks <dylanperks23@gmail.com>
Date: Sun, 4 Aug 2019 17:09:31 +0100
Subject: [PATCH 45/46] Update InputHandler.cs

---
 src/Input/Silk.NET.Input.Desktop/InputHandler.cs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
index 2ea74504d8..a9b6f42d39 100644
--- a/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
+++ b/src/Input/Silk.NET.Input.Desktop/InputHandler.cs
@@ -33,9 +33,10 @@ public static unsafe void RegisterContext(GlfwInputContext ctx)
             Contexts.Add(ctx);
 
             // register callbacks
-            Util.Do(() => Util.Glfw.SetKeyCallback((WindowHandle*) ctx._window.Handle, KeyCallback));
-            Util.Do(() => Util.Glfw.SetMouseButtonCallback((WindowHandle*)ctx._window.Handle, MouseCallback));
-            Util.Do(() => Util.Glfw.SetScrollCallback((WindowHandle*)ctx._window.Handle, ScrollCallback));
+            var handle = (WindowHandle*) ctx._window.Handle;
+            Util.Do(() => Util.Glfw.SetKeyCallback(handle, KeyCallback));
+            Util.Do(() => Util.Glfw.SetMouseButtonCallback(handle, MouseCallback));
+            Util.Do(() => Util.Glfw.SetScrollCallback(handle, ScrollCallback));
             ctx._window.OnUpdate += ctx.WindowUpdate;
         }
 

From 1ca81fb7abbab95bfe4ea9ff7c5ada9c26b8a0ff Mon Sep 17 00:00:00 2001
From: Dylan Perks <dylanperks23@gmail.com>
Date: Sun, 4 Aug 2019 17:12:16 +0100
Subject: [PATCH 46/46] Update GlfwInputContext.cs

---
 src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
index ac5e61fc9e..64a1f0caa8 100644
--- a/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
+++ b/src/Input/Silk.NET.Input.Desktop/GlfwInputContext.cs
@@ -10,6 +10,8 @@
 using Silk.NET.Input.Common;
 using Silk.NET.Input.Desktop.Collections;
 using Silk.NET.Windowing.Common;
+using Silk.NET.Windowing.Desktop;
+
 
 namespace Silk.NET.Input.Desktop
 {