public void StartHook()
{
if (hookPtr != IntPtr.Zero)
{
return;
}
hook = (nCode, wParam, lParam) =>
{
if (nCode >= 0)
{
var args = KeyboardHookEventArgs.Create((KeyboardMessage)wParam, lParam);
if (args != null)
{
state[args.Button] = args.Pressed;
MouseEvent?.Invoke(args);
}
}
return(NativeMethods.CallNextHookEx(hookPtr, nCode, wParam, lParam));
};
hookPtr = NativeMethods.SetWindowsHookEx(HookType.WH_KEYBOARD_LL, hook, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
if (hookPtr == IntPtr.Zero)
{
throw new Win32Exception("Unable to set KeyboardHook");
}
logger.Info("Keyboard Windows API hook is set up");
}
public void Update(GameTime gameTime)
{
_previousState = _mouseState;
_mouseState = Mouse.GetState();
if (JustPressed)
{
OnPressedEvent?.Invoke(_mouseState, _previousState);
}
else if (HeldDown)
{
OnHeldDownEvent?.Invoke(_mouseState, _previousState);
}
else if (JustReleased)
{
OnReleaseEvent?.Invoke(_mouseState, _previousState);
}
if (_mouseState.ScrollWheelValue != _previousState.ScrollWheelValue)
{
if (OnScrollEvent != null)
{
var scrollBy = _mouseState.ScrollWheelValue - _previousState.ScrollWheelValue;
OnScrollEvent.Invoke(scrollBy);
}
}
}
private static IntPtr MouseHookForLeftClickUpEvent(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
var message = (MouseMessages)wParam;
if (message == MouseMessages.WmLButtonDown)
{
if (StopOnClick)
{
UnhookWindowsHookEx(_mouseHookID);
}
}
if (message == MouseMessages.WmLButtonDown || message == MouseMessages.WmMButtonDown ||
message == MouseMessages.WmRButtonDown)
{
System.Windows.Point point = new System.Windows.Point(Cursor.Position.X, Cursor.Position.Y);
MouseEvent?.Invoke(null, new MouseCoordinateEventArgs()
{
MouseCoordinates = point, MouseMessage = message
});
}
}
return(CallNextHookEx(_mouseHookID, nCode, wParam, lParam));
}
private static int CommonWndProc(IntPtr oldWndProc, IntPtr hWnd, int msg, int wParam, int lParam)
{
if (Main.IsPluginDisabled)
{
return(0);
}
try
{
var result = Win32.CallWindowProcW(oldWndProc, hWnd, msg, wParam, lParam);
if (msg == WM_KEYDOWN && _onKeyboardDown != null)
{
_onKeyboardDown.Invoke(wParam);
}
else if (_onMouseAction != null && Enum.IsDefined(typeof(MouseMessage), msg))
{
_onMouseAction.Invoke((MouseMessage)msg);
}
return(result);
}
catch (Exception e)
{
Logger.Error(e.Message, e);
return(0);
}
}
private static IntPtr MouseHookForLeftClickUpEvent(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
var message = (MouseMessages)wParam;
if (message == MouseMessages.WM_LBUTTONDOWN)
{
if (stopOnClick)
{
UnhookWindowsHookEx(_mouseHookID);
}
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
System.Windows.Point point = new System.Windows.Point(hookStruct.pt.x, hookStruct.pt.y);
MouseEvent?.Invoke(null, new MouseCoordinateEventArgs()
{
MouseCoordinates = point
});
}
}
return(CallNextHookEx(_mouseHookID, nCode, wParam, lParam));
}
private unsafe static IntPtr LLMouseCallback(int nCode, MouseButtonsState wParam, MouseLowlevelHookStruct *lParam)
{
if (nCode > -1)
{
MouseEvent.Invoke(nCode, wParam, *lParam);
}
return(User32.CallNextHookEx(KBHook, nCode, (IntPtr)wParam, (IntPtr)lParam));
}
private void Device_MouseInput(object sender, MouseInputEventArgs e)
{
//var p = EngineRef.MousePosition;
//MousePositionLocal = new Vector2(p.X, p.Y);
MouseOffset = new Vector2(e.X, e.Y);
MouseEvent?.Invoke(new MouseMoveEventArgs()
{
Position = Vector2.Zero, Offset = MouseOffset
});
}
public static void Start()
{
if (!Run)
{
Run = true;
IntPtr handleIn = GetStdHandle(STD_INPUT_HANDLE);
new Thread(() =>
{
while (true)
{
uint numRead = 0;
INPUT_RECORD[] record = new INPUT_RECORD[1];
record[0] = new INPUT_RECORD();
ReadConsoleInput(handleIn, record, 1, ref numRead);
if (Run)
{
switch (record[0].EventType)
{
case INPUT_RECORD.MOUSE_EVENT:
MouseEvent?.Invoke(record[0].MouseEvent);
switch (record[0].MouseEvent.dwButtonState)
{
case MOUSE_EVENT_RECORD.FROM_LEFT_1ST_BUTTON_PRESSED:
ClickEvent?.Invoke(record[0].MouseEvent);
break;
case MOUSE_EVENT_RECORD.SCROLLED_UP:
ScrollUpEvent?.Invoke(record[0].MouseEvent);
break;
case MOUSE_EVENT_RECORD.SCROLLED_DOWN:
ScrollDownEvent?.Invoke(record[0].MouseEvent);
break;
}
break;
case INPUT_RECORD.KEY_EVENT:
KeyEvent?.Invoke(record[0].KeyEvent);
break;
case INPUT_RECORD.WINDOW_BUFFER_SIZE_EVENT:
WindowBufferSizeEvent?.Invoke(record[0].WindowBufferSizeEvent);
break;
}
}
else
{
uint numWritten = 0;
WriteConsoleInput(handleIn, record, 1, ref numWritten);
return;
}
}
}).Start();
}
}
public static void Start()
{
if (ConsoleInputHandle == IntPtr.Zero)
{
return;
}
if (Running)
{
return;
}
Running = true;
IsEchoInputEnabled = true;
IsWindowInputEnabled = true;
IsMouseInputEnabled = true;
IntPtr handleIn = ConsoleInputHandle;
new Thread(() =>
{
while (true)
{
UInt32 numRead = 0;
INPUT_RECORD[] record = new INPUT_RECORD[1];
record[0] = new INPUT_RECORD();
ReadConsoleInput(handleIn, record, 1, ref numRead);
if (Running)
{
switch (record[0].EventType)
{
case INPUT_RECORD.MOUSE_EVENT:
MouseEvent?.Invoke(record[0].MouseEvent);
break;
case INPUT_RECORD.KEY_EVENT:
KeyEvent?.Invoke(record[0].KeyEvent);
break;
case INPUT_RECORD.WINDOW_BUFFER_SIZE_EVENT:
WindowBufferSizeEvent?.Invoke(record[0].WindowBufferSizeEvent);
break;
}
}
else
{
UInt32 numWritten = 0;
WriteConsoleInput(handleIn, record, 1, ref numWritten);
return;
}
}
}).Start();
}
void RaiseMouseLeave(MouseEventArgs e)
{
OnMouseLeave(e);
if (MouseLeave != null)
{
MouseLeave(this, e);
}
m_onMouseLeave.Invoke(e);
}
void RaiseMouseEnter(MouseEventArgs e)
{
OnMouseEnter(e);
if (MouseEnter != null)
{
MouseEnter(this, e);
}
m_onMouseEnter.Invoke(e);
}
void RaiseMouseWheel(MouseEventArgs e)
{
OnMouseWheel(e);
if (MouseWheel != null)
{
MouseWheel(this, e);
}
m_onMouseWheel.Invoke(e);
}
void RaiseMouseUp(MouseEventArgs e)
{
OnMouseUp(e);
if (MouseUp != null)
{
MouseUp(this, e);
}
m_onMouseUp.Invoke(e);
}
void RaiseMouseDown(MouseEventArgs e)
{
OnMouseDown(e);
if (MouseDown != null)
{
MouseDown(this, e);
}
m_onMouseDown.Invoke(e);
}
public void Check()
{
if (Mouse.current.leftButton.wasPressedThisFrame)
{
OnLeftMouseDown?.Invoke();
}
if (Mouse.current.leftButton.wasReleasedThisFrame)
{
OnLeftMouseUp?.Invoke();
}
}
public void Raycast(AirVRCameraRig cameraRig)
{
RaycastHit hit = new RaycastHit();
Ray ray = new Ray(cameraRig.rightHandAnchor.position, cameraRig.rightHandAnchor.forward);
Debug.DrawLine(ray.origin, ray.direction * 500, Color.red);
if (Physics.Raycast(ray, out hit, Mathf.Infinity))
{
mouseRayEvents.Invoke(hit.transform.gameObject);
}
}
public void StartHook()
{
hook = (nCode, wParam, lParam) =>
{
if (nCode >= 0)
{
var args = MouseHookEventArgs.Create((MouseMessage)wParam, lParam);
if (args != null)
{
MouseEvent?.Invoke(args);
}
}
return(NativeMethods.CallNextHookEx(hookPtr, nCode, wParam, lParam));
};
hookPtr = NativeMethods.SetWindowsHookEx(HookType.WH_MOUSE_LL, hook, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
if (hookPtr == IntPtr.Zero)
{
throw new Win32Exception("Unable to set MouseHook");
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Escape))
{
OnEsc?.Invoke(KeyCode.Escape);
}
if (Input.GetMouseButtonDown(0))
{
if (!EventSystem.current.IsPointerOverGameObject())
{
MouseData data = new MouseData();
data.ButtonId = 0;
data.Time = 0;
data.StartPosition = Input.mousePosition;
_mouseEvents.Add(data);
}
}
else if (Input.GetMouseButton(0) && _mouseEvents.Count != 0)
{
_mouseEvents[0].Time += Time.deltaTime;
if (_mouseEvents[0].Time > 0.25f)
{
OnHold.Invoke(_mouseEvents[0]);
}
}
else if (Input.GetMouseButtonUp(0))
{
MouseData data = _mouseEvents[0];
_mouseEvents.RemoveAt(0);
data.EndPosition = Input.mousePosition;
if (data.Time < 0.25f)
{
OnClick.Invoke(data);
}
else
{
OnRelease.Invoke(data);
}
}
}
public static void Start()
{
if (!run)
{
run = true;
IntPtr handleIn = GetStdHandle(STD_INPUT_HANDLE);
new Thread(() =>
{
while (true)
{
uint numRead = 0;
INPUT_RECORD[] record = new INPUT_RECORD[1];
record[0] = new INPUT_RECORD();
ReadConsoleInput(handleIn, record, 1, ref numRead);
if (run)
{
switch (record[0].EventType)
{
case INPUT_RECORD.MOUSE_EVENT:
MouseEvent?.Invoke(record[0].MouseEvent);
break;
case INPUT_RECORD.KEY_EVENT:
KeyEvent?.Invoke(record[0].KeyEvent);
break;
case INPUT_RECORD.WINDOW_BUFFER_SIZE_EVENT:
WindowBufferSizeEvent?.Invoke(record[0].WindowBufferSizeEvent);
break;
}
}
else
{
uint numWritten = 0;
WriteConsoleInput(handleIn, record, 1, ref numWritten);
return;
}
}
}).Start();
}
}
protected override void WndProc(ref Message m)
{
switch ((Win32.WM)m.Msg)
{
case Win32.WM.MOUSEACTIVATE:
// Make the window not activate when clicked (return MA_NOACTIVATE)
m.Result = (IntPtr)3;
// Returning immediately prevents activation when another window on the same thread is active
return;
case Win32.WM.LBUTTONDOWN:
case Win32.WM.LBUTTONUP:
case Win32.WM.RBUTTONDOWN:
case Win32.WM.RBUTTONUP:
case Win32.WM.MBUTTONDOWN:
case Win32.WM.MBUTTONUP:
case Win32.WM.MOUSEWHEEL:
case Win32.WM.MOUSELEAVE:
MouseEvent?.Invoke(this, m);
break;
case Win32.WM.MOUSEMOVE:
// Optimization: check that the mouse has actually moved before forwarding event
short x = (short)m.LParam,
y = (short)(m.LParam.ToInt32() >> 16);
if (x != lastX || y != lastY)
{
lastX = x;
lastY = y;
MouseEvent?.Invoke(this, m);
}
break;
}
base.WndProc(ref m);
}
void Update()
{
if (Input.GetMouseButtonDown(0))
{
onAttack.Invoke(Input.mousePosition);
}
if (Input.GetMouseButtonDown(1))
{
onInteract.Invoke(Input.mousePosition);
}
if (Input.GetMouseButtonUp(0))
{
releaseAttack.Invoke(Input.mousePosition);
}
if (Input.GetMouseButtonUp(1))
{
releaseInteract.Invoke(Input.mousePosition);
}
if (prevMousePosition != Input.mousePosition)
{
mouseMove.Invoke(Input.mousePosition);
}
float scroll = Input.mouseScrollDelta.y;
if (scroll != 0f)
{
if (scroll > 0f)
{
onSlotChange.Invoke(-1);
}
else
{
onSlotChange.Invoke(1);
}
}
prevMousePosition = Input.mousePosition;
}
protected override int HookProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode < 0)
{
return(CallNextHook(nCode, wParam, lParam));
}
var mouseAttributes = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
var e = new MouseHookBaseEventArgs
{
Point = new Point
{
X = mouseAttributes.Point.X,
Y = mouseAttributes.Point.Y
},
ScrollValue = (Enum.IsDefined(typeof(XButton), (int)mouseAttributes.MouseData.High) == false) ?
(mouseAttributes.MouseData.High / WheelDelta) : 0,
XButton = Enum.IsDefined(typeof(XButton), (int)mouseAttributes.MouseData.High) ?
(XButton)mouseAttributes.MouseData.High :
XButton.NONE,
Flag = (MouseHookFlags)mouseAttributes.Flags,
// How to interpret time:
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644939(v=vs.85).aspx
Time = TimeSpan.FromMilliseconds(mouseAttributes.Time),
MouseMessage = (MouseInputNotifications)wParam.ToInt32(),
ExtraInfo = mouseAttributes.ExtraInfo.ToUInt64()
};
MouseEvent?.Invoke(this, e);
if (e.Handled)
{
// Do not pass Go. Do not collect $200.
return(-1);
}
return(CallNextHook(nCode, wParam, lParam));
}
void RaiseBox2DMouseDown(object sender, MouseEventArgs e)
{
m_onBox2DMouseDown.Invoke(e);
}
private void NewMouseEvent(IntPtr wParam, MSLLHOOKSTRUCT hookStruct)
{
MouseEvent?.Invoke(this, new LowLevelMouseEventArgs((EventType)wParam, hookStruct));
}
protected static void OnMouseAction(MouseButton key)
{
MouseEvent?.Invoke(key);
}
void OnMouseUp()
{
onMouseUp.Invoke();
}
void RaiseBox2DMouseMove(object sender, MouseEventArgs e)
{
m_onBox2DMouseMove.Invoke(e);
}
private void MouseDispatch(MouseButtons button, int clicks, POINT point, short mouseDelta)
{
MouseEvent?.Invoke(this, new MouseEventArgs(button, clicks, point.x, point.y, mouseDelta));
}
/// <summary>
/// Callback function
/// </summary>
private IntPtr HookFunc(int nCode, IntPtr wParam, IntPtr lParam)
{
// parse system messages
if (nCode >= 0)
{
var data = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
var message = (MouseMessages)wParam;
var isDown = false;
var isUp = false;
SimpleMouseButtons button;
switch (message)
{
case MouseMessages.WM_MOUSEMOVE:
break;
case MouseMessages.WM_LBUTTONDOWN:
isDown = true;
break;
case MouseMessages.WM_RBUTTONDOWN:
isDown = true;
break;
case MouseMessages.WM_MBUTTONDOWN:
isDown = true;
break;
case MouseMessages.WM_LBUTTONUP:
isUp = true;
break;
case MouseMessages.WM_RBUTTONUP:
isUp = true;
break;
case MouseMessages.WM_MBUTTONUP:
isUp = true;
break;
case MouseMessages.WM_MOUSEWHEEL:
break;
case MouseMessages.WM_MOUSEHWHEEL:
break;
case MouseMessages.WM_LBUTTONDBLCLK:
break;
case MouseMessages.WM_RBUTTONDBLCLK:
break;
case MouseMessages.WM_MBUTTONDBLCLK:
break;
case MouseMessages.WM_XBUTTONDOWN:
isDown = true;
break;
case MouseMessages.WM_XBUTTONUP:
isUp = true;
break;
case MouseMessages.WM_XBUTTONDBLCLK:
break;
default:
break;
}
if (MouseMessages.WM_LBUTTONDOWN == message)
{
LeftButtonDown?.Invoke(data);
}
if (MouseMessages.WM_LBUTTONUP == message)
{
LeftButtonUp?.Invoke(data);
}
if (MouseMessages.WM_RBUTTONDOWN == message)
{
RightButtonDown?.Invoke(data);
}
if (MouseMessages.WM_RBUTTONUP == message)
{
RightButtonUp?.Invoke(data);
}
if (MouseMessages.WM_MOUSEMOVE == message)
{
MouseMove?.Invoke(data);
}
if (MouseMessages.WM_MOUSEWHEEL == message)
{
MouseWheel?.Invoke(data);
}
if (MouseMessages.WM_LBUTTONDBLCLK == message)
{
DoubleClick?.Invoke(data);
}
if (MouseMessages.WM_MBUTTONDOWN == message)
{
MiddleButtonDown?.Invoke(data);
}
if (MouseMessages.WM_MBUTTONUP == message)
{
MiddleButtonUp?.Invoke(data);
}
//Generic Event, fire with type
MouseEvent?.Invoke(data, message);
}
return(CallNextHookEx(hookID, nCode, wParam, lParam));
}
void OnMouseUpAsButton()
{
onMouseUpAsButton.Invoke();
}
