 |
CUGL 2.1
Cornell University Game Library
|
|
CUGL 2.1
Cornell University Game Library
|
#include <CUPanGesture.h>
Public Types | |
| typedef std::function< void(const PanEvent &event, bool focus)> | Listener |
Public Member Functions | |
| bool | isTouchScreen () const |
| void | setTouchScreen (bool flag) |
| bool | isFingerSensitive () const |
| void | setFingerSensitive (bool flag) |
| bool | isActive () const |
| const Vec2 | getDelta () const |
| const Vec2 | getPan () const |
| const Vec2 | getPosition () const |
| int | getFingers () const |
| virtual bool | requestFocus (Uint32 key) override |
| bool | isListener (Uint32 key) const |
| const Listener | getBeginListener (Uint32 key) const |
| const Listener | getEndListener (Uint32 key) const |
| const Listener | getChangeListener (Uint32 key) const |
| bool | addBeginListener (Uint32 key, Listener listener) |
| bool | addEndListener (Uint32 key, Listener listener) |
| bool | addChangeListener (Uint32 key, Listener listener) |
| bool | removeBeginListener (Uint32 key) |
| bool | removeEndListener (Uint32 key) |
| bool | removeChangeListener (Uint32 key) |
 Public Member Functions inherited from cugl::InputDevice | |
