TnbDxInput.h

[詳解]

#pragma once
#include "TnbDef.h"
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 #define DIRECTINPUT_VERSION 0x0800
#endif
#include <atlbase.h>
#include <dinput.h>
#pragma comment(lib,"dinput8.lib")
#pragma comment(lib,"dxguid.lib")
 
 
 
//TNB Library
namespace TNB{
namespace DX
{
 
 
 
class CDirectInputDevice : CCopyImpossible
{
public:
 
    CDirectInputDevice(void) : m_deviceSize(0), m_hResult(E_FAIL)
    {
    }
 
    ~CDirectInputDevice(void)
    {
        Destroy(); 
    }
 
    void Destroy(void)
    {
        m_pDiObject = NULL;
        loop ( i, m_deviceSize )
        {
            m_apDiDevice[i] = NULL;
        }
        m_deviceSize = 0;
        m_hResult = E_FAIL;
    }
 
    bool Create(DWORD dwDevType, HINSTANCE hInst = NULL)
    {
        Destroy();
        if ( hInst == NULL )
        {
            hInst = GetInstanceHandleByTnb(EI_Process);
        }
        //DirectInputオブジェクトの生成
        m_hResult = ::DirectInput8Create(hInst, DIRECTINPUT_VERSION,
                        IID_IDirectInput8, reinterpret_cast<LPVOID*>(&m_pDiObject), NULL);
        if ( FAILED(m_hResult) )
        {
            return false;
        }
        //DirectInputデバイスオブジェクト達の生成
        if ( m_pDiObject->EnumDevices(dwDevType, ms_Callback, this, DIEDFL_ATTACHEDONLY) != DI_OK )
        {
            Destroy();
            return false;
        }
        return true;
    }
 
    bool Create(const GUID& guid, HINSTANCE hInst = NULL)
    {
        Destroy();
        if ( hInst == NULL )
        {
            hInst = GetInstanceHandleByTnb(EI_Process);
        }
        //DirectInputオブジェクトの生成
        m_hResult = ::DirectInput8Create(hInst, DIRECTINPUT_VERSION,
                        IID_IDirectInput8, reinterpret_cast<LPVOID*>(&m_pDiObject), NULL);
        if ( FAILED(m_hResult) )
        {
            return false;
        }
        // デバイス・オブジェクトを作成
        m_hResult = m_pDiObject->CreateDevice(guid, &m_apDiDevice[0], NULL); 
        if ( FAILED(m_hResult) )
        {
            m_pDiObject = NULL;
            return false;
        }
        m_deviceSize = 1;
        return true;
    }
 
    const IDirectInput8* ReferObject(void) const
    {
        return m_pDiObject;
    }
 
    size_t GetDeviceNum(void) const
    {
        return  m_deviceSize;
    }
 
    IDirectInputDevice8* operator[](INDEX index) const
    {
        if ( index < MAX )
        {
            return m_apDiDevice[index]; 
        }
        return NULL;
    }
 
private:
    enum { MAX = 16 };                                  // 最大Device数
    CComPtr<IDirectInput8>          m_pDiObject;        
    size_t                          m_deviceSize;       
    CComPtr<IDirectInputDevice8>    m_apDiDevice[MAX];  
    HRESULT                         m_hResult;          
    static BOOL CALLBACK ms_Callback(const DIDEVICEINSTANCE* pInst, VOID* pContext)
    {
        CDirectInputDevice* P = static_cast<CDirectInputDevice*>(pContext);
        size_t l = P->m_deviceSize;
        if ( l < MAX - 1 )
        {
            HRESULT hr = P->m_pDiObject->CreateDevice(pInst->guidInstance, &(P->m_apDiDevice[l]), NULL);
            if ( SUCCEEDED(hr) ) 
            {
                (P->m_deviceSize)++;
                return DIENUM_CONTINUE;
            }
        }
        return DIENUM_STOP;
    }
};
 
 
 
template<typename TYP>
class CDirectInputT
{
public:
 
    CDirectInputT(HINSTANCE hInst = NULL) : m_hInst(hInst), m_boIsInit(false)
    {
        Zero(m_state);
    }
 
    bool Initialize(HWND hWnd = NULL, DWORD dwMode = DISCL_NONEXCLUSIVE | DISCL_FOREGROUND)
    {
        if ( ! OnCreate(m_dx, m_hInst) )
        {
            return false; 
        }
        loop ( i, m_dx.GetDeviceNum() )
        {
            // データ形式を設定
            if ( ! OnSetDataFormat(m_dx[i]) )
            {
                return false;
            }
            //モードを設定
            if ( hWnd != NULL && FAILED(m_dx[i]->SetCooperativeLevel(hWnd, dwMode)) )
            {
                return false;
            }
            //デバイスの設定
            if ( ! OnSetProperty(m_dx[i]) )
            {
                return false; 
            }
        }
        m_boIsInit = true;
        return true;
    }
 
