Version: 2019.1
Input Convencional de Juego
Teclado móvil

Mobile device input

En dispositivos móviles, la clase Input ofrece acceso al input de la pantalla táctil, acelerómetro y geográfico/ubicación.

Acceso al teclado en los dispositivos móviles se proporciona a través de iOS keyboard.

Multi-touch screen

The iPhone, iPad and iPod Touch devices are capable of tracking up to five fingers touching the screen simultaneously. You can retrieve the status of each finger touching the screen during the last frame by accessing the Input.touches property array.

Los dispositivos Android no tienen un limite unificado en cuántos dedos pueden rastrear. En vez, esto varia de dispositivo en dispositivo y puede ser cualquiera desde dos dedos en dispositivos viejos hasta cinco dedos en algunos nuevos dispositivos.

Cada toque de dedo es representado por una estructura de dato Input.Touch:

Property: Description:
fingerId The unique index for a touch.
position The screen position of the touch.
deltaPosition The screen position change since the last frame.
deltaTime Amount of time that has passed since the last state change.
tapCount The iPhone/iPad screen is able to distinguish quick finger taps by the user. This counter will let you know how many times the user has tapped the screen without moving a finger to the sides. Android devices do not count number of taps, this field is always 1.
phase Describes the state of the touch, which can help you determine whether the user has just started to touch screen, just moved their finger or just lifted their finger.
Began A finger just touched the screen.
Moved A finger moved on the screen.
Stationary A finger is touching the screen but hasn’t moved since the last frame.
Ended A finger was lifted from the screen. This is the final phase of a touch.
Canceled The system cancelled tracking for the touch, as when (for example) the user puts the device to their face or more than five touches happened simultaneously. This is the final phase of a touch.

Here’s an example script that shoots a ray whenever the user taps on the screen:

using UnityEngine;

public class TouchInput : MonoBehaviour
{
    GameObject particle;

    void Update()
    {
        foreach(Touch touch in Input.touches)
        {
            if (touch.phase == TouchPhase.Began)
            {
                // Construct a ray from the current touch coordinates
                Ray ray = Camera.main.ScreenPointToRay(touch.position);
                if (Physics.Raycast(ray))
                {
                    // Create a particle if hit
                    Instantiate(particle, transform.position, transform.rotation);
                }
            }
        }
    }
}

Mouse simulation

Encima del soporte nativo táctil Unity iOS/Android proporciona una simulación de mouse. Usted puede utilizar una funcionalidad de mouse desde la clase estándar Input. Tenga en cuenta que dispositivos iOS/Android están diseñados para soportar múltiples toques de dedos. Utilizar la funcionalidad mouse, solo va a soportar un solo toque de dedo. También, el toque de dedo en dispositivos móviles se puede mover de una área a otra sin un movimiento entre ellos. La simulación de mouse en dispositivos móviles va a proporcionar movimiento, por lo que es muy diferente comparado a un input táctil. La recomendación es utilizar la simulación mouse durante un desarrollo temprano pero utilizar input táctil tan pronto como sea posible.

Acelerómetro

A medida que el dispositivo móvil se mueva, un acelerómetro integrado reporta una aceleración lineal. cambios a lo largo de los tres principales ejes en un espacio tridimensional. Aceleración a lo largo de cada eje es reportado directamente por el hardware como valores de una fuerza gravitacional(G-force values). Un valor de 1.0 representa una carga de aproximadamente +1g a lo largo del eje determinado mientras un valor de –1.0 representa –1g. Si mantiene el dispositivo en posición vertical (con el botón de inicio en el fondo) al frente de usted, el eje X es positivo a lo largo de la derecha, el eje Y es positivo directamente arriba, y el eje Z es apuntando positivamente hacia usted.

Usted puede recuperar el valor del acelerómetro accediendo a la propiedad Input.acceleration.

El siguiente es un ejemplo de script que moverá un objeto utilizando el acelerómetro:

using UnityEngine;

public class Accelerometer : MonoBehaviour
{
    float speed = 10.0f;

    void Update()
    {
        Vector3 dir = Vector3.zero;
        // we assume that the device is held parallel to the ground
        // and the Home button is in the right hand

        // remap the 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 the 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);
    }
}

Low-Pass Filter (Filtro de Paso Bajo)

Las lecturas de acelerómetros pueden ser bruscas y ruidosas. Aplicando filtro de paso bajo(low-pass filtering) en la señal le permite a usted suavizarlo y deshacerse de ruidos de alta frecuencia.

El siguiente script le muestra a usted cómo aplicar un filtro de paso bajo(low-pass filtering) a las lecturas del acelerómetro:

using UnityEngine;

public class LowPassFilterExample : MonoBehaviour
{
    float accelerometerUpdateInterval = 1.0f / 60.0f;
    float lowPassKernelWidthInSeconds = 1.0f;

    private float lowPassFilterFactor;
    private Vector3 lowPassValue = Vector3.zero;

    void Start()
    {
        lowPassFilterFactor = accelerometerUpdateInterval / lowPassKernelWidthInSeconds;
        lowPassValue = Input.acceleration;
    }

    private void Update()
    {
        lowPassValue = LowPassFilterAccelerometer(lowPassValue);
    }

    Vector3 LowPassFilterAccelerometer(Vector3 prevValue)
    {
        Vector3 newValue = Vector3.Lerp(prevValue, Input.acceleration, lowPassFilterFactor);
        return newValue;
    }
}

Cuanto mayor sea el valor de LowPassKernelWidthInSeconds, más lento será el valor filtrado convergiendo hacia la muestra del input actual (y vice versa).

Quisiera la mayor precisión posible al leer el acelerómetro. ¿Qué debo hacer?

Leyendo la variable deInput.acceleration no es igual al sampling del hardware. Puesto simplemente, Unity prueba el hardware a una frecuencia de 60Hz y almacena el resultado a una variable. En realidad, las cosas son un poco más complicadas – el sampling del acelerómetro no ocurre en un intervalo de tiempo consistente, si bajo cargas significativas de CPU. Como un resultado, el sistema puede reportar 2 ejemplos durante un cuadre, luego un ejemplo durante el siguiente cuadro.

Usted puede acceder a todas las mediciones realizadas por el acelerómetro durante el cuadro. El siguiente código ilustrará un simple promedio de todos los eventos del acelerómetro recolectados dentro el último cuadro:

public class AccelerationEvents : MonoBehaviour
{ 
    void Update()
    {
        GetAccelerometerValue();
    }

    Vector3 GetAccelerometerValue()
    {
        Vector3 acc = Vector3.zero;
        float period = 0.0f;

        foreach(AccelerationEvent evnt in Input.accelerationEvents)
        {
            acc += evnt.acceleration * evnt.deltaTime;
            period += evnt.deltaTime;
        }
        if (period > 0)
        {
            acc *= 1.0f / period;
        }
        return acc;
    }
}
Input Convencional de Juego
Teclado móvil