input.cpp

VC++ DEMO, used for the beginners and the amour

// CONSOLE.cpp: implementation of the CONSOLE class.
//
//////////////////////////////////////////////////////////////////////
#include "HEADERS.H"
#include "INPUT.H"
USING NAMESPACE CGE::INPUT;
#define BUFFER_SIZE 256
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
LONG CONSOLE::m_MouseX = 0;
LONG CONSOLE::m_MouseY = 0;
LONG CONSOLE::m_MouseDeltaX = 0;
LONG CONSOLE::m_MouseDeltaY = 0;
//////////////////////////////////////////////////////////////////////

CONSOLE::CONSOLE()
{
	m_pDI = 0;
	m_pKeyboard = m_pMouse = 0;
	m_ModifierState = 0;
	m_d3dMouseSpeed = 1;

	m_d3dKeyPressed.clear();
	m_d3dKeyJustPressed.clear();
	m_d3dKeyJustUnPressed.clear();
	m_d3dKeyboard.clear();

	m_d3dMouseKeyPressed.clear();
	m_d3dMouseKeyJustPressed.clear();
	m_d3dMouseKeyJustUnPressed.clear();
	m_d3dMouse.clear();

}

CONSOLE::~CONSOLE()
{
	if ( m_pKeyboard )
	{
		m_pKeyboard->Unacquire();
	}

	if ( m_pMouse )
	{
		m_pMouse->Unacquire();
	}

	SAFE_RELEASE(m_pKeyboard);
	SAFE_RELEASE(m_pMouse);
	SAFE_RELEASE(m_pDI);
}

BOOL CONSOLE::Create()
{
	HRESULT hr;
	hr = DirectInput8Create((HINSTANCE)GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, 
							(void**)&m_pDI, NULL);
	if (SUCCEEDED(hr))
	{
		return true;
	}
	return false;
}

BOOL CONSOLE::CreateKeyboard()
{
	HRESULT    hr; 
	hr = m_pDI->CreateDevice(GUID_SysKeyboard, &m_pKeyboard, NULL); 
	if (FAILED(hr))
	{ 
		return false;
	} 
	hr = m_pKeyboard->SetDataFormat(&c_dfDIKeyboard); 	
	if (FAILED(hr))
	{ 
		return false; 
	} 
	return true;
}

BOOL CONSOLE::CreateMouse()
{
	HRESULT  hr; 
	hr = m_pDI->CreateDevice(GUID_SysMouse, &m_pMouse, NULL); 
	if (FAILED(hr))
	{ 
		return false;
	} 
	hr = m_pMouse->SetDataFormat(&c_dfDIMouse2); 	
	if (FAILED(hr))
	{ 
		return false; 
	} 
	return true;
}

BOOL CONSOLE::SetMouseBehavior(void *hWnd, unsigned long dwBehavior)
{
	HRESULT hr;
	DIPROPDWORD dipdw;
	
	hr = m_pMouse->SetCooperativeLevel((HWND)hWnd, dwBehavior); 
	if (FAILED(hr))
	{ 
		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            = BUFFER_SIZE; // Arbitary buffer size
	
	if( FAILED( hr = m_pMouse->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph ) ) )
	{	return false;	}

	hr = m_pMouse->Acquire();
	if (FAILED(hr))
	{
		return false;
	}
	return true;
}

BOOL CONSOLE::SetKeyboardBehavior(void *hWnd, unsigned long dwBehavior)
{
	HRESULT hr;
    DIPROPDWORD	BufferData;
	// Set the cooperative level 
	hr = m_pKeyboard->SetCooperativeLevel((HWND)hWnd, dwBehavior); 
	if (FAILED(hr))
	{ 
		return false; 
	} 
	ZeroMemory(&BufferData,sizeof(DIPROPDWORD));
	BufferData.diph.dwSize		= sizeof(DIPROPDWORD);
	BufferData.diph.dwHeaderSize	= sizeof(DIPROPHEADER);
	BufferData.diph.dwObj		= 0;
	BufferData.diph.dwHow		= DIPH_DEVICE;
	BufferData.dwData			= BUFFER_SIZE;	
	/* set the size of the keyboard buffer */
	hr = m_pKeyboard->SetProperty(DIPROP_BUFFERSIZE, &BufferData.diph);
	if (FAILED(hr))
	{
		return false;
	}
	hr = m_pKeyboard->Acquire();
	if (FAILED(hr))
	{
		return false;
	}
	return true;
}

