// --------------------------------------------------------------------
public void OnFrameTick()
{
OpenTK.Input.KeyboardState keyboardState = OpenTK.Input.Keyboard.GetState();
bool keySDown = keyboardState.IsKeyDown(OpenTK.Input.Key.S);
bool keyADown = keyboardState.IsKeyDown(OpenTK.Input.Key.A);
bool keyWDown = keyboardState.IsKeyDown(OpenTK.Input.Key.W);
bool keyDDown = keyboardState.IsKeyDown(OpenTK.Input.Key.D);
if (keyDDown)
{
MoveCamera(Vector3.UnitX * DragFactor * 10);
}
if (keySDown)
{
MoveCamera(Vector3.UnitZ * DragFactor * 10);
}
if (keyWDown)
{
MoveCamera(-Vector3.UnitZ * DragFactor * 10);
}
if (keyADown)
{
MoveCamera(-Vector3.UnitX * DragFactor * 10);
}
if (keyADown || keyDDown || keySDown || keyWDown)
{
mBoundControl.Refresh();
}
}
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();
}
public static void UpdateFromOpenTK(OpenTK.Input.KeyboardState keyboard)
{
for (int i = 0; i < (int)OpenTK.Input.Key.LastKey; i++)
{
var key = (OpenTK.Input.Key)i;
_current.SetState(translateOpenTKKey(key), keyboard.IsKeyDown(key) ? KeyState.Down : KeyState.Up);
}
}
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 OnUpdateFrame(OpenTK.FrameEventArgs e)
{
OpenTK.Input.KeyboardState input = OpenTK.Input.Keyboard.GetState();
if (input.IsKeyDown(OpenTK.Input.Key.Escape))
{
Exit();
}
base.OnUpdateFrame(e);
}
public void KeyPress(OpenTK.Input.KeyboardState keyState)
{
if (keyState.IsKeyDown(OpenTK.Input.Key.E))
{
this.E = this.E + 5;
this.D = this.D - 5;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.D))
{
this.E = this.E - 5;
this.D = this.D + 5;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.C))
{
this.C = this.C + 5;
this.B = this.B - 5;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.B))
{
this.C = this.C - 5;
this.B = this.B + 5;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.I))
{
this.I = this.I + 1;
this.O = this.O - 1;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.O))
{
this.I = this.I - 1;
this.O = this.O + 1;
}
}
public PrimitiveType getPrimitive()
{
OpenTK.Input.KeyboardState keyboardState = OpenTK.Input.Keyboard.GetState();
if (this.listenKeyPress && keyboardState.IsKeyDown(OpenTK.Input.Key.Space))
{
this.listenKeyPress = false;
this.index++;
if (this.index >= this.primitives.Length)
{
this.index = 0;
}
Task.Run(async() => {
await Task.Delay(200);
this.listenKeyPress = true;
});
}
return(this.primitives[this.index]);
}
/// <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)))
{
}
}
protected override void OnUpdateFrame(FrameEventArgs e)
{
base.OnUpdateFrame(e);
var state = OpenTK.Input.Keyboard.GetState();
if (state.IsKeyDown(OpenTK.Input.Key.Escape))
{
this.Close();
}
helicopter.Collision = helicopter.Box.Intersects(blocoC.Box);
helicopter.ColideTop = helicopter.Box.IntersectsWithTop(blocoC.Box);
camera.Move();
helicopter.HandleInput();
if (oldState.IsKeyDown(OpenTK.Input.Key.B) && state.IsKeyUp(OpenTK.Input.Key.B))
{
DrawBoundingBox = !DrawBoundingBox;
}
//System.Diagnostics.Debug.WriteLine(helicopter.Collision);
//if (helicopter.Position.Y < 40)
//{
// //if (state.IsKeyDown(OpenTK.Input.Key.Space))
// // helicopter.Position = new OpenTK.Vector3(helicopter.Position.X, helicopter.Position.Y + (0.3f * altitude), helicopter.Position.Z);
// //else if(state.IsKeyUp(OpenTK.Input.Key.Space) && helicopter.Position.Y > 0)
// // helicopter.Position = new OpenTK.Vector3(helicopter.Position.X, helicopter.Position.Y - (0.1f * altitude), helicopter.Position.Z);
//}
//(float)CubicEaseInOut(altitude,0,30,30)
oldState = state;
}
public void KeyPress(OpenTK.Input.KeyboardState keyState)
{
if (keyState.IsKeyDown(OpenTK.Input.Key.Number1) || keyState.IsKeyDown(OpenTK.Input.Key.Keypad1))
{
this.mundo.SelectPoint(0);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Number2) || keyState.IsKeyDown(OpenTK.Input.Key.Keypad2))
{
this.mundo.SelectPoint(1);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Number3) || keyState.IsKeyDown(OpenTK.Input.Key.Keypad3))
{
this.mundo.SelectPoint(2);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Number4) || keyState.IsKeyDown(OpenTK.Input.Key.Keypad4))
{
this.mundo.SelectPoint(3);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Plus) || keyState.IsKeyDown(OpenTK.Input.Key.KeypadPlus))
{
this.delayedKeyAction(() => this.mundo.IncreaseSplineControlPoint());
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Minus) || keyState.IsKeyDown(OpenTK.Input.Key.KeypadMinus))
{
this.delayedKeyAction(() => this.mundo.DecreaseSplineControlPoint());
}
if (keyState.IsKeyDown(OpenTK.Input.Key.C))
{
this.mundo.moveSelectedPoint(Direction.UP);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.B))
{
this.mundo.moveSelectedPoint(Direction.DOWN);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.E))
{
this.mundo.moveSelectedPoint(Direction.LEFT);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.D))
{
this.mundo.moveSelectedPoint(Direction.RIGHT);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.R))
{
this.mundo.reset();
}
}
private void KeyboardUpdate(double timeSinceLastFrame, ref double[] refTranslation, ref double[] refRotation)
{
OpenTK.Input.KeyboardState keyState = OpenTK.Input.Keyboard.GetState();
/*
* By convention, the double arrays are ordered in x,y,z order (x = 0, y = 1, z = 2).
* Orientation is right handed, with an inverted Z-axis.
*
* Translation is converted during calculation to account for facing.
*/
if (keyState.IsKeyDown(OpenTK.Input.Key.W))
{
refTranslation[2] += 500000 * Math.Cos(Facing[1]);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.S))
{
refTranslation[2] += -500000 * Math.Cos(Facing[1]);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.D))
{
refTranslation[0] += 500000 * Math.Cos(Facing[1]);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.A))
{
refTranslation[0] += -500000 * Math.Cos(Facing[1]);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Q))
{
refTranslation[1] += 500000 * Math.Cos(Facing[2]);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.E))
{
refTranslation[1] += -500000 * Math.Cos(Facing[2]);
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Keypad7))
{
refRotation[2] += 1;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Keypad9))
{
refRotation[2] += -1;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Keypad8))
{
refRotation[0] += 1;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Keypad5))
{
refRotation[0] += -1;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Keypad4))
{
refRotation[1] += 1;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.Keypad6))
{
refRotation[1] += -1;
}
if (keyState.IsKeyDown(OpenTK.Input.Key.ShiftLeft) || keyState.IsKeyDown(OpenTK.Input.Key.ShiftRight))
{
for (int i = 0; i < refTranslation.Length; i++)
{
refTranslation[i] *= 10;
}
}
if (keyState.IsKeyDown(OpenTK.Input.Key.ControlLeft))
{
for (int i = 0; i < refTranslation.Length; i++)
{
refTranslation[i] *= 100;
}
}
for (int i = 0; i < 3; i++)
{
refRotation[i] *= timeSinceLastFrame;
refTranslation[i] *= timeSinceLastFrame;
Position[i] += refTranslation[i];
}
}
public static bool KeyReleased(OpenTK.Input.Key key)
{
return(CurrentState.IsKeyUp(key) && lastState.IsKeyDown(key));
}
/// <summary>
/// Gets a value indicating whether the specified keyboard key is pressed on current frame.
/// </summary>
/// <param name="key">The keyboard key to check.</param>
/// <returns><code>true</code> if pressed, otherwise false.</returns>
public bool IsKeyDown(Key key)
{
return(_state.IsKeyDown((OpenTK.Input.Key)key));
}
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
}
public override bool IsKeyDown(int key)
{
OpenTK.Input.KeyboardState state = OpenTK.Input.Keyboard.GetState();
return(state.IsKeyDown((OpenTK.Input.Key)key));
}
public void tポーリング(bool bWindowがアクティブ中)
{
for (int i = 0; i < 256; i++)
{
this.bKeyPushDown[i] = false;
this.bKeyPullUp[i] = false;
}
if (bWindowがアクティブ中)
{
//this.list入力イベント = new List<STInputEvent>( 32 );
this.list入力イベント.Clear(); // #xxxxx 2012.6.11 yyagi; To optimize, I removed new();
//string d = DateTime.Now.ToString( "yyyy/MM/dd HH:mm:ss.ffff" );
#region [ 入力 ]
//-----------------------------
OpenTK.Input.KeyboardState currentState = OpenTK.Input.Keyboard.GetState();
if (currentState.IsConnected)
{
for (int index = 0; index < Enum.GetNames(typeof(OpenTK.Input.Key)).Length; index++)
{
if (currentState[(OpenTK.Input.Key)index])
{
var key = DeviceConstantConverter.TKKtoKey((OpenTK.Input.Key)index);
if (SlimDXKey.Unknown == key)
{
continue; // 未対応キーは無視。
}
if (this.bKeyState[(int)key] == false)
{
if (key != SlimDXKey.Return || (bKeyState[(int)SlimDXKey.LeftAlt] == false && bKeyState[(int)SlimDXKey.RightAlt] == false)) // #23708 2016.3.19 yyagi
{
var ev = new STInputEvent()
{
nKey = (int)key,
b押された = true,
b離された = false,
nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻, // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
nVelocity = CInput管理.n通常音量,
};
this.list入力イベント.Add(ev);
this.bKeyState[(int)key] = true;
this.bKeyPushDown[(int)key] = true;
}
//if ( (int) key == (int) SlimDXKey.Space )
//{
// Trace.TraceInformation( "FDK(direct): SPACE key registered. " + ct.nシステム時刻 );
//}
}
}
{
// #xxxxx: 2017.5.7: from: DIK (SharpDX.DirectInput.Key) を SlimDX.DirectInput.Key に変換。
var key = DeviceConstantConverter.TKKtoKey((OpenTK.Input.Key)index);
if (SlimDXKey.Unknown == key)
{
continue; // 未対応キーは無視。
}
if (this.bKeyState[(int)key] == true && !currentState.IsKeyDown((OpenTK.Input.Key)index)) // 前回は押されているのに今回は押されていない → 離された
{
var ev = new STInputEvent()
{
nKey = (int)key,
b押された = false,
b離された = true,
nTimeStamp = CSound管理.rc演奏用タイマ.nシステム時刻, // 演奏用タイマと同じタイマを使うことで、BGMと譜面、入力ずれを防ぐ。
nVelocity = CInput管理.n通常音量,
};
this.list入力イベント.Add(ev);
this.bKeyState[(int)key] = false;
this.bKeyPullUp[(int)key] = true;
}
}
}
}
//-----------------------------
#endregion
}
}
public static bool IsKeyDown(OpenTK.Input.Key k) => state.IsKeyDown(k);
