unity3d
Vector3

Einführung

Syntax

• public Vector3 ();
• public Vector3 (Float x, Float y);
• public Vector3 (float x, float y, float z);
• Vector3.Lerp (Vector3 startPosition, Vector3 targetPosition, Float-BewegungFraktion);
• Vector3.LerpUnclamped (Vector3 startPosition, Vector3 targetPosition, Float-BewegungFraction);
• Vector3.MoveTowards (Vector3 startPosition, Vector3 targetPosition, Schwimmdistanz);

Statische Werte

Die Vector3 Struktur enthält einige statische Variablen, die häufig verwendete Vector3 Werte Vector3 . Die meisten stellen eine Richtung dar , aber sie können immer noch kreativ verwendet werden, um zusätzliche Funktionen bereitzustellen.

Vector3.zero und Vector3.one

Vector3.zero und Vector3.one werden normalerweise in Verbindung mit einem normalisierten Vector3 . ein Vector3 bei dem die x , y und z Werte eine Stärke von 1 haben. Vector3.zero stellt Vector3.zero den niedrigsten Wert dar, während Vector3.one den größten Wert darstellt.

Vector3.zero wird auch häufig verwendet, um die Standardposition bei Objekttransformationen Vector3.zero .

Die folgende Klasse verwendet Vector3.zero und Vector3.one zum Aufblasen und Vector3.one einer Kugel.

using UnityEngine;

public class Inflater : MonoBehaviour 
{
    <summary>A sphere set up to inflate and deflate between two values.</summary>
    public ScaleBetween sphere;

    ///<summary>On start, set the sphere GameObject up to inflate
    /// and deflate to the corresponding values.</summary>
    void Start()
    {
        // Vector3.zero = Vector3(0, 0, 0); Vector3.one = Vector3(1, 1, 1);
        sphere.SetScale(Vector3.zero, Vector3.one);
    }
}

Statische Anweisungen

Die statischen Richtungen können in einer Reihe von Anwendungen nützlich sein, wobei die Richtung entlang der positiven und negativen Richtung aller drei Achsen liegt. Es ist wichtig zu wissen, dass Unity ein linkshändiges Koordinatensystem verwendet, das die Richtung beeinflusst.

Die folgende Klasse verwendet die statischen Vector3 Richtungen, um Objekte entlang der drei Achsen zu verschieben.

using UnityEngine;

public class StaticMover : MonoBehaviour 
{
    <summary>GameObjects set up to move back and forth between two directions.</summary>
    public MoveBetween xMovement, yMovement, zMovement;

    ///<summary>On start, set each MoveBetween GameObject up to move
    /// in the corresponding direction(s).</summary>
    void Start()
    {
        // Vector3.left = Vector3(-1, 0, 0); Vector3.right = Vector3(1, 0, 0);
        xMovement.SetDirections(Vector3.left, Vector3.right);

        // Vector3.down = Vector3(0, -1, 0); Vector3.up = Vector3(0, 0, 1);
        yMovement.SetDirections(Vector3.down, Vector3.up);

        // Vector3.back = Vector3(0, 0, -1); Vector3.forward = Vector3(0, 0, 1);
        zMovement.SetDirections(Vector3.back, Vector3.forward);
    }
}

Index

Einen Vector3 erstellen

Eine Vector3 Struktur kann auf verschiedene Arten erstellt werden. Vector3 ist eine Struktur und muss daher normalerweise vor der Verwendung instanziiert werden.

Konstrukteure

Es gibt drei eingebaute Konstruktoren zum Instantiieren eines Vector3 .

Konvertieren von einem Vector2 oder Vector4

In seltenen Vector2 können Sie auf Situationen Vector2 in denen Sie die Koordinaten einer Vector2 oder Vector4 Struktur als Vector3 . In solchen Fällen können Sie den Vector2 oder Vector4 einfach direkt in den Vector3 , ohne ihn vorher zu instantiieren. Wie sollte davon ausgegangen werden, ein Vector2 nur struct passieren x und y - Werte, während eine Vector4 Klasse seine auslassen wird w .

Wir können die direkte Konvertierung im folgenden Skript sehen.

void VectorConversionTest()
{
    Vector2 vector2 = new Vector2(50, 100);
    Vector4 vector4 = new Vector4(50, 100, 200, 400);

    Vector3 fromVector2 = vector2;
    Vector3 fromVector4 = vector4;

    Debug.Log("Vector2 conversion: " + fromVector2);
    Debug.Log("Vector4 conversion: " + fromVector4);
}

Bewegung anwenden

Die Vector3 Struktur enthält einige statische Funktionen, die Vector3 sind, wenn Sie eine Bewegung auf den Vector3 anwenden Vector3 .

Lerp und LerpUnclamped

