unity3d
Vector3

前書き

構文

• public Vector3（）;
• public Vector3（float x、float y）;
• public Vector3（浮動小数点数x、浮動小数点数y、浮動小数点数z）。
• Vector3.Lerp（Vector3 startPosition、Vector3 targetPosition、float movementFraction）;
• Vector3.LerpUnclamped（Vector3 startPosition、Vector3 targetPosition、float movementFraction）;
• Vector3.MoveTowards（Vector3 startPosition、Vector3 targetPosition、浮動距離）。

静的値

Vector3構造体には、よく使用されるVector3値を提供するいくつかの静的変数が含まれています。ほとんどが方向性を表していますが 、追加機能を提供するために創造的に使用できます。

Vector3.zeroおよびVector3.one

Vector3.zeroとVector3.oneは通常、 正規化された Vector3に接続して使用されます。つまり、 Vector3 x 、 y及びzの値がこのように1の大きさを有するが、 Vector3.zero一方、最も低い値を示しVector3.one最大値を表します。

Vector3.zeroは、オブジェクト変換のデフォルトの位置を設定するためによく使用されます。

次のクラスでは、 Vector3.zeroとVector3.oneを使用して球体を膨張させて収縮させます。

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

静的な方向

静的な方向は、3つの軸すべての正および負に沿った方向を伴う多くの用途において有用であり得る。 Unityは方向に影響する左手座標系を採用することに注意することが重要です。

次のクラスでは、静的なVector3方向を使用して3つの軸に沿ってオブジェクトを移動します。

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

インデックス

Vector3の作成

Vector3構造はいくつかの方法で作成できます。 Vector3は構造体なので、通常は使用前にインスタンス化する必要があります。

コンストラクタ

Vector3をインスタンス化するためのコンストラクタが3つ組み込まれています。

Vector2またはVector4からの変換

まれている間、あなたはの座標治療する必要があるだろうな状況に遭遇するかもしれVector2またはVector4ような構造Vector3 。このような場合、あなたは簡単に渡すことができますVector2またはVector4直接にVector3以前にそれをインスタンス化せずに、。仮定すると、 Vector2構造体はxとy値だけを渡し、 Vector4クラスはそのwを省略します。

以下のスクリプトで直接変換を見ることができます。

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

運動を適用する

Vector3構造体には、 Vector3動きを適用するときに有用な静的関数が含まれています。

LerpとLerpUnclamped

lerp関数は、指定された割合に基づいて2つの座標間の移動を提供します。 Lerpが2つの座標間の移動のみを許可する場合、 LerpUnclampedは2つの座標の境界の外側に移動する分数をLerpUnclampedます。

私たちは、移動の割合をfloatとして提供します。値が0.5場合、2つのVector3の座標の中間点が見つかります。値が0または1第一又は第二戻りますVector3これらの値は（従って第1復帰ない動きに相関のいずれかとして、respectivleyをVector3 ）、または完了動き（これは第2復帰Vector3 ）。どちらの機能も運動量の変化に対応しないことに注意することが重要です。これは手動で説明する必要があります。

Lerpでは、すべての値が0と1間でクランプされ0 。これは、方向に向かって動きを提供したい場合に便利です。また、目的地をオーバーシュートしたくない場合にも便利です。 LerpUnclampedは任意の値をとることができ、目的地から離れるか、目的地を越えて移動するために使用できます。

次のスクリプトは、 LerpとLerpUnclampedを使用してオブジェクトを一定のペースで移動します。

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はLerp 非常によく似ています。コアの違いは、2つのポイントの間の部分ではなく、移動する実際の距離を提供することです。 MoveTowardsはターゲットVector3拡張されないことに注意することが重要Vector3 。

LerpUnclamped場合と同様に、ターゲットVector3から遠ざかるように負の距離値を指定することができます。このような場合、ターゲットVector3を決して通過しないので、動きは不定です。このような場合、ターゲットVector3を「反対方向」として扱うことができます。 Vector3が開始Vector3に対して同じ方向を指しているVector3 、負の動きは通常のように動作するはずです。

次のスクリプトは、 MoveTowardsを使用して、スムーズな距離を使用してオブジェクトのグループを一連の位置に移動します。

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はスムージングをMoveTowardsだMoveTowards変種と考えてください。公式の文書によると、この機能は、スムーズなカメラフォローを行うために最も一般的に使用されます。

開始およびターゲットのVector3座標にVector3て、ベロシティを表すVector3と、移動を完了するのに必要なおよその時間を表すfloatも提供する必要があります。前の例とは異なり、我々は内部的にインクリメントされるべき基準として速度を提供する。これをメモすることが重要です。機能を実行している間に機能の速度を変更すると、機能が望ましくない結果になる可能性があります。

必要な変数に加えて、オブジェクトの最大速度を表すfloatと、オブジェクトへの前回のSmoothDamp呼び出し以降の時間ギャップを表すfloatを提供することもできます。これらの値を提供する必要はありません。デフォルトでは最大速度はなく、時間差はTime.deltaTimeと解釈されTime.deltaTime 。さらに重要なことに、 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);
    }
}