 |
CUGL 2.0
Cornell University Game Library
|
|
CUGL 2.0
Cornell University Game Library
|
#include <CUPinchInput.h>
Public Types | |
| typedef std::function< void(const PinchEvent &event, bool focus)> | Listener |
Public Member Functions | |
| bool | isTouchScreen () const |
| void | setTouchScreen (bool flag) |
| float | getThreshold () const |
| void | setThreshold (float threshold) |
| bool | isActive () const |
| float | getDelta () const |
| float | getPinch () const |
| int | getFingers () const |
| const Vec2 | getPosition () 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 | |
| PinchInput () | |
| virtual | ~PinchInput () |
| bool | init () |
| virtual void | dispose () override |
| virtual void | clearState () override |
| virtual bool | updateState (const SDL_Event &event, const Timestamp &stamp) override |
| 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 |
| float | _threshold |
| PinchEvent | _event |
| std::unordered_map< Uint32, Listener > | _beginListeners |
| std::unordered_map< Uint32, Listener > | _finishListeners |
| std::unordered_map< Uint32, Listener > | _changeListeners |
| 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 pinch/zoom events.
A pinch is a gesture where two or more fingers are pulled apart or brought closure together. Technically the latter is a pinch while the former is a zoom. However, most UX designers lump these two gestures together.
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 pinches. 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 pinch in screen coordinates, you should set the screen attribute to true with setTouchScreen. In this case, the pinch distance will be scaled according to the minor axis of the display (so a vertical pinch and a horizontal pinch will have the same value even though the number of pixels along each axis is not the same). In those cases where the device is known to be the screen (Android, iOS devices), this value starts out as true.
SDL treats pinches, rotations, and pans as all the same gesture. The only way to distinguish them is with the treshold factor. This tells the system to ignore small gestures.
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 pinch changes in a single animation frame.
Listeners are guaranteed to catch all changes in the pinch size, 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 pinch/zoom in the PinchInput 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 pinch 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 PinchInput device.
The function type is equivalent to
std::function<void(const PinchEvent& event, bool focus)>
| event | The touch event for this pinch/zoom |
| focus | Whether the listener currently has focus |
|
protected |
Creates and initializes a new pinch input device.
WARNING: Never allocate a pinch input device directly. Always use the Input#activate() method instead.
|
inlineprotectedvirtual |
Deletes this input device, disposing of all resources
| bool cugl::PinchInput::addBeginListener | ( | Uint32 | key, |
| Listener | listener | ||
| ) |
Adds a pinch 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 pinch crosses the distance threshold.
| key | The identifier for the listener |
| listener | The listener to add |
| bool cugl::PinchInput::addChangeListener | ( | Uint32 | key, |
| Listener | listener | ||
| ) |
Adds a pinch 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 pinch distance changes.
| key | The identifier for the listener |
| listener | The listener to add |
| bool cugl::PinchInput::addEndListener | ( | Uint32 | key, |
| Listener | listener | ||
| ) |
Adds a pinch 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 pinch 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::PinchInput::getBeginListener | ( | Uint32 | key | ) | const |
Returns the pinch begin listener for the given object key
This listener is invoked when pinch 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::PinchInput::getChangeListener | ( | Uint32 | key | ) | const |
Returns the pinch change listener for the given object key
This listener is invoked when the pinch distance changes.
| key | The identifier for the listener |
|
inline |
Returns the change in the pinch distance since the last animation frame.
This value is positive if the pinch is a zoom, and negative if it is a true pinch.
| const Listener cugl::PinchInput::getEndListener | ( | Uint32 | key | ) | const |
Returns the pinch end listener for the given object key
This listener is invoked when all (but one) fingers in an active pinch 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 pinch gesture.
This value may change over the course of the pinch gesture. However, there are always guaranteed to be at least two fingers.
|
inline |
Returns the cumulative pinch distance since the gesture began.
This value is positive if the pinch is a zoom, and negative if it is a true pinch. A pinch can both zoom and pinch in a single gesture.
|
inline |
Returns the normalized center of the pinch.
This value may change over the course of the pinch gesture.
|
inline |
Returns the distance threshold for pinch events.
SDL treats pinches, rotations, and pans as all the same gesture. The only way to distinguish them is with the treshold factor. A pinch that covers less distance than the threshold will not be recorded. This tells the system to ignore small gestures.
|
inlineprotected |
Initializes this device, acquiring any necessary resources
|
inline |
Returns true if the device is in the middle of an active pinch.
If the device is not an in active pinch, all other polling methods will return the default value.
| bool cugl::PinchInput::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: pinch begin, pinch end, or pinch 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 pinches. 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 pinch information will scale with the display. Otherwise, the pinch 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::PinchInput::removeBeginListener | ( | Uint32 | key | ) |
Removes the pinch 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 pinch crosses the distance threshold.
| key | The identifier for the listener |
| bool cugl::PinchInput::removeChangeListener | ( | Uint32 | key | ) |
Removes the pinch 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 pinch distance changes.
| key | The identifier for the listener |
| bool cugl::PinchInput::removeEndListener | ( | Uint32 | key | ) |
Removes the pinch 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 pinch 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.
| void cugl::PinchInput::setThreshold | ( | float | threshold | ) |
Sets the distance threshold for pinch events.
SDL treats pinches, rotations, and pans as all the same gesture. The only way to distinguish them is with the treshold factor. A pinch that covers less distance than the threshold will not be recorded. This tells the system to ignore small gestures.
| threshold | The distance threshold for pinch events. |
| void cugl::PinchInput::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 pinches. 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 pinch information will scale with the display. Otherwise, the pinch 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 pinch being processed
|
protected |
The set of listeners called whenever a pinch begins
|
protected |
The set of listeners called whenever a pinch is moved
|
protected |
The pinch event data (stored whether or not there is an event)
|
protected |
The set of listeners called whenever a pinch ends
|
protected |
Whether or not this input device is a touch screen
|
protected |
The movement threshold for generating a pinch event
1.8.16