1489 lines
No EOL
86 KiB
C++
1489 lines
No EOL
86 KiB
C++
#include "StdAfx.h"
|
||
#include "InputDevice.h"
|
||
#include "InputReceiver.h"
|
||
#include "CountryByCountryKeyboard.h"
|
||
#include "SundriesFunc.h"
|
||
#include <mmsystem.h>
|
||
|
||
#ifdef _DEBUG
|
||
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
|
||
#endif
|
||
|
||
//#define _KAL_TEST
|
||
|
||
SWrappingData g_EnableWrappingData[] = {
|
||
{ DIK_ESCAPE, VK_ESCAPE },
|
||
{ DIK_1, '1' },
|
||
{ DIK_2, '2' },
|
||
{ DIK_3, '3' },
|
||
{ DIK_4, '4' },
|
||
{ DIK_5, '5' },
|
||
{ DIK_6, '6' },
|
||
{ DIK_7, '7' },
|
||
{ DIK_8, '8' },
|
||
{ DIK_9, '9' },
|
||
{ DIK_0, '0' },
|
||
{ DIK_BACK, VK_BACK },
|
||
{ DIK_Q, 'Q' },
|
||
{ DIK_W, 'W' },
|
||
{ DIK_E, 'E' },
|
||
{ DIK_R, 'R' },
|
||
{ DIK_T, 'T' },
|
||
{ DIK_Y, 'Y' },
|
||
{ DIK_U, 'U' },
|
||
{ DIK_I, 'I' },
|
||
{ DIK_O, 'O' },
|
||
{ DIK_P, 'P' },
|
||
{ DIK_A, 'A' },
|
||
{ DIK_S, 'S' },
|
||
{ DIK_D, 'D' },
|
||
{ DIK_F, 'F' },
|
||
{ DIK_G, 'G' },
|
||
{ DIK_H, 'H' },
|
||
{ DIK_J, 'J' },
|
||
{ DIK_K, 'K' },
|
||
{ DIK_L, 'L' },
|
||
{ DIK_SEMICOLON, VK_OEM_1 },
|
||
{ DIK_APOSTROPHE, VK_OEM_7 },
|
||
{ DIK_GRAVE, VK_OEM_3 },
|
||
{ DIK_BACKSLASH, VK_OEM_5 },
|
||
{ DIK_Z, 'Z' },
|
||
{ DIK_X, 'X' },
|
||
{ DIK_C, 'C' },
|
||
{ DIK_V, 'V' },
|
||
{ DIK_B, 'B' },
|
||
{ DIK_N, 'N' },
|
||
{ DIK_M, 'M' },
|
||
{ DIK_COMMA, VK_OEM_COMMA },
|
||
{ DIK_PERIOD, VK_OEM_PERIOD },
|
||
{ DIK_SLASH, VK_OEM_2 },
|
||
{ DIK_MULTIPLY, VK_MULTIPLY },
|
||
{ DIK_SPACE, VK_SPACE },
|
||
{ DIK_NUMPAD7, VK_NUMPAD7 },
|
||
{ DIK_NUMPAD8, VK_NUMPAD8 },
|
||
{ DIK_NUMPAD9, VK_NUMPAD9 },
|
||
{ DIK_SUBTRACT, VK_SUBTRACT },
|
||
{ DIK_NUMPAD4, VK_NUMPAD4 },
|
||
{ DIK_NUMPAD5, VK_NUMPAD5 },
|
||
{ DIK_NUMPAD6, VK_NUMPAD6 },
|
||
{ DIK_ADD, VK_ADD },
|
||
{ DIK_NUMPAD1, VK_NUMPAD1 },
|
||
{ DIK_NUMPAD2, VK_NUMPAD2 },
|
||
{ DIK_NUMPAD3, VK_NUMPAD3 },
|
||
{ DIK_NUMPAD0, VK_NUMPAD0 },
|
||
{ DIK_DECIMAL, VK_DECIMAL },
|
||
{ DIK_DIVIDE, VK_DIVIDE },
|
||
{ DIK_HOME, VK_HOME },
|
||
{ DIK_UP, VK_UP },
|
||
{ DIK_PRIOR, VK_PRIOR },
|
||
{ DIK_LEFT, VK_LEFT },
|
||
{ DIK_RIGHT, VK_RIGHT },
|
||
{ DIK_END, VK_END },
|
||
{ DIK_DOWN, VK_DOWN },
|
||
{ DIK_NEXT, VK_NEXT },
|
||
{ DIK_INSERT, VK_INSERT },
|
||
{ DIK_DELETE, VK_DELETE },
|
||
{ DIK_LCONTROL, VK_LCONTROL },
|
||
{ DIK_MINUS, VK_OEM_MINUS },
|
||
{ DIK_EQUALS, VK_OEM_PLUS },
|
||
};
|
||
|
||
BYTE _ToDIK( BYTE cVK )
|
||
{
|
||
for( int i = 0; i < _countof(g_EnableWrappingData); ++i )
|
||
{
|
||
if( g_EnableWrappingData[i].cVK == cVK )
|
||
return g_EnableWrappingData[i].cDIK;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
BYTE _ToVK( BYTE cDIK )
|
||
{
|
||
for( int i = 0; i < _countof(g_EnableWrappingData); ++i )
|
||
{
|
||
if( g_EnableWrappingData[i].cDIK == cDIK )
|
||
return g_EnableWrappingData[i].cVK;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
BYTE _NoNumLockVKToNumLockVK( BYTE cVK )
|
||
{
|
||
switch( cVK )
|
||
{
|
||
case VK_HOME: return VK_NUMPAD7;
|
||
case VK_UP: return VK_NUMPAD8;
|
||
case VK_PRIOR: return VK_NUMPAD9;
|
||
case VK_LEFT: return VK_NUMPAD4;
|
||
case 0x0c: return VK_NUMPAD5;
|
||
case VK_RIGHT: return VK_NUMPAD6;
|
||
case VK_END: return VK_NUMPAD1;
|
||
case VK_DOWN: return VK_NUMPAD2;
|
||
case VK_NEXT: return VK_NUMPAD3;
|
||
case VK_INSERT: return VK_NUMPAD0;
|
||
case VK_DELETE: return VK_DECIMAL;
|
||
}
|
||
return cVK;
|
||
}
|
||
|
||
bool _IsEnableWrappingDIK( BYTE cDIK )
|
||
{
|
||
for( int i = 0; i < _countof(g_EnableWrappingData); ++i )
|
||
{
|
||
if( g_EnableWrappingData[i].cDIK == cDIK )
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
BYTE _GetCurrentPushKey( bool bTransNumLock )
|
||
{
|
||
BYTE cVK = 0;
|
||
for( int i = 0; i < _countof(g_EnableWrappingData); ++i )
|
||
{
|
||
if( GetKeyState( g_EnableWrappingData[i].cVK )&0x80 )
|
||
{
|
||
cVK = g_EnableWrappingData[i].cVK;
|
||
break;
|
||
}
|
||
}
|
||
if( cVK == 0 ) return 0;
|
||
|
||
// 넘락키 토글 안켜있는채로 Numpad7누르면 Home으로 온다. 그래서 현재 numlock상태에 따라 변환 처리를 해준다.
|
||
if( bTransNumLock ) cVK = _NoNumLockVKToNumLockVK( cVK );
|
||
return _ToDIK(cVK);
|
||
}
|
||
|
||
BOOL CALLBACK EnumObjectsCallback( const DIDEVICEOBJECTINSTANCE* pdidoi, VOID* pContext );
|
||
|
||
int CInputDevice::ms_InverseModeCount = 0;
|
||
int CInputDevice::ms_InverseMode = 0; //입력 반전 모드(1:키보드&마우스, 2: 키보드, 3: 마우스)
|
||
|
||
void CInputDevice::SetInverseMode(int nMode)
|
||
{
|
||
ms_InverseMode = nMode;
|
||
}
|
||
|
||
bool CInputDevice::IsInverseKeyboard()
|
||
{
|
||
return (ms_InverseModeCount > 0 ? (ms_InverseMode == 1 || ms_InverseMode == 2) : false);
|
||
}
|
||
|
||
bool CInputDevice::IsInverseMouse()
|
||
{
|
||
return (ms_InverseModeCount > 0 ? (ms_InverseMode == 1 || ms_InverseMode == 3) : false);
|
||
}
|
||
|
||
void CInputDevice::ResetInverseMode()
|
||
{
|
||
ms_InverseModeCount = 0;
|
||
ms_InverseMode = 0;
|
||
}
|
||
|
||
CInputDevice::CInputDevice()
|
||
{
|
||
m_pDI = NULL;
|
||
m_bCheckWndFocus = false;
|
||
m_bForcePassProcess = false;
|
||
m_hWnd = NULL;
|
||
int i = 0;
|
||
for (; i < eABSENCE_MAX; ++i)
|
||
{
|
||
m_AbsenceCheckTimers[i].fAbsenceCheckTimer = eABSENCE_MIN;
|
||
m_AbsenceCheckTimers[i].bHoldAbsenceCheckTimer = false;
|
||
}
|
||
}
|
||
|
||
CInputDevice::~CInputDevice()
|
||
{
|
||
Finalize();
|
||
}
|
||
|
||
void CInputDevice::Finalize()
|
||
{
|
||
SAFE_DELETE_PVEC( m_pVecDevice );
|
||
SAFE_DELETE_VEC( m_pVecReceiverList );
|
||
SAFE_RELEASE( m_pDI );
|
||
}
|
||
|
||
bool CInputDevice::IsValidAbsenceChecktype(eAbsenceCheckTimerType type) const
|
||
{
|
||
return (type >= eABSENCE_MIN && type < eABSENCE_MAX);
|
||
}
|
||
|
||
float CInputDevice::GetAbsenceCheckTimer(eAbsenceCheckTimerType type) const
|
||
{
|
||
if (IsValidAbsenceChecktype(type) == false)
|
||
return 0.f;
|
||
|
||
return m_AbsenceCheckTimers[type].fAbsenceCheckTimer;
|
||
}
|
||
|
||
void CInputDevice::ResetAbsenceCheckTimer(eAbsenceCheckTimerType type)
|
||
{
|
||
if (IsValidAbsenceChecktype(type) == false)
|
||
return;
|
||
|
||
m_AbsenceCheckTimers[type].fAbsenceCheckTimer = 0.f;
|
||
}
|
||
|
||
void CInputDevice::HoldAbsenceCheckTimer(eAbsenceCheckTimerType type, bool bHold)
|
||
{
|
||
if (IsValidAbsenceChecktype(type) == false)
|
||
return;
|
||
|
||
m_AbsenceCheckTimers[type].bHoldAbsenceCheckTimer = bHold;
|
||
}
|
||
|
||
void CInputDevice::Process( LOCAL_TIME LocalTime, float fDelta )
|
||
{
|
||
int i = 0;
|
||
for (; i < eABSENCE_MAX; ++i)
|
||
{
|
||
if (m_AbsenceCheckTimers[i].bHoldAbsenceCheckTimer == false)
|
||
{
|
||
m_AbsenceCheckTimers[i].fAbsenceCheckTimer += fDelta;
|
||
if (m_AbsenceCheckTimers[i].fAbsenceCheckTimer < 0.f)
|
||
m_AbsenceCheckTimers[i].fAbsenceCheckTimer = 0.f;
|
||
}
|
||
}
|
||
|
||
//m_PrevLocalTime = LocalTime;
|
||
|
||
if( m_bCheckWndFocus && GetFocus() != m_hWnd ) return;
|
||
|
||
int nEvent = 0;
|
||
bool bOnMsg = false;
|
||
for( DWORD i=0; i<m_pVecDevice.size(); i++ ) {
|
||
if( m_pVecDevice[i]->Process( LocalTime ) == true ) {
|
||
nEvent |= m_pVecDevice[i]->GetEvent();
|
||
bOnMsg = true;
|
||
|
||
int j = 0;
|
||
for (; j < eABSENCE_MAX; ++j)
|
||
{
|
||
m_AbsenceCheckTimers[j].fAbsenceCheckTimer = 0.f;
|
||
}
|
||
}
|
||
}
|
||
|
||
if( m_bForcePassProcess ) {
|
||
m_bForcePassProcess = false;
|
||
return;
|
||
}
|
||
if( bOnMsg ) {
|
||
for( DWORD i=0; i<m_pVecReceiverList.size(); i++ ) {
|
||
m_pVecReceiverList[i]->OnInputReceive( nEvent, LocalTime );
|
||
}
|
||
}
|
||
}
|
||
|
||
bool CInputDevice::Initialize( HWND hWnd, int nDeviceType, bool bCheckFocus )
|
||
{
|
||
HRESULT hResult;
|
||
bool bResult = true;
|
||
|
||
m_hWnd = hWnd;
|
||
m_bCheckWndFocus = bCheckFocus;
|
||
hResult = DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_pDI, NULL );
|
||
ADD_D3D_RES( m_pDI );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
if( nDeviceType & KEYBOARD ) bResult = CreateDevice( KEYBOARD );
|
||
if( nDeviceType & MOUSE ) bResult = CreateDevice( MOUSE );
|
||
if( nDeviceType & JOYPAD ) CreateDevice( JOYPAD );
|
||
|
||
if( ((CInputJoyPad *)GetDeviceObject( JOYPAD )) )
|
||
{
|
||
((CInputJoyPad *)GetDeviceObject( JOYPAD ))->SetKeyboard( ((CInputKeyboard *)GetDeviceObject( KEYBOARD )) );
|
||
((CInputJoyPad *)GetDeviceObject( JOYPAD ))->SetMouse( ((CInputMouse *)GetDeviceObject( MOUSE )) );
|
||
}
|
||
|
||
return bResult;
|
||
}
|
||
|
||
bool CInputDevice::CreateDevice( DEVICE_TYPE Type )
|
||
{
|
||
CInputDeviceBase *pDevice = NULL;
|
||
switch( Type ) {
|
||
case KEYBOARD:
|
||
pDevice = new CInputKeyboard;
|
||
break;
|
||
case MOUSE:
|
||
pDevice = new CInputMouse;
|
||
break;
|
||
case JOYPAD:
|
||
pDevice = new CInputJoyPad;
|
||
((CInputJoyPad *)pDevice)->SetHWND( m_hWnd );
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
if( pDevice->Initialize() == false ) {
|
||
SAFE_DELETE( pDevice );
|
||
return false;
|
||
}
|
||
m_pVecDevice.push_back( pDevice );
|
||
return true;
|
||
}
|
||
|
||
CInputDeviceBase *CInputDevice::GetDeviceObject( DEVICE_TYPE DeviceType )
|
||
{
|
||
for( DWORD i=0; i<m_pVecDevice.size(); i++ ) {
|
||
if( m_pVecDevice[i]->GetDeviceType() == DeviceType ) return m_pVecDevice[i];
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
void CInputDevice::ResetAllInput()
|
||
{
|
||
for( DWORD i=0; i<m_pVecDevice.size(); i++ ) {
|
||
m_pVecDevice[i]->ResetDeviceState();
|
||
}
|
||
}
|
||
|
||
CInputKeyboard::CInputKeyboard()
|
||
: CInputDeviceBase( CInputDevice::KEYBOARD )
|
||
{
|
||
m_pDIDevice = NULL;
|
||
m_dwApplyBufferCount = 0;
|
||
m_dwBufferCount = 8;
|
||
m_pDidod = new DIDEVICEOBJECTDATA[m_dwBufferCount];
|
||
memset( m_bKeyState, 0, sizeof(m_bKeyState) );
|
||
memset( m_PushKeyTime, 0, sizeof(m_PushKeyTime) );
|
||
memset( m_ReleaseKeyTime, 0, sizeof(m_ReleaseKeyTime) );
|
||
m_nEvent = 0;
|
||
|
||
SecureZeroMemory( &m_StartupStickyKeys, sizeof(m_StartupStickyKeys) );
|
||
SecureZeroMemory( &m_StartupToggleKeys, sizeof(m_StartupToggleKeys) );
|
||
SecureZeroMemory( &m_StartupFilterKeys, sizeof(m_StartupFilterKeys) );
|
||
}
|
||
|
||
CInputKeyboard::~CInputKeyboard()
|
||
{
|
||
Release();
|
||
}
|
||
|
||
void CInputKeyboard::Release()
|
||
{
|
||
if( m_pDIDevice ) m_pDIDevice->Unacquire();
|
||
SAFE_DELETEA( m_pDidod );
|
||
SAFE_RELEASE( m_pDIDevice );
|
||
|
||
AllowAccessibilityShortcutKeys( true );
|
||
}
|
||
|
||
bool CInputKeyboard::Initialize()
|
||
{
|
||
HRESULT hResult;
|
||
LPDIRECTINPUT8 pDI = CInputDevice::GetInstance().GetDI();
|
||
DIPROPDWORD dipdw;
|
||
|
||
hResult = pDI->CreateDevice( GUID_SysKeyboard, &m_pDIDevice, NULL );
|
||
ADD_D3D_RES( m_pDIDevice );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
hResult = m_pDIDevice->SetDataFormat( &c_dfDIKeyboard );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
hResult = m_pDIDevice->SetCooperativeLevel( CInputDevice::GetInstance().GetWndHandle(), DISCL_NONEXCLUSIVE | DISCL_FOREGROUND | DISCL_NOWINKEY );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
ZeroMemory( &dipdw, sizeof(DIPROPDWORD) );
|
||
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
|
||
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
||
dipdw.diph.dwObj = 0;
|
||
dipdw.diph.dwHow = DIPH_DEVICE;
|
||
dipdw.dwData = m_dwBufferCount;
|
||
|
||
hResult = m_pDIDevice->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
m_pDIDevice->Acquire();
|
||
|
||
ZeroMemory(&m_StartupStickyKeys, sizeof(STICKYKEYS));
|
||
ZeroMemory(&m_StartupToggleKeys, sizeof(TOGGLEKEYS));
|
||
ZeroMemory(&m_StartupFilterKeys, sizeof(FILTERKEYS));
|
||
m_StartupStickyKeys.cbSize = sizeof(STICKYKEYS);
|
||
m_StartupToggleKeys.cbSize = sizeof(TOGGLEKEYS);
|
||
m_StartupFilterKeys.cbSize = sizeof(FILTERKEYS);
|
||
|
||
// Save the current sticky/toggle/filter key settings so they can be restored them later
|
||
SystemParametersInfo(SPI_GETSTICKYKEYS, sizeof(STICKYKEYS), &m_StartupStickyKeys, 0);
|
||
SystemParametersInfo(SPI_GETTOGGLEKEYS, sizeof(TOGGLEKEYS), &m_StartupToggleKeys, 0);
|
||
SystemParametersInfo(SPI_GETFILTERKEYS, sizeof(FILTERKEYS), &m_StartupFilterKeys, 0);
|
||
|
||
AllowAccessibilityShortcutKeys( false );
|
||
|
||
return true;
|
||
}
|
||
|
||
// CInputMouse 와 중복 코드. m_pDIDevice를 base 레벨로 올리는 것에 대해 고려 by kalliste
|
||
HRESULT CInputKeyboard::SetCooperativeLevel(DWORD flag)
|
||
{
|
||
if( m_pDIDevice == NULL ) return DIERR_NOTFOUND;
|
||
|
||
return m_pDIDevice->SetCooperativeLevel( CInputDevice::GetInstance().GetWndHandle(), flag );
|
||
}
|
||
|
||
HRESULT CInputKeyboard::GetDeviceData()
|
||
{
|
||
if( m_pDIDevice == NULL ) return DIERR_NOTFOUND;
|
||
|
||
m_dwApplyBufferCount = m_dwBufferCount;
|
||
return m_pDIDevice->GetDeviceData( sizeof(DIDEVICEOBJECTDATA), m_pDidod, &m_dwApplyBufferCount, 0 );
|
||
}
|
||
|
||
bool CInputKeyboard::Process( LOCAL_TIME LocalTime )
|
||
{
|
||
HRESULT hResult;
|
||
|
||
// Release Event
|
||
m_nEvent = 0;
|
||
m_VecKeyList.clear();
|
||
m_VecKeyEventTime.clear();
|
||
|
||
hResult = GetDeviceData();
|
||
if( FAILED( hResult ) ) {
|
||
switch( hResult ) {
|
||
case DIERR_NOTFOUND:
|
||
Release();
|
||
Initialize();
|
||
return false;
|
||
default:
|
||
hResult = m_pDIDevice->Acquire();
|
||
ResetDeviceState();
|
||
// if( hResult == DIERR_OTHERAPPHASPRIO || hResult == DIERR_NOTACQUIRED ) return false;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
for( DWORD i=0; i<m_dwApplyBufferCount; i++ )
|
||
{
|
||
DWORD dwOfs = m_pDidod[i].dwOfs;
|
||
#if defined( PRE_ADD_MULTILANGUAGE )
|
||
DWORD dwOfs = GetCountryByCountryKeyboard().ChangeKey( m_pDidod[i].dwOfs );
|
||
#endif // #if defined( PRE_ADD_MULTILANGUAGE )
|
||
|
||
m_bKeyState[dwOfs] = ( m_pDidod[i].dwData & 0x80 ) ? true : false;
|
||
|
||
// Event 위해 저장~
|
||
if( m_bKeyState[dwOfs] == true ) {
|
||
m_nEvent |= CInputReceiver::IR_KEY_DOWN;
|
||
m_PushKeyTime[dwOfs] = LocalTime;
|
||
}
|
||
else {
|
||
m_nEvent |= CInputReceiver::IR_KEY_UP;
|
||
m_ReleaseKeyTime[dwOfs] = LocalTime;
|
||
}
|
||
|
||
m_VecKeyList.push_back( (BYTE)dwOfs );
|
||
m_VecKeyEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
}
|
||
|
||
if( m_dwApplyBufferCount > 0 ) return true;
|
||
return false;
|
||
}
|
||
|
||
void CInputKeyboard::SetKey( int index, bool bPush, LOCAL_TIME LocalTime, DWORD pushTime )
|
||
{
|
||
// if( m_bKeyState[index] )
|
||
// return;
|
||
|
||
m_bKeyState[index] = bPush;
|
||
|
||
// Event 위해 저장~
|
||
if( m_bKeyState[index] == true ) {
|
||
m_nEvent |= CInputReceiver::IR_KEY_DOWN;
|
||
m_PushKeyTime[index] = LocalTime;
|
||
}
|
||
else {
|
||
m_nEvent |= CInputReceiver::IR_KEY_UP;
|
||
m_ReleaseKeyTime[index] = LocalTime;
|
||
}
|
||
|
||
m_VecKeyList.push_back( (BYTE)index );
|
||
m_VecKeyEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - pushTime ) );
|
||
}
|
||
|
||
// 전체화면 모드에서 Shift 키 연타 등의 윈도우 숏컷키로 인해서 화면 전환되서
|
||
// 게임 플레이에 지장을 받지 않도록 한다. by realgaia
|
||
void CInputKeyboard::AllowAccessibilityShortcutKeys( bool bAllowKeys )
|
||
{
|
||
if( bAllowKeys )
|
||
{
|
||
// Restore StickyKeys/etc to original state and enable Windows key
|
||
STICKYKEYS sk = m_StartupStickyKeys;
|
||
TOGGLEKEYS tk = m_StartupToggleKeys;
|
||
FILTERKEYS fk = m_StartupFilterKeys;
|
||
|
||
SystemParametersInfo(SPI_SETSTICKYKEYS, sizeof(STICKYKEYS), &sk, 0);
|
||
SystemParametersInfo(SPI_SETTOGGLEKEYS, sizeof(TOGGLEKEYS), &tk, 0);
|
||
SystemParametersInfo(SPI_SETFILTERKEYS, sizeof(FILTERKEYS), &fk, 0);
|
||
}
|
||
else
|
||
{
|
||
// Disable StickyKeys/etc shortcuts but if the accessibility feature is on,
|
||
// then leave the settings alone as its probably being usefully used
|
||
|
||
STICKYKEYS skOff = m_StartupStickyKeys;
|
||
if( (skOff.dwFlags & SKF_STICKYKEYSON) == 0 )
|
||
{
|
||
// Disable the hotkey and the confirmation
|
||
skOff.dwFlags &= ~SKF_HOTKEYACTIVE;
|
||
skOff.dwFlags &= ~SKF_CONFIRMHOTKEY;
|
||
|
||
SystemParametersInfo(SPI_SETSTICKYKEYS, sizeof(STICKYKEYS), &skOff, 0);
|
||
}
|
||
|
||
TOGGLEKEYS tkOff = m_StartupToggleKeys;
|
||
if( (tkOff.dwFlags & TKF_TOGGLEKEYSON) == 0 )
|
||
{
|
||
// Disable the hotkey and the confirmation
|
||
tkOff.dwFlags &= ~TKF_HOTKEYACTIVE;
|
||
tkOff.dwFlags &= ~TKF_CONFIRMHOTKEY;
|
||
|
||
SystemParametersInfo(SPI_SETTOGGLEKEYS, sizeof(TOGGLEKEYS), &tkOff, 0);
|
||
}
|
||
|
||
FILTERKEYS fkOff = m_StartupFilterKeys;
|
||
if( (fkOff.dwFlags & FKF_FILTERKEYSON) == 0 )
|
||
{
|
||
// Disable the hotkey and the confirmation
|
||
fkOff.dwFlags &= ~FKF_HOTKEYACTIVE;
|
||
fkOff.dwFlags &= ~FKF_CONFIRMHOTKEY;
|
||
|
||
SystemParametersInfo(SPI_SETFILTERKEYS, sizeof(FILTERKEYS), &fkOff, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
CInputMouse::CInputMouse()
|
||
: CInputDeviceBase( CInputDevice::MOUSE )
|
||
{
|
||
m_pDIDevice = NULL;
|
||
m_dwApplyBufferCount = 0;
|
||
m_dwBufferCount = 32;
|
||
m_pDidod = new DIDEVICEOBJECTDATA[m_dwBufferCount];
|
||
|
||
m_MousePos = D3DXVECTOR2( 0.f, 0.f );
|
||
m_MouseVariation = D3DXVECTOR3( 0.f, 0.f, 0.f );
|
||
memset( m_bButtonState, 0, sizeof(m_bButtonState) );
|
||
memset( m_ButtonLastTime, 0, sizeof(m_ButtonLastTime) );
|
||
memset( m_MouseEventTime, 0, sizeof(m_MouseEventTime) );
|
||
m_nEvent = 0;
|
||
}
|
||
|
||
CInputMouse::~CInputMouse()
|
||
{
|
||
Release();
|
||
}
|
||
|
||
void CInputMouse::Release()
|
||
{
|
||
if( m_pDIDevice ) m_pDIDevice->Unacquire();
|
||
SAFE_RELEASE( m_pDIDevice );
|
||
SAFE_DELETEA( m_pDidod );
|
||
}
|
||
|
||
bool CInputMouse::Initialize()
|
||
{
|
||
HRESULT hResult;
|
||
DIPROPDWORD dipdw;
|
||
LPDIRECTINPUT8 pDI = CInputDevice::GetInstance().GetDI();
|
||
|
||
hResult = pDI->CreateDevice( GUID_SysMouse, &m_pDIDevice, NULL );
|
||
if( FAILED( hResult ) ) return false;
|
||
ADD_D3D_RES( m_pDIDevice );
|
||
|
||
hResult = m_pDIDevice->SetDataFormat( &c_dfDIMouse2 );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
hResult = m_pDIDevice->SetCooperativeLevel( CInputDevice::GetInstance().GetWndHandle(), DISCL_NONEXCLUSIVE | DISCL_BACKGROUND | DISCL_NOWINKEY );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
|
||
ZeroMemory( &dipdw, sizeof(DIPROPDWORD) );
|
||
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
|
||
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
||
dipdw.diph.dwObj = 0;
|
||
dipdw.diph.dwHow = DIPH_DEVICE;
|
||
dipdw.dwData = m_dwBufferCount;
|
||
|
||
hResult = m_pDIDevice->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
m_pDIDevice->Acquire();
|
||
|
||
return true;
|
||
}
|
||
|
||
HRESULT CInputMouse::GetDeviceData()
|
||
{
|
||
if( m_pDIDevice == NULL ) return DIERR_NOTFOUND;
|
||
|
||
m_dwApplyBufferCount = m_dwBufferCount;
|
||
return m_pDIDevice->GetDeviceData( sizeof(DIDEVICEOBJECTDATA), m_pDidod, &m_dwApplyBufferCount, 0 );
|
||
}
|
||
|
||
bool CInputMouse::Process( LOCAL_TIME LocalTime )
|
||
{
|
||
HRESULT hResult;
|
||
|
||
// Release Event
|
||
m_nEvent = 0;
|
||
m_VecEventList.clear();
|
||
|
||
hResult = GetDeviceData();
|
||
if( FAILED( hResult ) ) {
|
||
switch( hResult ) {
|
||
case DI_OK: break;
|
||
case DIERR_NOTFOUND:
|
||
Release();
|
||
Initialize();
|
||
return false;
|
||
default:
|
||
hResult = m_pDIDevice->Acquire();
|
||
ResetDeviceState();
|
||
// if( hResult == DIERR_OTHERAPPHASPRIO || hResult == DIERR_NOTACQUIRED ) return false;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
m_MouseVariation = D3DXVECTOR3( 0.f, 0.f, 0.f );
|
||
DWORD dwLocalTime = timeGetTime();
|
||
for( DWORD i=0; i<m_dwApplyBufferCount; i++ ) {
|
||
|
||
emMOUSE_BUTTON mouseButton(buttonMax);
|
||
|
||
switch( m_pDidod[i].dwOfs ) {
|
||
case DIMOFS_X:
|
||
m_MousePos.x += (float)(int)m_pDidod[i].dwData;
|
||
m_MouseVariation.x += (float)(int)m_pDidod[i].dwData;
|
||
m_nEvent |= CInputReceiver::IR_MOUSE_MOVE;
|
||
m_MouseEventTime[0] = (LOCAL_TIME) LocalTime - (LOCAL_TIME)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
break;
|
||
case DIMOFS_Y:
|
||
m_MousePos.y += (float)(int)m_pDidod[i].dwData;
|
||
m_MouseVariation.y += (float)(int)m_pDidod[i].dwData;
|
||
m_nEvent |= CInputReceiver::IR_MOUSE_MOVE;
|
||
m_MouseEventTime[0] = (LOCAL_TIME) LocalTime - (LOCAL_TIME)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
break;
|
||
case DIMOFS_Z:
|
||
m_MouseVariation.z += (float)(int)m_pDidod[i].dwData;
|
||
m_nEvent |= CInputReceiver::IR_MOUSE_WHEEL;
|
||
m_MouseEventTime[1] = (LOCAL_TIME) LocalTime - (LOCAL_TIME)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
break;
|
||
case DIMOFS_BUTTON0:
|
||
m_bButtonState[0] = ( m_pDidod[i].dwData & 0x80 ) ? true : false;
|
||
m_nEvent |= ( m_bButtonState[0] == true ) ? CInputReceiver::IR_MOUSE_LB_DOWN : CInputReceiver::IR_MOUSE_LB_UP;
|
||
m_MouseEventTime[ 2 + ( ( m_bButtonState[0] == true ) ? 0 : 1 ) ] = (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
mouseButton = buttonLeft;
|
||
break;
|
||
case DIMOFS_BUTTON1:
|
||
m_bButtonState[1] = ( m_pDidod[i].dwData & 0x80 ) ? true : false;
|
||
m_nEvent |= ( m_bButtonState[1] == true ) ? CInputReceiver::IR_MOUSE_RB_DOWN : CInputReceiver::IR_MOUSE_RB_UP;
|
||
m_MouseEventTime[ 4 + ( ( m_bButtonState[1] == true ) ? 0 : 1 ) ] = (LOCAL_TIME) LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
mouseButton = buttonRight;
|
||
break;
|
||
case DIMOFS_BUTTON2:
|
||
m_bButtonState[2] = ( m_pDidod[i].dwData & 0x80 ) ? true : false;
|
||
m_nEvent |= ( m_bButtonState[2] == true ) ? CInputReceiver::IR_MOUSE_WB_DOWN : CInputReceiver::IR_MOUSE_WB_UP;
|
||
m_MouseEventTime[ 6 + ( ( m_bButtonState[2] == true ) ? 0 : 1 ) ] = (LOCAL_TIME) LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
mouseButton = buttonMiddle;
|
||
break;
|
||
}
|
||
|
||
m_VecEventList.push_back( m_pDidod[i].dwOfs );
|
||
|
||
// Note : 마우스 버튼의 더블클릭 체크
|
||
//
|
||
if( mouseButton != buttonMax )
|
||
{
|
||
if( m_bButtonState[mouseButton] )
|
||
{
|
||
if( (m_pDidod[i].dwTimeStamp - m_ButtonLastTime[mouseButton]) < 330 )
|
||
{
|
||
switch( mouseButton )
|
||
{
|
||
case buttonLeft:
|
||
m_nEvent |= CInputReceiver::IR_MOUSE_LB_DBCLK;
|
||
m_MouseEventTime[8] = (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
break;
|
||
case buttonRight:
|
||
m_nEvent |= CInputReceiver::IR_MOUSE_RB_DBCLK;
|
||
m_MouseEventTime[9] = (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
break;
|
||
case buttonMiddle:
|
||
m_nEvent |= CInputReceiver::IR_MOUSE_WB_DBCLK;
|
||
m_MouseEventTime[10] = (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp );
|
||
break;
|
||
}
|
||
|
||
m_ButtonLastTime[mouseButton] = 0;
|
||
}
|
||
else
|
||
{
|
||
m_ButtonLastTime[mouseButton] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if( m_dwApplyBufferCount > 0 ) return true;
|
||
return false;
|
||
}
|
||
|
||
void CInputMouse::SetLeftButton( bool bPush, LOCAL_TIME LocalTime, DWORD pushTime )
|
||
{
|
||
m_bButtonState[0] = bPush;
|
||
m_nEvent |= ( m_bButtonState[0] == true ) ? CInputReceiver::IR_MOUSE_LB_DOWN : CInputReceiver::IR_MOUSE_LB_UP;
|
||
m_MouseEventTime[ 2 + ( ( m_bButtonState[0] == true ) ? 0 : 1 ) ] = (LOCAL_TIME)LocalTime - (int)( timeGetTime() - pushTime );
|
||
}
|
||
|
||
void CInputMouse::SetRightButton( bool bPush, LOCAL_TIME LocalTime, DWORD pushTime )
|
||
{
|
||
m_bButtonState[1] = bPush;
|
||
m_nEvent |= ( m_bButtonState[1] == true ) ? CInputReceiver::IR_MOUSE_RB_DOWN : CInputReceiver::IR_MOUSE_RB_UP;
|
||
m_MouseEventTime[ 4 + ( ( m_bButtonState[1] == true ) ? 0 : 1 ) ] = (LOCAL_TIME)LocalTime - (int)( timeGetTime() - pushTime );
|
||
}
|
||
|
||
// CInputKeyboard 와 중복 코드. m_pDIDevice를 base 레벨로 올리는 것에 대해 고려 by kalliste
|
||
HRESULT CInputMouse::SetCooperativeLevel(DWORD flag)
|
||
{
|
||
if( m_pDIDevice == NULL ) return DIERR_NOTFOUND;
|
||
|
||
return m_pDIDevice->SetCooperativeLevel( CInputDevice::GetInstance().GetWndHandle(), flag );
|
||
}
|
||
|
||
|
||
|
||
CInputJoyPad::CInputJoyPad()
|
||
: CInputDeviceBase( CInputDevice::JOYPAD )
|
||
{
|
||
m_pDIDevice = NULL;
|
||
m_dwApplyBufferCount = 0;
|
||
m_dwBufferCount = 32;
|
||
m_pDidod = new DIDEVICEOBJECTDATA[m_dwBufferCount];
|
||
|
||
memset( m_bButtonState, 0 , sizeof(m_bButtonState));
|
||
memset( m_ReleaseJoypadTime, 0, sizeof(m_ReleaseJoypadTime) );
|
||
memset( m_PushJoypadTime, 0, sizeof(m_PushJoypadTime) );
|
||
|
||
memset( m_ButtonPush, 0, sizeof(m_ButtonPush) );
|
||
memset( m_UIButtonPush, 0, sizeof(m_UIButtonPush) );
|
||
|
||
m_nEvent = 0;
|
||
|
||
m_pWrappingKey = NULL;
|
||
m_pUIWrappingKey = NULL;
|
||
m_pWrappingButton = NULL;
|
||
m_pWrappingAssistButton = NULL;
|
||
m_pUIWrappingButton = NULL;
|
||
m_pUIWrappingAssistButton = NULL;
|
||
|
||
m_pKeyboard = NULL;
|
||
m_pMouse = NULL;
|
||
|
||
m_iWrappingSize = 0;
|
||
m_iUIWrappingSize = 0;
|
||
|
||
m_fCameraSpeed = 0.27f;
|
||
m_fCursorSpeed = 0.10f;
|
||
|
||
m_hWnd = NULL;
|
||
}
|
||
|
||
CInputJoyPad::~CInputJoyPad()
|
||
{
|
||
Release();
|
||
}
|
||
|
||
void CInputJoyPad::Release()
|
||
{
|
||
if( m_pDIDevice ) m_pDIDevice->Unacquire();
|
||
SAFE_RELEASE( m_pDIDevice );
|
||
SAFE_DELETEA( m_pDidod );
|
||
}
|
||
|
||
bool CInputJoyPad::Initialize()
|
||
{
|
||
HRESULT hResult;
|
||
DIPROPDWORD dipdw;
|
||
LPDIRECTINPUT8 pDI = CInputDevice::GetInstance().GetDI();
|
||
|
||
hResult = pDI->CreateDevice( GUID_Joystick, &m_pDIDevice, NULL );
|
||
if( FAILED( hResult ) ) return false;
|
||
ADD_D3D_RES( m_pDIDevice );
|
||
|
||
hResult = m_pDIDevice->SetDataFormat( &c_dfDIJoystick2 );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
hResult = m_pDIDevice->SetCooperativeLevel( CInputDevice::GetInstance().GetWndHandle(), DISCL_NONEXCLUSIVE | DISCL_FOREGROUND | DISCL_NOWINKEY );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
|
||
ZeroMemory( &dipdw, sizeof(DIPROPDWORD) );
|
||
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
|
||
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
||
dipdw.diph.dwObj = 0;
|
||
dipdw.diph.dwHow = DIPH_DEVICE;
|
||
dipdw.dwData = m_dwBufferCount;
|
||
|
||
hResult = m_pDIDevice->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
hResult = m_pDIDevice->EnumObjects( EnumObjectsCallback, (VOID *)m_pDIDevice, DIDFT_ALL );
|
||
if( FAILED( hResult ) ) return false;
|
||
|
||
m_pDIDevice->Acquire();
|
||
|
||
return true;
|
||
}
|
||
|
||
HRESULT CInputJoyPad::GetDeviceData()
|
||
{
|
||
if( m_pDIDevice == NULL ) return DIERR_NOTFOUND;
|
||
|
||
m_dwApplyBufferCount = m_dwBufferCount;
|
||
return m_pDIDevice->GetDeviceData( sizeof(DIDEVICEOBJECTDATA), m_pDidod, &m_dwApplyBufferCount, 0 );
|
||
}
|
||
|
||
bool CInputJoyPad::Process( LOCAL_TIME LocalTime )
|
||
{
|
||
HRESULT hResult;
|
||
|
||
// Release Event
|
||
m_nEvent = 0;
|
||
m_VecEventList.clear();
|
||
m_VecEventTime.clear();
|
||
|
||
hResult = GetDeviceData();
|
||
if( FAILED( hResult ) ) {
|
||
switch( hResult ) {
|
||
case DI_OK: break;
|
||
case DIERR_NOTFOUND:
|
||
Release();
|
||
Initialize();
|
||
return false;
|
||
default:
|
||
hResult = m_pDIDevice->Acquire();
|
||
//ResetDeviceState();
|
||
// if( hResult == DIERR_OTHERAPPHASPRIO || hResult == DIERR_NOTACQUIRED ) return false;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
hResult = m_pDIDevice->Poll();
|
||
if( FAILED(hResult) )
|
||
{
|
||
hResult = m_pDIDevice->Acquire();
|
||
while( hResult == DIERR_INPUTLOST )
|
||
hResult = m_pDIDevice->Acquire();
|
||
return false;
|
||
}
|
||
|
||
DIJOYSTATE2 js;
|
||
m_pDIDevice->GetDeviceState( sizeof(DIJOYSTATE2), &js );
|
||
DWORD dwLocalTime = timeGetTime();
|
||
for( DWORD i=0; i<m_dwApplyBufferCount; i++ ) {
|
||
|
||
switch( m_pDidod[i].dwOfs ) {
|
||
case DIJOFS_X :
|
||
{
|
||
js.lX > 500 ? m_bButtonState[LS_RIGHT] = true : m_bButtonState[LS_RIGHT] = false;
|
||
js.lX < -500 ? m_bButtonState[LS_LEFT] = true : m_bButtonState[LS_LEFT] = false;
|
||
|
||
if( m_bButtonState[LS_RIGHT] ) {
|
||
m_PushJoypadTime[LS_RIGHT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( LS_RIGHT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[LS_RIGHT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[LS_RIGHT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( m_bButtonState[LS_LEFT] ) {
|
||
m_PushJoypadTime[LS_LEFT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( LS_LEFT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[LS_LEFT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[LS_LEFT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case DIJOFS_Y :
|
||
{
|
||
js.lY > 500 ? m_bButtonState[LS_DOWN] = true : m_bButtonState[LS_DOWN] = false;
|
||
js.lY < -500 ? m_bButtonState[LS_UP] = true : m_bButtonState[LS_UP] = false;
|
||
|
||
if( m_bButtonState[LS_DOWN] ) {
|
||
m_PushJoypadTime[LS_DOWN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( LS_DOWN );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[LS_DOWN] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[LS_DOWN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( m_bButtonState[LS_UP] ) {
|
||
m_PushJoypadTime[LS_UP] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( LS_UP );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[LS_UP] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[LS_UP] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case DIJOFS_Z :
|
||
{
|
||
js.lZ > 500 ? m_bButtonState[LS_ZOOMIN] = true : m_bButtonState[LS_ZOOMIN] = false;
|
||
js.lZ < -500 ? m_bButtonState[LS_ZOOMOUT] = true : m_bButtonState[LS_ZOOMOUT] = false;
|
||
|
||
if( m_bButtonState[LS_ZOOMIN] ) {
|
||
m_PushJoypadTime[LS_ZOOMIN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( LS_ZOOMIN );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[LS_ZOOMIN] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[LS_ZOOMIN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( m_bButtonState[LS_ZOOMOUT] ) {
|
||
m_PushJoypadTime[LS_ZOOMOUT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( LS_ZOOMOUT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[LS_ZOOMOUT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[LS_ZOOMOUT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case DIJOFS_RX :
|
||
{
|
||
js.lRx > 500 ? m_bButtonState[RS_RIGHT] = true : m_bButtonState[RS_RIGHT] = false;
|
||
js.lRx < -500 ? m_bButtonState[RS_LEFT] = true : m_bButtonState[RS_LEFT] = false;
|
||
|
||
if( m_bButtonState[RS_RIGHT] ) {
|
||
m_PushJoypadTime[RS_RIGHT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( RS_RIGHT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[RS_RIGHT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[RS_RIGHT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( m_bButtonState[RS_LEFT] ) {
|
||
m_PushJoypadTime[RS_LEFT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( RS_LEFT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[RS_LEFT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[RS_LEFT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case DIJOFS_RY :
|
||
{
|
||
js.lRy > 500 ? m_bButtonState[RS_DOWN] = true : m_bButtonState[RS_DOWN] = false;
|
||
js.lRy < -500 ? m_bButtonState[RS_UP] = true : m_bButtonState[RS_UP] = false;
|
||
|
||
if( m_bButtonState[RS_DOWN] ) {
|
||
m_PushJoypadTime[RS_DOWN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( RS_DOWN );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[RS_DOWN] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[RS_DOWN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( m_bButtonState[RS_UP] ) {
|
||
m_PushJoypadTime[RS_UP] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( RS_UP );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[RS_UP] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[RS_UP] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case DIJOFS_RZ :
|
||
{
|
||
js.lRz > 500 ? m_bButtonState[RS_ZOOMIN] = true : m_bButtonState[RS_ZOOMIN] = false;
|
||
js.lRz < -500 ? m_bButtonState[RS_ZOOMOUT] = true : m_bButtonState[RS_ZOOMOUT] = false;
|
||
|
||
if( m_bButtonState[RS_ZOOMIN] ) {
|
||
m_PushJoypadTime[RS_ZOOMIN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( RS_ZOOMIN );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[RS_ZOOMIN] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[RS_ZOOMIN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( m_bButtonState[RS_ZOOMOUT] ) {
|
||
m_PushJoypadTime[RS_ZOOMOUT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( RS_ZOOMOUT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[RS_ZOOMOUT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_ReleaseJoypadTime[RS_ZOOMOUT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
|
||
case DIJOFS_POV(0) :
|
||
{
|
||
if( js.rgdwPOV[0] == 0 || js.rgdwPOV[0] == 4500 || js.rgdwPOV[0] == 31500 ) {
|
||
m_bButtonState[MS_UP] = true;
|
||
|
||
m_PushJoypadTime[MS_UP] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( MS_UP );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[MS_UP] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_bButtonState[MS_UP] = false;
|
||
m_ReleaseJoypadTime[MS_UP] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( js.rgdwPOV[0] == 18000 || js.rgdwPOV[0] == 13500 || js.rgdwPOV[0] == 22500 ) {
|
||
m_bButtonState[MS_DOWN] = true;
|
||
|
||
m_PushJoypadTime[MS_DOWN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( MS_DOWN );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[MS_DOWN] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_bButtonState[MS_DOWN] = false;
|
||
m_ReleaseJoypadTime[MS_DOWN] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( js.rgdwPOV[0] == 9000 || js.rgdwPOV[0] == 4500 || js.rgdwPOV[0] == 13500 ) {
|
||
m_bButtonState[MS_RIGHT] = true;
|
||
|
||
m_PushJoypadTime[MS_RIGHT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( MS_RIGHT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[MS_RIGHT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_bButtonState[MS_RIGHT] = false;
|
||
m_ReleaseJoypadTime[MS_RIGHT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
|
||
if( js.rgdwPOV[0] == 27000 || js.rgdwPOV[0] == 22500 || js.rgdwPOV[0] == 31500 ) {
|
||
m_bButtonState[MS_LEFT] = true;
|
||
|
||
m_PushJoypadTime[MS_LEFT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN;
|
||
|
||
m_VecEventList.push_back( MS_LEFT );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[MS_LEFT] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
else {
|
||
m_bButtonState[MS_LEFT] = false;
|
||
m_ReleaseJoypadTime[MS_LEFT] = LocalTime;
|
||
m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
int index = B0;
|
||
for( int itr = DIJOFS_BUTTON0 ; itr <= DIJOFS_BUTTON31; ++itr )
|
||
{
|
||
if( m_pDidod[i].dwOfs == itr )
|
||
{
|
||
m_bButtonState[index] = ( m_pDidod[i].dwData & 0x80 ) ? true : false;
|
||
|
||
m_bButtonState[index] ? m_PushJoypadTime[index] = LocalTime, m_nEvent |= CInputReceiver::IR_JOYPAD_DOWN
|
||
: m_ReleaseJoypadTime[index] = LocalTime, m_nEvent |= CInputReceiver::IR_JOYPAD_UP;
|
||
|
||
m_VecEventList.push_back( index );
|
||
m_VecEventTime.push_back( (LOCAL_TIME)LocalTime - (int)( timeGetTime() - m_pDidod[i].dwTimeStamp ) );
|
||
|
||
m_JoypadTimeStamp[index] = m_pDidod[i].dwTimeStamp;
|
||
}
|
||
++index;
|
||
}
|
||
}
|
||
|
||
if( m_pWrappingButton && m_pKeyboard && m_pMouse )
|
||
{
|
||
bool bPush;
|
||
INPUT input;
|
||
|
||
for( int itr = 0; itr < IW_NORMALATTK; ++itr )
|
||
{
|
||
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[itr], m_pWrappingAssistButton[itr]) );
|
||
|
||
if( bPush )
|
||
{
|
||
m_pKeyboard->SetKey( m_pWrappingKey[itr], bPush, LocalTime, m_JoypadTimeStamp[ m_pWrappingAssistButton[itr] ] );
|
||
m_ButtonPush[itr] = true;
|
||
}
|
||
else if( m_ButtonPush[itr] )
|
||
{
|
||
m_pKeyboard->SetKey( m_pWrappingKey[itr], bPush, LocalTime, m_JoypadTimeStamp[ m_pWrappingAssistButton[itr] ] );
|
||
m_ButtonPush[itr] = false;
|
||
}
|
||
|
||
}
|
||
|
||
//Rebirth
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_REBIRTH], m_pWrappingAssistButton[IW_REBIRTH]) );
|
||
BYTE cVK = _ToVK(m_pWrappingKey[IW_REBIRTH]);
|
||
if( bPush )
|
||
{
|
||
::ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_KEYBOARD;
|
||
input.ki.wVk = cVK;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_ButtonPush[IW_REBIRTH] = true;
|
||
}
|
||
else
|
||
{
|
||
::ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_KEYBOARD;
|
||
input.ki.wVk = cVK;
|
||
input.ki.dwFlags = KEYEVENTF_KEYUP;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_ButtonPush[IW_REBIRTH] = false;
|
||
}
|
||
|
||
//Shift-Key(키보드 셋팅에는 없는 것이라서 별도러 처리한다.)
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_AVOID], m_pWrappingAssistButton[IW_AVOID]) );
|
||
if( bPush )
|
||
{
|
||
m_pKeyboard->SetKey( 42, bPush, LocalTime, m_JoypadTimeStamp[ m_pWrappingAssistButton[IW_AVOID] ] );
|
||
m_ButtonPush[IW_AVOID] = true;
|
||
}
|
||
else if( m_ButtonPush[IW_AVOID] )
|
||
{
|
||
m_pKeyboard->SetKey( 42, bPush, LocalTime, m_JoypadTimeStamp[ m_pWrappingAssistButton[IW_AVOID] ] );
|
||
m_ButtonPush[IW_AVOID] = false;
|
||
}
|
||
|
||
for( int itr = 0; itr < UIWrappingKeyIndex_Amount; ++itr )
|
||
{
|
||
if( IW_PVPTAB == itr ) continue;
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pUIWrappingButton[itr], m_pUIWrappingAssistButton[itr]) );
|
||
BYTE cVK = _ToVK(m_pUIWrappingKey[itr]);
|
||
ULONG ref = 0;
|
||
|
||
if ( bPush )
|
||
{
|
||
::ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_KEYBOARD;
|
||
input.ki.wVk = cVK;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_UIButtonPush[itr] = true;
|
||
}
|
||
else
|
||
{
|
||
if( m_UIButtonPush[itr] )
|
||
{
|
||
::ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_KEYBOARD;
|
||
input.ki.wVk = cVK;
|
||
input.ki.dwFlags = KEYEVENTF_KEYUP;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_UIButtonPush[itr] = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
//ESC - PVP
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pUIWrappingButton[IW_PVPTAB], m_pUIWrappingAssistButton[IW_PVPTAB]) );
|
||
if( bPush )
|
||
{
|
||
m_pKeyboard->SetKey( m_pUIWrappingKey[IW_PVPTAB], bPush, LocalTime, m_JoypadTimeStamp[ m_pUIWrappingAssistButton[IW_PVPTAB] ] );
|
||
m_UIButtonPush[IW_PVPTAB] = true;
|
||
}
|
||
else if( m_UIButtonPush[IW_PVPTAB] )
|
||
{
|
||
m_pKeyboard->SetKey( m_pUIWrappingKey[IW_PVPTAB], bPush, LocalTime, m_JoypadTimeStamp[ m_pUIWrappingAssistButton[IW_PVPTAB] ] );
|
||
m_UIButtonPush[IW_PVPTAB] = false;
|
||
}
|
||
|
||
//마우스 처리
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_NORMALATTK], m_pWrappingAssistButton[IW_NORMALATTK]) );
|
||
if( bPush )
|
||
{
|
||
if( !m_ButtonPush[IW_NORMALATTK] )
|
||
{
|
||
ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_MOUSE;
|
||
input.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_ButtonPush[IW_NORMALATTK] = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if( m_ButtonPush[IW_NORMALATTK] )
|
||
{
|
||
ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_MOUSE;
|
||
input.mi.dwFlags = MOUSEEVENTF_LEFTUP;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_ButtonPush[IW_NORMALATTK] = false;
|
||
}
|
||
}
|
||
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_SPECIALATTK], m_pWrappingAssistButton[IW_SPECIALATTK]) );
|
||
if( bPush )
|
||
{
|
||
if( !m_ButtonPush[IW_SPECIALATTK] )
|
||
{
|
||
ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_MOUSE;
|
||
input.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_ButtonPush[IW_SPECIALATTK] = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if( m_ButtonPush[IW_SPECIALATTK] )
|
||
{
|
||
ZeroMemory(&input, sizeof(input));
|
||
input.type = INPUT_MOUSE;
|
||
input.mi.dwFlags = MOUSEEVENTF_RIGHTUP;
|
||
::SendInput(1, &input, sizeof(input));
|
||
m_ButtonPush[IW_SPECIALATTK] = false;
|
||
}
|
||
}
|
||
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_LOOKLEFT], m_pWrappingAssistButton[IW_LOOKLEFT]) );
|
||
if( bPush )
|
||
{
|
||
POINT pt;
|
||
GetCursorPos(&pt);
|
||
pt.x -= (int)(m_fCursorSpeed * 100.0f);
|
||
SetCursorPos(pt.x, pt.y);
|
||
}
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_LOOKRIGHT], m_pWrappingAssistButton[IW_LOOKRIGHT]) );
|
||
if( bPush )
|
||
{
|
||
POINT pt;
|
||
GetCursorPos(&pt);
|
||
pt.x += (int)(m_fCursorSpeed * 100.0f);
|
||
SetCursorPos(pt.x, pt.y);
|
||
}
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_LOOKUP], m_pWrappingAssistButton[IW_LOOKUP]) );
|
||
if( bPush )
|
||
{
|
||
POINT pt;
|
||
GetCursorPos(&pt);
|
||
pt.y -= (int)(m_fCursorSpeed * 100.0f);
|
||
SetCursorPos(pt.x, pt.y);
|
||
}
|
||
bPush = IsPushJoypadButton( std::make_pair(m_pWrappingButton[IW_LOOKDOWN], m_pWrappingAssistButton[IW_LOOKDOWN]) );
|
||
if( bPush )
|
||
{
|
||
POINT pt;
|
||
GetCursorPos(&pt);
|
||
pt.y += (int)(m_fCursorSpeed * 100.0f);
|
||
SetCursorPos(pt.x, pt.y);
|
||
}
|
||
}
|
||
|
||
if( m_dwApplyBufferCount > 0 ) return true;
|
||
return false;
|
||
}
|
||
|
||
bool CInputJoyPad::IsPushJoypadButton( std::pair<BYTE, BYTE> & cKeys )
|
||
{
|
||
if( CInputJoyPad::NULL_VALUE == cKeys.second )
|
||
{
|
||
return IsPushButton( cKeys.first ) ? IsPushEnable(cKeys) : false;
|
||
}
|
||
else if( IsPushButton( cKeys.first ) && IsPushButton( cKeys.second ) )
|
||
{
|
||
LOCAL_TIME mainTime = GetPushButtonTime( cKeys.first );
|
||
LOCAL_TIME assistTime = GetPushButtonTime( cKeys.second );
|
||
|
||
return mainTime <= assistTime ? true : false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// CInputKeyboard 와 중복 코드. m_pDIDevice를 base 레벨로 올리는 것에 대해 고려 by kalliste
|
||
HRESULT CInputJoyPad::SetCooperativeLevel(DWORD flag)
|
||
{
|
||
if( m_pDIDevice == NULL ) return DIERR_NOTFOUND;
|
||
|
||
return m_pDIDevice->SetCooperativeLevel( CInputDevice::GetInstance().GetWndHandle(), flag );
|
||
}
|
||
|
||
BOOL CALLBACK EnumObjectsCallback( const DIDEVICEOBJECTINSTANCE* pdidoi, VOID* pContext )
|
||
{
|
||
|
||
LPDIRECTINPUTDEVICE8 pJoystic = (LPDIRECTINPUTDEVICE8)pContext;
|
||
|
||
if( pdidoi->dwType & DIDFT_AXIS )
|
||
{
|
||
DIPROPRANGE diprg;
|
||
diprg.diph.dwSize = sizeof(DIPROPRANGE);
|
||
diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
||
diprg.diph.dwHow = DIPH_BYID;
|
||
diprg.diph.dwObj = pdidoi->dwType; // Specify the enumerated axis
|
||
diprg.lMin = -1000;
|
||
diprg.lMax = +1000;
|
||
|
||
// Set the range for the axis
|
||
if( FAILED( pJoystic->SetProperty( DIPROP_RANGE, &diprg.diph ) ) )
|
||
return DIENUM_STOP;
|
||
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void CInputJoyPad::SetWrappingButton(BYTE * pWrappingButton, BYTE * pWrappingAssistButton, BYTE * pUIWrappingButton, BYTE * pUIWrappingAssistButton, int wrappingSize, int uiWrappingSize)
|
||
{
|
||
m_pWrappingButton = pWrappingButton;
|
||
m_pWrappingAssistButton = pWrappingAssistButton;
|
||
m_pUIWrappingButton = pUIWrappingButton;
|
||
m_pUIWrappingAssistButton = pUIWrappingAssistButton;
|
||
|
||
m_iWrappingSize = wrappingSize;
|
||
m_iUIWrappingSize = uiWrappingSize;
|
||
}
|
||
|
||
void CInputJoyPad::SetWrappingKey( BYTE *pWrappingKey, BYTE *pUIWrappingKey )
|
||
{
|
||
m_pWrappingKey = pWrappingKey;
|
||
m_pUIWrappingKey = pUIWrappingKey;
|
||
}
|
||
|
||
/*
|
||
단일키는 복수 키에 씹히게 만들어야 한다.
|
||
*/
|
||
bool CInputJoyPad::IsPushEnable( std::pair<BYTE, BYTE> & cKeys )
|
||
{
|
||
if( !m_pWrappingButton || !m_pWrappingAssistButton || !m_pUIWrappingButton || !m_pUIWrappingAssistButton )
|
||
return false;
|
||
|
||
//복수 키거나 메인키가 없으면 리턴한다.
|
||
if( NULL_VALUE == cKeys.first || NULL_VALUE != cKeys.second)
|
||
return false;
|
||
|
||
for( int itr = 0; itr < m_iWrappingSize; ++itr )
|
||
{
|
||
if( cKeys.first == m_pWrappingAssistButton[itr] )
|
||
{
|
||
if( m_bButtonState[ m_pWrappingButton[itr] ] )
|
||
return false;
|
||
}
|
||
}
|
||
|
||
for( int itr = 0; itr < m_iUIWrappingSize; ++itr )
|
||
{
|
||
if( cKeys.first == m_pUIWrappingAssistButton[itr] )
|
||
{
|
||
if( m_bButtonState[ m_pUIWrappingButton[itr] ] )
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void CInputJoyPad::SetKeyboard( CInputKeyboard * pKeyboard )
|
||
{
|
||
m_pKeyboard = pKeyboard;
|
||
}
|
||
void CInputJoyPad::SetMouse( CInputMouse * pMouse )
|
||
{
|
||
m_pMouse = pMouse;
|
||
} |