wehub-resource-sync
735 lines
27 KiB
C#
735 lines
27 KiB
C#
using System.Collections;
|
|
using System.Runtime.InteropServices;
|
|
using T3.Editor.App;
|
|
|
|
// Drawn heavily from Emma Burrows code project sample
|
|
// which closely follows the C++ MS WM_INPUT sample.
|
|
|
|
namespace T3.Editor.Gui.Interaction.Camera;
|
|
|
|
public sealed partial class SpaceMouse
|
|
{
|
|
public sealed class SpaceMouseDevice: IWindowsFormsMessageHandler
|
|
{
|
|
#region const definitions
|
|
|
|
private const int RIDEV_INPUTSINK = 0x00000100;
|
|
private const int RID_HEADER = 0x10000005;
|
|
private const int RID_INPUT = 0x10000003;
|
|
|
|
private const int HID_USAGE_GENERIC_MULTIAXIS_CONTROLLER = 0x08;
|
|
private const int HID_USAGE_PAGE_GENERIC = 0x01;
|
|
private const int LOGITECH_3DX_VID = 0x046d;
|
|
private const int SIZEOF_STANDARD_REPORT = 15;
|
|
|
|
private const int FAPPCOMMAND_MASK = 0xF000;
|
|
private const int FAPPCOMMAND_MOUSE = 0x8000;
|
|
private const int FAPPCOMMAND_OEM = 0x1000;
|
|
|
|
private const int RIM_TYPEHID = 2;
|
|
|
|
private const int RIDI_DEVICENAME = 0x20000007; // return length is the character length not the byte size
|
|
private const int RIDI_DEVICEINFO = 0x2000000b;
|
|
|
|
private const int WM_INPUT = 0x00FF;
|
|
|
|
|
|
#endregion const definitions
|
|
|
|
#region structs & enums
|
|
|
|
public enum RAW3DxMouseEventType
|
|
{
|
|
TranslationVector = 1,
|
|
RotationVector = 2,
|
|
ButtonReport = 3
|
|
}
|
|
|
|
#region Windows.h structure declarations
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAWINPUTDEVICELIST
|
|
{
|
|
public IntPtr hDevice;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwType;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAWINPUTHEADER
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwType;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwSize;
|
|
|
|
public IntPtr hDevice;
|
|
public int wParam;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAWHID
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwSizHid;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwCount;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RID_DEVICE_INFO_HID
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int cbSize;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwType;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwVendorID;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwProductID;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwVersionNumber;
|
|
|
|
[MarshalAs(UnmanagedType.U2)]
|
|
public short usUsagePage;
|
|
|
|
[MarshalAs(UnmanagedType.U2)]
|
|
public short usUsage;
|
|
|
|
[MarshalAs(UnmanagedType.U4)] // padding to get the size right
|
|
public int unused1;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int unused2;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct BUTTONSSTR
|
|
{
|
|
[MarshalAs(UnmanagedType.U2)]
|
|
public ushort usButtonFlags;
|
|
|
|
[MarshalAs(UnmanagedType.U2)]
|
|
public ushort usButtonData;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAW3DMOUSE_EVENTTYPE
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwSizeHid; // byte size of each report
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwCount; // number of input packed
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte eventType; // 1 for translation vector, 2 for rot vector, 3 for buttons
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAW3DMOUSEMOTION_T
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwSizeHid; // byte size of each report
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwCount; // number of input packed
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte eventType; // 1 for translation vector
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte X_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte X_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Y_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Y_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Z_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Z_hb;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAW3DMOUSEMOTION_TR_COMBINED
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwSizeHid; // byte size of each report
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwCount; // number of input packed
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte eventType; // 1 for translation vector
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte X_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte X_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Y_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Y_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Z_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Z_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte RX_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte RX_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte RY_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte RY_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte RZ_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte RZ_hb;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAW3DMOUSEMOTION_R
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwSizeHid; // byte size of each report
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwCount; // number of input packed
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte eventType; // 2 for rotation vector
|
|
|
|
public byte X_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte X_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Y_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Y_hb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Z_lb;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte Z_hb;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAW3DMOUSEBUTTONS
|
|
{
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwSizeHid; // byte size of each report
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwCount; // number of input packed
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte eventType; // 3 for buttons report
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte b1;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte b2;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte b3;
|
|
|
|
[MarshalAs(UnmanagedType.U1)]
|
|
public byte b4;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
internal struct RAWINPUTDEVICE
|
|
{
|
|
[MarshalAs(UnmanagedType.U2)]
|
|
public ushort usUsagePage;
|
|
|
|
[MarshalAs(UnmanagedType.U2)]
|
|
public ushort usUsage;
|
|
|
|
[MarshalAs(UnmanagedType.U4)]
|
|
public int dwFlags;
|
|
|
|
public IntPtr hwndTarget;
|
|
}
|
|
#endregion Windows.h structure declarations
|
|
|
|
/// <summary>
|
|
/// Class encapsulating the information about a
|
|
/// keyboard event, including the device it
|
|
/// originated with and what key was pressed
|
|
/// </summary>
|
|
public class DeviceInfo
|
|
{
|
|
public string deviceName;
|
|
public IntPtr deviceHandle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// ButtonMask from device
|
|
/// </summary>
|
|
public sealed class ButtonMask
|
|
{
|
|
public ButtonMask(byte b1, byte b2, byte b3, byte b4)
|
|
{
|
|
this.mask = (System.UInt32)(b1 + (b2 << 8) + (b3 << 16) + (b4 << 24));
|
|
}
|
|
|
|
public UInt32 Mask { get { return mask; } set { mask = value; } }
|
|
|
|
public UInt32 Pressed { get { return mask; } }
|
|
|
|
private System.UInt32 mask;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Translation Vector from device
|
|
/// </summary>
|
|
public sealed class TranslationVector
|
|
{
|
|
public TranslationVector(int x, int y, int z)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
}
|
|
|
|
public TranslationVector(byte xl, byte xh, byte yl, byte yh, byte zl, byte zh)
|
|
{
|
|
this.x = (int)(xl + (System.Int16)((System.Int16)xh << 8));
|
|
this.y = (int)(yl + (System.Int16)((System.Int16)yh << 8));
|
|
this.z = (int)(zl + (System.Int16)((System.Int16)zh << 8));
|
|
}
|
|
|
|
public int X { get { return x; } set { x = value; } }
|
|
public int Y { get { return y; } set { y = value; } }
|
|
public int Z { get { return z; } set { z = value; } }
|
|
|
|
private int x;
|
|
private int y;
|
|
private int z;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rotation Vector from device
|
|
/// </summary>
|
|
public sealed class RotationVector
|
|
{
|
|
public RotationVector(int x, int y, int z)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
}
|
|
|
|
public RotationVector(byte xl, byte xh, byte yl, byte yh, byte zl, byte zh)
|
|
{
|
|
this.x = (int)(xl + (System.Int16)((System.Int16)xh << 8));
|
|
this.y = (int)(yl + (System.Int16)((System.Int16)yh << 8));
|
|
this.z = (int)(zl + (System.Int16)((System.Int16)zh << 8));
|
|
}
|
|
|
|
public int X { get { return x; } set { x = value; } }
|
|
public int Y { get { return y; } set { y = value; } }
|
|
public int Z { get { return z; } set { z = value; } }
|
|
|
|
private int x;
|
|
private int y;
|
|
private int z;
|
|
|
|
}
|
|
|
|
#endregion structs & enums
|
|
|
|
#region DllImports
|
|
|
|
[DllImport("User32.dll")]
|
|
private static extern uint GetRawInputDeviceList(IntPtr pRawInputDeviceList, ref uint uiNumDevices, uint cbSize);
|
|
|
|
[DllImport("User32.dll")]
|
|
private static extern uint GetRawInputDeviceInfo(IntPtr hDevice, uint uiCommand, IntPtr pData, ref uint pcbSize);
|
|
|
|
[DllImport("User32.dll")]
|
|
private static extern bool RegisterRawInputDevices(RAWINPUTDEVICE[] pRawInputDevice, uint uiNumDevices, uint cbSize);
|
|
|
|
[DllImport("User32.dll")]
|
|
private static extern uint GetRawInputData(IntPtr hRawInput, uint uiCommand, IntPtr pData, ref uint pcbSize, uint cbSizeHeader);
|
|
|
|
#endregion DllImports
|
|
|
|
#region Variables and event handling
|
|
|
|
/// <summary>
|
|
/// List of 3Dx devices
|
|
/// Key: the device handle
|
|
/// Value: the device info class
|
|
/// </summary>
|
|
private readonly Hashtable _deviceList = new();
|
|
|
|
//Event and delegate
|
|
public delegate void MotionEventHandler(object sender, MotionEventArgs e);
|
|
|
|
public event MotionEventHandler MotionEvent;
|
|
|
|
public delegate void ButtonEventHandler(object sender, ButtonEventArgs e);
|
|
|
|
public event ButtonEventHandler ButtonEvent;
|
|
|
|
/// <summary>
|
|
/// Arguments provided by the handler for a motion event
|
|
/// </summary>
|
|
public sealed class MotionEventArgs : EventArgs
|
|
{
|
|
private DeviceInfo _deviceInfo;
|
|
private TranslationVector _translationVector;
|
|
private RotationVector _rotationVector;
|
|
|
|
public MotionEventArgs(DeviceInfo dInfo, TranslationVector translationVector, RotationVector rotationVector)
|
|
{
|
|
_deviceInfo = dInfo;
|
|
_translationVector = translationVector;
|
|
_rotationVector = rotationVector;
|
|
}
|
|
|
|
public MotionEventArgs(DeviceInfo dInfo, TranslationVector translationVector)
|
|
{
|
|
_deviceInfo = dInfo;
|
|
_translationVector = translationVector;
|
|
}
|
|
|
|
public MotionEventArgs(DeviceInfo dInfo, RotationVector rotationVector)
|
|
{
|
|
_deviceInfo = dInfo;
|
|
_rotationVector = rotationVector;
|
|
}
|
|
|
|
public MotionEventArgs()
|
|
{
|
|
}
|
|
|
|
public TranslationVector TranslationVector { get { return _translationVector; } set { _translationVector = value; } }
|
|
|
|
public RotationVector RotationVector { get { return _rotationVector; } set { _rotationVector = value; } }
|
|
|
|
public DeviceInfo DeviceInfo { get { return _deviceInfo; } set { _deviceInfo = value; } }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Arguments provided by the handler for a button event
|
|
/// </summary>
|
|
public sealed class ButtonEventArgs : EventArgs
|
|
{
|
|
private DeviceInfo _deviceInfo;
|
|
private ButtonMask _buttonMask;
|
|
|
|
public ButtonEventArgs(DeviceInfo dInfo, ButtonMask buttonMask)
|
|
{
|
|
_deviceInfo = dInfo;
|
|
_buttonMask = buttonMask;
|
|
}
|
|
|
|
public ButtonEventArgs()
|
|
{
|
|
}
|
|
|
|
public ButtonMask ButtonMask { get { return _buttonMask; } set { _buttonMask = value; } }
|
|
|
|
public DeviceInfo DeviceInfo { get { return _deviceInfo; } set { _deviceInfo = value; } }
|
|
}
|
|
|
|
#endregion Variables and event handling
|
|
|
|
#region SpaceMouse( IntPtr hwnd )
|
|
|
|
/// <summary>
|
|
/// InputDevice constructor; registers the raw input devices
|
|
/// for the calling window.
|
|
/// </summary>
|
|
/// <param name="hwnd">Handle of the window listening for key presses</param>
|
|
public SpaceMouseDevice(IntPtr hwnd)
|
|
{
|
|
RAWINPUTDEVICE[] rid = new RAWINPUTDEVICE[1];
|
|
|
|
rid[0].usUsagePage = HID_USAGE_PAGE_GENERIC;
|
|
rid[0].usUsage = HID_USAGE_GENERIC_MULTIAXIS_CONTROLLER;
|
|
rid[0].dwFlags = RIDEV_INPUTSINK;
|
|
rid[0].hwndTarget = hwnd;
|
|
|
|
// Don't register each physical device, just the type (MultiAxis Controller)
|
|
if (!RegisterRawInputDevices(rid, (uint)rid.Length, (uint)Marshal.SizeOf(rid[0])))
|
|
{
|
|
throw new ApplicationException("Failed to register raw input device(s).");
|
|
}
|
|
}
|
|
|
|
#endregion SpaceMouse( IntPtr hwnd )
|
|
|
|
#region int EnumerateDevices()
|
|
|
|
/// <summary>
|
|
/// Iterates through the list provided by GetRawInputDeviceList,
|
|
/// counting 3Dx devices and adding them to deviceList.
|
|
/// </summary>
|
|
/// <returns>The number of 3Dx devices found.</returns>
|
|
public int EnumerateDevices()
|
|
{
|
|
|
|
int NumberOfDevices = 0;
|
|
uint deviceCount = 0;
|
|
int dwSize = (Marshal.SizeOf(typeof(RAWINPUTDEVICELIST)));
|
|
|
|
if (GetRawInputDeviceList(IntPtr.Zero, ref deviceCount, (uint)dwSize) == 0)
|
|
{
|
|
IntPtr pRawInputDeviceList = Marshal.AllocHGlobal((int)(dwSize * deviceCount));
|
|
GetRawInputDeviceList(pRawInputDeviceList, ref deviceCount, (uint)dwSize);
|
|
|
|
for (int i = 0; i < deviceCount; i++)
|
|
{
|
|
uint pcbSize = 0;
|
|
|
|
RAWINPUTDEVICELIST rid = (RAWINPUTDEVICELIST)Marshal.PtrToStructure(
|
|
new IntPtr((pRawInputDeviceList.ToInt64() + (dwSize * i))),
|
|
typeof(RAWINPUTDEVICELIST));
|
|
|
|
GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICENAME, IntPtr.Zero, ref pcbSize);
|
|
|
|
if (pcbSize > 0)
|
|
{
|
|
IntPtr pData = Marshal.AllocHGlobal((int)pcbSize);
|
|
GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICENAME, pData, ref pcbSize);
|
|
string deviceName = Marshal.PtrToStringAnsi(pData);
|
|
|
|
//If the device is identified as a HID device with usagePage 1, usage 8,
|
|
//create a DeviceInfo object to store information about it
|
|
if (rid.dwType == RIM_TYPEHID)
|
|
{
|
|
DeviceInfo dInfo = new DeviceInfo();
|
|
|
|
// Create an object to set the size in the struct. Then marshall it to a ptr to pass to RI.
|
|
RID_DEVICE_INFO_HID hidInfo = new RID_DEVICE_INFO_HID();
|
|
int dwHidInfoSize = Marshal.SizeOf(hidInfo);
|
|
hidInfo.cbSize = dwHidInfoSize;
|
|
IntPtr pHIDData = Marshal.AllocHGlobal(dwHidInfoSize);
|
|
Marshal.StructureToPtr(hidInfo, pHIDData, true);
|
|
|
|
uint uHidInfoSize = (uint)dwHidInfoSize;
|
|
|
|
GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICEINFO, pHIDData, ref uHidInfoSize);
|
|
|
|
// Marshal back to an object to retrieve info
|
|
hidInfo = (RID_DEVICE_INFO_HID)Marshal.PtrToStructure(pHIDData, typeof(RID_DEVICE_INFO_HID));
|
|
|
|
dInfo.deviceName = Marshal.PtrToStringAnsi(pData);
|
|
dInfo.deviceHandle = rid.hDevice;
|
|
|
|
|
|
//If it is a 3Dx device and it isn't already in the list,
|
|
//add it to the deviceList hashtable and increase the
|
|
//NumberOfDevices count
|
|
if (Is3DxDevice(hidInfo) && !_deviceList.Contains(rid.hDevice))
|
|
{
|
|
Console.WriteLine("Using 3Dx device: " + deviceName);
|
|
NumberOfDevices++;
|
|
_deviceList.Add(rid.hDevice, dInfo);
|
|
}
|
|
|
|
Marshal.FreeHGlobal(pHIDData);
|
|
}
|
|
|
|
Marshal.FreeHGlobal(pData);
|
|
}
|
|
}
|
|
|
|
Marshal.FreeHGlobal(pRawInputDeviceList);
|
|
return NumberOfDevices;
|
|
}
|
|
else
|
|
{
|
|
throw new ApplicationException("Error!");
|
|
}
|
|
}
|
|
|
|
private bool Is3DxDevice(RID_DEVICE_INFO_HID hidInfo)
|
|
{
|
|
return hidInfo.dwVendorID == LOGITECH_3DX_VID &&
|
|
hidInfo.usUsagePage == HID_USAGE_PAGE_GENERIC &&
|
|
hidInfo.usUsage == HID_USAGE_GENERIC_MULTIAXIS_CONTROLLER;
|
|
}
|
|
|
|
#endregion EnumerateDevices()
|
|
|
|
#region ProcessInputCommand( Message message )
|
|
|
|
/// <summary>
|
|
/// Processes WM_INPUT messages to retrieve information about any
|
|
/// keyboard events that occur.
|
|
/// </summary>
|
|
/// <param name="message">The WM_INPUT message to process.</param>
|
|
private void ProcessInputCommand(System.Windows.Forms.Message message)
|
|
{
|
|
uint dwSize = 0;
|
|
|
|
// First call to GetRawInputData sets the value of dwSize
|
|
// dwSize can then be used to allocate the appropriate amount of memory,
|
|
// storing the pointer in "buffer".
|
|
GetRawInputData(message.LParam,
|
|
RID_HEADER, IntPtr.Zero,
|
|
ref dwSize,
|
|
(uint)Marshal.SizeOf(typeof(RAWINPUTHEADER)));
|
|
|
|
IntPtr headerBuffer = Marshal.AllocHGlobal((int)dwSize);
|
|
try
|
|
{
|
|
// Check that buffer points to something, and if so,
|
|
// call GetRawInputData again to fill the allocated memory
|
|
// with information about the input
|
|
if (headerBuffer != IntPtr.Zero &&
|
|
GetRawInputData(message.LParam,
|
|
RID_HEADER,
|
|
headerBuffer,
|
|
ref dwSize,
|
|
(uint)Marshal.SizeOf(typeof(RAWINPUTHEADER))) == dwSize)
|
|
{
|
|
|
|
RAWINPUTHEADER header = (RAWINPUTHEADER)Marshal.PtrToStructure(headerBuffer, typeof(RAWINPUTHEADER));
|
|
if (header.dwType == RIM_TYPEHID)
|
|
{
|
|
DeviceInfo dInfo = null;
|
|
|
|
if (_deviceList.Contains(header.hDevice))
|
|
{
|
|
dInfo = (DeviceInfo)_deviceList[header.hDevice];
|
|
}
|
|
else
|
|
{
|
|
// Device not in list. Reenumerate all of them again. Could warn the code with some sort of Connect/Disconnect event.
|
|
EnumerateDevices();
|
|
dInfo = (DeviceInfo)_deviceList[header.hDevice];
|
|
}
|
|
|
|
// The header tells us the size of the actual event
|
|
IntPtr eventBuffer = Marshal.AllocHGlobal(header.dwSize);
|
|
|
|
uint eventSize = (uint)header.dwSize;
|
|
if (eventBuffer != IntPtr.Zero &&
|
|
GetRawInputData(message.LParam,
|
|
RID_INPUT,
|
|
eventBuffer,
|
|
ref eventSize,
|
|
(uint)Marshal.SizeOf(typeof(RAWINPUTHEADER))) == header.dwSize)
|
|
{
|
|
RAW3DMOUSE_EVENTTYPE eventType =
|
|
(RAW3DMOUSE_EVENTTYPE)Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt64() + Marshal.SizeOf(typeof(RAWINPUTHEADER))),
|
|
typeof(RAW3DMOUSE_EVENTTYPE));
|
|
switch (eventType.eventType)
|
|
{
|
|
case (byte)RAW3DxMouseEventType.TranslationVector:
|
|
if (header.dwSize == Marshal.SizeOf(typeof(RAWINPUTHEADER)) + SIZEOF_STANDARD_REPORT) // standard length T report
|
|
{
|
|
RAW3DMOUSEMOTION_T t =
|
|
(RAW3DMOUSEMOTION_T)
|
|
Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt64() + Marshal.SizeOf(typeof(RAWINPUTHEADER))),
|
|
typeof(RAW3DMOUSEMOTION_T));
|
|
TranslationVector tv = new TranslationVector(t.X_lb, t.X_hb, t.Y_lb, t.Y_hb, t.Z_lb, t.Z_hb);
|
|
// Console.Write("Motion Event = {0} {1} {2}", tv.X, tv.Y, tv.Z);
|
|
MotionEvent?.Invoke(this, new MotionEventArgs(dInfo, tv));
|
|
}
|
|
else // "High Speed" firmware version includes both T and R vector in the same report
|
|
{
|
|
RAW3DMOUSEMOTION_TR_COMBINED tr =
|
|
(RAW3DMOUSEMOTION_TR_COMBINED)
|
|
Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt64() + Marshal.SizeOf(typeof(RAWINPUTHEADER))),
|
|
typeof(RAW3DMOUSEMOTION_TR_COMBINED));
|
|
TranslationVector tv = new TranslationVector(tr.X_lb, tr.X_hb, tr.Y_lb, tr.Y_hb, tr.Z_lb, tr.Z_hb);
|
|
RotationVector rv = new RotationVector(tr.RX_lb, tr.RX_hb, tr.RY_lb, tr.RY_hb, tr.RZ_lb, tr.RZ_hb);
|
|
// Console.WriteLine("6DOF Motion Event = {0} {1} {2} {3} {4} {5}", tv.X, tv.Y, tv.Z, rv.X, rv.Y, rv.Z);
|
|
MotionEvent?.Invoke(this, new MotionEventArgs(dInfo, tv, rv));
|
|
}
|
|
|
|
break;
|
|
|
|
case (byte)RAW3DxMouseEventType.RotationVector:
|
|
{
|
|
RAW3DMOUSEMOTION_R r =
|
|
(RAW3DMOUSEMOTION_R)
|
|
Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt64() + Marshal.SizeOf(typeof(RAWINPUTHEADER))),
|
|
typeof(RAW3DMOUSEMOTION_R));
|
|
RotationVector rv = new RotationVector(r.X_lb, r.X_hb, r.Y_lb, r.Y_hb, r.Z_lb, r.Z_hb);
|
|
// Console.WriteLine(" {0} {1} {2}", rv.X, rv.Y, rv.Z);
|
|
MotionEvent?.Invoke(this, new MotionEventArgs(dInfo, rv));
|
|
}
|
|
break;
|
|
|
|
case (byte)RAW3DxMouseEventType.ButtonReport:
|
|
RAW3DMOUSEBUTTONS b =
|
|
(RAW3DMOUSEBUTTONS)
|
|
Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt64() + Marshal.SizeOf(typeof(RAWINPUTHEADER))),
|
|
typeof(RAW3DMOUSEBUTTONS));
|
|
ButtonMask bm = new ButtonMask(b.b1, b.b2, b.b3, b.b4);
|
|
Console.WriteLine("raw.buttons = {0:X}", bm.Pressed);
|
|
ButtonEvent?.Invoke(this, new ButtonEventArgs(dInfo, bm));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Marshal.FreeHGlobal(headerBuffer);
|
|
}
|
|
}
|
|
|
|
#endregion ProcessInputCommand( Message message )
|
|
|
|
#region ProcessMessage(Message message)
|
|
|
|
/// <summary>
|
|
/// Filters Windows messages for WM_INPUT messages and calls
|
|
/// ProcessInputCommand if necessary.
|
|
/// </summary>
|
|
/// <param name="message">The Windows message.</param>
|
|
public void ProcessMessage(System.Windows.Forms.Message message)
|
|
{
|
|
switch (message.Msg)
|
|
{
|
|
case WM_INPUT:
|
|
{
|
|
ProcessInputCommand(message);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion ProcessMessage( Message message )
|
|
}
|
|
} |