Die Lerp-Funktionen sorgen für eine Bewegung zwischen zwei Koordinaten basierend auf einem bereitgestellten Bruchteil. LerpUnclamped Lerp nur eine Bewegung zwischen den beiden Koordinaten LerpUnclamped erlaubt LerpUnclamped Brüche, die sich außerhalb der Grenzen zwischen den beiden Koordinaten bewegen.

Den Bewegungsanteil stellen wir als float bereit. Mit einem Wert von 0.5 finden wir den Mittelpunkt zwischen den beiden Vector3 -Koordinaten. Ein Wert von 0 oder 1 gibt den ersten oder zweiten Vector3 zurück, da diese Werte entweder mit keiner Bewegung korrelieren (und somit den ersten Vector3 ) oder eine abgeschlossene Bewegung (die den zweiten Vector3 ). Es ist wichtig zu beachten, dass keine der Funktionen für die Änderung des Bewegungsanteils geeignet ist. Dies müssen wir manuell berücksichtigen.

Bei Lerp werden alle Werte zwischen 0 und 1 geklemmt. Dies ist nützlich, wenn wir uns in eine Richtung bewegen möchten und das Ziel nicht überschreiten möchten. LerpUnclamped kann einen beliebigen Wert annehmen und kann verwendet werden, um sich vom Ziel weg oder am Ziel vorbei zu LerpUnclamped .

Das folgende Skript verwendet Lerp und LerpUnclamped , um ein Objekt in einem gleichmäßigen Tempo zu verschieben.

using UnityEngine;

public class Lerping : MonoBehaviour
{
    /// <summary>The red box will use Lerp to move. We will link
    /// this object in via the inspector.</summary>
    public GameObject lerpObject;
    /// <summary>The starting position for our red box.</summary>
    public Vector3 lerpStart = new Vector3(0, 0, 0);
    /// <summary>The end position for our red box.</summary>
    public Vector3 lerpTarget = new Vector3(5, 0, 0);

    /// <summary>The blue box will use LerpUnclamped to move. We will 
    /// link this object in via the inspector.</summary>
    public GameObject lerpUnclampedObject;
    /// <summary>The starting position for our blue box.</summary>
    public Vector3 lerpUnclampedStart = new Vector3(0, 3, 0);
    /// <summary>The end position for our blue box.</summary>
    public Vector3 lerpUnclampedTarget = new Vector3(5, 3, 0);

    /// <summary>The current fraction to increment our lerp functions by.</summary>
    public float lerpFraction = 0;

    private void Update()
    {
        // First, I increment the lerp fraction. 
        // delaTime * 0.25 should give me a value of +1 every second.
        lerpFraction += (Time.deltaTime * 0.25f);

        // Next, we apply the new lerp values to the target transform position.
        lerpObject.transform.position 
            = Vector3.Lerp(lerpStart, lerpTarget, lerpFraction);
        lerpUnclampedObject.transform.position 
            = Vector3.LerpUnclamped(lerpUnclampedStart, lerpUnclampedTarget, lerpFraction);
    }
}

MoveTowards

MoveTowards verhält sich ähnlich wie Lerp ; Der Hauptunterschied besteht darin, dass wir eine tatsächliche Entfernung angeben, anstatt einen Bruch zwischen zwei Punkten. Es ist wichtig zu MoveTowards , dass MoveTowards sich nicht über das Ziel Vector3 .

Ähnlich wie bei LerpUnclamped können wir einen negativen Abstandswert LerpUnclamped , um sich vom Ziel Vector3 . In solchen Fällen bewegen wir uns niemals am Ziel Vector3 und somit ist die Bewegung unbestimmt. In diesen Fällen können wir das Ziel Vector3 als "entgegengesetzte Richtung" behandeln. Solange der Vector3 in die gleiche Richtung Vector3 , sollte sich die negative Bewegung relativ zum Start Vector3 wie normal verhalten.

Das folgende Skript verwendet MoveTowards , um eine Gruppe von Objekten mit einem geglätteten Abstand zu einer Gruppe von Positionen zu verschieben.

using UnityEngine;
    
public class MoveTowardsExample : MonoBehaviour
{
    /// <summary>The red cube will move up, the blue cube will move down, 
    /// the green cube will move left and the yellow cube will move right.
    /// These objects will be linked via the inspector.</summary>
    public GameObject upCube, downCube, leftCube, rightCube;
    /// <summary>The cubes should move at 1 unit per second.</summary>
    float speed = 1f;

    void Update()
    {
        // We determine our distance by applying a deltaTime scale to our speed.
        float distance = speed * Time.deltaTime;

        // The up cube will move upwards, until it reaches the 
        //position of (Vector3.up * 2), or (0, 2, 0).
        upCube.transform.position 
            = Vector3.MoveTowards(upCube.transform.position, (Vector3.up * 2f), distance);

        // The down cube will move downwards, as it enforces a negative distance..
        downCube.transform.position
            = Vector3.MoveTowards(downCube.transform.position, Vector3.up * 2f, -distance);

        // The right cube will move to the right, indefinetly, as it is constantly updating
        // its target position with a direction based off the current position.
        rightCube.transform.position = Vector3.MoveTowards(rightCube.transform.position, 
            rightCube.transform.position + Vector3.right, distance);

        // The left cube does not need to account for updating its target position, 
        // as it is moving away from the target position, and will never reach it.
        leftCube.transform.position
            = Vector3.MoveTowards(leftCube.transform.position, Vector3.right, -distance);
    }
}

