DirectX Input 键盘实现

// DInputKeyboard.h: interface for the CDInputKeyboard class.
//
//////////////////////////////////////////////////////////////////////

#pragma once

#define DIRECTINPUT_VERSION 0x800
#include <afxtempl.h>
#include <dinput.h>
#pragma comment(lib, "dinput8.lib")
#pragma comment(lib, "DXguid.Lib")

class CDInputKeyboard  
{
    #define BUFFERCOUNT 256
    LPDIRECTINPUT         lpDirectInput;            
    LPDIRECTINPUTDEVICE   lpdiKeyboard;     
    BOOL                  KeyboardAcquired;
    BOOL                  KeyboardFound;
    CTypedPtrArray <CPtrArray, LPDIDEVICEINSTANCE> m_KeyboInstance_Array;

protected:
    virtual BOOL ProcessInputKey(TCHAR tChar)
    {
        return false;
    }

  static BOOL CALLBACK DIEnumDevicesProc(LPCDIDEVICEINSTANCE lpddi, 
                                  LPVOID pvRef)
  {  
    if (GET_DIDEVICE_TYPE(lpddi->dwDevType) == DI8DEVTYPE_KEYBOARD
            || ((lpddi->dwDevType & DIDEVTYPE_HID) && GET_DIDEVICE_TYPE(lpddi->dwDevType) == DI8DEVTYPE_DEVICE ) )
    { 
      LPDIDEVICEINSTANCE pNewdid = (LPDIDEVICEINSTANCE) new DIDEVICEINSTANCE;
      memcpy(pNewdid, lpddi, sizeof(DIDEVICEINSTANCE));
      ((CDInputKeyboard *)pvRef)->m_KeyboInstance_Array.Add(pNewdid);
    }
    return DIENUM_CONTINUE;  
  } // DIEnumDevicesProc

  void RemoveGUID()
  {
    KeyboardFound = 0;
    while(m_KeyboInstance_Array.GetSize() > 0)
    {
      delete m_KeyboInstance_Array.GetAt(0);
      m_KeyboInstance_Array.RemoveAt(0);
    }
  }

public:  
  HWND                hMainWindow;         // app window handle
  
  virtual BOOL InitInput(HWND hWnd)
  {
    ASSERT(lpDirectInput == NULL);
    ASSERT(hWnd);

    hMainWindow = hWnd;

    HINSTANCE hInstance = (HINSTANCE) GetWindowLong(hMainWindow, GWL_HINSTANCE); // program instance
    // try to create DirectInput object
    if(DirectInput8Create(hInstance, DIRECTINPUT_VERSION,  IID_IDirectInput8, (LPVOID*)&lpDirectInput, NULL) != DI_OK)
    {
      lpDirectInput = NULL;
      OutputDebugString( _T("Failed to create DirectInput object./n") );
      return FALSE;
    }
    return TRUE;
  }

  INT_PTR EnumKeyboard()
  {
    RemoveGUID();
    if(lpDirectInput)
    {
      // enumerate devices so we can get the GUIDs
      if (lpDirectInput->EnumDevices(0, 
                            DIEnumDevicesProc,
                            this, 
                            DIEDFL_ALLDEVICES) != DI_OK)
      {
        OutputDebugString( _T("Could not enumerate devices./n") );
      }
    }
    return m_KeyboInstance_Array.GetSize();
  }

  BOOL Unacquire()
  {
    if(lpdiKeyboard)
    {
      lpdiKeyboard->Unacquire();
      lpdiKeyboard->Release();
      lpdiKeyboard = NULL;
    }
    KeyboardAcquired = false;
    return TRUE;
  }

  BOOL Acquire(INT_PTR nPos = -1)
  {
    Unacquire();

    if(lpDirectInput == NULL)
    {
      OutputDebugString( _T("lpDirectInput is NULL./n") );
      return FALSE;
    }

    GUID KeyboardGUID =  GUID_SysKeyboard;
    if(nPos >=0 && nPos < m_KeyboInstance_Array.GetSize())
    {
      KeyboardGUID = m_KeyboInstance_Array.GetAt(nPos)->guidInstance;
    }
    
   // try to create keyboard device
    if(lpDirectInput->CreateDevice(KeyboardGUID, &lpdiKeyboard, NULL) != DI_OK ) //GUID_SysKeyboard
    {
      OutputDebugString( _T("Failed to create keyboard device./n") );
            Unacquire();
      return FALSE;
    }

    // set kbd cooperative level
    if (lpdiKeyboard->SetCooperativeLevel(hMainWindow, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE) != DI_OK)
    {
      OutputDebugString( _T("Failed to set keyboard cooperative level./n") );
            Unacquire();
      return FALSE;
    }

    // set kbd data format
    if (lpdiKeyboard->SetDataFormat(&c_dfDIKeyboard) != DI_OK)
    {
      OutputDebugString( _T("Failed to set keyboard data format./n") );
            Unacquire();
      return FALSE;
    }

   // set kbd buffer size
    DIPROPDWORD dipdw = {0};
    dipdw.diph.dwSize = sizeof(DIPROPDWORD);
    dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
    dipdw.diph.dwObj = 0;
    dipdw.diph.dwHow = DIPH_DEVICE;
    dipdw.dwData = BUFFERCOUNT; // * sizeof(DIDEVICEOBJECTDATA);
    if (lpdiKeyboard->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph) != DI_OK) 
    {
      OutputDebugString( _T("Failed to set keyboard buffer size./n") );
            Unacquire();
      return FALSE;
    }

