GxSysInput.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxUnitLocate;
 
//===========================================================================
//===========================================================================
class GxInputInitialInformation : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxInputInitialInformation, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxInputInitialInformation)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxInputInitialInformation(void)
    : _networkPadCount(0)
    , _enableDInputKeyboard(false)
    , _enableForegroundKeyboard(true)
    , _enableForegroundPad(true)
    , _enableForegroundMouse(true)
    , _useDualshock(false)
    , _supportedStyleSetMask(0)
    {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    void loadJson(const GxJson::GxJsonNode& jsonNode);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    u32 _networkPadCount;           
    b32 _enableDInputKeyboard;      
    b32 _enableForegroundKeyboard;  
    b32 _enableForegroundPad;       
    b32 _enableForegroundMouse;     
    b32 _useDualshock;              
    u32 _supportedStyleSetMask;     
 
};
 
//===========================================================================
//===========================================================================
class GxInputDevice : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    static const s32 INVALID_HANDLE  = -1;
    static const s32 INVALID_USER_ID = -1;
 
    GX_RTTI_ABSTRACT_CLASS(GxInputDevice, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxInputDevice)
 
    
    enum class KIND
    {
        NONE = 0,       
        UNKNOWN,        
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
        PAD_XBOX,       
#endif //_WINDOWS || _PS4 || _PS5 || _XBOX_XS
 
#if defined(_WINDOWS) || GX_DEVELOP
        KEYBOARD,       
        MOUSE,          
#endif //_WINDOWS || GX_DEVELOP
 
#if defined(_WINDOWS)
        PAD_PC,         
        KEYBOARD_DINPUT,
#if GX_DEVELOP
        PAD_VIRTUAL,    
#endif //GX_DEVELOP
#elif defined(_NX64)
        PAD_NX,         
#endif // _NX64
#if defined(_WINDOWS) || defined(_PS4) || defined(_PS5)
        PAD_PS4,        
#endif //_WINDOWS || _PS4 || _PS5
#if defined(_WINDOWS)
        IME_TEXT,       
#endif //_WINDOWS
        PAD_NETWORK,    
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxInputDevice(void);
    ~GxInputDevice(void) override {}
    virtual b32 initialize(void) = 0;
 
    //---------------------------------------------------------------------------
    //---------------------------------------------------------------------------
 
    virtual void getInputDataDevice(void) = 0;
    virtual void update(void) = 0;
    virtual void clear(void) = 0;
#if GX_DEVELOP
    virtual void developRender(void) = 0;
#endif //GX_DEVELOP
    virtual void saveInput(void) = 0;
    virtual void loadInput(void) = 0;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr s32 getRepeatStart(void) const { return _repeatStart; }
    constexpr void setRepeatStart(s32 time){ _repeatStart = time; }
    constexpr s32 getRepeatInterval(void) const { return _repeatInterval; }
    constexpr void setRepeatInterval(s32 intervalTime){ _repeatInterval = intervalTime; }
    constexpr u32 getNumber(void) const { return _number; }
    constexpr void setNumber(u32 number){ _number = number; }
    constexpr void setKind(KIND kind){ _kind = kind; }
    constexpr KIND getKind(void) const { return _kind; }
    virtual b32 isEnable(void) const = 0;
    virtual b32 isOk(void) = 0;
    virtual b32 isCancel(void) = 0;
    GX_FORCE_INLINE virtual s32 getUserId(void) const { return INVALID_USER_ID; }
    virtual void setUserId(s32 /*id*/) {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    s32 _repeatStart;       
    s32 _repeatInterval;    
    u32 _number;            
    KIND _kind;             
 
};
 
class GxPad;
#if defined(_WINDOWS) || GX_DEVELOP
class GxKeyboard;
class GxMouse;
class GxImeText;
#endif //_WINDOWS || GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxSysInput : public GxSysBase, public SingletonBase<GxSysInput>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxSysInput, GxSysBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSysInput)
 
    
    enum class DEVICE
    {
        DEFAULT = -1,           
        PAD_0 = 0,              
        PAD_1,                  
        PAD_2,                  
        PAD_3,                  
#if defined(_NX64) || defined(_WINDOWS)
        PAD_4,                  
        PAD_5,                  
        PAD_6,                  
        PAD_7,                  
#endif //_NX64 || _WINDOWS
#if defined(_NX64)
        PAD_8,                  
#elif defined(_WINDOWS)
#if GX_DEVELOP
        PAD_VIRTUAL,            
#endif //GX_DEVELOP
#endif //_WINDOWS
        PAD_MAX,                
 
#if defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
        USER_ASSIGNED_CONTROLLER_MAX = PAD_MAX,     
#endif //_PS4 || _PS5 || _XBOX_XS
 
#if defined(_WINDOWS)
        KEYBOARD = PAD_MAX,     
        MOUSE,                  
        IME_TEXT,               
        OFFLINE_MAX,            
#elif defined(_PS4) || defined(_PS5) || defined(_XBOX_XS)
#if GX_DEVELOP
        KEYBOARD = USER_ASSIGNED_CONTROLLER_MAX,    
        MOUSE,                  
        OFFLINE_MAX,            
#else //GX_DEVELOP
        OFFLINE_MAX = USER_ASSIGNED_CONTROLLER_MAX, 
#endif // !GX_DEVELOP
#else //_PS4 || _PS5 || _XBOX_XS
#if GX_DEVELOP
        KEYBOARD = PAD_MAX,     
        MOUSE,                  
        OFFLINE_MAX,            
#else //GX_DEVELOP
        OFFLINE_MAX = PAD_MAX,  
#endif // !GX_DEVELOP
#endif // !(_PS4 || _PS5)
 
        NETWORK_PAD_START = OFFLINE_MAX,    
 
#if defined(_PS4) || defined(_PS5)
        USER_ASSIGNED_CONTROLLER_START  = PAD_0,    
        USER_ASSIGNED_CONTROLLER_END    = USER_ASSIGNED_CONTROLLER_START + USER_ASSIGNED_CONTROLLER_MAX - 1,    
#endif //_PS4 || _PS5
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_COUNT(DEVICE, static_cast<s32>(DEVICE::PAD_MAX) + 1)
#endif //GX_DEVELOP
 
    enum class PLAY_PAD
    {
        ONCE,       
        LOOP,       
        LOOP_LOCAL, 
        MAX,        
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(PLAY_PAD)
#endif //GX_DEVELOP
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxSysInput(void);
    ~GxSysInput(void) override {}
    b32 initialize(const GxClassBase* pInitializeInformation) override;
    GX_FORCE_INLINE virtual b32 isInitialized(void) { return _isInitialized; };
    void terminate(void) override;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    void update(void) override;
#if GX_DEVELOP
    void developRender(void);
#endif //GX_DEVELOP
    void saveInputAll(void);
    void loadInputAll(void);
#if GX_DEVELOP
    void recordPad(void);
#endif //GX_DEVELOP
    void playPad(void);
    void stopPadRecorder(void);
    constexpr void setPlayPadMode(PLAY_PAD mode){ _playPadMode = mode; }
    constexpr PLAY_PAD getPlayPadMode(void) const { return _playPadMode; }
protected:
    GxInputDevice* createDevice(GxInputDevice::KIND kind);
    void updatePlayPad(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    constexpr u32 getDeviceMax(void){ return static_cast<s32>(DEVICE::OFFLINE_MAX) + _networkPadCount; }
    constexpr GxInputDevice* getDevice(u32 number) const { return static_cast<GxInputDevice*>(_deviceArray[number]); }
    GxPad* getPad(DEVICE number = DEVICE::DEFAULT) const;
#if defined(_WINDOWS) || GX_DEVELOP
    GX_FORCE_INLINE GxKeyboard* getKeyboard(void) const { return gx_cast<GxKeyboard*>(static_cast<GxInputDevice*>(_deviceArray[static_cast<s32>(DEVICE::KEYBOARD)])); }
    GX_FORCE_INLINE GxMouse* getMouse(void) const { return gx_cast<GxMouse*>(static_cast<GxInputDevice*>(_deviceArray[static_cast<s32>(DEVICE::MOUSE)])); }
#if defined(_WINDOWS)
    constexpr IDirectInput8* getDirectInput(void) const { return _pDirectInput; }
    constexpr u32 getRetrySequence(void) const { return _retrySequence; }
    void updateConnectState(void);
    GX_FORCE_INLINE b32 isEnableForegroundKeyboard(void) const { return _enableForegroundKeyboard; }
    GX_FORCE_INLINE b32 isEnableForegroundPad(void) const { return _enableForegroundPad; }
    GX_FORCE_INLINE b32 isEnableForegroundMouse(void) const { return _enableForegroundMouse; }
    GX_FORCE_INLINE GxImeText* getImeText(void) const { return gx_cast<GxImeText*>(static_cast<GxInputDevice*>(_deviceArray[static_cast<s32>(DEVICE::IME_TEXT)])); }
#elif _XBOX_XS
    GX_FORCE_INLINE ComPtr<IGameInput> getGameInput(void) const { return _pGameInput; }
#endif // _XBOX_XS
#endif //_WINDOWS || GX_DEVELOP
 
#if defined(_PS4) || defined(_PS5)
    s32 getInputPs4UserId( u32 number );
 
    void setUserId( u32 number, s32 userId );
 
    void updateUserId(void);
#endif // _PS4 || _PS5
 
#if defined(_NX64)
    void setSupportedStyleSet(u32 padStyleMask);
#endif //_NX64
 
    b32 isOk(void) const;
    b32 isCancel(void) const;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxArray _deviceArray;           
    u32 _networkPadCount;           
    b32 _isInitialized;             
    PLAY_PAD _playPadMode;          
    b32 _isPadPlay;                 
#if defined(_WINDOWS)
    u32 _retrySequence;             
    IDirectInput8* _pDirectInput;   
    b32 _enableForegroundKeyboard;  
    b32 _enableForegroundPad;       
    b32 _enableForegroundMouse;     
#elif defined(_XBOX_XS)
    ComPtr<IGameInput> _pGameInput; 
#elif defined(_NX64)
    u32 _supportedStyleSetMask;     
#endif //_NX64
 
};
 
// アクセスインターフェース
GX_FORCE_INLINE GxSysInput* getGxSysInput(void){ return GxSysInput::getSingletonPointer(); }
 
GX_CORE_NAMESPACE_END()