| Uint32 | acquireKey () |
| Uint32 | currentFocus () const |
| void | releaseFocus () |
Protected Member Functions | |
| PanGesture () | |
| virtual | ~PanGesture () |
| bool | init () |
| virtual void | dispose () override |
| virtual void | clearState () override |
| virtual bool | updateState (const SDL_Event &event, const Timestamp &stamp) override |
| Vec2 | getScaledPosition (float x, float y) |
| virtual void | queryEvents (std::vector< Uint32 > &eventset) override |
| Protected Member Functions inherited from cugl::InputDevice | |
| InputDevice () | |
| virtual | ~InputDevice () |
| bool | initWithName (const std::string name) |
Protected Attributes | |
| bool | _screen |
| bool | _active |
| bool | _fingery |
| float | _threshold |
| PanEvent | _event |
| std::unordered_map< Sint64, Vec2 > | _fingers |
| size_t | _updated |
| std::unordered_map< Uint32, Listener > | _beginListeners |
| std::unordered_map< Uint32, Listener > | _finishListeners |
| std::unordered_map< Uint32, Listener > | _motionListeners |
| Protected Attributes inherited from cugl::InputDevice | |
| std::string | _name |
| Uint32 | _focus |
| Uint32 | _nextKey |
Friends | |
| class | Input |
Additional Inherited Members | |
| Static Public Attributes inherited from cugl::InputDevice | |
| static const Uint32 | RESERVED_KEY = UINT32_MAX |
This class is an input device recognizing pan events.
A pan is a gesture where two or more fingers are moved together across the touch device. If the pan is done very quickly, it is often called a swipe. Most UX designers assign different meanings to pans, depending on the number of fingers involved. For example, on Apple devices, two fingers is used to scroll while three moves to a new page.
This input device is a touch device that supports multitouch gestures. This is often the screen itself, but this is not always guaranteed. For example, the trackpad on MacBooks support pans. For that reason, we cannot guarantee that the touches scale with the display. Instead, all gesture information is normalized, with the top left corner of the touch device being (0,0) and the lower right being (1,1).
If you know that the touch device is the screen, and would like to measure the pan in screen coordinates, you should set the screen attribute to true with setTouchScreen. In this case, the pan distance will be scaled to the display. In those cases where the device is known to be the screen (Android, iOS devices), this value starts out as true.
As with most devices, we provide support for both listeners and polling the mouse. Polling the device will query the touch screen at the start of the frame, but it may miss those case in there are multiple pan updates in a single animation frame.
Listeners are guaranteed to catch all changes in the pan position, as long as they are detected by the OS. However, listeners are not called as soon as the event happens. Instead, the events are queued and processed at the start of the animation frame, before the method Application#update(float) is called.
This type represents a listener for a pan in the PanGesture class.
In CUGL, listeners are implemented as a set of callback functions, not as objects. This allows each listener to implement as much or as little functionality as it wants. A listener is identified by a key which should be a globally unique unsigned int.
While pan listeners do not traditionally require focus like a keyboard does, we have included that functionality. While only one listener can have focus at a time, all listeners will receive input from the PanInput device.
The function type is equivalent to
std::function<void(const PanEvent& event, bool focus)>
| event | The touch event for this pan event |
| focus | Whether the listener currently has focus |
|
protected |
Creates and initializes a new pan input device.
WARNING: Never allocate a pan input device directly. Always use the Input#activate() method instead.
|
inlineprotectedvirtual |
Deletes this input device, disposing of all resources
| bool cugl::PanGesture::addBeginListener | ( | Uint32 | key, |
| Listener | listener | ||
| ) |
Adds a pan begin listener for the given object key
There can only be one listener for a given key. If there is already a listener for the key, the method will fail and return false. You must remove a listener before adding a new one for the same key.
This listener is invoked when pan crosses the distance threshold.
| key | The identifier for the listener |
| listener | The listener to add |
| bool cugl::PanGesture::addChangeListener | ( | Uint32 | key, |
| Listener | listener | ||
| ) |
Adds a pan change listener for the given object key
There can only be one listener for a given key. If there is already a listener for the key, the method will fail and return false. You must remove a listener before adding a new one for the same key.
This listener is invoked when the pan position changes.
| key | The identifier for the listener |
| listener | The listener to add |
| bool cugl::PanGesture::addEndListener | ( | Uint32 | key, |
| Listener | listener | ||
| ) |
Adds a pan end listener for the given object key
There can only be one listener for a given key. If there is already a listener for the key, the method will fail and return false. You must remove a listener before adding a new one for the same key.
This listener is invoked when all (but one) fingers in an active pan are released.
| key | The identifier for the listener |
| listener | The listener to add |
|
overrideprotectedvirtual |
Clears the state of this input device, readying it for the next frame.
Many devices keep track of what happened "this" frame. This method is necessary to advance the frame.
Implements cugl::InputDevice.
|
overrideprotectedvirtual |
Unintializes this device, returning it to its default state
An uninitialized device may not work without reinitialization.
Reimplemented from cugl::InputDevice.
| const Listener cugl::PanGesture::getBeginListener | ( | Uint32 | key | ) | const |
Returns the pan begin listener for the given object key
This listener is invoked when pan crosses the distance threshold.
If there is no listener for the given key, it returns nullptr.
| key | The identifier for the listener |
| const Listener cugl::PanGesture::getChangeListener | ( | Uint32 | key | ) | const |
Returns the pan change listener for the given object key
This listener is invoked when the pan position changes.
| key | The identifier for the listener |
|
inline |
Returns the change in the pan position since the last animation frame.
| const Listener cugl::PanGesture::getEndListener | ( | Uint32 | key | ) | const |
Returns the pan end listener for the given object key
This listener is invoked when all (but one) fingers in an active pan are released.
If there is no listener for the given key, it returns nullptr.
| key | The identifier for the listener |
|
inline |
Returns the number of fingers involved in the pan gesture.
This value may change over the course of the pan gesture. However, there are always guaranteed to be at least two fingers.
| const Vec2 cugl::PanGesture::getPan | ( | ) | const |
Returns the cumulative pan vector since the gesture began.
|
inline |
Returns the current position of the pan.
This position is computed as the centroid of all of the fingers involved in the pan.
|
protected |
Returns the scale/unscaled touch position.
The value returned depends on the value of attribute _screen. If this attribute is false, the position is normalized to the unit square. Otherwise it is scaled to the touch screen.
|
inlineprotected |
Initializes this device, acquiring any necessary resources
|
inline |
Returns true if the device is in the middle of an active pan.
If the device is not an in active pan, all other polling methods will return the default value.
|
inline |
Returns true if changing the number of fingers interrupts the pan
This only affects the listener interface. When using the polling interface, it is up to the application to determine when a pan starts and stops.
| bool cugl::PanGesture::isListener | ( | Uint32 | key | ) | const |
Returns true if key represents a listener object
An object is a listener if it is a listener for any of the three actions: pan begin, pan end, or pan change.
| key | The identifier for the listener |
|
inline |
Returns true if this device is a touch screen.
This device is not guaranteed to be a touch screen. For example, the trackpad on MacBooks support pans. We do try to make our best guess about whether or not a device is a touch screen, but on some devices this may need to be set manually.
If this value is true, all pan information will scale with the display. Otherwise, the pan will be normalized to a unit square, where the top left corner of the touch device is (0,0) and the lower right is (1,1). You may want to set this value to false for true cross-platform gesture support.
|
overrideprotectedvirtual |
Determine the SDL events of relevance and store there types in eventset.
An SDL_EventType is really Uint32. This method stores the SDL event types for this input device into the vector eventset, appending them to the end. The Input dispatcher then uses this information to set up subscriptions.
| eventset | The set to store the event types. |
Implements cugl::InputDevice.
| bool cugl::PanGesture::removeBeginListener | ( | Uint32 | key | ) |
Removes the pan begin listener for the given object key
If there is no active listener for the given key, this method fails and returns false.
This listener is invoked when pan crosses the distance threshold.
| key | The identifier for the listener |
| bool cugl::PanGesture::removeChangeListener | ( | Uint32 | key | ) |
Removes the pan change listener for the given object key
If there is no active listener for the given key, this method fails and returns false.
This listener is invoked when the pan position changes.
| key | The identifier for the listener |
| bool cugl::PanGesture::removeEndListener | ( | Uint32 | key | ) |
Removes the pan end listener for the given object key
If there is no active listener for the given key, this method fails and returns false.
This listener is invoked when all (but one) fingers in an active pan are released.
| key | The identifier for the listener |
|
overridevirtual |
Requests focus for the given identifier
Only a listener can have focus. This method returns false if key does not refer to an active listener
| key | The identifier for the focus object |
Reimplemented from cugl::InputDevice.
|
inline |
Sets whether changing the number of fingers interrupts the pan
This only affects the listener interface. When using the polling interface, it is up to the application to determine when a pan starts and stops.
| flag | Whether changing the number of fingers interrupts the pan |
| void cugl::PanGesture::setTouchScreen | ( | bool | flag | ) |
Sets whether this device is a touch screen.
This device is not guaranteed to be a touch screen. For example, the trackpad on MacBooks support pans. We do try to make our best guess about whether or not a device is a touch screen, but on some devices this may need to be set manually.
If this value is true, all pan information will scale with the display. Otherwise, the pan will be normalized to a unit square, where the top left corner of the touch device is (0,0) and the lower right is (1,1). You may want to set this value to false for true cross-platform gesture support.
| flag | Whether this device is a touch screen. |
|
overrideprotectedvirtual |
Processes an SDL_Event
The dispatcher guarantees that an input device only receives events that it subscribes to.
| event | The input event to process |
| stamp | The event timestamp in CUGL time |
Implements cugl::InputDevice.
|
protected |
Whether or not there is an active pan being processed
|
protected |
The set of listeners called whenever a pan begins
|
protected |
The pan event data (stored whether or not there is an event)
|
protected |
The current finger positions
|
protected |
Whether or not the pan is sensitive to the number of fingers
|
protected |
The set of listeners called whenever a pan ends
|
protected |
The set of listeners called whenever a pan is moved
|
protected |
Whether or not this input device is a touch screen
|
protected |
The distance threshold for generating a pan event
|
protected |
The number of fingers updated this pass
1.8.16