    bool Acquire(void)
    {
        if ( ! m_boIsInit )
        {
            return false;
        }
        loop ( i, m_dx.GetDeviceNum() )
        {
            if ( FAILED(m_dx[i]->Acquire()) )
            {
                return false; 
            }
        }
        return true;
    }
    
    bool Unacquire(void)
    {
        if ( ! m_boIsInit )
        {
            return false;
        }
        loop ( i, m_dx.GetDeviceNum() )
        {
            if ( FAILED(m_dx[i]->Unacquire()) )
            {
                return false; 
            }
        }
        return true;
    }
 
    void Poll(void)
    {
        if ( m_boIsInit )
        {
            loop ( i, m_dx.GetDeviceNum() )
            {
                m_dx[i]->Poll();
            }
        }
    }
 
    size_t GetDeviceNum(void) const
    {
        return m_dx.GetDeviceNum();
    }
 
    const TYP* Get(INDEX index = 0) const
    {
        if ( m_boIsInit && IsInRange(index, GetDeviceNum()) )
        {
            IDirectInputDevice8* px = m_dx[index];
            if ( px != NULL && SUCCEEDED(px->GetDeviceState(sizeof(TYP), &m_state)) )
            {
                return &m_state;
            }
        }
        return NULL;
    }
 
protected:
 
    virtual bool OnCreate(CDirectInputDevice& _dx, HINSTANCE hInst) = 0;
 
    virtual bool OnSetDataFormat(IDirectInputDevice8* _px) = 0;
 
    virtual bool OnSetProperty(IDirectInputDevice8* _px) = 0;
 
private:
    CDirectInputDevice  m_dx;       
    bool                m_boIsInit; 
    HINSTANCE           m_hInst;    
    mutable TYP         m_state;    
};
 
 
 
class CDirectInputMouse : public CDirectInputT<DIMOUSESTATE2>
{
    DEFSUPER(CDirectInputT<DIMOUSESTATE2>);
public:
 
    const DIMOUSESTATE2* Get(INDEX index = 0) const
    {
        return _super::Get(index);
    }   
 
protected:
 
    virtual bool OnCreate(CDirectInputDevice& _dx, HINSTANCE hInst)
    {
        return _dx.Create(GUID_SysMouse, hInst);
    }
 
    virtual bool OnSetDataFormat(IDirectInputDevice8* _px)
    {
        return !! SUCCEEDED(_px->SetDataFormat(&c_dfDIMouse2));
    }
 
    virtual bool OnSetProperty(IDirectInputDevice8* _px)
    {
        // 軸モードを設定
        DIPROPDWORD diprop      = {sizeof(DIPROPDWORD)};
        diprop.diph.dwHeaderSize = sizeof(diprop.diph); 
        diprop.diph.dwHow       = DIPH_DEVICE;
        diprop.dwData           = DIPROPAXISMODE_REL;   //相対値モード
        return !! SUCCEEDED(_px->SetProperty(DIPROP_AXISMODE, &diprop.diph));
    }
};
 
 
 
class CDirectInputJoystick : public CDirectInputT<DIJOYSTATE2>
{
    DEFSUPER(CDirectInputT<DIJOYSTATE2>);
public:
 
    const DIJOYSTATE2* Get(INDEX index = 0) const
    {
        return _super::Get(index);
    }   
 
    virtual LONG GetStickRange(void) const
    {
        return 1000;
    }
 
protected:
 
    virtual bool OnCreate(CDirectInputDevice& _dx, HINSTANCE hInst)
    {
        return _dx.Create(DI8DEVCLASS_GAMECTRL, hInst);
    }
 
    virtual bool OnSetDataFormat(IDirectInputDevice8* _px)
    {
        return !! SUCCEEDED(_px->SetDataFormat(&c_dfDIJoystick2));
    }
 
    virtual bool OnSetProperty(IDirectInputDevice8* _px)
    {
        TParam p = { _px, this };
        return (_px->EnumObjects(ms_EnumObjectsCallback, &p, DIDFT_ALL)) == DI_OK;
    }
 
private:
 
    struct TParam
    {
        IDirectInputDevice8*    pDev;
        CDirectInputJoystick*   pJoystick;
    };
    static BOOL CALLBACK ms_EnumObjectsCallback(const DIDEVICEOBJECTINSTANCE* pdidoi, LPVOID pContext)
    {
        TParam* P = static_cast<TParam*>(pContext);
        if ( (pdidoi->dwType & DIDFT_AXIS) != 0 )
        {
            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              = P->pJoystick->GetStickRange() * -1;
            diprg.lMax              = P->pJoystick->GetStickRange();
            // Set the range for the axis
            if ( FAILED(P->pDev->SetProperty(DIPROP_RANGE, &diprg.diph)) )
            {
                return false;
            }
        }
        return true;
    }
};
 
 
 
};//DX
};//TNB