BOOL CONSOLE::UpdateKeyboard()
{
	KEYVECTOR::iterator	KeyIterator;
	DIDEVICEOBJECTDATA		BufferedKeys[BUFFER_SIZE];
	DWORD					NumKeys = BUFFER_SIZE; 
    HRESULT					hr;
	DWORD					dwLoop;
	if (m_pKeyboard)
	{
		m_d3dKeyJustPressed.clear();
		m_d3dKeyJustUnPressed.clear();

		hr = m_pKeyboard->GetDeviceData(sizeof(DIDEVICEOBJECTDATA), BufferedKeys, &NumKeys, 0); 

		if (SUCCEEDED(hr))
		{
			if (hr == DI_BUFFEROVERFLOW)
			{
				return false;
			}
			for (dwLoop = 0; dwLoop < NumKeys; ++dwLoop)
			{
				KeyboardKey     			Key;
				ModifierState		Modifier;
				
				Key.m_ScanCode  = BufferedKeys[dwLoop].dwOfs;
				Key.m_Modifier  = m_ModifierState;

				Modifier = GetModifierState(BufferedKeys[dwLoop].dwOfs);

				if ( BufferedKeys[dwLoop].dwData & 0x80 )
				{
					if ( Modifier != MODIFIER_NONE)
					{
						m_ModifierState |= Modifier;
					}
					else
					{
						Key.m_HotKey = KEY_JUSTPRESSED;
						m_d3dKeyJustPressed.push_back(Key);
						Key.m_HotKey = KEY_PRESSED;
						KeyIterator = std::find(m_d3dKeyPressed.begin(), m_d3dKeyPressed.end(), Key);
						if (KeyIterator == m_d3dKeyPressed.end())
						{	m_d3dKeyPressed.push_back(Key);	}
					}
				}
				else
				{
					if (Modifier != MODIFIER_NONE)
					{
						m_ModifierState ^= Modifier;						
					}
					
					KeyIterator = m_d3dKeyPressed.begin();
					while (KeyIterator != m_d3dKeyPressed.end())
					{
						if ((*KeyIterator).m_ScanCode == Key.m_ScanCode||
							(*KeyIterator).m_Modifier == Modifier)
						{
							(*KeyIterator).m_HotKey = KEY_JUSTUNPRESSED;
							m_d3dKeyJustUnPressed.push_back(*KeyIterator);
							m_d3dKeyPressed.erase(KeyIterator);
						}
						else
						{
							KeyIterator++;
						}
					}
					
				}
			}
			KeyboardHotKey();
		}
		else
		{
			if ((hr == DIERR_INPUTLOST) ||
				(hr == DIERR_NOTACQUIRED))
			{
				hr = m_pKeyboard->Acquire();
			}
		}
	}

	return (SUCCEEDED(hr));
}

