表示 3D的 向量和点。

    这个结构用于在 Unity 传递 3D 位置和方向。它包含向量运算的函数。

    返回原向量的拷贝，并且它的模最大不超过maxLength所指示的长度。也就是说，限制向量长度到一个特定的长度。

    示例：

    Vector3.Dot 点乘

    两个向量的点乘积。点积是一个浮点型的值，两个向量的长度相乘，然后乘以它们之间夹角的余弦值。对于normalized向量，如果他们指向在完全相同的方向，Dot返回1。如果他们指向完全相反的方向，返回-1。对于其他的情况返回一个数（例如：如果是垂直的Dot返回0）。

    示例：

    2.     using System.Collections;
    4.     public class ExampleClass : MonoBehaviour {
    5.         public Transform other;
    6.         void Update() {
    7.             if (other) {
    8.                 Vector3 forward = transform.TransformDirection(Vector3.forward);
    9.                 Vector3 toOther = other.position - transform.position;
    10.                 if (Vector3.Dot(forward, toOther) < 0)
    11.                     print("The other transform is behind me!");
    13.             }
    14.         }
    15.     }

    Vector3.Cross 叉乘

    示例：

    1.     using UnityEngine;
    2.     using System.Collections;
    4.     public class ExampleClass : MonoBehaviour {
    5.         Vector3 GetNormal(Vector3 a, Vector3 b, Vector3 c) {
    6.             Vector3 side1 = b - a;
    7.             Vector3 side2 = c - a;
    8.             return Vector3.Cross(side1, side2).normalized;
    9.         }
    10.     }

    两个向量之间的线性插值。按照分数t在from到to之间插值。这是最常用的寻找一点沿一条线的两个端点之间一些分数的方式（例如，在那些点之间逐渐移动一个对象）。这分数是在范围[ 0…1]。t是夹在 [0…1]之间，当t = 0时，返回from，当t = 1时，返回to。当t = 0.5 返回from和to的中间点。

    示例：

    Vector3.Slerp 球形差值

    两个向量之间的弧形插值通过t数值在from和to之间插值。这与线性内插之间的不同（即， “线性插值” ）是该向量被视为方向而不是空间中的点。返回的向量的方向是由角内插，其大小是from和to的幅度之间进行内插。

    示例：

    1.     using UnityEngine;
    2.     using System.Collections;
    4.     public class ExampleClass : MonoBehaviour {
    5.         public Transform sunrise;
    6.         public Transform sunset;
    7.         public float journeyTime = 1.0F;
    8.         private float startTime;
    10.         void Start() {
    11.             startTime = Time.time;
    12.         }
    14.         void Update() {
    15.             Vector3 center = (sunrise.position + sunset.position) * 0.5F;
    16.             center -= new Vector3(0, 1, 0);
    17.             Vector3 riseRelCenter = sunrise.position - center;
    18.             Vector3 setRelCenter = sunset.position - center;
    19.             float fracComplete = (Time.time - startTime) / journeyTime;
    20.             transform.position = Vector3.Slerp(riseRelCenter, setRelCenter, fracComplete);
    21.             transform.position += center;
    22.         }
    23.     }

    Vector3.MoveTowards

    当前的地点移向目标。这个函数的返回值是一个点maxdistancedelta单位更接近于目标/点沿着当前的和目标之间的线。如果目标是比maxdistancedelta /然后返回值将等于目标接近（即移动不会超过目标）。maxdistancedelta负值可以用来从目标推开该向量。

    1.     using UnityEngine;
    2.     using System.Collections;
    4.     public class ExampleClass : MonoBehaviour {
    5.         public Transform target;
    6.         public float speed;
    8.         void Update() {
    9.             float step = speed * Time.deltaTime;
    10.             transform.position = Vector3.MoveTowards(transform.position, target.position, step);
    11.         }
    12.     }

    随着时间的推移，逐渐改变一个向量朝向预期的目标。向量由一些像弹簧阻尼器函数平滑，这将永远不会超过。最常见的用途是相机平滑跟随。

    示例：

    Vector3.RotateTowards 转向

    当前的向量转向目标。

    这个函数类似于MoveTowards除了将向量被视为一个方向，而不是一个位置上。当前向量将被旋转朝向目标方向由maxRadiansDelta的角度，虽然会恰好落在目标，而不是超过。如果当前的大小和目标的是不同的，那么结果的幅度将被线性地旋转过程中进行插值。如果一个负值用于maxRadiansDelta ，向量会转离目标/直到它指向完全相反的方向，然后停止。

    示例：

    1.     using UnityEngine;
    2.     using System.Collections;
    4.     public class ExampleClass : MonoBehaviour {
    5.         public Transform target;
    6.         public float speed;
    8.         void Update() {
    9.             Vector3 targetDir = target.position - transform.position;
    10.             float step = speed * Time.deltaTime;
    11.             Vector3 newDir = Vector3.RotateTowards(transform.forward, targetDir, step, 0.0F);
    12.             Debug.DrawRay(transform.position, newDir, Color.red);
    13.             transform.rotation = Quaternion.LookRotation(newDir);
    14.         }
    15.     }

    源码

    1. using System;
    2. using System.Runtime.InteropServices;
    3. using scm = System.ComponentModel;
    4. using uei = UnityEngine.Internal;
    6. namespace UnityEngine
    7. {
    8.     // Representation of 3D vectors and points.
    9.     [StructLayout(LayoutKind.Sequential)]
    10.     public partial struct Vector3
    11.     {
    12.         public const float kEpsilon = 0.00001F;
    14.         // X component of the vector.
    15.         public float x;
    16.         // Y component of the vector.
    17.         public float y;
    18.         // Z component of the vector.
    19.         public float z;
    21.         // Linearly interpolates between two vectors.
    22.         public static Vector3 Lerp(Vector3 a, Vector3 b, float t)
    23.         {
    24.             t = Mathf.Clamp01(t);
    25.             return new Vector3(
    26.                 a.x + (b.x - a.x) * t,
    27.                 a.y + (b.y - a.y) * t,
    28.                 a.z + (b.z - a.z) * t
    29.                 );
    30.         }
    32.         // Linearly interpolates between two vectors without clamping the interpolant
    33.         public static Vector3 LerpUnclamped(Vector3 a, Vector3 b, float t)
    34.         {
    35.             return new Vector3(
    36.                 a.x + (b.x - a.x) * t,
    37.                 a.y + (b.y - a.y) * t,
    38.                 a.z + (b.z - a.z) * t
    39.                 );
    40.         }
    42.         // Moves a point /current/ in a straight line towards a /target/ point.
    43.         public static Vector3 MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta)
    44.         {
    45.             Vector3 toVector = target - current;
    46.             float dist = toVector.magnitude;
    47.             if (dist <= maxDistanceDelta || dist < float.Epsilon)
    48.                 return target;
    49.             return current + toVector / dist * maxDistanceDelta;
    50.         }
    52.         [uei.ExcludeFromDocs]
    53.         public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed)
    54.         {
    55.             float deltaTime = Time.deltaTime;
    56.             return SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
    58.         [uei.ExcludeFromDocs]
    59.         public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime)
    60.         {
    61.             float deltaTime = Time.deltaTime;
    63.             return SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
    64.         }
    66.         // Gradually changes a vector towards a desired goal over time.
    67.         public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, [uei.DefaultValue("Mathf.Infinity")]  float maxSpeed, [uei.DefaultValue("Time.deltaTime")]  float deltaTime)
    68.         {
    69.             smoothTime = Mathf.Max(0.0001F, smoothTime);
    70.             float omega = 2F / smoothTime;
    72.             float x = omega * deltaTime;
    73.             float exp = 1F / (1F + x + 0.48F * x * x + 0.235F * x * x * x);
    74.             Vector3 change = current - target;
    75.             Vector3 originalTo = target;
    77.             float maxChange = maxSpeed * smoothTime;
    78.             change = Vector3.ClampMagnitude(change, maxChange);
    79.             target = current - change;
    81.             Vector3 temp = (currentVelocity + omega * change) * deltaTime;
    82.             currentVelocity = (currentVelocity - omega * temp) * exp;
    83.             Vector3 output = target + (change + temp) * exp;
    85.             if (Vector3.Dot(originalTo - current, output - originalTo) > 0)
    86.             {
    87.                 output = originalTo;
    88.                 currentVelocity = (output - originalTo) / deltaTime;
    89.             }
    91.             return output;
    92.         }
    94.         // Access the x, y, z components using [0], [1], [2] respectively.
    95.         public float this[int index]
    96.         {
    97.             get
    98.             {
    99.                 switch (index)
    100.                 {
    101.                     case 0: return x;
    102.                     case 1: return y;
    103.                     case 2: return z;
    104.                     default:
    105.                         throw new IndexOutOfRangeException("Invalid Vector3 index!");
    106.                 }
    107.             }
    109.             set
    110.             {
    111.                 switch (index)
    112.                 {
    113.                     case 0: x = value; break;
    114.                     case 1: y = value; break;
    115.                     case 2: z = value; break;
    116.                     default:
    117.                         throw new IndexOutOfRangeException("Invalid Vector3 index!");
    118.                 }
    119.             }
    120.         }
    122.         // Creates a new vector with given x, y, z components.
    123.         public Vector3(float x, float y, float z) { this.x = x; this.y = y; this.z = z; }
    124.         // Creates a new vector with given x, y components and sets /z/ to zero.
    125.         public Vector3(float x, float y) { this.x = x; this.y = y; z = 0F; }
    127.         // Set x, y and z components of an existing Vector3.
    128.         public void Set(float newX, float newY, float newZ) { x = newX; y = newY; z = newZ; }
    130.         // Multiplies two vectors component-wise.
    131.         public static Vector3 Scale(Vector3 a, Vector3 b) { return new Vector3(a.x * b.x, a.y * b.y, a.z * b.z); }
    133.         // Multiplies every component of this vector by the same component of /scale/.
    134.         public void Scale(Vector3 scale) { x *= scale.x; y *= scale.y; z *= scale.z; }
    136.         // Cross Product of two vectors.
    137.         public static Vector3 Cross(Vector3 lhs, Vector3 rhs)
    138.         {
    139.             return new Vector3(
    140.                 lhs.y * rhs.z - lhs.z * rhs.y,
    141.                 lhs.z * rhs.x - lhs.x * rhs.z,
    142.                 lhs.x * rhs.y - lhs.y * rhs.x);
    143.         }
    145.         // used to allow Vector3s to be used as keys in hash tables
    146.         public override int GetHashCode()
    147.         {
    148.             return x.GetHashCode() ^ (y.GetHashCode() << 2) ^ (z.GetHashCode() >> 2);
    149.         }
    151.         // also required for being able to use Vector3s as keys in hash tables
    152.         public override bool Equals(object other)
    153.         {
    154.             if (!(other is Vector3)) return false;
    156.             Vector3 rhs = (Vector3)other;
    157.             return x.Equals(rhs.x) && y.Equals(rhs.y) && z.Equals(rhs.z);
    158.         }
    160.         // Reflects a vector off the plane defined by a normal.
    161.         public static Vector3 Reflect(Vector3 inDirection, Vector3 inNormal)
    162.         {
    163.             return -2F * Dot(inNormal, inDirection) * inNormal + inDirection;
    164.         }
    166.         // *undoc* --- we have normalized property now
    167.         public static Vector3 Normalize(Vector3 value)
    168.         {
    169.             float mag = Magnitude(value);
    170.             if (mag > kEpsilon)
    171.                 return value / mag;
    172.             else
    173.                 return zero;
    174.         }
    176.         // Makes this vector have a ::ref::magnitude of 1.
    177.         public void Normalize()
    178.         {
    179.             float mag = Magnitude(this);
    180.             if (mag > kEpsilon)
    181.                 this = this / mag;
    182.             else
    183.                 this = zero;
    184.         }
    186.         // Returns this vector with a ::ref::magnitude of 1 (RO).
    187.         public Vector3 normalized { get { return Vector3.Normalize(this); } }
    189.         // Dot Product of two vectors.
    190.         public static float Dot(Vector3 lhs, Vector3 rhs) { return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z; }
    192.         // Projects a vector onto another vector.
    193.         public static Vector3 Project(Vector3 vector, Vector3 onNormal)
    194.         {
    195.             float sqrMag = Dot(onNormal, onNormal);
    196.             if (sqrMag < Mathf.Epsilon)
    197.             else
    199.         }
    201.         // Projects a vector onto a plane defined by a normal orthogonal to the plane.
    202.         public static Vector3 ProjectOnPlane(Vector3 vector, Vector3 planeNormal)
    203.         {
    204.             return vector - Project(vector, planeNormal);
    205.         }
    207.         // Returns the angle in degrees between /from/ and /to/. This is always the smallest
    208.         public static float Angle(Vector3 from, Vector3 to)
    209.         {
    210.             return Mathf.Acos(Mathf.Clamp(Vector3.Dot(from.normalized, to.normalized), -1F, 1F)) * Mathf.Rad2Deg;
    211.         }
    213.         // The smaller of the two possible angles between the two vectors is returned, therefore the result will never be greater than 180 degrees or smaller than -180 degrees.
    214.         // If you imagine the from and to vectors as lines on a piece of paper, both originating from the same point, then the /axis/ vector would point up out of the paper.
    215.         // The measured angle between the two vectors would be positive in a clockwise direction and negative in an anti-clockwise direction.
    216.         public static float SignedAngle(Vector3 from, Vector3 to, Vector3 axis)
    217.         {
    218.             Vector3 fromNorm = from.normalized, toNorm = to.normalized;
    219.             float unsignedAngle = Mathf.Acos(Mathf.Clamp(Vector3.Dot(fromNorm, toNorm), -1F, 1F)) * Mathf.Rad2Deg;
    220.             float sign = Mathf.Sign(Vector3.Dot(axis, Vector3.Cross(fromNorm, toNorm)));
    221.             return unsignedAngle * sign;
    222.         }
    224.         // Returns the distance between /a/ and /b/.
    225.         public static float Distance(Vector3 a, Vector3 b)
    226.         {
    227.             Vector3 vec = new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
    228.             return Mathf.Sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
    229.         }
    231.         // Returns a copy of /vector/ with its magnitude clamped to /maxLength/.
    232.         public static Vector3 ClampMagnitude(Vector3 vector, float maxLength)
    233.         {
    234.             if (vector.sqrMagnitude > maxLength * maxLength)
    235.                 return vector.normalized * maxLength;
    236.             return vector;
    237.         }
    239.         // *undoc* --- there's a property now
    240.         public static float Magnitude(Vector3 vector) { return Mathf.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z); }
    242.         // Returns the length of this vector (RO).
    243.         public float magnitude { get { return Mathf.Sqrt(x * x + y * y + z * z); } }
    245.         // *undoc* --- there's a property now
    246.         public static float SqrMagnitude(Vector3 vector) { return vector.x * vector.x + vector.y * vector.y + vector.z * vector.z; }
    248.         // Returns the squared length of this vector (RO).
    249.         public float sqrMagnitude { get { return x * x + y * y + z * z; } }
    251.         // Returns a vector that is made from the smallest components of two vectors.
    252.         public static Vector3 Min(Vector3 lhs, Vector3 rhs)
    253.         {
    254.             return new Vector3(Mathf.Min(lhs.x, rhs.x), Mathf.Min(lhs.y, rhs.y), Mathf.Min(lhs.z, rhs.z));
    255.         }
    257.         // Returns a vector that is made from the largest components of two vectors.
    258.         public static Vector3 Max(Vector3 lhs, Vector3 rhs)
    259.         {
    260.             return new Vector3(Mathf.Max(lhs.x, rhs.x), Mathf.Max(lhs.y, rhs.y), Mathf.Max(lhs.z, rhs.z));
    261.         }
    263.         static readonly Vector3 zeroVector = new Vector3(0F, 0F, 0F);
    264.         static readonly Vector3 oneVector = new Vector3(1F, 1F, 1F);
    265.         static readonly Vector3 upVector = new Vector3(0F, 1F, 0F);
    266.         static readonly Vector3 downVector = new Vector3(0F, -1F, 0F);
    267.         static readonly Vector3 leftVector = new Vector3(-1F, 0F, 0F);
    268.         static readonly Vector3 rightVector = new Vector3(1F, 0F, 0F);
    269.         static readonly Vector3 forwardVector = new Vector3(0F, 0F, 1F);
    270.         static readonly Vector3 backVector = new Vector3(0F, 0F, -1F);
    271.         static readonly Vector3 positiveInfinityVector = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);
    272.         static readonly Vector3 negativeInfinityVector = new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
    274.         // Shorthand for writing @@Vector3(0, 0, 0)@@
    275.         public static Vector3 zero { get { return zeroVector; } }
    276.         // Shorthand for writing @@Vector3(1, 1, 1)@@
    277.         public static Vector3 one { get { return oneVector; } }
    278.         // Shorthand for writing @@Vector3(0, 0, 1)@@
    279.         public static Vector3 forward { get { return forwardVector; } }
    280.         public static Vector3 back { get { return backVector; } }
    281.         // Shorthand for writing @@Vector3(0, 1, 0)@@
    282.         public static Vector3 up { get { return upVector; } }
    283.         public static Vector3 down { get { return downVector; } }
    284.         public static Vector3 left { get { return leftVector; } }
    285.         // Shorthand for writing @@Vector3(1, 0, 0)@@
    286.         public static Vector3 right { get { return rightVector; } }
    287.         // Shorthand for writing @@Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)@@
    288.         public static Vector3 positiveInfinity { get { return positiveInfinityVector; } }
    289.         // Shorthand for writing @@Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)@@
    290.         public static Vector3 negativeInfinity { get { return negativeInfinityVector; } }
    292.         // Adds two vectors.
    293.         public static Vector3 operator+(Vector3 a, Vector3 b) { return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z); }
    294.         // Subtracts one vector from another.
    295.         public static Vector3 operator-(Vector3 a, Vector3 b) { return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z); }
    296.         // Negates a vector.
    297.         public static Vector3 operator-(Vector3 a) { return new Vector3(-a.x, -a.y, -a.z); }
    298.         // Multiplies a vector by a number.
    299.         public static Vector3 operator*(Vector3 a, float d) { return new Vector3(a.x * d, a.y * d, a.z * d); }
    300.         // Multiplies a vector by a number.
    301.         public static Vector3 operator*(float d, Vector3 a) { return new Vector3(a.x * d, a.y * d, a.z * d); }
    302.         // Divides a vector by a number.
    303.         public static Vector3 operator/(Vector3 a, float d) { return new Vector3(a.x / d, a.y / d, a.z / d); }
    305.         // Returns true if the vectors are equal.
    306.         public static bool operator==(Vector3 lhs, Vector3 rhs)
    307.         {
    308.             // Returns false in the presence of NaN values.
    309.             return SqrMagnitude(lhs - rhs) < kEpsilon * kEpsilon;
    310.         }
    312.         // Returns true if vectors are different.
    313.         public static bool operator!=(Vector3 lhs, Vector3 rhs)
    314.         {
    315.             // Returns true in the presence of NaN values.
    316.             return !(lhs == rhs);
    317.         }
    319.         public override string ToString()
    320.         {
    321.             return UnityString.Format("({0:F1}, {1:F1}, {2:F1})", x, y, z);
    322.         }
    324.         public string ToString(string format)
    325.         {
    326.             return UnityString.Format("({0}, {1}, {2})", x.ToString(format), y.ToString(format), z.ToString(format));
    327.         }
    329.         [System.Obsolete("Use Vector3.forward instead.")]
    330.         public static Vector3 fwd { get { return new Vector3(0F, 0F, 1F); } }
    331.         [System.Obsolete("Use Vector3.Angle instead. AngleBetween uses radians instead of degrees and was deprecated for this reason")]
    332.         public static float AngleBetween(Vector3 from, Vector3 to) { return Mathf.Acos(Mathf.Clamp(Vector3.Dot(from.normalized, to.normalized), -1F, 1F)); }
    333.         [System.Obsolete("Use Vector3.ProjectOnPlane instead.")]
    334.         public static Vector3 Exclude(Vector3 excludeThis, Vector3 fromThat) { return ProjectOnPlane(fromThat, excludeThis); }
    336. }

    ?