    // try to acquire the keyboard
    if (lpdiKeyboard->Acquire() != DI_OK)
    {
      OutputDebugString( _T("Failed to acquire the keyboard./n") );
            Unacquire();
      return FALSE;
    }

    KeyboardAcquired = TRUE;
    return TRUE;      
  }

  BOOL ReacquireInput(void)
  {
  //the keyboard
    if(lpdiKeyboard != NULL)
    {
      lpdiKeyboard->Acquire();
    }
    else
    {
      // keyboard device has not been created.
      return FALSE;
    }
    // if we get here, we are acquired again
    KeyboardAcquired = TRUE;

    return TRUE;
  }  // ReacquireInputDevices()

  BOOL PollKeyboard(void) //Reads the keyboard state
  {
    if(lpdiKeyboard && KeyboardAcquired)
    {
      BYTE diKeys[257] = {0};
      if (lpdiKeyboard->GetDeviceState(256, &diKeys) == DI_OK)
      {
        if(diKeys[DIK_LWIN] & 0x80) /* Left Windows key */
        {
        }
        if(diKeys[DIK_RWIN] & 0x80) /* Right Windows key */
        {
        }
      
        return TRUE;  // success
      }
    }
    return FALSE;
  } // PollKeyboard()

  HRESULT ReadKeyboardInput(void)
  {
        HRESULT hRes = DI_OK;
        if(KeyboardAcquired)
        {
            DIDEVICEOBJECTDATA  KbdBuffer[BUFFERCOUNT] = {0};
            DWORD dwItems = BUFFERCOUNT;
            hRes = lpdiKeyboard->GetDeviceData(sizeof(DIDEVICEOBJECTDATA),
                                                                    KbdBuffer, &dwItems, 0);
            if(hRes == DI_OK || hRes == DI_BUFFEROVERFLOW)
            {

                for (DWORD k = 0; k < dwItems; k++)
                {
                    LPDIDEVICEOBJECTDATA lpdidod = &KbdBuffer[k];

                    TCHAR VKey = MapVirtualKey(lpdidod->dwOfs, 3); //映射到虚拟键
                    ProcessInputKey(VKey); //处理输入

                    CString dbgStr, tmpStr;
                    dbgStr.Format(_T("%d"), lpdidod->dwSequence);
                    tmpStr.Format(_T(". Scan code 0x%04X"), lpdidod->dwOfs);
                    dbgStr += tmpStr;            
                    dbgStr += (lpdidod->dwData & 0x80)? _T(" pressed ") : _T(" released ");        
                    tmpStr.Format(_T(". Age: %d ms"), GetTickCount() - lpdidod->dwTimeStamp);
                    dbgStr += tmpStr;
                    dbgStr += _T("/n");
                    OutputDebugString(dbgStr);        
                }
            }
            else if(hRes == DIERR_INPUTLOST)
            {
                ReacquireInput(); 
                hRes = S_FALSE;
            } 
        }
    return hRes;
  }


////////////////////////////////////////////////
  CDInputKeyboard()
  {
    hMainWindow = NULL;
    lpDirectInput = NULL;
    lpdiKeyboard = NULL;
    KeyboardAcquired = 0;
    KeyboardFound = 0;
    m_KeyboInstance_Array.RemoveAll();
  }

  virtual ~CDInputKeyboard()
  {
    if(lpdiKeyboard)
    {
      lpdiKeyboard->Unacquire();
      lpdiKeyboard->Release();
      lpdiKeyboard = NULL;
    }

    if(lpDirectInput)
    {
      lpDirectInput->Release();
      lpDirectInput = NULL;
    }

    RemoveGUID();
  }


};