SmoothDamp

SmoothDamp Sie sich SmoothDamp als eine Variante von MoveTowards mit integrierter Glättung vor. Laut offizieller Dokumentation wird diese Funktion am häufigsten verwendet, um eine reibungslose Kameraführung zu ermöglichen.

Neben den Start- und Ziel- Vector3 Koordinaten müssen wir auch einen Vector3 , um die Geschwindigkeit darzustellen, und einen float der die ungefähre Zeit darstellt, die die Bewegung benötigt. Im Gegensatz zu vorherigen Beispielen geben wir die Geschwindigkeit als Referenz an , um sie intern zu erhöhen. Es ist wichtig, dies zu beachten, da das Ändern der Geschwindigkeit außerhalb der Funktion, während wir die Funktion noch ausführen, zu unerwünschten Ergebnissen führen kann.

Zusätzlich zu den erforderlichen Variablen, können wir auch einen float die maximale Geschwindigkeit unseres Objektes zu repräsentieren, und einen float den Zeitabstand seit dem letzten darstellen SmoothDamp Aufruf an das Objekt. Wir müssen diese Werte nicht angeben . Standardmäßig gibt es keine Höchstgeschwindigkeit, und die Zeitlücke wird als Time.deltaTime interpretiert. Noch wichtiger ist, wenn Sie die Funktion eins pro Objekt innerhalb einer MonoBehaviour.Update() Funktion MonoBehaviour.Update() , müssen Sie keine MonoBehaviour.Update() .

using UnityEngine;
    
public class SmoothDampMovement : MonoBehaviour
{
    /// <summary>The red cube will imitate the default SmoothDamp function. 
    /// The blue cube will move faster by manipulating the "time gap", while 
    /// the green cube will have an enforced maximum speed. Note that these 
    /// objects have been linked via the inspector.</summary>
    public GameObject smoothObject, fastSmoothObject, cappedSmoothObject;

    /// <summary>We must instantiate the velocities, externally, so they may 
    /// be manipulated from within the function. Note that by making these 
    /// vectors public, they will be automatically instantiated as Vector3.Zero 
    /// through the inspector. This also allows us to view the velocities, 
    /// from the inspector, to observe how they change.</summary>
    public Vector3 regularVelocity, fastVelocity, cappedVelocity;

    /// <summary>Each object should move 10 units along the X-axis.</summary>
    Vector3 regularTarget = new Vector3(10f, 0f);
    Vector3 fastTarget = new Vector3(10f, 1.5f);
    Vector3 cappedTarget = new Vector3(10f, 3f);

    /// <summary>We will give a target time of 5 seconds.</summary>
    float targetTime = 5f;

    void Update()
    {
        // The default SmoothDamp function will give us a general smooth movement.
        smoothObject.transform.position = Vector3.SmoothDamp(smoothObject.transform.position,
            regularTarget, ref regularVelocity, targetTime);

        // Note that a "maxSpeed" outside of reasonable limitations should not have any 
        // effect, while providing a "deltaTime" of 0 tells the function that no time has 
        // passed since the last SmoothDamp call, resulting in no movement, the second time.
        smoothObject.transform.position = Vector3.SmoothDamp(smoothObject.transform.position,
            regularTarget, ref regularVelocity, targetTime, 10f, 0f);

        // Note that "deltaTime" defaults to Time.deltaTime due to an assumption that this 
        // function will be called once per update function. We can call the function 
        // multiple times during an update function, but the function will assume that enough
        // time has passed to continue the same approximate movement. As a result, 
        // this object should reach the target, quicker.
        fastSmoothObject.transform.position = Vector3.SmoothDamp(
            fastSmoothObject.transform.position, fastTarget, ref fastVelocity, targetTime);
        fastSmoothObject.transform.position = Vector3.SmoothDamp(
            fastSmoothObject.transform.position, fastTarget, ref fastVelocity, targetTime);

        // Lastly, note that a "maxSpeed" becomes irrelevant, if the object does not 
        // realistically reach such speeds. Linear speed can be determined as 
        // (Distance / Time), but given the simple fact that we start and end slow, we can 
        // infer that speed will actually be higher, during the middle. As such, we can
        // infer that a value of (Distance / Time) or (10/5) will affect the 
        // function. We will half the "maxSpeed", again, to make it more noticeable.
        cappedSmoothObject.transform.position = Vector3.SmoothDamp(
            cappedSmoothObject.transform.position, 
            cappedTarget, ref cappedVelocity, targetTime, 1f);
    }
}