BOOL CONSOLE::UpdateMouse()
{
	MOUSEKEYVECTOR::iterator MouseKeyIterator;
    DIDEVICEOBJECTDATA didod[ BUFFER_SIZE ];  // Receives buffered data 
    DWORD              dwElements = BUFFER_SIZE;
    DWORD              dwLoop;
    HRESULT            hr;
	MouseKey        MouseKey;
	m_MouseDeltaX = 0;
	m_MouseDeltaY = 0;

    if( NULL != m_pMouse ) 
    {

		m_d3dMouseKeyJustPressed.clear();
		m_d3dMouseKeyJustUnPressed.clear();

		hr = m_pMouse->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),didod, &dwElements, 0 );

		if( SUCCEEDED(hr) ) 
		{
			if (hr == DI_BUFFEROVERFLOW)
			{
				return false;
			}
			for (dwLoop = 0; dwLoop < dwElements; ++dwLoop)
			{
				
				switch( didod[ dwLoop ].dwOfs )
				{
				case DIMOFS_BUTTON0:
					MouseKey.m_MouseButton = MOUSEBUTTON_LEFT;
					break;
					
				case DIMOFS_BUTTON1:
					MouseKey.m_MouseButton = MOUSEBUTTON_RIGHT;
					break;
					
				case DIMOFS_BUTTON2:
					MouseKey.m_MouseButton = MOUSEBUTTON_MIDDLE;
					break;
					
				case DIMOFS_BUTTON3:
					break;
				case DIMOFS_X:	
					m_MouseDeltaX += m_d3dMouseSpeed * didod[ dwLoop ].dwData;
					m_MouseX += m_MouseDeltaX;
					break;
					
				case DIMOFS_Y:
					m_MouseDeltaY += m_d3dMouseSpeed * didod[ dwLoop ].dwData;
					m_MouseY += m_d3dMouseSpeed * didod[ dwLoop ].dwData;
					break;
				case DIMOFS_Z:
					break;
	
				default:break;
				}

				MouseKey.m_MouseX = m_MouseX;
				MouseKey.m_MouseY = m_MouseY;

				if ( MouseKey.m_MouseButton )
				{
					if ( MOUSEKEYDOWN(didod[dwLoop].dwData) )
					{
						MouseKey.m_HotKey = KEY_JUSTPRESSED;
						m_d3dMouseKeyJustPressed.push_back(MouseKey);
						MouseKey.m_HotKey = KEY_PRESSED;
						MouseKeyIterator = std::find(m_d3dMouseKeyPressed.begin(), m_d3dMouseKeyPressed.end(), MouseKey);
						if (MouseKeyIterator == m_d3dMouseKeyPressed.end())
						{	m_d3dMouseKeyPressed.push_back(MouseKey);	}
					}
					else
					{	
						MouseKey.m_HotKey = KEY_JUSTUNPRESSED;
						m_d3dMouseKeyJustUnPressed.push_back(MouseKey);
						MouseKey.m_HotKey = KEY_NONE;
						MouseKeyIterator = m_d3dMouseKeyPressed.begin();
						while (MouseKeyIterator != m_d3dMouseKeyPressed.end())
						{
							if ((*MouseKeyIterator).m_MouseButton == MouseKey.m_MouseButton)
							{
								m_d3dMouseKeyPressed.erase(MouseKeyIterator);
							}
							else
							{
								MouseKeyIterator++;
							}
						}	
					}
				}
			}
			MouseHotSpot();
		}
		
		else
		{
			if ( hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED ) 
			{
				hr = m_pMouse->Acquire();
			}
		}
		
	}	
	return (SUCCEEDED(hr));
}

ModifierState CONSOLE::GetModifierState(unsigned char nScanCode)
{
	ModifierState nState = MODIFIER_NONE;
	
	if ((nScanCode == DIK_LCONTROL) ||
		(nScanCode == DIK_RCONTROL))
	{
		nState = MODIFIER_CTRL;
	}
	else
	if ((nScanCode == DIK_LMENU) ||
			(nScanCode == DIK_RMENU))
	{
		nState = MODIFIER_ALT;
	}
	else
	if ((nScanCode == DIK_LSHIFT) ||
		(nScanCode == DIK_RSHIFT))
	{
		nState = MODIFIER_SHIFT;
	}
			
	return nState;
}

void CONSOLE::SetKeyboardHotKey(const KeyboardKey & Key,const HotKey & HotKey)
{
	if ( m_d3dKeyboard.find(Key) == m_d3dKeyboard.end())
	{
		m_d3dKeyboard[Key] = HotKey;
	}
}

void CONSOLE::KeyboardHotKey()
{
	KEYVECTOR::iterator KeyIterator;
	KEYBOARDMAP::iterator HotKeyIterator;

	for (KeyIterator = m_d3dKeyPressed.begin(); KeyIterator != m_d3dKeyPressed.end(); KeyIterator++)
	{
		HotKeyIterator = m_d3dKeyboard.find((*KeyIterator));
		if (HotKeyIterator != m_d3dKeyboard.end())
		{
			(*HotKeyIterator).second.m_HotKeyCallback((*HotKeyIterator).second.m_HotID,0,0);
		}
	}
	
	for (KeyIterator = m_d3dKeyJustPressed.begin(); KeyIterator != m_d3dKeyJustPressed.end(); KeyIterator++)
	{
		HotKeyIterator = m_d3dKeyboard.find((*KeyIterator));
		if (HotKeyIterator != m_d3dKeyboard.end())
		{
			(*HotKeyIterator).second.m_HotKeyCallback((*HotKeyIterator).second.m_HotID,0,0);
		}
	}
	
	for (KeyIterator = m_d3dKeyJustUnPressed.begin(); KeyIterator != m_d3dKeyJustUnPressed.end(); KeyIterator++)
	{
		HotKeyIterator = m_d3dKeyboard.find((*KeyIterator));
		if (HotKeyIterator != m_d3dKeyboard.end())
		{
			(*HotKeyIterator).second.m_HotKeyCallback((*HotKeyIterator).second.m_HotID,0,0);
		}
	}

}

