unity3d
Vector3

Invoering

Syntaxis

• openbare Vector3 ();
• public Vector3 (float x, float y);
• public Vector3 (float x, float y, float z);
• Vector3.Lerp (Vector3 startPosition, Vector3 targetPosition, float movementFraction);
• Vector3.LerpUnclamped (Vector3 startPosition, Vector3 targetPosition, float movementFraction);
• Vector3.MoveTowards (Vector3 startPosition, Vector3 targetPosition, floatafstand);

Statische waarden

De Vector3 structuur bevat enkele statische variabelen die veelgebruikte Vector3 waarden bieden. De meeste vertegenwoordigen een richting , maar ze kunnen nog steeds creatief worden gebruikt om extra functionaliteit te bieden.

Vector3.zero en Vector3.one

Vector3.zero en Vector3.one worden meestal gebruikt in verband met een genormaliseerde Vector3 ; dat wil zeggen een Vector3 waarbij de x , y en z waarden een grootte van 1 hebben. Als zodanig vertegenwoordigt Vector3.zero de laagste waarde, terwijl Vector3.one de grootste waarde vertegenwoordigt.

Vector3.zero wordt ook vaak gebruikt om de standaardpositie op Vector3.zero te stellen.

De volgende klasse gebruikt Vector3.zero en Vector3.one om een bol op te blazen en Vector3.one te laten.

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 aanwijzingen

De statische richtingen kunnen nuttig zijn in een aantal toepassingen, met een richting langs de positieve en negatieve van alle drie de assen. Het is belangrijk op te merken dat Unity een linkshandig coördinatensysteem hanteert, dat invloed heeft op de richting.

De volgende klasse gebruikt de statische Vector3 richtingen om objecten langs de drie assen te verplaatsen.

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);
    }
}

Inhoudsopgave

Een vector maken3

Een Vector3 structuur kan op verschillende manieren worden gemaakt. Vector3 is een struct en moet als zodanig meestal vóór gebruik worden geïnstantieerd.

constructors

Er zijn drie ingebouwde constructeurs voor het instantiëren van een Vector3 .

Converteren van een Vector2 of Vector4

Hoewel zeldzaam, kun je situaties Vector2 waarin je de coördinaten van een Vector2 of Vector4 structuur als een Vector3 zou moeten behandelen. In dergelijke gevallen kunt u de Vector2 of Vector4 rechtstreeks in de Vector3 , zonder hem vooraf te instantiëren. Zoals moet worden aangenomen, zal een Vector2 structuur alleen x en y waarden doorgeven, terwijl een Vector4 klasse zijn w Vector4 .

We kunnen directe conversie zien in het onderstaande script.

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);
}

Beweging toepassen

De Vector3 structuur bevat een aantal statische functies die Vector3 kunnen zijn wanneer we beweging op de Vector3 willen toepassen.

Lerp en LerpUnclamped

De lerp-functies zorgen voor beweging tussen twee coördinaten op basis van een opgegeven fractie. Waar Lerp alleen beweging tussen de twee coördinaten toestaat, staat LerpUnclamped breuken toe die buiten de grenzen tussen de twee coördinaten bewegen.

We bieden de fractie van beweging als een float . Met een waarde van 0.5 vinden we het middelpunt tussen de twee Vector3 -coördinaten. Een waarde van 0 of 1 retourneert de eerste of tweede Vector3 , respectievelijk, omdat deze waarden ofwel correleren met geen beweging (dus de eerste Vector3 ), of voltooide beweging (dit retourneert de tweede Vector3 ). Het is belangrijk op te merken dat geen van beide functies geschikt is voor verandering in de bewegingsfractie. Dit is iets waar we handmatig rekening mee moeten houden.

Met Lerp worden alle waarden tussen 0 en 1 geklemd. Dit is handig wanneer we beweging in een richting willen bieden en de bestemming niet voorbij willen schieten. LerpUnclamped kan elke waarde aannemen en kan worden gebruikt om beweging weg van de bestemming of voorbij de bestemming te bieden.

Het volgende script gebruikt Lerp en LerpUnclamped om een object in een consistent tempo te verplaatsen.

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 gedraagt zich zeer vergelijkbaar met Lerp ; het kernverschil is dat we een werkelijke afstand bieden om te bewegen, in plaats van een breuk tussen twee punten. Het is belangrijk op te merken dat MoveTowards zich niet voorbij het doel Vector3 .

Net als bij LerpUnclamped , kunnen we een negatieve afstandswaarde bieden om weg te gaan van het doel Vector3 . In dergelijke gevallen gaan we nooit voorbij het doel Vector3 , en dus is beweging onbeperkt. In deze gevallen kunnen we het doel Vector3 als een "tegengestelde richting" behandelen; zolang de Vector3 in dezelfde richting wijst, ten opzichte van de start Vector3 , zou negatieve beweging zich normaal moeten gedragen.

Het volgende script gebruikt MoveTowards om een groep objecten met een afgevlakte afstand naar een set posities te verplaatsen.

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

Beschouw SmoothDamp als een variant van MoveTowards met ingebouwde smoothing. Volgens officiële documentatie wordt deze functie meestal gebruikt om vloeiende camerabewaking uit te voeren.

Samen met de start en target Vector3 coördinaten moeten wij ook een Vector3 om de snelheid representeren, en een float die de geschatte tijd neemt om de beweging te voltooien. In tegenstelling tot eerdere voorbeelden bieden we de snelheid als referentie , intern op te voeren. Het is belangrijk om hier rekening mee te houden, omdat het veranderen van de snelheid buiten de functie terwijl we de functie nog uitvoeren, ongewenste resultaten kan hebben.

Naast de vereiste variabelen, kunnen we ook een float om de maximale snelheid van ons object weer te geven, en een float om de tijdsverschil weer te geven sinds de vorige SmoothDamp aanroep naar het object. We hoeven niet om deze waarden te verstrekken; standaard is er geen maximumsnelheid en wordt het tijdsverschil geïnterpreteerd als Time.deltaTime . Wat nog belangrijker is, als je belt de functie één per object in een MonoBehaviour.Update() functie, moet je niet nodig om een tijd kloof verklaren.

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);
    }
}