unity3d
Eingabesystem

Lesetaste drücken und Unterschied zwischen GetKey, GetKeyDown und GetKeyUp

Der Eingang muss von der Aktualisierungsfunktion gelesen werden.

Referenz für alle verfügbaren Keycode-Nummern .

1. Input.GetKey drücken mit Input.GetKey :

Input.GetKey gibt wiederholt true während der Benutzer den angegebenen Schlüssel gedrückt hält. Dies kann verwendet werden, um eine Waffe wiederholt abzufeuern, während Sie die angegebene Taste gedrückt halten. Unten ist ein Beispiel für das automatische Abschießen von Kugeln, wenn die Leertaste gedrückt gehalten wird. Der Spieler muss die Taste nicht immer wieder drücken und loslassen.

public GameObject bulletPrefab;
public float shootForce = 50f;

void Update()
{
    if (Input.GetKey(KeyCode.Space))
    {
        Debug.Log("Shooting a bullet while SpaceBar is held down");

        //Instantiate bullet
        GameObject bullet = Instantiate(bulletPrefab, transform.position, transform.rotation) as GameObject;

        //Get the Rigidbody from the bullet then add a force to the bullet
        bullet.GetComponent<Rigidbody>().AddForce(bullet.transform.forward * shootForce);
    }
}

2. Lesetaste drücken mit Input.GetKeyDown :

Input.GetKeyDown wird nur einmal wahr, wenn die angegebene Taste gedrückt wird. Dies ist der Hauptunterschied zwischen Input.GetKey und Input.GetKeyDown . Ein Beispiel dafür ist das Ein- und Ausschalten einer Benutzeroberfläche oder einer Taschenlampe oder eines Elements.

public Light flashLight;
bool enableFlashLight = false;

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        //Toggle Light 
        enableFlashLight = !enableFlashLight;
        if (enableFlashLight)
        {
            flashLight.enabled = true;
            Debug.Log("Light Enabled!");
        }
        else
        {
            flashLight.enabled = false;
            Debug.Log("Light Disabled!");
        }
    }
}

3. Lesetaste drücken mit Input.GetKeyUp :

Dies ist das genaue Gegenteil von Input.GetKeyDown . Es wird verwendet, um zu erkennen, wann der Tastendruck losgelassen / aufgehoben wird. Genau wie Input.GetKeyDown gibt es nur einmal true . Beispielsweise können Sie enable Licht enable wenn die Taste mit Input.GetKeyDown gedrückt wird, und das Licht deaktivieren, wenn die Taste mit Input.GetKeyUp .

public Light flashLight;
void Update()
{
    //Disable Light when Space Key is pressed
    if (Input.GetKeyDown(KeyCode.Space))
    {
        flashLight.enabled = true;
        Debug.Log("Light Enabled!");
    }

    //Disable Light when Space Key is released
    if (Input.GetKeyUp(KeyCode.Space))
    {
        flashLight.enabled = false;
        Debug.Log("Light Disabled!");
    }
}

Beschleunigungssensor lesen (Basic)

Input.acceleration wird zum Lesen des Beschleunigungssensors verwendet. Es gibt Vector3 als ein Ergebnis , das enthält x , y und z - Achse - Werte im 3D - Raum.

void Update()
{
    Vector3 acclerometerValue = rawAccelValue();
    Debug.Log("X: " + acclerometerValue.x + "  Y: " + acclerometerValue.y + "  Z: " + acclerometerValue.z);
}

Vector3 rawAccelValue()
{
    return Input.acceleration;
}

Beschleunigungssensor lesen (Advance)

Die Verwendung von Rohwerten direkt vom Beschleunigungssensor zum Bewegen oder Drehen eines GameObjects kann zu Problemen wie ruckartigen Bewegungen oder Vibrationen führen. Es wird empfohlen, die Werte vor der Verwendung zu glätten. Tatsächlich sollten die Werte des Beschleunigungssensors vor der Verwendung immer geglättet werden. Dies kann mit einem Tiefpassfilter erreicht werden. Vector3.Lerp kommt Vector3.Lerp zum Einsatz.

//The lower this value, the less smooth the value is and faster Accel is updated. 30 seems fine for this
const float updateSpeed = 30.0f;

float AccelerometerUpdateInterval = 1.0f / updateSpeed;
float LowPassKernelWidthInSeconds = 1.0f;
float LowPassFilterFactor = 0;
Vector3 lowPassValue = Vector3.zero;

void Start()
{
    //Filter Accelerometer
    LowPassFilterFactor = AccelerometerUpdateInterval / LowPassKernelWidthInSeconds;
    lowPassValue = Input.acceleration;
}

