Touch

Description
Structure describing the status of a finger touching the screen.
Devices can track a number of different pieces of data about a touch on a touchscreen,
including its phase (ie, whether it has just started, ended or moved), its position and
whether the touch was a single contact or several taps. Furthermore, the continuity of a
touch between frame updates can be detected by the device, so a consistent ID number can
be reported across frames and used to determine how a particular finger is moving.
The Touch struct is used by Unity to store data relating to a single touch instance and is
returned by the Input.GetTouch function. Fresh calls to GetTouch will be required on each
frame update to obtain the latest touch information from the device but the fingerID
property can be used to identify the same touch between frames.
See Also: Input.GetTouch, TouchPhase enum.
Variables
deltaPosition The position delta since last change.
deltaTime
Amount of time that has passed since the last recorded change in Touch
values.
fingerId The unique index for the touch.
phase Describes the phase of the touch.
position The position of the touch in pixel coordinates.
tapCount Number of taps.
Touch.deltaPosition
var deltaPosition: Vector2;
Description
The position delta since last change.
The absolute position of the touch is recorded periodically and available in the position
property. The deltaPosition value is a Vector2 that represents the difference between the
touch position recorded on the most recent update and that recorded on the previous update.
The deltaTime value gives the time that elapsed between the previous and current updates;
you can calculate the touch's speed of motion by dividing deltaPosition.magnitude by
deltaTime.
Touch.deltaTime
var deltaTime: float;
Description
Amount of time that has passed since the last recorded change in Touch values.
Values for the various touch properties are updated periodically. The deltaTime value is
simply the amount of time that elapsed between the previous update and the current one.
This is primarily useful for determining the movement speed of the touch position with
reference to deltaPosition.
var fingerId: int;
Description
The unique index for the touch.
All current touches are reported in the Input.touches array or by using the Input.GetTouch
function with the equivalent array index. However, the array index is not guaranteed to be
the same from one frame to the next. The fingerID value, however, consistently refers to
the same touch across frames. This ID value is very useful when analysing gestures and is
more reliable than identifying fingers by their proximity to previous position, etc.
Touch.phase
var phase: TouchPhase;
Description
Describes the phase of the touch.
The touch phase refers to the action the finger has taken on the most recent frame update.
Since a touch is tracked over its "lifetime" by the device, the start and end of a touch and
movements in between can be reported on the frames they occur. The phase property can
be used as the basis of a "switch' statement or as part of a more sophisitcated state handling
system.

var startPos: Vector2;
var direction: Vector2;
var directionChosen: boolean;
function Update () {
// Track a single touch as a direction control.
if (Input.touchCount > 0) {
var touch = Input.GetTouch(0);
// Handle finger movements based on touch phase.
switch (touch.phase) {
// Record initial touch position.
case TouchPhase.Began:
startPos = touch.position;
directionChosen = false;
break;
// Determine direction by comparing the current touch
// position with the initial one.
case TouchPhase.Moved:
direction = touch.position - startPos;
break;
// Report that a direction has been chosen when the finger is lifted.
case TouchPhase.Ended:
directionChosen = true;
break;
}
}


if (directionChosen) {
// Something that uses the chosen direction...
}
}
Touch.position
var position: Vector2;
Description
The position of the touch in pixel coordinates.
Touch.tapCount
var tapCount: int;
Description
Number of taps.
This is intended as a way to detect "double-clicks", etc, from the finger in a particular
position. In some circumstances, two fingers may be tapped alternately and this may
incorrectly register as a single finger tapping and simultaneously moving.
Input.acceleration

static var acceleration: Vector3;
Description
Last measured linear acceleration of a device in three-dimensional space. (Read Only)
// Move object using accelerometer
var speed = 10.0;







function Update () {
var dir : Vector3 = Vector3.zero;
// we assume that device is held parallel to the ground
// and Home button is in the right hand
// remap device acceleration axis to game coordinates:
// 1) XY plane of the device is mapped onto XZ plane
// 2) rotated 90 degrees around Y axis
dir.x = -Input.acceleration.y;
dir.z = Input.acceleration.x;
// clamp acceleration vector to unit sphere
if (dir.sqrMagnitude > 1)
dir.Normalize();

// Make it move 10 meters per second instead of 10 meters per frame...
dir *= Time.deltaTime;
// Move object
transform.Translate (dir * speed);
}
Input.touchCount
static var touchCount: int;
Description
Number of touches. Guaranteed not to change throughout the frame. (Read Only)

