CUTouchscreen.h

//
//  CUTouchscreen.h
//  Cornell University Game Library (CUGL)
//
//  This class provides basic touch support. While it supports multitouch, it
//  only receives one touch per event.  For complex multitouch events (such as
//  gestures) you should use GestureInput instead.
//
//  This class is a singleton and should never be allocated directly.  It
//  should only be accessed via the Input dispatcher.
//
//  CUGL zlib 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/12/16

#ifndef __CU_TOUCHSCREEN_H__
#define __CU_TOUCHSCREEN_H__

#include "CUInput.h"
#include <cugl/math/CURect.h>

namespace cugl {

#define CU_INVALID_TOUCH    -1

#pragma mark -
    
typedef Sint64 TouchID;

class TouchEvent {
public:
    Timestamp timestamp;
    TouchID touch;
    Vec2 position;
    float pressure;
    
    TouchEvent() : touch(-1), pressure(0) {}
    
    TouchEvent(TouchID finger, const Vec2& point, float force, const Timestamp& stamp) {
        touch = finger; position = point; pressure = force; timestamp = stamp;
    }
};

#pragma mark -
#pragma mark TouchListener

typedef std::function<void(const TouchEvent& event, bool focus)> TouchListener;

#pragma mark -
#pragma mark TouchMotionListener

typedef std::function<void(const TouchEvent& event, const Vec2& previous, bool focus)> TouchMotionListener;

#pragma mark -

class Touchscreen : public InputDevice {
protected:
    std::unordered_map<TouchID,Vec2> _previous;
    std::unordered_map<TouchID,Vec2> _current;
    
    std::unordered_map<Uint32, TouchListener> _beginListeners;
    std::unordered_map<Uint32, TouchListener> _finishListeners;
    std::unordered_map<Uint32, TouchMotionListener> _moveListeners;

    Touchscreen() : InputDevice() {}
    
    virtual ~Touchscreen() {}
    
    virtual void dispose() override;

#pragma mark Data Polling
public:
    bool touchDown(TouchID touch) const {
        return _current.find(touch) != _current.end();
    }
    
    bool touchPressed(TouchID touch) const {
        return (_current.find(touch) != _current.end() &&
                _previous.find(touch) == _previous.end());
    }
    
    bool touchReleased(TouchID touch) {
        return (_current.find(touch) == _current.end() &&
                _previous.find(touch) != _previous.end());
    }
    
    Vec2 touchPosition(TouchID touch) const;
    
    Vec2 touchOffset(TouchID touch) const;
    
    unsigned int touchCount() const { return (unsigned int)_current.size(); }

    const std::vector<TouchID> touchSet() const;
    
#pragma mark Listeners

    virtual bool requestFocus(Uint32 key) override;
    
    bool isListener(Uint32 key) const;
    
    const TouchListener getBeginListener(Uint32 key) const;
    
    const TouchListener getEndListener(Uint32 key) const;
    
    const TouchMotionListener getMotionListener(Uint32 key) const;
    
    bool addBeginListener(Uint32 key, TouchListener listener);
    
    bool addEndListener(Uint32 key, TouchListener listener);
    
    bool addMotionListener(Uint32 key, TouchMotionListener listener);

    bool removeBeginListener(Uint32 key);
    
    bool removeEndListener(Uint32 key);
    
    bool removeMotionListener(Uint32 key);
    
protected:
#pragma mark Input Device

    virtual void clearState() override;
    
    virtual bool updateState(const SDL_Event& event, const Timestamp& stamp) override;
    
    virtual void queryEvents(std::vector<Uint32>& eventset) override;
    
    // Apparently friends are not inherited
    friend class Input;
};

};

#endif /* __CU_TOUCHSCREEN_H__ */