Unity Vector3

没什么干货，仅用于自己加深记忆。

 

namespace UnityEngine
{
    public struct Vector3 : IEquatable<Vector3>
    {
        //这两个意义未知
        public const float kEpsilon = 1E-05F;
        public const float kEpsilonNormalSqrt = 1E-15F;

        public float x;
        public float y;
        public float z;


        public Vector3(float x, float y);
        public Vector3(float x, float y, float z);


        //下标[0][1][2]代表x,y,z    Vector3 v3 = new Vector3(0, 0, 0); v3[0] = 1;
        public float this[int index] { get; set; }


        public static Vector3 right { get; }
        public static Vector3 left { get; }
        public static Vector3 up { get; }
        public static Vector3 down { get; }
        public static Vector3 back { get; }
        public static Vector3 forward { get; }
        public static Vector3 one { get; }
        public static Vector3 zero { get; }

        //  Shorthand for writing Vector3(float.NegativeInfinity, float.NegativeInfinity,
        //  float.NegativeInfinity).    负无穷  意义何在，用在什么地方？
        public static Vector3 negativeInfinity { get; }

        //  Shorthand for writing Vector3(float.PositiveInfinity, float.PositiveInfinity,
        //  float.PositiveInfinity).    正无穷
        public static Vector3 positiveInfinity { get; }
       
        public float sqrMagnitude { get; }//向量长度平方
        public Vector3 normalized { get; }//向量单位向量
        public float magnitude { get; }//向量长度




        //返回两个向量间的夹角（0-180）
        public static float Angle(Vector3 from, Vector3 to);
        
        //钳制求模  返回向量 vector 的副本，长度不超过 maxLength
        public static Vector3 ClampMagnitude(Vector3 vector, float maxLength);
        
        public static Vector3 Cross(Vector3 lhs, Vector3 rhs);
       
        public static float Distance(Vector3 a, Vector3 b);
       
        public static float Dot(Vector3 lhs, Vector3 rhs);
        
        //钳制性的线性差值,返回值限定在a和b之间
        public static Vector3 Lerp(Vector3 a, Vector3 b, float t);
        
        //非钳制性的线性差值,返回值会超过a和b的范围
        public static Vector3 LerpUnclamped(Vector3 a, Vector3 b, float t);

        //某向量大小
        public static float Magnitude(Vector3 vector);
        
        //返回由两个向量的最大分量组成的向量。lhs(1, 2, 3),rhs(3, 5, 1),返回（3,5,3）
        public static Vector3 Max(Vector3 lhs, Vector3 rhs);
        
        public static Vector3 Min(Vector3 lhs, Vector3 rhs);
        
        //计算当前和目标指定的点之间的位置，移动不超过 maxDistanceDelta 指定的距离。
        //与Lerp（）的区别，第三个参数 Lerp（）指的是比例，MoveTowards（）指的是具体距离
        //current(1, 0, 0),target(10, 0, 0),距离为9，那么maxDistanceDelta范围就是（-9，9）；
        //大于9，取9，小于-9，取-9；若：取0，返回（1,0,0）；取1，返回（2,0,0）；取-1，返回（0,0,0）；移动不会超过目标,maxdistancedelta为负值时，可以用来从目标推开该向量
        public static Vector3 MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta);
        
        //某向量单位向量
        public static Vector3 Normalize(Vector3 value);

        //归一化 normal，归一化 tangent并且确保它垂直于 normal。
        //归一化 binormal 并确保它到 normal和tangent两者之间相互垂直。
        public static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent, ref Vector3 binormal);

        //归一化 normal，归一化 tangent 并且确保它垂直于 normal
        public static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent);
       
        // vector 在 onNormal 上的投影
        public static Vector3 Project(Vector3 vector, Vector3 onNormal);
        
        //投影 vector 到以 planeNormal 为法向量的平面上
        public static Vector3 ProjectOnPlane(Vector3 vector, Vector3 planeNormal);
       
        //将一个向量反射出由法线定义的平面。
        public static Vector3 Reflect(Vector3 inDirection, Vector3 inNormal);
        
        //参考 MoveTowards（），最后一个参数还没理解
        public static Vector3 RotateTowards(Vector3 current, Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta);

        //将两个向量按分量相乘。a(1, 2, 3),b(3, 5, 1),返回（3,10,3）
        public static Vector3 Scale(Vector3 a, Vector3 b);
       
        //带符号角度，暂未研究透
        public static float SignedAngle(Vector3 from, Vector3 to, Vector3 axis);
       
        //球面插值两个向量。     见图组1、图组2
        public static Vector3 Slerp(Vector3 a, Vector3 b, float t);
       
        //球面插值两个向量，不钳制。     见图组3
        public static Vector3 SlerpUnclamped(Vector3 a, Vector3 b, float t);

        //光滑阻尼    参数还没有完全理解
        public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, [DefaultValue("Mathf.Infinity")] float maxSpeed, [DefaultValue("Time.deltaTime")] float deltaTime);
     
        public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed);
     
        public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime);

        public static float SqrMagnitude(Vector3 vector);




        public bool Equals(Vector3 other);
       
        public override bool Equals(object other);

        //暂未知
        public override int GetHashCode();

        public void Normalize();
        
        //将这个向量的每个分量 乘以 参数对应轴的分量。
        public void Scale(Vector3 scale);
       
        // Vector3 vector = Vector3.zero; vector.Set(0.1f, 0.2f, 0.3f);
        public void Set(float newX, float newY, float newZ);
        
        //为这个向量返回格式化良好的字符串。  transform.position.ToString("0.000")
        public string ToString(string format);
        
        public override string ToString();




        public static Vector3 operator +(Vector3 a, Vector3 b);
        public static Vector3 operator -(Vector3 a);
        public static Vector3 operator -(Vector3 a, Vector3 b);
        public static Vector3 operator *(Vector3 a, float d);
        public static Vector3 operator *(float d, Vector3 a);
        public static Vector3 operator /(Vector3 a, float d);
        public static bool operator ==(Vector3 lhs, Vector3 rhs);
        public static bool operator !=(Vector3 lhs, Vector3 rhs);
    }
}

图组1

 图组2

 图组3