private void OnMouseMove(float scaleX, float scaleY)
{
int x1, y1, x2, y2;
GetBorders(out x1, out y1, out x2, out y2);
bool mouseMove =
(_mouseX != (_mouseX = (int)((Mouse.X - x1) / scaleX))) |
(_mouseY != (_mouseY = (int)((Mouse.Y - y1) / scaleY)));
if (mouseMove)
{
MouseButton buttons = MouseButton.None;
TkMouseState mouse = Mouse.GetState();
if (mouse.IsButtonDown(TkMouseButton.Left))
{
buttons |= MouseButton.Left;
}
if (mouse.IsButtonDown(TkMouseButton.Right))
{
buttons |= MouseButton.Right;
}
if (buttons != MouseButton.None)
{
TopScreen?.MouseDrag(new ScreenEventArgs(_mouseX, _mouseY, buttons));
}
TopScreen?.MouseMove(new ScreenEventArgs(_mouseX, _mouseY, buttons));
}
}
public override void UpdateMouse()
{
CurrentMouseState = OpenTK.Input.Mouse.GetState();
if (MouseLook)
{
if (CurrentMouseState != PreviousMouseState)
{
MouseDelta.X = CurrentMouseState.X - PreviousMouseState.X;
MouseDelta.Y = CurrentMouseState.Y - PreviousMouseState.Y;
MouseDelta *= MouseSensitivity;
if (InvertMouseX)
{
Camera.Yaw -= MouseDelta.X;
}
else
{
Camera.Yaw += MouseDelta.X;
}
if (InvertMouseY)
{
Camera.Pitch += MouseDelta.Y;
}
else
{
Camera.Pitch -= MouseDelta.Y;
}
}
}
PreviousMouseState = CurrentMouseState;
}
public static unsafe MouseState GetState(int index)
{
OpenTK.Input.MouseState state = OpenTK.Input.Mouse.GetState(index);
MouseState actual = *(MouseState *)(&state);
actual.X = window.Mouse.X;
actual.Y = window.Mouse.Y;
return(actual);
}
void update_mouseButtonStates(ref MouseState e, OpenTK.Input.MouseState otk_e)
{
for (int i = 0; i < MouseState.MaxButtons; i++)
{
if (otk_e.IsButtonDown((OpenTK.Input.MouseButton)i))
{
e.EnableBit(i);
}
}
}
public static unsafe MouseState GetState()
{
OpenTK.Input.MouseState state = OpenTK.Input.Mouse.GetState();
MouseState actual = *(MouseState *)(&state);
actual.X = window.Mouse.X;
actual.Y = window.Mouse.Y;
actual.Scroll = new MouseScroll(actual.Scroll.X, deltaPrecise);//.Y = ;
//deltaPrecise = 0;
return(actual);
}
/// <summary>
/// Initializes a new instance of the <see cref="Mouse"/> class
/// that related to specified <see cref="RenderWindow"/>.
/// </summary>
/// <param name="window">The window.</param>
public Mouse(RenderWindow window)
{
if (window != null)
{
_renderWindow = window;
_state = window.GameWindow.Mouse.GetState();
}
else
{
_state = OpenTK.Input.Mouse.GetState();
}
}
public void UpdateFromMouse()
{
try
{
OpenTK.Input.MouseState mouseState = OpenTK.Input.Mouse.GetState();
OpenTK.Input.KeyboardState keyboardState = OpenTK.Input.Keyboard.GetState();
if (OpenTK.Input.Mouse.GetState().RightButton == OpenTK.Input.ButtonState.Pressed)
{
float xAmount = OpenTK.Input.Mouse.GetState().X - mouseXLast;
float yAmount = (OpenTK.Input.Mouse.GetState().Y - mouseYLast);
Pan(xAmount, yAmount, true);
}
if (mouseState.LeftButton == OpenTK.Input.ButtonState.Pressed)
{
// Dragging left/right rotates around the y-axis.
// Dragging up/down rotates around the x-axis.
float xAmount = (OpenTK.Input.Mouse.GetState().Y - mouseYLast);
float yAmount = OpenTK.Input.Mouse.GetState().X - mouseXLast;
Rotate(xAmount * rotateXSpeed, yAmount * rotateYSpeed);
}
// Holding shift changes zoom speed.
float zoomAmount = zoomSpeed * zoomDistanceScale;
if (keyboardState.IsKeyDown(OpenTK.Input.Key.ShiftLeft) || OpenTK.Input.Keyboard.GetState().IsKeyDown(OpenTK.Input.Key.ShiftRight))
{
zoomAmount *= shiftZoomMultiplier;
}
// Zooms in or out with arrow keys.
if (keyboardState.IsKeyDown(OpenTK.Input.Key.Down))
{
Zoom(-zoomAmount, true);
}
else if (keyboardState.IsKeyDown(OpenTK.Input.Key.Up))
{
Zoom(zoomAmount, true);
}
// Scroll wheel zooms in or out.
float scrollZoomAmount = (mouseState.WheelPrecise - mouseSLast) * scrollWheelZoomSpeed;
Zoom(scrollZoomAmount * zoomAmount, true);
UpdateLastMousePosition();
}
catch (Exception)
{
// RIP OpenTK...
}
UpdateMatrices();
}
/// <summary>Graphical Event Handling</summary>
public override void FrameUpdate(FrameEventArgs e)
{
// Get states from OpenTK
OpenTK.Input.KeyboardState input = OpenTK.Input.Keyboard.GetState();
OpenTK.Input.MouseState mouse = OpenTK.Input.Mouse.GetState();
// Keyboard
if (input.IsKeyDown(OpenTK.Input.Key.Escape))
{
m_Win.Exit();
}
// Mouse
if (mouse.X > m_Win.Location.X && mouse.X < (m_Win.Location.X + m_Win.Size.Width) &&
(mouse.Y > m_Win.Location.Y && mouse.Y < (m_Win.Location.Y + m_Win.Size.Height)))
{
}
}
public override void UpdateFromMouse()
{
try
{
OpenTK.Input.MouseState mouseState = OpenTK.Input.Mouse.GetState();
OpenTK.Input.KeyboardState keyboardState = OpenTK.Input.Keyboard.GetState();
if (OpenTK.Input.Mouse.GetState().RightButton == OpenTK.Input.ButtonState.Pressed)
{
float xAmount = OpenTK.Input.Mouse.GetState().X - mouseXLast;
float yAmount = (OpenTK.Input.Mouse.GetState().Y - mouseYLast);
Pan(xAmount, yAmount, true);
}
// Holding shift changes zoom speed.
float zoomAmount = zoomSpeed * zoomDistanceScale;
if (keyboardState.IsKeyDown(OpenTK.Input.Key.ShiftLeft) || OpenTK.Input.Keyboard.GetState().IsKeyDown(OpenTK.Input.Key.ShiftRight))
{
zoomAmount *= shiftZoomMultiplier;
}
// Zooms in or out with arrow keys.
if (keyboardState.IsKeyDown(OpenTK.Input.Key.Down))
{
Zoom(-zoomAmount, true);
}
else if (keyboardState.IsKeyDown(OpenTK.Input.Key.Up))
{
Zoom(zoomAmount, true);
}
// Scroll wheel zooms in or out.
float scrollZoomAmount = (mouseState.WheelPrecise - mouseSLast) * scrollWheelZoomSpeed;
scale -= scrollZoomAmount * zoomAmount;
scale = Math.Max(scale, 0);
}
catch (Exception)
{
// RIP OpenTK...
}
UpdateLastMousePosition();
UpdateMatrices();
}
protected override void OnRenderFrame(FrameEventArgs e)
{
OpenTK.Input.MouseState mouseState = OpenTK.Input.Mouse.GetState();
if (mouseState.IsButtonDown(OpenTK.Input.MouseButton.Left))
{
xPosition -= e.Time;
}
if (mouseState.IsButtonDown(OpenTK.Input.MouseButton.Right))
{
xPosition += e.Time;
}
GL.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
Matrix4 projMatrix = Matrix4.CreateOrthographicOffCenter(0, DEFAULT_WIDTH, 0, DEFAULT_HEIGHT, -1.0f, 1.0f);
Matrix4 viewMatrix = Matrix4.Identity;
Matrix4.CreateRotationZ((float)RotationAngle, out Matrix4 tempMatrix);
Matrix4.CreateTranslation((float)xPosition * 200, -50.0f, 0.0f, out Matrix4 tempMatrix2);
foreach (var obj in GameObjects)
{
Matrix4 mvp = tempMatrix2 * tempMatrix * obj.ModelMatrix * viewMatrix * projMatrix;
GL.UseProgram(MainShaderProgram.ProgramId);
GlCustomUtil.Bind3dObject(obj);
GL.UniformMatrix4(MainShaderProgram.MatrixShaderLocation, false, ref mvp);
GL.DrawElements(PrimitiveType.Triangles, obj.Indices.Length, DrawElementsType.UnsignedInt, 0);
var x = GL.GetError();
}
SwapBuffers();
}
/// <summary>
/// Initializes a new instance of the <see cref="Mouse"/> class
/// from specified mouse index.
/// </summary>
/// <param name="stateIndex">The index of the mouse.</param>
public Mouse(int stateIndex)
{
_state = OpenTK.Input.Mouse.GetState(stateIndex);
}
internal Mouse(OpenTK.Input.MouseState state)
{
_state = state;
}
private void window_MouseUp(object sender, TKMouseButtonEventArgs e)
{
this.mouseStateBuffer = e.Mouse;
}
void UpdateMousePosition()
{
mouse_current = System.Windows.Forms.Cursor.Position;
if (FreeMouse)
{
mouse_current.Offset(-d_MainWindow.X, -d_MainWindow.Y);
mouse_current.Offset(0, -System.Windows.Forms.SystemInformation.CaptionHeight);
}
if (!d_MainWindow.Focused)
{
return;
}
if (freemousejustdisabled)
{
mouse_previous = mouse_current;
freemousejustdisabled = false;
}
if (!FreeMouse)
{
//There are two versions:
//a) System.Windows.Forms.Cursor and GameWindow.CursorVisible = true.
//It works by centering global mouse cursor every frame.
//*Windows:
// *OK.
// *On a few YouTube videos mouse cursor is not hiding properly.
// That could be just a problem with video recording software.
//*Ubuntu: Broken, mouse cursor doesn't hide.
//*Mac: Broken, mouse doesn't move at all.
//b) OpenTk.Input.Mouse and GameWindow.CursorVisible = false.
//Uses raw mouse coordinates, movement is not accelerated.
//*Windows:
// *OK.
// *Worse than a), because this doesn't use system-wide mouse acceleration.
//*Ubuntu: Broken, crashes with "libxi" library missing.
//*Mac: OK.
if (!IsMac)
{
//a)
int centerx = d_MainWindow.Bounds.Left + (d_MainWindow.Bounds.Width / 2);
int centery = d_MainWindow.Bounds.Top + (d_MainWindow.Bounds.Height / 2);
mouse_delta = new Point(mouse_current.X - mouse_previous.X,
mouse_current.Y - mouse_previous.Y);
System.Windows.Forms.Cursor.Position =
new Point(centerx, centery);
mouse_previous = new Point(centerx, centery);
}
else
{
//b)
var state = OpenTK.Input.Mouse.GetState();
float dx = state.X - mouse_previous_state.X;
float dy = state.Y - mouse_previous_state.Y;
mouse_previous_state = state;
//These are raw coordinates, so need to apply acceleration manually.
float dx2 = (dx * Math.Abs(dx) * MouseAcceleration1);
float dy2 = (dy * Math.Abs(dy) * MouseAcceleration1);
dx2 += dx * MouseAcceleration2;
dy2 += dy * MouseAcceleration2;
mouse_delta = new PointF(dx2, dy2);
}
}
}
public static void CheckEvents()
{
SakuraGameWindow.ProcessEvents();
bool __isWinFocused = SakuraGameWindow.getFocused();
OpenTK.Input.KeyboardState keyboard = OpenTK.Input.Keyboard.GetState();
GamePadData gamePadData = GamePad.__gamePadData;
gamePadData.ButtonsPrev = gamePadData.Buttons;
gamePadData.ButtonsDown = 0;
gamePadData.Buttons = 0;
gamePadData.ButtonsUp = 0;
if (__isWinFocused)
{
if (keyboard.IsKeyDown(OpenTK.Input.Key.Escape))
{
System.Environment.Exit(0);
}
//
if (keyboard.IsKeyDown(OpenTK.Input.Key.Left))
{
if (!__isKeyLeftDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Left;
}
__isKeyLeftDown = true;
gamePadData.Buttons |= GamePadButtons.Left;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.Right))
{
if (!__isKeyRightDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Right;
}
__isKeyRightDown = true;
gamePadData.Buttons |= GamePadButtons.Right;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.Up))
{
if (!__isKeyUpDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Up;
}
__isKeyUpDown = true;
gamePadData.Buttons |= GamePadButtons.Up;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.Down))
{
if (!__isKeyDownDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Down;
}
__isKeyDownDown = true;
gamePadData.Buttons |= GamePadButtons.Down;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.A))
{
if (!__isKeyADown)
{
gamePadData.ButtonsDown |= GamePadButtons.Square;
}
__isKeyADown = true;
gamePadData.Buttons |= GamePadButtons.Square;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.W))
{
if (!__isKeyWDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Triangle;
}
__isKeyWDown = true;
gamePadData.Buttons |= GamePadButtons.Triangle;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.D))
{
if (!__isKeyDDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Circle;
gamePadData.ButtonsDown |= GamePadButtons.Back;
}
__isKeyDDown = true;
gamePadData.Buttons |= GamePadButtons.Circle;
gamePadData.Buttons |= GamePadButtons.Back;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.S))
{
if (!__isKeySDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Cross;
gamePadData.ButtonsDown |= GamePadButtons.Enter;
}
__isKeySDown = true;
gamePadData.Buttons |= GamePadButtons.Cross;
gamePadData.Buttons |= GamePadButtons.Enter;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.X))
{
if (!__isKeyXDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Start;
}
__isKeyXDown = true;
gamePadData.Buttons |= GamePadButtons.Start;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.Z))
{
if (!__isKeyZDown)
{
gamePadData.ButtonsDown |= GamePadButtons.Select;
}
__isKeyZDown = true;
gamePadData.Buttons |= GamePadButtons.Select;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.Q))
{
if (!__isKeyQDown)
{
gamePadData.ButtonsDown |= GamePadButtons.L;
}
__isKeyQDown = true;
gamePadData.Buttons |= GamePadButtons.L;
}
if (keyboard.IsKeyDown(OpenTK.Input.Key.E))
{
if (!__isKeyEDown)
{
gamePadData.ButtonsDown |= GamePadButtons.R;
}
__isKeyEDown = true;
gamePadData.Buttons |= GamePadButtons.R;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.Left))
{
if (__isKeyLeftDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Left;
}
__isKeyLeftDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.Right))
{
if (__isKeyRightDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Right;
}
__isKeyRightDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.Up))
{
if (__isKeyUpDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Up;
}
__isKeyUpDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.Down))
{
if (__isKeyDownDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Down;
}
__isKeyDownDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.A))
{
if (__isKeyADown)
{
gamePadData.ButtonsUp |= GamePadButtons.Square;
}
__isKeyADown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.W))
{
if (__isKeyWDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Triangle;
}
__isKeyWDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.D))
{
if (__isKeyDDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Circle;
gamePadData.ButtonsUp |= GamePadButtons.Back;
}
__isKeyDDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.S))
{
if (__isKeySDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Cross;
gamePadData.ButtonsUp |= GamePadButtons.Enter;
}
__isKeySDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.X))
{
if (__isKeyXDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Start;
}
__isKeyXDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.Z))
{
if (__isKeyZDown)
{
gamePadData.ButtonsUp |= GamePadButtons.Select;
}
__isKeyZDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.Q))
{
if (__isKeyQDown)
{
gamePadData.ButtonsUp |= GamePadButtons.L;
}
__isKeyQDown = false;
}
if (keyboard.IsKeyUp(OpenTK.Input.Key.E))
{
if (__isKeyEDown)
{
gamePadData.ButtonsUp |= GamePadButtons.R;
}
__isKeyEDown = false;
}
}
else
{
__isKeyLeftDown = false;
__isKeyRightDown = false;
__isKeyUpDown = false;
__isKeyDownDown = false;
__isKeyADown = false;
__isKeyWDown = false;
__isKeyDDown = false;
__isKeySDown = false;
__isKeyXDown = false;
__isKeyZDown = false;
__isKeyQDown = false;
__isKeyEDown = false;
}
Touch.__data.Clear();
if (__isWinFocused)
{
//OpenTK.Input.MouseState mouse = OpenTK.Input.Mouse.GetState();
OpenTK.Input.MouseState mouse = OpenTK.Input.Mouse.GetCursorState();
OpenTK.Point pt = SakuraGameWindow.PointToClient(new OpenTK.Point(mouse.X, mouse.Y));
float winW = SakuraGameWindow.getWidth();
float winH = SakuraGameWindow.getHeight();
if (mouse.IsButtonUp(OpenTK.Input.MouseButton.Left))
{
if (__isMouseLeftDown == true)
{
TouchData touchData = new TouchData();
touchData.ID = 0;
touchData.Status = TouchStatus.Up;
touchData.X = (winW > 0 ? (float)pt.X / winW : 0) - 0.5f;
touchData.Y = (winH > 0 ? (float)pt.Y / winH : 0) - 0.5f;
Touch.__data.Add(touchData);
//Debug.WriteLine("down:" + pt.X + "," + pt.Y);
}
__isMouseLeftDown = false;
}
//OpenTK.WindowState wState = MyGameWindow.getWindowState();
//wState != OpenTK.WindowState.Minimized
if (mouse.IsButtonDown(OpenTK.Input.MouseButton.Left))
{
if (__isMouseLeftDown == false)
{
TouchData touchData = new TouchData();
touchData.ID = 0;
touchData.Status = TouchStatus.Down;
touchData.X = (winW > 0 ? (float)pt.X / winW : 0) - 0.5f;
touchData.Y = (winH > 0 ? (float)pt.Y / winH : 0) - 0.5f;
Touch.__data.Add(touchData);
}
else
{
TouchData touchData = new TouchData();
touchData.ID = 0;
touchData.Status = TouchStatus.Move;
touchData.X = (winW > 0 ? (float)pt.X / winW : 0) - 0.5f;
touchData.Y = (winH > 0 ? (float)pt.Y / winH : 0) - 0.5f;
Touch.__data.Add(touchData);
}
__isMouseLeftDown = true;
}
}
else
{
__isMouseLeftDown = false;
}
#if false
double delta = __timer.Elapsed.TotalMilliseconds;
double frame = 1000.0 / 24.0;
if (delta < frame)
{
int free = (int)(frame - delta);
Thread.Sleep(free);
//Debug.WriteLine("Sleep: " + free);
}
__timer.Restart();
#endif
}
private Vector2 getUpdatedPosition(OpenTK.Input.MouseState state, OpenTKMouseState lastState)
{
Vector2 currentPosition;
if ((state.RawFlags & RawMouseFlags.MOUSE_MOVE_ABSOLUTE) > 0)
{
const int raw_input_resolution = 65536;
if (mapAbsoluteInputToWindow)
{
// map directly to local window
currentPosition.X = ((float)((state.X - raw_input_resolution / 2f) * sensitivity.Value) + raw_input_resolution / 2f) / raw_input_resolution * host.Window.Width;
currentPosition.Y = ((float)((state.Y - raw_input_resolution / 2f) * sensitivity.Value) + raw_input_resolution / 2f) / raw_input_resolution
* host.Window.Height;
}
else
{
Rectangle screenRect = (state.RawFlags & RawMouseFlags.MOUSE_VIRTUAL_DESKTOP) > 0
? Platform.Windows.Native.Input.GetVirtualScreenRect()
: new Rectangle(0, 0, DisplayDevice.Default.Width, DisplayDevice.Default.Height);
// map to full screen space
currentPosition.X = (float)state.X / raw_input_resolution * screenRect.Width + screenRect.X;
currentPosition.Y = (float)state.Y / raw_input_resolution * screenRect.Height + screenRect.Y;
// find local window coordinates
var clientPos = host.Window.PointToClient(new Point((int)Math.Round(currentPosition.X), (int)Math.Round(currentPosition.Y)));
// apply sensitivity from window's centre
currentPosition.X = (float)((clientPos.X - host.Window.Width / 2f) * sensitivity.Value + host.Window.Width / 2f);
currentPosition.Y = (float)((clientPos.Y - host.Window.Height / 2f) * sensitivity.Value + host.Window.Height / 2f);
}
}
else
{
if (lastState == null)
{
// when we return from being outside of the window, we want to set the new position of our game cursor
// to where the OS cursor is, just once.
var cursorState = OpenTK.Input.Mouse.GetCursorState();
var screenPoint = host.Window.PointToClient(new Point(cursorState.X, cursorState.Y));
currentPosition = new Vector2(screenPoint.X, screenPoint.Y);
}
else
{
currentPosition = lastState.Position + new Vector2(state.X - lastState.RawState.X, state.Y - lastState.RawState.Y) * (float)sensitivity.Value;
// When confining, clamp to the window size.
if (confineMode.Value == ConfineMouseMode.Always || confineMode.Value == ConfineMouseMode.Fullscreen && windowMode.Value == WindowMode.Fullscreen)
{
currentPosition = Vector2.Clamp(currentPosition, Vector2.Zero, new Vector2(host.Window.Width, host.Window.Height));
}
// update the windows cursor to match our raw cursor position.
// this is important when sensitivity is decreased below 1.0, where we need to ensure the cursor stays within the window.
var screenPoint = host.Window.PointToScreen(new Point((int)currentPosition.X, (int)currentPosition.Y));
OpenTK.Input.Mouse.SetPosition(screenPoint.X, screenPoint.Y);
}
}
return(currentPosition);
}
public UnfocusedMouseState(MouseState tkState, bool active, Vector2?mappedPosition)
: base(tkState, active, mappedPosition)
{
}
internal static void NextTick()
{
LastPos = Pos;
state = OpenTK.Input.Mouse.GetState();
}
public void UpdateState()
{
this.mouseState = this.mouseStateBuffer;
}
private void window_MouseWheel(object sender, TKMouseWheelEventArgs e)
{
this.mouseStateBuffer = e.Mouse;
}
public OpenTKPollMouseState(OpenTK.Input.MouseState tkState, bool active, Vector2?mappedPosition)
: base(tkState, active, mappedPosition)
{
}
public void UpdateMouse()
{
current = OpenTK.Input.Mouse.GetState ();
if (current != previous)
{
int xdelta = current.X - previous.X;
int ydelta = current.Y - previous.Y;
xrot += Convert.ToSingle (ydelta);
yrot += Convert.ToSingle (xdelta);
}
previous = current;
}
