GainputInputDevice.h

#ifndef GAINPUTINPUTDEVICE_H_
#define GAINPUTINPUTDEVICE_H_

namespace gainput
{


enum ButtonType
{
    BT_BOOL,    
    BT_FLOAT,   
    BT_COUNT    
};



class GAINPUT_LIBEXPORT InputDevice
{
public:
    enum DeviceType
    {
        DT_MOUSE,       
        DT_KEYBOARD,        
        DT_PAD,         
        DT_TOUCH,       
        DT_BUILTIN,     
        DT_REMOTE,      
        DT_GESTURE,     
        DT_CUSTOM,      
        DT_COUNT        
    };

    enum DeviceVariant
    {
        DV_STANDARD,        
        DV_RAW,         
        DV_NULL         
    };

    enum DeviceState
    {
        DS_OK,          
        DS_LOW_BATTERY,     
        DS_UNAVAILABLE      
    };

    static const unsigned AutoIndex = unsigned(-1);


    InputDevice(InputManager& manager, DeviceId device, unsigned index);

    virtual ~InputDevice();


    void Update(InputDeltaState* delta);

    DeviceId GetDeviceId() const { return deviceId_; }
    unsigned GetIndex() const { return index_; }

    virtual DeviceType GetType() const = 0;
    virtual DeviceVariant GetVariant() const { return DV_STANDARD; }
    virtual const char* GetTypeName() const = 0;
    virtual bool IsLateUpdate() const { return false; }
    DeviceState GetState() const;
    virtual bool IsAvailable() const { return GetState() == DS_OK || GetState() == DS_LOW_BATTERY; }

    virtual bool IsValidButtonId(DeviceButtonId deviceButton) const = 0;

    bool GetBool(DeviceButtonId deviceButton) const;
    bool GetBoolPrevious(DeviceButtonId deviceButton) const;
    float GetFloat(DeviceButtonId deviceButton) const;
    float GetFloatPrevious(DeviceButtonId deviceButton) const;


    virtual size_t GetAnyButtonDown(DeviceButtonSpec* outButtons, size_t maxButtonCount) const { GAINPUT_UNUSED(outButtons); GAINPUT_UNUSED(maxButtonCount); return 0; }


    virtual size_t GetButtonName(DeviceButtonId deviceButton, char* buffer, size_t bufferLength) const { GAINPUT_UNUSED(deviceButton); GAINPUT_UNUSED(buffer); GAINPUT_UNUSED(bufferLength); return 0; }
    virtual ButtonType GetButtonType(DeviceButtonId deviceButton) const = 0;


    virtual DeviceButtonId GetButtonByName(const char* name) const { GAINPUT_UNUSED(name); return InvalidDeviceButtonId; }

    InputState* GetInputState() { return state_; }
    const InputState* GetInputState() const { return state_; }
    InputState* GetPreviousInputState() { return previousState_; }
    virtual InputState* GetNextInputState() { return 0; }

    float GetDeadZone(DeviceButtonId buttonId) const;
    void SetDeadZone(DeviceButtonId buttonId, float value);

    void SetDebugRenderingEnabled(bool enabled);
    bool IsDebugRenderingEnabled() const { return debugRenderingEnabled_; }

#if defined(GAINPUT_DEV) || defined(GAINPUT_ENABLE_RECORDER)
    bool IsSynced() const { return synced_; }

    void SetSynced(bool synced) { synced_ = synced; }
#endif

protected:
    InputManager& manager_;

    DeviceId deviceId_;

    unsigned index_;

    InputState* state_;
    InputState* previousState_;

    float* deadZones_;

    bool debugRenderingEnabled_;

#if defined(GAINPUT_DEV) || defined(GAINPUT_ENABLE_RECORDER)
    bool synced_;
#endif


    virtual void InternalUpdate(InputDeltaState* delta) = 0;


    virtual DeviceState InternalGetState() const = 0;


    size_t CheckAllButtonsDown(DeviceButtonSpec* outButtons, size_t maxButtonCount, unsigned start, unsigned end) const;
};


inline
bool
InputDevice::GetBool(DeviceButtonId deviceButton) const
{
    if (!IsAvailable())
    {
        return false;
    }
    GAINPUT_ASSERT(state_);
    return state_->GetBool(deviceButton);
}

inline
bool
InputDevice::GetBoolPrevious(DeviceButtonId deviceButton) const
{
    if (!IsAvailable())
    {
        return false;
    }
    GAINPUT_ASSERT(previousState_);
    return previousState_->GetBool(deviceButton);
}

inline
float
InputDevice::GetFloat(DeviceButtonId deviceButton) const
{
    if (!IsAvailable())
    {
        return 0.0f;
    }
    GAINPUT_ASSERT(state_);
    return state_->GetFloat(deviceButton);
}

inline
float
InputDevice::GetFloatPrevious(DeviceButtonId deviceButton) const
{
    if (!IsAvailable())
    {
        return 0.0f;
    }
    GAINPUT_ASSERT(previousState_);
    return previousState_->GetFloat(deviceButton);
}

}

#endif