void Update()
{

    //Get Raw Accelerometer values (pass in false to get raw Accelerometer values)
    Vector3 rawAccelValue = filterAccelValue(false);
    Debug.Log("RAW X: " + rawAccelValue.x + "  Y: " + rawAccelValue.y + "  Z: " + rawAccelValue.z);

    //Get smoothed Accelerometer values (pass in true to get Filtered Accelerometer values)
    Vector3 filteredAccelValue = filterAccelValue(true);
    Debug.Log("FILTERED X: " + filteredAccelValue.x + "  Y: " + filteredAccelValue.y + "  Z: " + filteredAccelValue.z);
}

//Filter Accelerometer
Vector3 filterAccelValue(bool smooth)
{
    if (smooth)
        lowPassValue = Vector3.Lerp(lowPassValue, Input.acceleration, LowPassFilterFactor);
    else
        lowPassValue = Input.acceleration;

    return lowPassValue;
}

Beschleunigungssensor lesen (Präzision)

Lesen Sie den Beschleunigungssensor präzise ab.

In diesem Beispiel wird Speicher zugewiesen:

void Update()
{
    //Get Precise Accelerometer values 
    Vector3 accelValue = preciseAccelValue();
    Debug.Log("PRECISE X: " + accelValue.x + "  Y: " + accelValue.y + "  Z: " + accelValue.z);

}

Vector3 preciseAccelValue()
{
    Vector3 accelResult = Vector3.zero;
    foreach (AccelerationEvent tempAccelEvent in Input.accelerationEvents)
    {
        accelResult = accelResult + (tempAccelEvent.acceleration * tempAccelEvent.deltaTime);
    }
    return accelResult;
}

In diesem Beispiel wird kein Speicher zugewiesen:

void Update()
{
    //Get Precise Accelerometer values 
    Vector3 accelValue = preciseAccelValue();
    Debug.Log("PRECISE X: " + accelValue.x + "  Y: " + accelValue.y + "  Z: " + accelValue.z);

}

Vector3 preciseAccelValue()
{
    Vector3 accelResult = Vector3.zero;
    for (int i = 0; i < Input.accelerationEventCount; ++i)
    {
        AccelerationEvent tempAccelEvent = Input.GetAccelerationEvent(i);
        accelResult = accelResult + (tempAccelEvent.acceleration * tempAccelEvent.deltaTime);
    }
    return accelResult;
}

Beachten Sie, dass dies nicht gefiltert wird. Bitte sehen Sie hier, wie Sie die Beschleunigungsmesser-Werte glätten, um Rauschen zu entfernen.

Lesen Sie die Maustaste (Links, Mitte, Rechts)

Diese Funktionen werden verwendet, um Mausklicks zu überprüfen.

• Input.GetMouseButton(int button);
• Input.GetMouseButtonDown(int button);
• Input.GetMouseButtonUp(int button);

Sie haben alle den gleichen Parameter.

• 0 = Linke Maustaste.
• 1 = Klicken Sie mit der rechten Maustaste.
• 2 = mittlerer Mausklick.

GetMouseButton wird verwendet, um zu erkennen, wann die Maustaste gedrückt gehalten wird. Es wird true wenn die angegebene Maustaste gedrückt wird.

void Update()
{
    if (Input.GetMouseButton(0))
    {
        Debug.Log("Left Mouse Button Down");
    }

    if (Input.GetMouseButton(1))
    {
        Debug.Log("Right Mouse Button Down");
    }

    if (Input.GetMouseButton(2))
    {
        Debug.Log("Middle Mouse Button Down");
    }
}

GetMouseButtonDown wird verwendet, um festzustellen, wann ein Mausklick erfolgt. Wenn sie einmal gedrückt wird, wird true . Es wird erst dann wieder true zurückgegeben, wenn die Maustaste losgelassen und erneut gedrückt wird.

void Update()
{
    if (Input.GetMouseButtonDown(0))
    {
        Debug.Log("Left Mouse Button Clicked");
    }

    if (Input.GetMouseButtonDown(1))
    {
        Debug.Log("Right Mouse Button Clicked");
    }

    if (Input.GetMouseButtonDown(2))
    {
        Debug.Log("Middle Mouse Button Clicked");
    }
}

GetMouseButtonUp wird verwendet, um zu erkennen, wann die angegebene Maustaste losgelassen wird. Dies ist nur true wenn die angegebene Maustaste losgelassen wird. Um wieder wahr zu sein, muss es erneut gedrückt und losgelassen werden.

void Update()
{
    if (Input.GetMouseButtonUp(0))
    {
        Debug.Log("Left Mouse Button Released");
    }

    if (Input.GetMouseButtonUp(1))
    {
        Debug.Log("Right Mouse Button Released");
    }

    if (Input.GetMouseButtonUp(2))
    {
        Debug.Log("Middle Mouse Button Released");
    }
}