void CONSOLE::SetMouseHotSpot( const MouseKey & MouseKey,const HotSpot & HotSpot)
{
	if ( m_d3dMouse.find(MouseKey) == m_d3dMouse.end())
	{
		m_d3dMouse[ MouseKey ] = HotSpot;
	}
}

void CONSOLE::MouseHotSpot()
{
	MOUSEHOTKEYMAP::iterator HotSpotIterator;
	MOUSEKEYVECTOR::iterator MouseKeyIterator;
	// 数据装配
	LONG MouseXY = 0;
	for (MouseKeyIterator = m_d3dMouseKeyPressed.begin(); MouseKeyIterator != m_d3dMouseKeyPressed.end(); MouseKeyIterator++)
	{
		HotSpotIterator = m_d3dMouse.find((*MouseKeyIterator));
		if (HotSpotIterator != m_d3dMouse.end())
		{
			if ( BOOL_RANGE((*MouseKeyIterator).m_MouseX,(*HotSpotIterator).second.m_MinX,(*HotSpotIterator).second.m_MaxX) &&
				BOOL_RANGE((*MouseKeyIterator).m_MouseY,(*HotSpotIterator).second.m_MinY,(*HotSpotIterator).second.m_MaxY))
			{
				MouseXY = MAKEWORD((*MouseKeyIterator).m_MouseY,(*MouseKeyIterator).m_MouseX);
				(*HotSpotIterator).second.m_HotSpotCallback((*HotSpotIterator).second.m_HotID,(*MouseKeyIterator).m_MouseButton,MouseXY);			
			}
		}
	}
	for (MouseKeyIterator = m_d3dMouseKeyJustPressed.begin(); MouseKeyIterator != m_d3dMouseKeyJustPressed.end(); MouseKeyIterator++)
	{
		HotSpotIterator = m_d3dMouse.find((*MouseKeyIterator));	
		if (HotSpotIterator != m_d3dMouse.end())
		{
			if ( BOOL_RANGE((*MouseKeyIterator).m_MouseX,(*HotSpotIterator).second.m_MinX,(*HotSpotIterator).second.m_MaxX) &&
				BOOL_RANGE((*MouseKeyIterator).m_MouseY,(*HotSpotIterator).second.m_MinY,(*HotSpotIterator).second.m_MaxY))
			{
				MouseXY = MAKELONG((*MouseKeyIterator).m_MouseY,(*MouseKeyIterator).m_MouseX);
				(*HotSpotIterator).second.m_HotSpotCallback((*HotSpotIterator).second.m_HotID,(*MouseKeyIterator).m_MouseButton,MouseXY);			
			}
		}
	}
	for (MouseKeyIterator = m_d3dMouseKeyJustUnPressed.begin(); MouseKeyIterator != m_d3dMouseKeyJustUnPressed.end(); MouseKeyIterator++)
	{
		HotSpotIterator = m_d3dMouse.find((*MouseKeyIterator));		
		if (HotSpotIterator != m_d3dMouse.end())
		{
			if ( BOOL_RANGE((*MouseKeyIterator).m_MouseX,(*HotSpotIterator).second.m_MinX,(*HotSpotIterator).second.m_MaxX) &&
				BOOL_RANGE((*MouseKeyIterator).m_MouseY,(*HotSpotIterator).second.m_MinY,(*HotSpotIterator).second.m_MaxY))
			{
				MouseXY = MAKEWORD((*MouseKeyIterator).m_MouseY,(*MouseKeyIterator).m_MouseX);
				(*HotSpotIterator).second.m_HotSpotCallback((*HotSpotIterator).second.m_HotID,(*MouseKeyIterator).m_MouseButton,MouseXY);			
			}
		}
	}

}

void CONSOLE::ReleaseMouseHotSpot(MouseKey MouseKey)
{
	MOUSEHOTKEYMAP::iterator HotSpotIterator;

	if ( (HotSpotIterator = m_d3dMouse.find(MouseKey)) != m_d3dMouse.end())
	{
		m_d3dMouse.erase(HotSpotIterator);
	}
}

void CONSOLE::ReleaseKeyboardHotKey(KeyboardKey Key)
{
	KEYBOARDMAP::iterator HotKeyIterator;
	if ( (HotKeyIterator = m_d3dKeyboard.find(Key)) != m_d3dKeyboard.end())
	{
		m_d3dKeyboard.erase(HotKeyIterator);
	}
}