CUInput.h

//
//  CUInput.h
//  Cornell University Game Library (CUGL)
//
//  This class is an event dispatcher that works as a singleton service.  That
//  is, it is singleton that allows us to access a modular collection of other
//  singletons (in this case input devices) that implement a common interface.
//  This makes sense for singletons that need flexible functionality like input
//  devices and asset managers.
//
//  We use templates to completely decouple the input devices from this class.
//  That is, this class does not need to know the type of any new input device.
//  Instead, you attach the devices by a template, which hashes the device by
//  the type id.  When the user requests a device, the type of the device is
//  hashed to retrieve the singleton.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 7/8/16
 
#ifndef __CU_INPUT_H__
#define __CU_INPUT_H__
 
#include <cugl/base/CUBase.h>
#include <cugl/util/CUTimestamp.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <typeindex>
 
#ifndef UINT32_MAX
#define UINT32_MAX  (0xffffffff)
#endif
 
namespace cugl {
    
class InputDevice;
 
#pragma mark -
 
class Input {
#pragma mark Values
protected:
    static Input* _singleton;
    
    Timestamp _reference;
    Uint32 _roffset;
    
    std::unordered_map<std::type_index, InputDevice*> _devices;
    
    std::unordered_map<Uint32,std::unordered_set<std::type_index>> _subscribers;
 
#pragma mark Constructor
 
    Input()  {}
    
    ~Input() { shutdown(); }
 
#pragma mark Application Access
 
    static bool start();
 
    static void stop();
    
    static Input* get();
 
    void clear();
 
    bool update(SDL_Event event);
    
    // All of the above methods should only be accessed by this class
    friend class Application;
 
#pragma mark Internal Helpers
 
    bool registerDevice(std::type_index key, InputDevice* input);
    
    InputDevice* unregisterDevice(std::type_index key);
    
    void shutdown();
 
 
#pragma mark Service Access
public:
    template <typename T>
    static T* get() {
        if (!_singleton) { return nullptr; }
        std::type_index indx = std::type_index(typeid(T));
        auto it = _singleton->_devices.find(indx);
        if (it != _singleton->_devices.end()) {
            return static_cast<T*>(it->second);
        }
        return nullptr;
    }
    
    template <typename T>
    static inline bool activate() {
        if (!_singleton) { return false; }
        std::type_index indx = std::type_index(typeid(T));
        auto it = _singleton->_devices.find(indx);
        // Return true if we are already active
        if (it != _singleton->_devices.end()) {
            return true;
        } else {
            T* alloc = new T();
            // Fail gracefully if the user gave us a bad class.
            if (alloc->init() && _singleton->registerDevice(indx,dynamic_cast<InputDevice*>(alloc))) {
                return true;
            } else {
                delete alloc;
            }
        }
        return false;
    }
    
    template <typename T>
    static bool deactivate() {
        if (!_singleton) { return false; }
        std::type_index indx = std::type_index(typeid(T));
        auto it = _singleton->_devices.find(indx);
        // Fail if we are not active
        if (it != _singleton->_devices.end()) {
            delete static_cast<T*>(_singleton->unregisterDevice(indx));
            return true;
        }
        return false;
    }
 
};
 
 
#pragma mark -
 
class InputDevice {
protected:
    Uint32 _focus;
 
public:
    static const Uint32 RESERVED_KEY = UINT32_MAX;
    
    Uint32 currentFocus() const { return _focus; }
    
    virtual bool requestFocus(Uint32 key) { _focus = key; return true; }
    
    void releaseFocus() { _focus = RESERVED_KEY; }
 
protected:
    InputDevice() : _focus(UINT32_MAX) {}
 
    virtual ~InputDevice() { }
 
    virtual bool init() { return true; }
 
    virtual void dispose() {}
    
    virtual void clearState() = 0;
    
    virtual bool updateState(const SDL_Event& event, const Timestamp& stamp) = 0;
    
    virtual void queryEvents(std::vector<Uint32>& eventset) = 0;
    
    // Only Input can access these methods.
    friend class Input;
};
    
}
 
#endif /* __CU_INPUT_H__ */