GainputInputManager.h

#ifndef GAINPUTINPUTMANAGER_H_
#define GAINPUTINPUTMANAGER_H_


namespace gainput
{
    

class GAINPUT_LIBEXPORT InputManager
{
public:

    InputManager(bool useSystemTime = true, Allocator& allocator = GetDefaultAllocator());

    ~InputManager();


    void SetDisplaySize(int width, int height) { displayWidth_ = width; displayHeight_ = height; }

#if defined(GAINPUT_PLATFORM_LINUX)

    void HandleEvent(XEvent& event);
#endif
#if defined(GAINPUT_PLATFORM_WIN)

    void HandleMessage(const MSG& msg);
#endif
#if defined(GAINPUT_PLATFORM_ANDROID)
    int32_t HandleInput(AInputEvent* event);

    struct DeviceInput
    {
        InputDevice::DeviceType deviceType;
        unsigned deviceIndex;
        ButtonType buttonType;
        DeviceButtonId buttonId;
        union
        {
            float f;
            bool b;
        } value;
    };
    void HandleDeviceInput(DeviceInput const& input);
#endif


    void Update();


    void Update(uint64_t deltaTime);

    Allocator& GetAllocator() const { return allocator_; }

    uint64_t GetTime() const;


    template<class T> DeviceId CreateDevice(unsigned index = InputDevice::AutoIndex, InputDevice::DeviceVariant variant = InputDevice::DV_STANDARD);

    template<class T> T* CreateAndGetDevice(unsigned index = InputDevice::AutoIndex, InputDevice::DeviceVariant variant = InputDevice::DV_STANDARD);

    InputDevice* GetDevice(DeviceId deviceId);

    const InputDevice* GetDevice(DeviceId deviceId) const;

    DeviceId FindDeviceId(const char* typeName, unsigned index) const;

    DeviceId FindDeviceId(InputDevice::DeviceType type, unsigned index) const;

    typedef HashMap<DeviceId, InputDevice*> DeviceMap;
    typedef DeviceMap::iterator iterator;
    typedef DeviceMap::const_iterator const_iterator;

    iterator begin() { return devices_.begin(); }
    iterator end() { return devices_.end(); }
    const_iterator begin() const { return devices_.begin(); }
    const_iterator end() const { return devices_.end(); }


    ListenerId AddListener(InputListener* listener);
    void RemoveListener(ListenerId listenerId);

    void ReorderListeners();


    size_t GetAnyButtonDown(DeviceButtonSpec* outButtons, size_t maxButtonCount) const;

    unsigned GetDeviceCountByType(InputDevice::DeviceType type) const;
    int GetDisplayWidth() const { return displayWidth_; }
    int GetDisplayHeight() const { return displayHeight_; }

    ModifierId AddDeviceStateModifier(DeviceStateModifier* modifier);
    void RemoveDeviceStateModifier(ModifierId modifierId);

    void EnqueueConcurrentChange(InputDevice& device, InputState& state, InputDeltaState* delta, DeviceButtonId buttonId, bool value);
    void EnqueueConcurrentChange(InputDevice& device, InputState& state, InputDeltaState* delta, DeviceButtonId buttonId, float value);

    void ConnectForStateSync(const char* ip, unsigned port);
    void StartDeviceStateSync(DeviceId deviceId);

    void SetDebugRenderingEnabled(bool enabled);
    bool IsDebugRenderingEnabled() const { return debugRenderingEnabled_; }
    void SetDebugRenderer(DebugRenderer* debugRenderer);
    DebugRenderer* GetDebugRenderer() const { return debugRenderer_; }

private:
    Allocator& allocator_;

    DeviceMap devices_;
    unsigned nextDeviceId_;

    HashMap<ListenerId, InputListener*> listeners_;
    unsigned nextListenerId_;
    Array<InputListener*> sortedListeners_;

    HashMap<ModifierId, DeviceStateModifier*> modifiers_;
    unsigned nextModifierId_;

    InputDeltaState* deltaState_;

    uint64_t currentTime_;
    struct Change
    {
        InputDevice* device;
        InputState* state;
        InputDeltaState* delta;
        DeviceButtonId buttonId;
        ButtonType type;
        union
        {
            bool b;
            float f;
        };
    };
    
    GAINPUT_CONC_QUEUE(Change) concurrentInputs_;

    int displayWidth_;
    int displayHeight_;
    bool useSystemTime_;

    bool debugRenderingEnabled_;
    DebugRenderer* debugRenderer_;
    
    void DeviceCreated(InputDevice* device);

    // Do not copy.
    InputManager(const InputManager &);
    InputManager& operator=(const InputManager &);

};


template<class T>
inline
DeviceId
InputManager::CreateDevice(unsigned index, InputDevice::DeviceVariant variant)
{
    T* device = allocator_.New<T>(*this, nextDeviceId_, index, variant);
    devices_[nextDeviceId_] = device;
    DeviceCreated(device);
    return nextDeviceId_++;
}

template<class T>
inline
T*
InputManager::CreateAndGetDevice(unsigned index, InputDevice::DeviceVariant variant)
{
    T* device = allocator_.New<T>(*this, nextDeviceId_, index, variant);
    devices_[nextDeviceId_] = device;
    ++nextDeviceId_;
    DeviceCreated(device);
    return device;
}

inline
InputDevice*
InputManager::GetDevice(DeviceId deviceId)
{
    DeviceMap::iterator it = devices_.find(deviceId);
    if (it == devices_.end())
    {
        return 0;
    }
    return it->second;
}

inline
const InputDevice*
InputManager::GetDevice(DeviceId deviceId) const
{
    DeviceMap::const_iterator it = devices_.find(deviceId);
    if (it == devices_.end())
    {
        return 0;
    }
    return it->second;
}


class DeviceStateModifier
{
public:

    virtual void Update(InputDeltaState* delta) = 0;
};

}

#endif