399 lines
11 KiB
C++
399 lines
11 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "stdafx.h"
|
|
#include "Keyboard.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
//
|
|
// Defines key state bit masks.
|
|
//
|
|
#define KEYSTATE_DOWN 0x0000FFFF
|
|
#define KEYSTATE_IMPULSE_DOWN 0x00010000
|
|
#define KEYSTATE_IMPULSE_UP 0x00020000
|
|
|
|
|
|
//
|
|
// List of allowed modifier keys and their associated bit masks.
|
|
//
|
|
static KeyMap_t ModifierKeyTable[] =
|
|
{
|
|
{ VK_SHIFT, KEY_MOD_SHIFT, 0 },
|
|
{ VK_CONTROL, KEY_MOD_CONTROL, 0 },
|
|
{ VK_MENU, KEY_MOD_ALT, 0 }
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CKeyboard::CKeyboard(void)
|
|
{
|
|
g_uKeyMaps = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor.
|
|
//-----------------------------------------------------------------------------
|
|
CKeyboard::~CKeyboard(void)
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a key binding to the
|
|
// Input : uChar - The virtual keycode of the primary key that must be held down.
|
|
// uModifierKeys - Bitflags specifying which modifier keys must be
|
|
// held down along with the key specified by uChar.
|
|
// uLogicalKey - An application-specific value that indicates which
|
|
// logical function
|
|
//-----------------------------------------------------------------------------
|
|
void CKeyboard::AddKeyMap(unsigned int uChar, unsigned int uModifierKeys, unsigned int uLogicalKey)
|
|
{
|
|
g_uKeyMap[g_uKeyMaps].uChar = uChar;
|
|
g_uKeyMap[g_uKeyMaps].uModifierKeys = uModifierKeys;
|
|
g_uKeyMap[g_uKeyMaps].uLogicalKey = uLogicalKey;
|
|
g_uKeyMaps++;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Clears the KEYSTATE_IMPULSE_UP and KEYSTATE_IMPULSE_DOWN flags from
|
|
// all physical and logical keys.
|
|
//-----------------------------------------------------------------------------
|
|
void CKeyboard::ClearImpulseFlags(void)
|
|
{
|
|
int nKey;
|
|
|
|
//
|
|
// Clear the impulse flags for all the physical keys.
|
|
//
|
|
for (nKey = 0; nKey < sizeof(g_uPhysicalKeyState) / sizeof(g_uPhysicalKeyState[0]); nKey++)
|
|
{
|
|
g_uPhysicalKeyState[nKey] &= ~(KEYSTATE_IMPULSE_DOWN | KEYSTATE_IMPULSE_UP);
|
|
}
|
|
|
|
//
|
|
// Clear the impulse flags for all the logical keys.
|
|
//
|
|
for (nKey = 0; nKey < sizeof(g_uLogicalKeyState) / sizeof(g_uLogicalKeyState[0]); nKey++)
|
|
{
|
|
g_uLogicalKeyState[nKey] &= ~(KEYSTATE_IMPULSE_DOWN | KEYSTATE_IMPULSE_UP);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Zeros out the key state for all physical and logical keys.
|
|
//-----------------------------------------------------------------------------
|
|
void CKeyboard::ClearKeyStates(void)
|
|
{
|
|
int nKey;
|
|
|
|
//
|
|
// Clear the physical key states.
|
|
//
|
|
for (nKey = 0; nKey < sizeof(g_uPhysicalKeyState) / sizeof(g_uPhysicalKeyState[0]); nKey++)
|
|
{
|
|
g_uPhysicalKeyState[nKey] = 0;
|
|
}
|
|
|
|
//
|
|
// Clear the logical key states.
|
|
//
|
|
for (nKey = 0; nKey < sizeof(g_uLogicalKeyState) / sizeof(g_uLogicalKeyState[0]); nKey++)
|
|
{
|
|
g_uLogicalKeyState[nKey] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Gets a floating point value indicating about how long the logical
|
|
// key has been held down during this sample period.
|
|
// Input : uLogicalKey - Logical key to check.
|
|
// Output : Returns one of the following values:
|
|
// 0.25 if a key was pressed and released during the sample period,
|
|
// 0.5 if it was pressed and held,
|
|
// 0 if held then released, and
|
|
// 1.0 if held for the entire time.
|
|
//-----------------------------------------------------------------------------
|
|
float CKeyboard::GetKeyScale(unsigned int uLogicalKey)
|
|
{
|
|
if (uLogicalKey >= MAX_LOGICAL_KEYS)
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
unsigned int uKeyState = g_uLogicalKeyState[uLogicalKey];
|
|
|
|
bool bImpulseDown = (uKeyState & KEYSTATE_IMPULSE_DOWN) != 0;
|
|
bool bImpulseUp = (uKeyState & KEYSTATE_IMPULSE_UP) != 0;
|
|
bool bDown = (uKeyState & KEYSTATE_DOWN) != 0;
|
|
float fValue = 0;
|
|
|
|
//
|
|
// If we have a leading edge and no trailing edge, the key should be down.
|
|
//
|
|
if (bImpulseDown && !bImpulseUp)
|
|
{
|
|
if (bDown)
|
|
{
|
|
//
|
|
// Pressed and held this frame.
|
|
//
|
|
fValue = 0.5;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we have a trailing edge and no leading edge, the key should be up.
|
|
//
|
|
if (bImpulseUp && !bImpulseDown)
|
|
{
|
|
if (!bDown)
|
|
{
|
|
//
|
|
// Released this frame.
|
|
//
|
|
fValue = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we have neither a leading edge nor a trailing edge, the key was either
|
|
// up the whole frame or down the whole frame.
|
|
//
|
|
if (!bImpulseDown && !bImpulseUp)
|
|
{
|
|
if (bDown)
|
|
{
|
|
//
|
|
// Held the entire frame
|
|
//
|
|
fValue = 1.0;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Up the entire frame.
|
|
//
|
|
fValue = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we have both a leading and trailing edge, it was either released and repressed
|
|
// this frame, or pressed and released this frame.
|
|
//
|
|
if (bImpulseDown && bImpulseUp)
|
|
{
|
|
if (bDown)
|
|
{
|
|
//
|
|
// Released and re-pressed this frame.
|
|
//
|
|
fValue = 0.75;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Pressed and released this frame.
|
|
//
|
|
fValue = 0.25;
|
|
}
|
|
}
|
|
|
|
return fValue;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the bit mask associated with the given modifier key.
|
|
// Input : uModifierKey - The virtual key code corresponding to the modifier key.
|
|
// Output : The modifier key's bitmask.
|
|
//-----------------------------------------------------------------------------
|
|
unsigned int CKeyboard::GetModifierKeyBit(unsigned int uChar)
|
|
{
|
|
for (int nKey = 0; nKey < sizeof(ModifierKeyTable) / sizeof(ModifierKeyTable[0]); nKey++)
|
|
{
|
|
if (ModifierKeyTable[nKey].uChar == uChar)
|
|
{
|
|
return(ModifierKeyTable[nKey].uModifierKeys);
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks to see if all of the modifier keys specified by bits in uModifierKeys
|
|
// are currently held down.
|
|
// Input : uModifierKeys - Contains bits indicating which modifier keys to check:
|
|
// KEY_MOD_SHIFT
|
|
// KEY_MOD_CONTROL
|
|
// KEY_MOD_ALT
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CKeyboard::IsKeyPressed(unsigned int uChar, unsigned int uModifierKeys)
|
|
{
|
|
if (!(g_uPhysicalKeyState[uChar] & KEYSTATE_DOWN))
|
|
{
|
|
return(false);
|
|
}
|
|
|
|
bool bKeyPressed = true;
|
|
|
|
for (int nKey = 0; nKey < sizeof(ModifierKeyTable) / sizeof(ModifierKeyTable[0]); nKey++)
|
|
{
|
|
if (g_uPhysicalKeyState[ModifierKeyTable[nKey].uChar] & KEYSTATE_DOWN)
|
|
{
|
|
if (!(uModifierKeys & ModifierKeyTable[nKey].uModifierKeys))
|
|
{
|
|
bKeyPressed = false;
|
|
}
|
|
}
|
|
else if (uModifierKeys & ModifierKeyTable[nKey].uModifierKeys)
|
|
{
|
|
bKeyPressed = false;
|
|
}
|
|
}
|
|
|
|
return(bKeyPressed);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines whether a key is an allowed modifier key, ie, whether it
|
|
// can be used in conjunction with other keys when performing key
|
|
// bindings.
|
|
// Input : uChar - Virtual key to check.
|
|
// Output : Returns true if this key is a modifier key, false if not.
|
|
//-----------------------------------------------------------------------------
|
|
bool CKeyboard::IsModifierKey(unsigned int uChar)
|
|
{
|
|
return((uChar == VK_SHIFT) || (uChar == VK_CONTROL) || (uChar == VK_MENU));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Given a key press/release event, updates the status of all logical
|
|
// keys.
|
|
// Input : uChar - The key whose state has changed.
|
|
// bPressed - True if the key was pressed, false if it was released.
|
|
//-----------------------------------------------------------------------------
|
|
void CKeyboard::UpdateLogicalKeys(unsigned int uChar, bool bPressed)
|
|
{
|
|
//
|
|
// Determine whether the key is a modifier key. If so, find its modifier bit.
|
|
//
|
|
bool bIsModifierKey = IsModifierKey(uChar);
|
|
unsigned int uModifierKeyBit = 0;
|
|
if (bIsModifierKey)
|
|
{
|
|
uModifierKeyBit = GetModifierKeyBit(uChar);
|
|
}
|
|
|
|
//
|
|
// For every key in the keymap that depends upon this physical key, update
|
|
// the state of the corresponding logical key based on this event.
|
|
//
|
|
for (unsigned int nKey = 0; nKey < g_uKeyMaps; nKey++)
|
|
{
|
|
unsigned int uPhysicalKey = g_uKeyMap[nKey].uChar;
|
|
unsigned int uLogicalKey = g_uKeyMap[nKey].uLogicalKey;
|
|
unsigned int uModifierKeys = g_uKeyMap[nKey].uModifierKeys;
|
|
|
|
if ((uPhysicalKey == uChar) || (uModifierKeys & uModifierKeyBit))
|
|
{
|
|
//
|
|
// Check the state of all modifier keys to which this logical key
|
|
// is bound to determine whether the logical key is pressed or not.
|
|
//
|
|
bool bLogicalKeyPressed = IsKeyPressed(g_uKeyMap[nKey].uChar, g_uKeyMap[nKey].uModifierKeys);
|
|
|
|
//
|
|
// Update the logical key state.
|
|
//
|
|
if (bPressed)
|
|
{
|
|
if (bLogicalKeyPressed)
|
|
{
|
|
if (!(g_uLogicalKeyState[uLogicalKey] & KEYSTATE_DOWN))
|
|
{
|
|
g_uLogicalKeyState[uLogicalKey] |= KEYSTATE_IMPULSE_DOWN;
|
|
}
|
|
|
|
g_uLogicalKeyState[uLogicalKey]++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (g_uLogicalKeyState[uLogicalKey] & KEYSTATE_DOWN)
|
|
{
|
|
g_uLogicalKeyState[uLogicalKey]--;
|
|
}
|
|
|
|
if (!(g_uLogicalKeyState[uLogicalKey] & KEYSTATE_DOWN))
|
|
{
|
|
g_uLogicalKeyState[uLogicalKey] |= KEYSTATE_IMPULSE_UP;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called by the client when a WM_KEYDOWN message is received.
|
|
// Input : Per CWnd::OnKeyDown.
|
|
//-----------------------------------------------------------------------------
|
|
void CKeyboard::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
|
|
{
|
|
if ((!(nFlags & 0x4000)) || (!(g_uPhysicalKeyState[nChar] & KEYSTATE_DOWN)))
|
|
{
|
|
g_uPhysicalKeyState[nChar] |= KEYSTATE_DOWN;
|
|
g_uPhysicalKeyState[nChar] |= KEYSTATE_IMPULSE_DOWN;
|
|
|
|
UpdateLogicalKeys(nChar, true);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called by the client when a WM_KEYUP message is received.
|
|
// Input : Per CWnd::OnKeyDown.
|
|
//-----------------------------------------------------------------------------
|
|
void CKeyboard::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
|
|
{
|
|
if (g_uPhysicalKeyState[nChar] & KEYSTATE_DOWN)
|
|
{
|
|
g_uPhysicalKeyState[nChar] &= ~KEYSTATE_DOWN;
|
|
}
|
|
|
|
g_uPhysicalKeyState[nChar] |= KEYSTATE_IMPULSE_UP;
|
|
|
|
UpdateLogicalKeys(nChar, false);
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Deletes all key bindings.
|
|
//-----------------------------------------------------------------------------
|
|
void CKeyboard::RemoveAllKeyMaps(void)
|
|
{
|
|
g_uKeyMaps = 0;
|
|
}
|
|
|