phaneron/DragonNest
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
DragonNest/Common/EngineUtil/InputDevice.cpp

1489 lines
42 KiB
C++
Raw Permalink Normal View History

Revert "修复编码问题" This reverts commit 9e69c0176761381247f2b24ccf58ac48ee50fba5.
2024-12-21 10:04:04 +08:00
#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;
// <20>Ѷ<EFBFBD>Ű <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD>ä<EFBFBD><C3A4> Numpad7<64><37><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Home<6D><65><EFBFBD><EFBFBD> <20>´<EFBFBD>. <20>׷<EFBFBD><D7B7><EFBFBD> <20><><EFBFBD><EFBFBD> numlock<63><6B><EFBFBD>¿<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȯ ó<><C3B3><EFBFBD><EFBFBD> <20><><EFBFBD>ش<EFBFBD>.
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; //<2F>Է<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(1:Ű<><C5B0><EFBFBD><EFBFBD>&<26><><EFBFBD>콺, 2: Ű<><C5B0><EFBFBD><EFBFBD>, 3: <20><><EFBFBD>콺)
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 <20><> <20>ߺ<EFBFBD> <20>ڵ<EFBFBD>. m_pDIDevice<63><65> base <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ø<EFBFBD><C3B8><EFBFBD> <20>Ϳ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 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 <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>~
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 <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>~
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 ) );
}
// <20><>üȭ<C3BC><C8AD> <20><><EFBFBD>忡<EFBFBD><E5BFA1> Shift Ű <20><>Ÿ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ű<EFBFBD><C5B0> <20><><EFBFBD>ؼ<EFBFBD> ȭ<><C8AD> <20><>ȯ<EFBFBD>Ǽ<EFBFBD>
// <20><><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7>̿<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ʵ<EFBFBD><CAB5><EFBFBD> <20>Ѵ<EFBFBD>. 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 : <20><><EFBFBD>콺 <20><>ư<EFBFBD><C6B0> <20><><EFBFBD><EFBFBD>Ŭ<EFBFBD><C5AC> üũ
//
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 <20><> <20>ߺ<EFBFBD> <20>ڵ<EFBFBD>. m_pDIDevice<63><65> base <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ø<EFBFBD><C3B8><EFBFBD> <20>Ϳ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 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(Ű<><C5B0><EFBFBD><EFBFBD> <20><><EFBFBD>ÿ<EFBFBD><C3BF><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̶<EFBFBD><CCB6><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3><EFBFBD>Ѵ<EFBFBD>.)
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;
}
//<2F><><EFBFBD>콺 ó<><C3B3>
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 <20><> <20>ߺ<EFBFBD> <20>ڵ<EFBFBD>. m_pDIDevice<63><65> base <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ø<EFBFBD><C3B8><EFBFBD> <20>Ϳ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> 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;
}
/*
<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ű<EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ű<EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD>Ѵ<EFBFBD>.
*/
bool CInputJoyPad::IsPushEnable( std::pair<BYTE, BYTE> & cKeys )
{
if( !m_pWrappingButton || !m_pWrappingAssistButton || !m_pUIWrappingButton || !m_pUIWrappingAssistButton )
return false;
//<2F><><EFBFBD><EFBFBD> Ű<>ų<EFBFBD> <20><><EFBFBD><EFBFBD>Ű<EFBFBD><C5B0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
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;
}
Reference in a new issue Copy permalink