Outsource Windows API definitions (extern) to CsWin32

Author: YoshiRulz

Directory.Packages.props

@@ -18,6 +18,7 @@
 		<PackageVersion Include="Microsoft.Data.Sqlite.Core" Version="8.0.4" />
 		<PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
 		<PackageVersion Include="Microsoft.Win32.Registry" Version="5.0.0" />
+		<PackageVersion Include="Microsoft.Windows.CsWin32" Version="0.3.183" />
 		<PackageVersion Include="MSTest" Version="3.8.3" />
 		<PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
 		<PackageVersion Include="Nullable" Version="1.3.1" />

src/BizHawk.Bizware.Input/KeyMouseInput/RawKeyMouseInput.cs

@@ -7,21 +7,28 @@
 using BizHawk.Common;
 using BizHawk.Common.CollectionExtensions;
 
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.UI.Input;
+using Windows.Win32.UI.Input.KeyboardAndMouse;
+using Windows.Win32.UI.WindowsAndMessaging;
+
 using static BizHawk.Common.RawInputImports;
-using static BizHawk.Common.WmImports;
+using static BizHawk.Common.WmImports1;
+using static Windows.Win32.Win32Imports;
 
 namespace BizHawk.Bizware.Input
 {
 	/// <summary>
 	/// Note: Only 1 window per device class (e.g. keyboards) is actually allowed to use RAWINPUT (last one to call RegisterRawInputDevices)
 	/// So only one instance can actually be used at the same time
 	/// </summary>
-	internal sealed class RawKeyMouseInput : IKeyMouseInput
+	internal sealed unsafe class RawKeyMouseInput : IKeyMouseInput
 	{
 		private const int WM_CLOSE = 0x0010;
 		private const int WM_INPUT = 0x00FF;
 
-		private IntPtr RawInputWindow;
+		private HWND RawInputWindow;
 		private bool _handleAltKbLayouts;
 		private List<KeyEvent> _keyEvents = [ ];
 		private (int X, int Y) _mouseDelta;
@@ -33,27 +40,29 @@ internal sealed class RawKeyMouseInput : IKeyMouseInput
 		private int RawInputBufferSize;
 		private readonly int RawInputBufferDataOffset;
 
-		private static readonly WNDPROC _wndProc = WndProc;
-
-		private static readonly Lazy<IntPtr> _rawInputWindowAtom = new(() =>
+		private static unsafe readonly Lazy<PCWSTR> _rawInputWindowAtom = new(() =>
 		{
-			var wc = default(WNDCLASSW);
-			wc.lpfnWndProc = _wndProc;
-			wc.hInstance = LoaderApiImports.GetModuleHandleW(null);
-			wc.lpszClassName = "RawKeyMouseInputClass";
-
-			var atom = RegisterClassW(ref wc);
-			if (atom == IntPtr.Zero)
+			WNDCLASSW wc = default;
+			wc.lpfnWndProc = WndProc;
+			wc.hInstance = GetModuleHandleW(default(PCWSTR));
+			var lpszClassNameStr = "RawKeyMouseInputClass";
+			PCWSTR atom;
+			fixed (char* lpszClassName = lpszClassNameStr)
+			{
+				wc.lpszClassName = lpszClassName;
+				atom = MAKEINTATOM(RegisterClassW(in wc));
+			}
+			if (atom.Value is null)
 			{
 				throw new InvalidOperationException("Failed to register RAWINPUT window class");
 			}
 
 			return atom;
 		});
 
-		private static unsafe IntPtr WndProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam)
+		private static LRESULT WndProc(HWND hWnd, uint uMsg, WPARAM wParam, LPARAM lParam)
 		{
-			var ud = GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+			var ud = GetWindowLongPtrW(hWnd, WINDOW_LONG_PTR_INDEX.GWLP_USERDATA);
 			if (ud == IntPtr.Zero)
 			{
 				return DefWindowProcW(hWnd, uMsg, wParam, lParam);
@@ -65,7 +74,7 @@ private static unsafe IntPtr WndProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntP
 			{
 				if (uMsg == WM_CLOSE)
 				{
-					SetWindowLongPtrW(hWnd, GWLP_USERDATA, IntPtr.Zero);
+					SetWindowLongPtrW(hWnd, WINDOW_LONG_PTR_INDEX.GWLP_USERDATA, IntPtr.Zero);
 					handle = GCHandle.FromIntPtr(ud);
 					rawKeyMouseInput = (RawKeyMouseInput)handle.Target;
 					Marshal.FreeCoTaskMem(rawKeyMouseInput.RawInputBuffer);
@@ -75,36 +84,48 @@ private static unsafe IntPtr WndProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntP
 				return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 			}
 
-			if (GetRawInputData(lParam, RID.INPUT, IntPtr.Zero,
-					out var size, sizeof(RAWINPUTHEADER)) == -1)
+			uint size = default;
+			if (GetRawInputData(
+				new(lParam),
+				RAW_INPUT_DATA_COMMAND_FLAGS.RID_INPUT,
+				pData: default,
+				ref size,
+				cbSizeHeader: unchecked((uint) sizeof(RAWINPUTHEADER)))
+					is uint.MaxValue/*-1*/)
 			{
 				return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 			}
 
 			// don't think size should ever be this big, but just in case
+			var allocOnHeap = size > 1024;
 			// also, make sure to align the buffer to a pointer boundary
-			var buffer = size > 1024
-				? new IntPtr[(size + sizeof(IntPtr) - 1) / sizeof(IntPtr)]
-				: stackalloc IntPtr[(size + sizeof(IntPtr) - 1) / sizeof(IntPtr)];
+			var roundedSize = unchecked((int) (size / sizeof(IntPtr)));
+			if ((size & 0b11U) is not 0U) roundedSize++;
+			var buffer = allocOnHeap ? new IntPtr[roundedSize] : stackalloc IntPtr[roundedSize];
 
 			handle = GCHandle.FromIntPtr(ud);
 			rawKeyMouseInput = (RawKeyMouseInput)handle.Target;
 
 			fixed (IntPtr* p = buffer)
 			{
 				var input = (RAWINPUT*)p;
-				if (GetRawInputData(lParam, RID.INPUT, input,
-						ref size, sizeof(RAWINPUTHEADER)) == -1)
+				if (GetRawInputData(
+					new(lParam),
+					RAW_INPUT_DATA_COMMAND_FLAGS.RID_INPUT,
+					pData: input,
+					ref size,
+					cbSizeHeader: unchecked((uint) sizeof(RAWINPUTHEADER)))
+						is uint.MaxValue/*-1*/)
 				{
 					return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 				}
 
-				if (input->header.dwType == RAWINPUTHEADER.RIM_TYPE.KEYBOARD)
+				if (input->header.dwType == RIM_TYPE.KEYBOARD)
 				{
 					rawKeyMouseInput.AddKeyInput(&input->data.keyboard);
 				}
 
-				if (input->header.dwType == RAWINPUTHEADER.RIM_TYPE.MOUSE)
+				if (input->header.dwType == RIM_TYPE.MOUSE)
 				{
 					rawKeyMouseInput.AddMouseInput(&input->data.mouse);
 				}
@@ -113,14 +134,14 @@ private static unsafe IntPtr WndProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntP
 			while (true)
 			{
 				var rawInputBuffer = (RAWINPUT*)rawKeyMouseInput.RawInputBuffer;
-				size = rawKeyMouseInput.RawInputBufferSize;
-				var count = GetRawInputBuffer(rawInputBuffer, ref size, sizeof(RAWINPUTHEADER));
+				size = unchecked((uint) rawKeyMouseInput.RawInputBufferSize);
+				var count = GetRawInputBuffer(rawInputBuffer, ref size, unchecked((uint) sizeof(RAWINPUTHEADER)));
 				if (count == 0)
 				{
 					break;
 				}
 
-				if (count == -1)
+				if (count is uint.MaxValue/*-1*/)
 				{
 					// From testing, it appears this never actually occurs in practice
 					// As GetRawInputBuffer will succeed as long as the buffer has room for at least 1 packet
@@ -136,15 +157,15 @@ private static unsafe IntPtr WndProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntP
 					break;
 				}
 
-				for (var i = 0u; i < (uint)count; i++)
+				for (var i = 0U; i < count; i++)
 				{
-					if (rawInputBuffer->header.dwType == RAWINPUTHEADER.RIM_TYPE.KEYBOARD)
+					if (rawInputBuffer->header.dwType == RIM_TYPE.KEYBOARD)
 					{
 						var keyboard = (RAWKEYBOARD*)((byte*)&rawInputBuffer->data.keyboard + rawKeyMouseInput.RawInputBufferDataOffset);
 						rawKeyMouseInput.AddKeyInput(keyboard);
 					}
 
-					if (rawInputBuffer->header.dwType == RAWINPUTHEADER.RIM_TYPE.MOUSE)
+					if (rawInputBuffer->header.dwType == RIM_TYPE.MOUSE)
 					{
 						var mouse = (RAWMOUSE*)((byte*)&rawInputBuffer->data.mouse + rawKeyMouseInput.RawInputBufferDataOffset);
 						rawKeyMouseInput.AddMouseInput(mouse);
@@ -157,20 +178,20 @@ private static unsafe IntPtr WndProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntP
 				}
 			}
 
-			return IntPtr.Zero;
+			return default;
 		}
 
 		private unsafe void AddKeyInput(RAWKEYBOARD* keyboard)
 		{
-			if ((keyboard->Flags & ~(RAWKEYBOARD.RI_KEY.E0 | RAWKEYBOARD.RI_KEY.BREAK)) == 0)
+			if ((keyboard->Flags & ~(RI_KEY.E0 | RI_KEY.BREAK)) == 0)
 			{
-				var rawKey = (RawKey)(keyboard->MakeCode | ((keyboard->Flags & RAWKEYBOARD.RI_KEY.E0) != 0 ? 0x80 : 0));
+				var rawKey = (RawKey)(keyboard->MakeCode | ((keyboard->Flags & RI_KEY.E0) != 0 ? 0x80 : 0));
 
 				// kind of a dumb hack, the Pause key is apparently special here
 				// keyboards would send scancode 0x1D with an E1 prefix, followed by 0x45 (which is NumLock!)
 				// this "NumLock" press will set the VKey to 255 (invalid VKey), so we can use that to know if this is actually a Pause press
 				// (note that DIK_PAUSE is just 0x45 with an E0 prefix, although this is likely just a conversion DirectInput does internally)
-				if (rawKey == RawKey.NUMLOCK && keyboard->VKey == VirtualKey.VK_NONE)
+				if (rawKey is RawKey.NUMLOCK && (VirtualKey) keyboard->VKey is VirtualKey.VK_NONE)
 				{
 					rawKey = RawKey.PAUSE;
 				}
@@ -182,62 +203,64 @@ private unsafe void AddKeyInput(RAWKEYBOARD* keyboard)
 
 				if (KeyEnumMap.TryGetValue(rawKey, out var key))
 				{
-					_keyEvents.Add(new(key, (keyboard->Flags & RAWKEYBOARD.RI_KEY.BREAK) == RAWKEYBOARD.RI_KEY.MAKE));
+					_keyEvents.Add(new(key, (keyboard->Flags & RI_KEY.BREAK) == RI_KEY.MAKE));
 				}
 			}
 		}
 
 		private unsafe void AddMouseInput(RAWMOUSE* mouse)
 		{
 			// raw input usually doesn't report absolute inputs, only in odd cases with e.g. touchscreen and rdp screen
-			if ((mouse->usFlags & RAWMOUSE.MOUSE_FLAGS.MOVE_ABSOLUTE) == RAWMOUSE.MOUSE_FLAGS.MOVE_ABSOLUTE)
+			if ((mouse->usFlags & MOUSE_STATE.MOUSE_MOVE_ABSOLUTE) == MOUSE_STATE.MOUSE_MOVE_ABSOLUTE)
 			{
 				_mouseDelta.X += mouse->lLastX - _lastMouseAbsPos.X;
 				_mouseDelta.Y += mouse->lLastY - _lastMouseAbsPos.Y;
 				_lastMouseAbsPos = (mouse->lLastX, mouse->lLastY);
 			}
-			else // ((mouse->usFlags & RAWMOUSE.MOUSE_FLAGS.MOVE_ABSOLUTE) == RAWMOUSE.MOUSE_FLAGS.MOVE_RELATIVE)
+			else // ((mouse->usFlags & MOUSE_STATE.MOUSE_MOVE_ABSOLUTE) == MOUSE_STATE.MOUSE_MOVE_RELATIVE)
 			{
 				_mouseDelta.X += mouse->lLastX;
 				_mouseDelta.Y += mouse->lLastY;
 			}
 		}
 
-		private static IntPtr CreateRawInputWindow()
+		private static unsafe HWND CreateRawInputWindow()
 		{
-			const int WS_CHILD = 0x40000000;
-			var window = CreateWindowExW(
+			var lpWindowNameStr = "RawKeyInput";
+			HWND window;
+			fixed (char* lpWindowName = lpWindowNameStr)
+			{
+				window = CreateWindowExW(
 					dwExStyle: 0,
 					lpClassName: _rawInputWindowAtom.Value,
-					lpWindowName: "RawKeyInput",
-					dwStyle: WS_CHILD,
+					lpWindowName: lpWindowName,
+					dwStyle: WINDOW_STYLE.WS_CHILD,
 					X: 0,
 					Y: 0,
 					nWidth: 1,
 					nHeight: 1,
-					hWndParent: HWND_MESSAGE,
-					hMenu: IntPtr.Zero,
-					hInstance: LoaderApiImports.GetModuleHandleW(null),
-					lpParam: IntPtr.Zero);
-
-			if (window == IntPtr.Zero)
+					hWndParent: HWND.HWND_MESSAGE,
+					hMenu: default,
+					hInstance: GetModuleHandleW(default(PCWSTR)),
+					lpParam: default);
+			}
+			if (window.IsNull)
 			{
 				throw new InvalidOperationException("Failed to create RAWINPUT window");
 			}
 
 			unsafe
 			{
-				var rid = stackalloc RAWINPUTDEVICE[2];
-				rid[0].usUsagePage = RAWINPUTDEVICE.HidUsagePage.GENERIC;
-				rid[0].usUsage = RAWINPUTDEVICE.HidUsageId.GENERIC_KEYBOARD;
-				rid[0].dwFlags = RAWINPUTDEVICE.RIDEV.INPUTSINK;
+				Span<RAWINPUTDEVICE> rid = stackalloc RAWINPUTDEVICE[2];
+				rid[0].usUsagePage = HidUsagePage.GENERIC;
+				rid[0].usUsage = HidUsageId.GENERIC_KEYBOARD;
+				rid[0].dwFlags = RAWINPUTDEVICE_FLAGS.RIDEV_INPUTSINK;
 				rid[0].hwndTarget = window;
-				rid[1].usUsagePage = RAWINPUTDEVICE.HidUsagePage.GENERIC;
-				rid[1].usUsage = RAWINPUTDEVICE.HidUsageId.GENERIC_MOUSE;
-				rid[1].dwFlags = RAWINPUTDEVICE.RIDEV.INPUTSINK;
+				rid[1].usUsagePage = HidUsagePage.GENERIC;
+				rid[1].usUsage = HidUsageId.GENERIC_MOUSE;
+				rid[1].dwFlags = RAWINPUTDEVICE_FLAGS.RIDEV_INPUTSINK;
 				rid[1].hwndTarget = window;
-
-				if (!RegisterRawInputDevices(rid, 2, sizeof(RAWINPUTDEVICE)))
+				if (!RegisterRawInputDevices(rid, unchecked((uint) sizeof(RAWINPUTDEVICE))))
 				{
 					DestroyWindow(window);
 					throw new InvalidOperationException("Failed to register RAWINPUTDEVICE");
@@ -280,11 +303,11 @@ public void Dispose()
 		{
 			lock (_lockObj)
 			{
-				if (RawInputWindow != IntPtr.Zero)
+				if (!RawInputWindow.IsNull)
 				{
 					// Can't use DestroyWindow, that's only allowed in the thread that created the window!
-					PostMessageW(RawInputWindow, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
-					RawInputWindow = IntPtr.Zero;
+					PostMessageW(RawInputWindow, WM_CLOSE, default, default);
+					RawInputWindow = HWND.Null;
 				}
 				else
 				{
@@ -310,15 +333,20 @@ public IEnumerable<KeyEvent> UpdateKeyInputs(bool handleAltKbLayouts)
 				{
 					RawInputWindow = CreateRawInputWindow();
 					var handle = GCHandle.Alloc(this, GCHandleType.Normal);
-					SetWindowLongPtrW(RawInputWindow, GWLP_USERDATA, GCHandle.ToIntPtr(handle));
+					SetWindowLongPtrW(RawInputWindow, WINDOW_LONG_PTR_INDEX.GWLP_USERDATA, GCHandle.ToIntPtr(handle));
 				}
 
 				_handleAltKbLayouts = handleAltKbLayouts;
 
-				while (PeekMessageW(out var msg, RawInputWindow, 0, 0, PM_REMOVE))
+				while (PeekMessageW(
+					out var msg,
+					RawInputWindow,
+					wMsgFilterMin: 0,
+					wMsgFilterMax: 0,
+					PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE))
 				{
-					TranslateMessage(ref msg);
-					DispatchMessageW(ref msg);
+					TranslateMessage(in msg);
+					DispatchMessageW(in msg);
 				}
 
 				var ret = _keyEvents;
@@ -340,13 +368,13 @@ public IEnumerable<KeyEvent> UpdateKeyInputs(bool handleAltKbLayouts)
 				{
 					RawInputWindow = CreateRawInputWindow();
 					var handle = GCHandle.Alloc(this, GCHandleType.Normal);
-					SetWindowLongPtrW(RawInputWindow, GWLP_USERDATA, GCHandle.ToIntPtr(handle));
+					SetWindowLongPtrW(RawInputWindow, WINDOW_LONG_PTR_INDEX.GWLP_USERDATA, GCHandle.ToIntPtr(handle));
 				}
 
-				while (PeekMessageW(out var msg, RawInputWindow, 0, 0, PM_REMOVE))
+				while (PeekMessageW(out var msg, RawInputWindow, 0, 0, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE))
 				{
-					TranslateMessage(ref msg);
-					DispatchMessageW(ref msg);
+					TranslateMessage(in msg);
+					DispatchMessageW(in msg);
 				}
 
 				var ret = _mouseDelta;
@@ -395,8 +423,7 @@ private static RawKey MapToRealKeyViaScanCode(RawKey key)
 				scanCode |= 0xE000;
 			}
 
-			const uint MAPVK_VSC_TO_VK_EX = 0x03;
-			var virtualKey = (VirtualKey)MapVirtualKeyW(scanCode, MAPVK_VSC_TO_VK_EX);
+			var virtualKey = (VirtualKey) MapVirtualKeyW(scanCode, MAP_VIRTUAL_KEY_TYPE.MAPVK_VSC_TO_VK_EX);
 			return VKeyToRawKeyMap.GetValueOrDefault(virtualKey);
 		}
 

src/BizHawk.Bizware.Input/SDL2/SDL2InputAdapter.cs

@@ -9,6 +9,8 @@
 using BizHawk.Common.NumberExtensions;
 #endif
 
+using Windows.Win32.UI.WindowsAndMessaging;
+
 using static SDL2.SDL;
 
 #pragma warning disable BHI1007 // target-typed Exception TODO don't
@@ -49,10 +51,15 @@ private static void DoSDLEventLoop()
 				// similar code shouldn't be needed on other platforms (which have global message queues and not thread local message queues)
 				if (!OSTailoredCode.IsUnixHost)
 				{
-					while (WmImports.PeekMessageW(out var msg, IntPtr.Zero, 0, 0, WmImports.PM_REMOVE))
+					while (WmImports.PeekMessageW(
+						out var msg,
+						hWnd: default,
+						wMsgFilterMin: 0,
+						wMsgFilterMax: 0,
+						PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE))
 					{
-						WmImports.TranslateMessage(ref msg);
-						WmImports.DispatchMessageW(ref msg);
+						WmImports.TranslateMessage(in msg);
+						WmImports.DispatchMessageW(in msg);
 					}
 				}