Использование клавиатуры средствами DirectInput

После достаточно долгого ожидания я выкладываю на суд общественности новые туториалы. Посвящены они будут использованию пользовательского ввода и обработке его средствами DirectInput8.

Сперва займемся самым простым - клавиатурой.

Для осуществления обработки ввода пользователя я создал специальный класс, в котором сделал все, что нужно для работы DInput. Пока в данном классе присутствует лишь часть, отвечающая за сам DirectInput и часть, дающая нам возможность работать с клавиатурой. В последующих уроках мы разберем как использовать мышку и джойстик. Вот прототип данного класса :

class csc_DInput
{
private:
	LPDIRECTINPUT8 p_dinput;
	void Accure	 (void);
	void UnAccure (void);
	
public:
	csc_DInput ();
	~csc_DInput ();

	int CreateDInput (HINSTANCE);
	int CreateKeyboard (HWND);
	void Destroy (void);
	void Update	(void);

	class _keyboard
	{
		friend class csc_DInput;
		private:
			LPDIRECTINPUTDEVICE8 p_dev;
			void Update (void);
			bool bActive;
			bool bUse;
			unsigned char keys[256];

		public:
			bool IsActive (void) { return bActive; };
			bool IsButD (DWORD);
			bool IsAnyButD (void);
	} keyboard;
};

он выглядит достаточно необычно, но все же прекрасно работает и нам сразу видно что за что отвечает и что с чем работает :

LPDIRECTINPUT8 p_dinput; - это интерфейс DirectInput8 с которым мы будем работать,
void Accure (void); - захват устройств ввода,
void UnAccure (void); - освобождение устройств ввода.

Эти две функции нужны для захвата и освобождения устройств ввода. Некоторые устройства (особенно клавиатуры и мыши) регулярно захватываются и освобождаются приложениями. Обычно они освобождаются автоматически в тот момент, когда приложение теряет фокус. Когда ваше приложение опять получает фокус, оно должно снова захватить устройство.

Далее идут конструктор и деструктор.

затем еще несколько общих функций

int CreateDInput (HINSTANCE); - создает исходный интерфейс DirectInput8 для нашей последующей работы,
int CreateKeyboard (HWND); - создание интерфейса устройства DirectInput8 для работы клавиатуры,
void Destroy (void); - уничтожение всего ранее созданного,
void Update (void); - обновление состояний всех используемых и активных устройств ввода (пока только клавиатуры).

Теперь посмотрим внутренности этих функций :

Для начала конструктор и деструктор :

csc_DInput::csc_DInput ()
{
	_RELEASE_ (keyboard.p_dev);
	_RELEASE_ (p_dinput);
	
	keyboard.bUse = false;
	keyboard.bActive = false;
};

csc_DInput::~csc_DInput () { };

здесь мы просто инициализируем и обнуляем необходимые нам интерфейсы и переменные.

Затем создание и уничтожение DirectInput8 :

int csc_DInput::CreateDInput (HINSTANCE hInst)
{
	HRESULT hr;
	if(FAILED(hr = DirectInput8Create (hInst, 
				DIRECTINPUT_VERSION, IID_IDirectInput8, 
				(void**)&p_dinput, 0))) return hr;
	return 0;
};

void csc_DInput::Destroy (void)
{
	UnAccure ();
	_RELEASE_ (keyboard.p_dev);
	_RELEASE_ (p_dinput);
	
	keyboard.bUse = false;
	keyboard.bActive = false;
};

в данном отрывке мы создаем интерфейс DirectInput8 одной строкой, а при уничтожении мы сперва освобождаем все устройства и затем освобождаем интерфейсы DirectInput8 предназначенные для работы с этими устройствами.

Далее захват и освобождение устройств ввода :

void csc_DInput::Accure (void)
{
	if(keyboard.p_dev) keyboard.p_dev->Acquire ();
};

void csc_DInput::UnAccure (void)
{
	if(keyboard.p_dev) keyboard.p_dev->Unacquire ();
};

Здесь я просто использовал функции, предназначенные для этих целей. Пока здесь присутствует только клавиатура, но впоследствии мы добавим и мышку и джойстик.

И последний общий метод - метод обновления состояний устройств :

void csc_DInput::Update (void)
{
	if(keyboard.bUse)
	if(keyboard.bActive)
		keyboard.Update ();
};

в данном методе мы будем вызывать методы классов соответствующих устройствам. Сначала проверяется используется ли устройство и активно ли оно и затем происходит вызов соответствующего метода.

Еще у нас осталась не рассмотрена функция создания клавиатуры, но для этого нам необходимо сперва рассмотреть соответствующий класс для работы с клавиатурой :

...
	class _keyboard
	{
		friend class csc_DInput;
		private:
			LPDIRECTINPUTDEVICE8 p_dev;
			void Update (void);
			bool bActive;
			bool bUse;
			unsigned char keys[256];

		public:
			bool IsActive (void) { return bActive; };
			bool IsButD (DWORD);
			bool IsAnyButD (void);
	} keyboard;
...

сперва мы объявляем класс csc_DInput дружественным данному, это нужно для того, чтобы выше содержащий класс имел доступ к приватным членам данного класса.

Далее у нас идут :

LPDIRECTINPUTDEVICE8 p_dev; - интерфейс устройства DirectInput8, в данном случае для клавиатуры,
void Update (void); - обновление состояния клавиатуры,
bool bActive; - активна ли клавиатура,
bool bUse; - используем ли мы клавиатуру,
unsigned char keys[256]; - статический массив, в котором будет храниться информация о состояниях клавиш после обновления