function Update () {
if (Input.touchCount > 0) {
print(Input.touchCount);
}
}
static var touches: Touch[];
Description
Returns list of objects representing status of all touches during last frame. (Read Only)
(Allocates temporary variables).
Each entry represents a status of a finger touching the screen.
// Prints number of fingers touching the screen
function Update () {
var fingerCount = 0;
for (var touch : Touch in Input.touches) {
if (touch.phase != TouchPhase.Ended && touch.phase
!= TouchPhase.Canceled)
fingerCount++;
}
if (fingerCount > 0)
print ("User has " + fingerCount + " finger(s)
touching the screen");
}
Input.GetTouch

static function GetTouch(index: int): Touch;
Description
Returns object representing status of a specific touch. (Does not allocate temporary
variables).
// Moves object according to finger movement on the screen
var speed : float = 0.1;
function Update () {
if (Input.touchCount > 0 &&
Input.GetTouch(0).phase == TouchPhase.Moved) {

// Get movement of the finger since last frame
var touchDeltaPosition:Vector2 = Input.GetTouch(0).deltaPosition;
// Move object across XY plane
transform.Translate (-touchDeltaPosition.x * speed,-touchDeltaPosition.y
* speed, 0);
}
}
Another example:
// Instantiates a projectile whenever the user taps on the screen
var projectile : GameObject;
function Update () {
for (var i = 0; i < Input.touchCount; ++i) {
if (Input.GetTouch(i).phase == TouchPhase.Began) {
clone = Instantiate (projectile,
transform.position, transform.rotation);
}
}
}
// Shoot a ray whenever the user taps on the screen
var particle : GameObject;
function Update () {
for (var i = 0; i < Input.touchCount; ++i) {
if (Input.GetTouch(i).phase == TouchPhase.Began) {
// Construct a ray from the current touch
coordinates
var ray = Camera.main.ScreenPointToRay
(Input.GetTouch(i).position);
if (Physics.Raycast (ray)) {
// Create a particle if hit
Instantiate (particle,
transform.position, transform.rotation);
}
}
}
}

TouchPhase
Description
Describes phase of a finger touch.
Variables
Began A finger touched the screen.
Moved A finger moved on the screen.
Stationary A finger is touching the screen but hasn't moved.
Ended A finger was lifted from the screen. This is the final phase of a touch.
Canceled The system cancelled tracking for the touch.
The OnTouch* event handlers are all declared public virtual void and passes the Touch
parameter. Meaning, each event handler could be called multiple times per Update()
depending on how many touches there are (Input.touchCount). We can treat each touch
separately by taking note of the finger id that comes with the touch.



All the while, I thought the touch phases have the following state diagram

Unfortunately, upon testing over and over again, it is POSSIBLE to start with Moved or
Ended! I havent noticed if it could start with Stationary since I dont use it for my projects
at the moment. But my point here is that the Began phase CAN BE SKIPPED! Im not
sure if this is intentional but its happening and it got me pulling my hair for the past couple
of days.
Im using an object pool in my project where the objects react to touch. When the user
touches, an object is created, lets call that Object 0. When the user touches again, another
object is created called Object 1. If Object 0 gets disabled (as part of the game mechanic)
and the user touches again, Object 0 will be re-intialized and treated as something new.
Objects dont get destroyed, rather, they become disabled. This is basically how object
pooling works.

Touch Phase

Touching into 3D


Moving 3D object

Drag and Rotate




Acelerometro


Orientacion

Input.deviceOrientation

static var deviceOrientation: DeviceOrientation;
Description
Device physical orientation as reported by OS. (Read Only)
// Play a sound if screen is facing downwards
function Update () {
if (Input.deviceOrientation == DeviceOrientation.FaceDown)
audio.Play();
}
Description
Describes physical orientation of the device as determined by the OS.
If device is physically situated between discrete positions, as when (for example) rotated
diagonally, system will report Unknown orientation.
Variables
Unknown The orientation of the device cannot be determined.
Portrait
The device is in portrait mode, with the device held upright and the
home button at the bottom.
PortraitUpsideDown
The device is in portrait mode but upside down, with the device held
upright and the home button at the top.
LandscapeLeft
The device is in landscape mode, with the device held upright and the
home button on the right side.
LandscapeRight
The device is in landscape mode, with the device held upright and the
home button on the left side.
FaceUp
The device is held parallel to the ground with the screen facing
upwards.
FaceDown
The device is held parallel to the ground
with the screen facing downwards.