CUMouse.h

//
//  CUMouse.h
//  Cornell University Game Library (CUGL)
//
//  This class provides basic mouse support. While SDL combines mouse and touch
//  support into the same interface, we do not.  All touches are handled by
//  the Touchscreen class.
//
//  This class is a singleton and should never be allocated directly.  It
//  should only be accessed via the Input dispatcher.
//
//  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/9/16
 
#ifndef __CU_MOUSE_H__
#define __CU_MOUSE_H__
 
#include <cugl/input/CUInput.h>
#include <cugl/math/CURect.h>
#include <cugl/math/CUVec2.h>
 
#define SDL_BUTTON_ALLMASK ((1 << 6) - 1)
 
namespace cugl {
    
#pragma mark -
 
class ButtonState {
private:
    Uint32 _state;
 
public:
#pragma mark Constructors
 
    ButtonState() : _state(0) { }
 
    ButtonState(Uint32 state) { _state = state; }
 
#pragma mark Buttons
 
    bool hasLeft() const    { return (_state & SDL_BUTTON_LMASK) != 0;  }
 
    bool hasMiddle() const  { return (_state & SDL_BUTTON_MMASK) != 0;  }
 
    bool hasRight() const   { return (_state & SDL_BUTTON_RMASK) != 0;  }
 
    bool hasX1() const      { return (_state & SDL_BUTTON_X1MASK) != 0; }
    
    bool hasX2() const      { return (_state & SDL_BUTTON_X2MASK) != 0; }
    
    void setLeft(bool value)    { toggle(SDL_BUTTON_LMASK,value);   }
 
    void setMiddle(bool value)  { toggle(SDL_BUTTON_MMASK,value);   }
 
    void setRight(bool value)   { toggle(SDL_BUTTON_RMASK,value);   }
    
    void setX1(bool value)      { toggle(SDL_BUTTON_X1MASK,value);  }
 
    void setX2(bool value)      { toggle(SDL_BUTTON_X2MASK,value);  }
 
    
#pragma mark Bitwise Operations
 
    ButtonState& operator&=(ButtonState mouse) {
        _state &= mouse._state;
        return *this;
    }
 
    ButtonState& operator|=(ButtonState mouse) {
        _state |= mouse._state;
        return *this;
    }
 
    ButtonState& operator^=(ButtonState mouse) {
        _state ^= mouse._state;
        return *this;
    }
    
    ButtonState& operator-=(ButtonState mouse) {
        _state &= ~mouse._state;
        return *this;
    }
 
    const ButtonState operator&(ButtonState mouse) const {
        return ButtonState(_state & mouse._state);
    }
 
    const ButtonState operator|(ButtonState mouse) const {
        return ButtonState(_state | mouse._state);
    }
 
    const ButtonState operator^(ButtonState mouse) const {
        return ButtonState(_state ^ mouse._state);
    }
 
    const ButtonState operator-(ButtonState mouse) const {
        return ButtonState(_state & ~mouse._state);
    }
 
    const ButtonState operator~() const {
        return ButtonState(~_state & SDL_BUTTON_ALLMASK);
    }
 
private:
    void toggle(Uint32 bmask, bool value) {
        _state = (value ? _state | bmask : _state & ~bmask);
    }
    
    // Allow MouseEvent direct access
    friend class MouseEvent;
};
    
#pragma mark -
    
class MouseEvent {
public:
    Timestamp timestamp;
    ButtonState buttons;
    Vec2 position;
    
    MouseEvent() {}
    
    MouseEvent(Uint32 state, const Vec2& point, const Timestamp& stamp) {
        buttons._state = state; timestamp = stamp; position = point;
    }
};
 
#pragma mark -
 
class MouseWheelEvent {
public:
    Timestamp timestamp;
    Vec2 direction;
    bool flipped;
    
    MouseWheelEvent() : flipped(false) {}
    
    MouseWheelEvent(const Vec2& offset, const Timestamp& stamp, bool flip=false) {
        direction = offset; timestamp = stamp; flipped = flip;
    }
 
};
 
#pragma mark -
#pragma mark Mouse
 
class Mouse : public InputDevice {
public:
    enum class PointerAwareness {
        BUTTON,
        DRAG,
        ALWAYS
    };
    
#pragma mark Listeners
 
    typedef std::function<void(const MouseEvent& event, Uint8 clicks, bool focus)> ButtonListener;
    
    typedef std::function<void(const MouseEvent& event, const Vec2& previous, bool focus)> MotionListener;
    
    typedef std::function<void(const MouseWheelEvent& event, bool focus)> WheelListener;
    
protected:
    PointerAwareness _awareness;
 
    ButtonState _lastState;
    ButtonState _currState;
    
    Vec2 _lastPoint;
    Vec2 _currPoint;
 
    Vec2 _wheelOffset;
    
    std::unordered_map<Uint32, ButtonListener> _pressListeners;
    std::unordered_map<Uint32, ButtonListener> _releaseListeners;
    std::unordered_map<Uint32, MotionListener> _moveListeners;
    std::unordered_map<Uint32, MotionListener> _dragListeners;
    std::unordered_map<Uint32, WheelListener> _wheelListeners;
 
#pragma mark Constructor
 
    Mouse() : InputDevice(), _awareness(PointerAwareness::BUTTON) {}
    
    virtual ~Mouse() { }
 
    virtual void dispose() override;
 
public:
    PointerAwareness getPointerAwareness() const { return _awareness; }
    
    void setPointerAwareness(PointerAwareness awareness) { _awareness = awareness; }
    
 
#pragma mark Data Polling
 
    ButtonState buttonDown() const { return _currState; }
    
    ButtonState buttonUp() const { return ~_currState; }
 
    ButtonState buttonPressed() const { return _currState-_lastState; }
 
    ButtonState buttonReleased() const { return _lastState-_currState; }
 
    Vec2 pointerPosition() const { return _currPoint; }
 
    Vec2 pointerOffset() const { return _currPoint-_lastPoint; }
 
    Vec2 wheelDirection() const { return _wheelOffset; }
    
#pragma mark Listeners
 
    virtual bool requestFocus(Uint32 key) override;
    
    bool isListener(Uint32 key) const;
    
    const ButtonListener getPressListener(Uint32 key) const;
    
    const ButtonListener getReleaseListener(Uint32 key) const;
 
    const MotionListener getDragListener(Uint32 key) const;
 
    const MotionListener getMotionListener(Uint32 key) const;
 
    const WheelListener getWheelListener(Uint32 key) const;
 
    bool addPressListener(Uint32 key, ButtonListener listener);
 
    bool addReleaseListener(Uint32 key, ButtonListener listener);
 
    bool addDragListener(Uint32 key, MotionListener listener);
 
    bool addMotionListener(Uint32 key, MotionListener listener);
 
    bool addWheelListener(Uint32 key, WheelListener listener);
 
    bool removePressListener(Uint32 key);
 
    bool removeReleaseListener(Uint32 key);
 
    bool removeDragListener(Uint32 key);
 
    bool removeMotionListener(Uint32 key);
 
    bool removeWheelListener(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_MOUSE_H__ */