bool IsActive (void) { return bActive; }; - возвращает нам информацию о том, активна ли клавиатура,
bool IsButD (DWORD); - возвращает нам - нажата ли конкретная клавиша на клавиатуре,
bool IsAnyButD (void); - возвращает нам - нажата ли вообще хоть одна клавиша на клавиатуре, полезно, например, для скрин сейверов.

Теперь мы можем рассмотреть функцию создания клавиатуры :

int csc_DInput::CreateKeyboard (HWND hWnd)
{
	HRESULT hr;
	if(FAILED(hr = p_dinput->CreateDevice (GUID_SysKeyboard, 
			&keyboard.p_dev, 0))) return hr;
	if(FAILED(hr = keyboard.p_dev->SetDataFormat (&c_dfDIKeyboard))) return hr;
	if(FAILED(hr = keyboard.p_dev->SetCooperativeLevel (hWnd, 
			DISCL_FOREGROUND | DISCL_NONEXCLUSIVE))) return hr;
	
	keyboard.bUse = true;
	keyboard.bActive = true;
	
	Accure ();
	return 0;
};

--- первоначально мы создаем интерфейс DirectInput8 для работы с клавиатурой, это показано флагом GUID_SysKeyboard .
--- затем мы задаем формат данных соответствующих клавиатуре.
--- и последний важный шаг - мы устанавливаем уровень кооперации.

--- далее мы говорим сами себе, что клавиатуру мы используем, и она активна, и захватываем ее.

После того как мы рассмотрели эту функцию, пришел черед рассмотреть внутренности класса предназначенного для работы с клавиатурой. У нас имеется в данном классе три метода и все они связаны , так или иначе, с обновлением :

void csc_DInput::_keyboard::Update (void)
{
	p_dev->GetDeviceState (sizeof(keys), (LPVOID)&keys);
};


bool csc_DInput::_keyboard::IsButD (DWORD index)
{
	if(keys[index] & 0x80) return true;
	return false;
};

bool csc_DInput::_keyboard::IsAnyButD (void)
{
	for(int i=0; i<256; i++)
		if(keys[i] & 0x80) return true;

	return false;
};

--- в функции обновления состояния мы просто обновляем состояние :)
--- во второй функции мы проверяем - а не нажата ли какая то конкретная клавиша на клавиатуре, какая конкретно нам нужна мы передаем на вход.
--- и в третей мы проверяем весь массив на предмет нажатия какой-либо клавиши.

Вот в принципе и все.

Рассмотрим еще только, как и что у нас поменялось в нашей программе. Я использовал пример из предыдущего урока, и заменил там весь ввод от клавиатуры, который обрабатывался Windows'ом в оконной функции, на ввод который обрабатывается DirectInput8. Для этого я создал отдельную функцию обработки пользовательского ввода :

//-----------------------------------------------------------------------------
// Name: ProcessUserInput ()
// Desc: 
//-----------------------------------------------------------------------------
void ProcessUserInput (void)
{
	directinput8.Update ();
	if(KEYDOWN(DIK_NEXT)) 
		p_d3d_Device->SetRenderState (D3DRS_FILLMODE, D3DFILL_WIREFRAME);
	if(KEYDOWN(DIK_PRIOR)) 
		p_d3d_Device->SetRenderState (D3DRS_FILLMODE, D3DFILL_SOLID);
	if(KEYDOWN(DIK_ADD)) distance--;
	if(KEYDOWN(DIK_SUBTRACT)) distance++;
	if(KEYDOWN(DIK_INSERT)) effect=0;
	if(KEYDOWN(DIK_DELETE)) effect=1;
	if(KEYDOWN(DIK_UP)) 
	{
		Donut.Move (sin(angel), 0.0f, cos(angel)); 
		Donut.Transform();
	};
	if(KEYDOWN(DIK_DOWN)) 
	{
		Donut.Move (-sin(angel), 0.0f, -cos(angel));
		Donut.Transform();
	};
	if(KEYDOWN(DIK_LEFT)) 
	{
		angel+=D3DXToRadian(-5);
		Donut.RotateY (D3DXToRadian(-5));
		Donut.Transform(); 
	};
	if(KEYDOWN(DIK_RIGHT)) 
	{
		angel+=D3DXToRadian(5);
		Donut.RotateY (D3DXToRadian(5));
		Donut.Transform();
	};
	if(KEYDOWN(DIK_HOME)) 
	{
		Donut.Scale (1, 1.1, 1);
		Donut.Transform();
	};
	if(KEYDOWN(DIK_END))
	{
		Donut.Scale (1, 0.9, 1);
		Donut.Transform();
	};
};

Вызывать ее нужно перед рендерингом :

while (1)
{
	if(PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
	{
		if(!GetMessage (&msg, NULL, 0, 0)) break;
		TranslateMessage (&msg); 
		DispatchMessage (&msg);
	}
	else
	if(bActive) 
	{ 
		ProcessUserInput ();
		RenderScreen (); 
	};
};

тут я еще использовал макрос для облегчения читаемости кода :

#define KEYDOWN(key) (directinput8.keyboard.IsButD(key)) 

Вот теперь действительно все.

Теперь, попробовав пример из предыдущего урока и из этого, вы почувствуете разницу при работе с клавиатурой :)