SDHK_Tool.Static.SS_EulerAngleConversion 欧拉角,角度转换计算

目录

1.Angle_PN_To_PN180 角度转换：正负无限 转换成 正负0~180 的角度

2.Angle_PN_To_P360 角度转换：正负无限 转换成 正0~360 的角度

3.Angle_P360_To_PN180 角度转换：正0~360 转换成 正负0~180 的角度

4.Angle_PN180_To_PN90 角度转换：正0~180 转换成 正负0~90 的角度

5.EulerAngle_PN_To_PN180 欧拉角转换：正负无限 转换成 正负0~180 的欧拉角

6.EulerAngle_PN_To_P360 欧拉角转换：正负无限 转换成 正0~360 的欧拉角

7.EulerAngle_P360_To_PN180 欧拉角转换：正0~360 转换成 正负0~180 的欧拉角

8.Get_Vector2_In_Angle 角度转换为二维向量（x为横，Y为竖）

9.Get_Angle_In_Vector2 二维向量转换为角度

10.Get_EulerAngle_In_Vector3 向量转换为欧拉角

11.Get_Vector3_In_EulerAngle 欧拉角转换为向量

12.Get_Vector3_RotateRound 获取点绕某轴旋转x度后的位置(三维)

13.Get_Vector2_RotateRound 获取点绕某轴旋转x度后的位置（二维）

14.Get_Angle_In_Vector2Deviation 获得两个二维向量的角度差，顺时针为正

15.Get_Angle_In_Vector3Deviation 获得两个三维向量的角度差，顺时针为正

16.Get_Angle_In_Transform 获得目标位置位于Transform的方位角度

全篇：

---

 * 作者：闪电Y黑客
 
 * 日期： 2019.6.11

 * 功能: 角度与向量的各种转换计算

 

1.Angle_PN_To_PN180 角度转换：正负无限 转换成 正负0~180 的角度

/// <summary>
/// 角度转换：正负无限 转换成 正负0~180 的角度
/// </summary>
/// <param name="Angle">要转换角度</param>
/// <returns>return ： 转换成 正负0~180 的角度</returns>
static public float Angle_PN_To_PN180(float Angle)
{
    Angle = Angle_PN_To_P360(Angle);
    return Angle_P360_To_PN180(Angle);
}

 

2.Angle_PN_To_P360 角度转换：正负无限 转换成 正0~360 的角度

/// <summary>
/// 角度转换：正负无限 转换成 正0~360 的角度
/// </summary>
/// <param name="Angle">要转换角度</param>
/// <returns>return ： 转换成 正0~360 的角度</returns>
static public float Angle_PN_To_P360(float Angle)
{
    return ((Angle %= 360) < 0) ? Angle + 360 : Angle;
}

 

3.Angle_P360_To_PN180 角度转换：正0~360 转换成 正负0~180 的角度

/// <summary>
/// 角度转换：正0~360 转换成 正负0~180 的角度
/// </summary>
/// <param name="Angle">要转换角度</param>
/// <returns>return ： 转换成 正负0~180 的角度</returns>
static public float Angle_P360_To_PN180(float Angle)
{
    return (Angle >= 180) ? Angle - 360 : Angle;
}

 

4.Angle_PN180_To_PN90 角度转换：正0~180 转换成 正负0~90 的角度

/// <summary>
/// 角度转换：正0~180 转换成 正负0~90 的角度
/// </summary>
/// <param name="Angle">要转换角度</param>
/// <returns>return ： 转换成 正负0~180 的角度</returns>
static public float Angle_PN180_To_PN90(float Angle)
{
    Angle = Mathf.Abs(Angle);
    return (Angle >= 90) ? Angle - 180 : Angle;
}

 

5.EulerAngle_PN_To_PN180 欧拉角转换：正负无限 转换成 正负0~180 的欧拉角

/// <summary>
/// 欧拉角转换：正负无限 转换成 正负0~180 的欧拉角
/// </summary>
/// <param name="EulerAngles">要转换的欧拉角</param>
/// <returns>return ： 转换成 正负0~180 的欧拉角</returns>
static public Vector3 EulerAngle_PN_To_PN180(Vector3 EulerAngles)
{
    EulerAngles.x = Angle_PN_To_PN180(EulerAngles.x);
    EulerAngles.y = Angle_PN_To_PN180(EulerAngles.y);
    EulerAngles.z = Angle_PN_To_PN180(EulerAngles.z);
    return EulerAngles;
}

 

6.EulerAngle_PN_To_P360 欧拉角转换：正负无限 转换成 正0~360 的欧拉角

/// <summary>
/// 欧拉角转换：正负无限 转换成 正0~360 的欧拉角
/// </summary>
/// <param name="EulerAngles">要转换的欧拉角</param>
/// <returns>return ： 转换成 正0~360 的欧拉角</returns>
static public Vector3 EulerAngle_PN_To_P360(Vector3 EulerAngles)
{
    EulerAngles.x = Angle_PN_To_P360(EulerAngles.x);
    EulerAngles.y = Angle_PN_To_P360(EulerAngles.y);
    EulerAngles.z = Angle_PN_To_P360(EulerAngles.z);
    return EulerAngles;
}

 

7.EulerAngle_P360_To_PN180 欧拉角转换：正0~360 转换成 正负0~180 的欧拉角

/// <summary>
/// 欧拉角转换：正0~360 转换成 正负0~180 的欧拉角
/// </summary>
/// <param name="EulerAngles">要转换的欧拉角</param>
/// <returns>return ： 转换成 正负0~180 的欧拉角</returns>
static public Vector3 EulerAngle_P360_To_PN180(Vector3 EulerAngles)
{
    EulerAngles.x = Angle_P360_To_PN180(EulerAngles.x);
    EulerAngles.y = Angle_P360_To_PN180(EulerAngles.y);
    EulerAngles.z = Angle_P360_To_PN180(EulerAngles.z);
    return EulerAngles;
}

 

8.Get_Vector2_In_Angle 角度转换为二维向量（x为横，Y为竖）

/// <summary>
/// 角度转换为二维向量（x为横，Y为竖）
/// </summary>
/// <param name="Angle_Z">要转换的角度</param>
/// <returns>return ： 转换的二维向量</returns>
static public Vector2 Get_Vector2_In_Angle(float Angle_Z)
{
    float NewAngle = Angle_PN_To_PN180(Angle_Z);

    float Angle_Y = Mathf.Abs(Angle_PN180_To_PN90(NewAngle));//计算Y轴需要的角度
    float Angle_X = Mathf.Abs(Angle_Y - 90);    //计算X轴需要的角度

    float Diameter = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, 1);//得到外接圆直径

    float Edge_Y = SS_TriangleSolutions.GetEdge_Angle_Diameter(SS_TriangleSolutions.Get_A_Angle_AAA(Angle_Y, 90), Diameter);//获得Y轴长度
    float Edge_X = SS_TriangleSolutions.GetEdge_Angle_Diameter(SS_TriangleSolutions.Get_A_Angle_AAA(Angle_X, 90), Diameter);//获得X轴长度

    Edge_Y = (Mathf.Abs(NewAngle) > 90) ? -Edge_Y : Edge_Y;//判断正负
    Edge_X = (Mathf.Abs((NewAngle - 90)) > 90) ? -Edge_X : Edge_X;//判断正负

    return new Vector2(Edge_X, Edge_Y);//返回最终向量
}

 

9.Get_Angle_In_Vector2 二维向量转换为角度

/// <summary>
/// 二维向量转换为角度
/// </summary>
/// <param name="vector2">要转换的向量</param>
/// <returns>return ： 转换角度</returns>
static public float Get_Angle_In_Vector2(Vector2 vector2)
{

    float Edge_X = Mathf.Abs(vector2.x);
    float Edge_Y = Mathf.Abs(vector2.y);

    float Edge_A = SS_TriangleSolutions.Get_A_Edge_EAE(90, Edge_X, Edge_Y);//获取向量长度
    float Diameter = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, Edge_A);//获得外接圆直径
    float Angle = SS_TriangleSolutions.GetAngle_Edge_Diameter(Edge_X, Diameter);//获取夹角

    //向量方位判断
    if (vector2.x < 0 && vector2.y >= 0) Angle = -Angle;
    if (vector2.x >= 0 && vector2.y < 0) Angle = 180 - Angle;
    if (vector2.x < 0 && vector2.y < 0) Angle = Angle - 180;

    return Angle;//返回最终角度
}

 

10.Get_EulerAngle_In_Vector3 向量转换为欧拉角

/// <summary>
/// 向量转换为欧拉角
/// </summary>
/// <param name="AngleVector3">指向向量</param>
/// <returns>return : 欧拉角</returns>
static public Vector3 Get_EulerAngle_In_Vector3(Vector3 AngleVector3)
{
    return Quaternion.LookRotation(AngleVector3).eulerAngles;
}

 

11.Get_Vector3_In_EulerAngle 欧拉角转换为向量

/// <summary>
/// 欧拉角转换为向量
/// </summary>
/// <param name="EulerAngles">欧拉角</param>
/// <returns>return : 向量</returns>
static public Vector3 Get_Vector3_In_EulerAngle(Vector3 EulerAngles)
{

    float Edge_Y = -Get_Vector2_In_Angle(EulerAngles.x).x;//向量Y轴 = - 单角度转二维向量（欧拉角.X轴角度）.X轴向量

    float Diameter = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, 1);//立体投影三角形外接圆直径 = 解三角.获取外接圆直接（直角，对边长=向量长度）

    float PN_Angle_X = Angle_PN_To_PN180(EulerAngles.x);//X轴角度转换 ： +-无限转换+-180度：用于判断向量方位
    float Angle_X = Mathf.Abs(Angle_PN180_To_PN90(PN_Angle_X));//角度转换 ：+-180转换+90度 ：用于解三角计算

    float PN_Angle_Y = Angle_PN_To_PN180(EulerAngles.y);//Y轴角度转换 ： +-无限转换+-180度：用于判断向量方位
    float Angle_Y = Mathf.Abs(Angle_PN180_To_PN90(PN_Angle_Y));//角度转换 ：+-180转换+90度 ：用于解三角计算

    //向量投影长度= 解三角.获取对边（ 180 -（X轴角度+90），立体投影三角形外接圆直径 ）
    float EdgePro = SS_TriangleSolutions.GetEdge_Angle_Diameter(180 - (Angle_X + 90), Diameter);

    //平面投影三角形外接圆直径 = 解三角.获取外接圆直接（直角，对边长=向量投影长度）
    float DiameterPro = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, EdgePro);

    float Edge_X = SS_TriangleSolutions.GetEdge_Angle_Diameter(Angle_Y, DiameterPro);//X轴向量 = 解三角.获取对边（Y轴角度，平面投影三角形外接圆直径）
    float Edge_Z = SS_TriangleSolutions.GetEdge_Angle_Diameter(90 - Angle_Y, DiameterPro);//Z轴向量 = 解三角.获取对边（直角-Y轴角度，平面投影三角形外接圆直径）     

    Edge_X = (Mathf.Abs(PN_Angle_X) < 90 && Angle_PN_To_P360(EulerAngles.y) < 180) ? Edge_X : -Edge_X;//向量X轴 = 三目(X轴角度 < 90 与 欧拉角.y<180)?正：负;
    Edge_Z = (Mathf.Abs(PN_Angle_X) < 90 && Mathf.Abs(PN_Angle_Y) < 90) ? Edge_Z : -Edge_Z;//向量Z轴 = 三目(X轴角度 < 90 与 Y轴角度<90)?负：正;

    return new Vector3(Edge_X, Edge_Y, Edge_Z);//返回最终向量

}

 

12.Get_Vector3_RotateRound 获取点绕某轴旋转x度后的位置(三维)

/// <summary>
/// 获取点绕某轴旋转x度后的位置
/// </summary>
/// <param name="position">要旋转的点</param>
/// <param name="center">旋转的中心点</param>
/// <param name="axis">旋转轴的方向</param>
/// <param name="angle">要旋转角度（顺时针为正）</param>
/// <returns>旋转后的位置</returns>
static public Vector3 Get_Vector3_RotateRound(Vector3 position, Vector3 center, Vector3 axis, float angle)
{
    Vector3 point = Quaternion.AngleAxis(angle, axis) * (position - center); //算出旋转后的向量
    Vector3 resultVec3 = center + point;        //加上旋转中心位置得到旋转后的位置
    return resultVec3;
}

 

13.Get_Vector2_RotateRound 获取点绕某轴旋转x度后的位置（二维）

/// <summary>
/// 获取点绕某轴旋转x度后的位置（二维）
/// </summary>
/// <param name="position">要旋转的点</param>
/// <param name="center">旋转的中心点</param>
/// <param name="axis">旋转轴的方向</param>
/// <param name="angle">一次旋转多少角度（顺时针为正）</param>
/// <returns>旋转后的位置</returns>
static public Vector2 Get_Vector2_RotateRound(Vector2 position, Vector2 center, int axis, float angle)
{
    Vector3 point = Quaternion.AngleAxis(angle, Vector3.forward * axis) * (new Vector3(position.x, 0, position.y) - new Vector3(center.x, 0, center.y)); //算出旋转后的向量
    Vector2 resultVec3 = center + new Vector2(point.x, point.z);        //加上旋转中心位置得到旋转后的位置
    return resultVec3;
}

 

14.Get_Angle_In_Vector2Deviation 获得两个二维向量的角度差，顺时针为正

/// <summary>
/// 获得两个二维向量的角度差，顺时针为正
/// </summary>
/// <param name="firstVector2">第一个向量</param>
/// <param name="secondVector2">第二个向量</param>
/// <param name="Direction">轴方向：true 为轴向自己（从前往后看）2d一般为false</param>
/// <returns>return : 返回正负180度角</returns>
static public float Get_Angle_In_Vector2Deviation(Vector2 firstVector2, Vector2 secondVector2, bool Direction)
{
    float direction = Vector3.Cross(firstVector2, secondVector2).z;   //根据两个向量判断左右方向

    float angle = Vector3.Angle(firstVector2, secondVector2);         //根据两个向量算出角度

    if ((direction < 0 && !Direction) || (direction > 0 && Direction))
    {
        angle = -angle;
    }
    return angle;
}

 

15.Get_Angle_In_Vector3Deviation 获得两个三维向量的角度差，顺时针为正

/// <summary>
/// 获得两个三维向量的角度差，顺时针为正
/// </summary>
/// <param name="firstVector3">第一个向量</param>
/// <param name="secondVector3">第二个向量</param>
/// <returns>第一位为左右角度，第二位为俯仰角，第三位为实际偏差角</returns>
static public Vector3 Get_Angle_In_Vector3Deviation(Vector3 firstVector3, Vector3 secondVector3)
{
    Vector3 firstEulerAngles = Get_EulerAngle_In_Vector3(firstVector3);
    Vector3 secondEulerAngles = Get_EulerAngle_In_Vector3(secondVector3);

    float Angle_Y = Mathf.DeltaAngle(firstEulerAngles.y, secondEulerAngles.y);//获得+-180差值

    float Angle_X = Mathf.DeltaAngle(firstEulerAngles.x, secondEulerAngles.x);//获得+-180差值

    float Angle = Vector3.Angle(firstVector3, secondVector3);

    return new Vector3(Angle_Y, Angle_X, Angle);
}

 

16.Get_Angle_In_Transform 获得目标位置位于Transform的方位角度

/// <summary>
/// 获得目标位置位于Transform的方位角度
/// </summary>
/// <param name="isTransform">Transform</param>
/// <param name="TargetVector3">目标点世界坐标位置</param>
/// <returns>return : 方位角度 </returns>
static public Vector3 Get_Angle_In_Transform(Transform isTransform, Vector3 TargetVector3)
{
    return EulerAngle_P360_To_PN180(Get_EulerAngle_In_Vector3(isTransform.InverseTransformPoint(TargetVector3)));
}

 

 

全篇：

using UnityEngine;

/*
 * 作者：闪电Y黑客
 * 
 * 日期： 2019.6.11
 * 
 * 功能: 角度与向量的各种转换计算
 */

namespace SDHK_Tool.Static
{
    /// <summary>
    /// 欧拉角,角度转换计算
    /// </summary>
    static public class SS_EulerAngleConversion
    {

        /// <summary>
        /// 角度转换：正负无限 转换成 正负0~180 的角度
        /// </summary>
        /// <param name="Angle">要转换角度</param>
        /// <returns>return ： 转换成 正负0~180 的角度</returns>
        static public float Angle_PN_To_PN180(float Angle)
        {
            Angle = Angle_PN_To_P360(Angle);
            return Angle_P360_To_PN180(Angle);
        }

        /// <summary>
        /// 角度转换：正负无限 转换成 正0~360 的角度
        /// </summary>
        /// <param name="Angle">要转换角度</param>
        /// <returns>return ： 转换成 正0~360 的角度</returns>
        static public float Angle_PN_To_P360(float Angle)
        {
            return ((Angle %= 360) < 0) ? Angle + 360 : Angle;
        }

        /// <summary>
        /// 角度转换：正0~360 转换成 正负0~180 的角度
        /// </summary>
        /// <param name="Angle">要转换角度</param>
        /// <returns>return ： 转换成 正负0~180 的角度</returns>
        static public float Angle_P360_To_PN180(float Angle)
        {
            return (Angle >= 180) ? Angle - 360 : Angle;
        }

        /// <summary>
        /// 角度转换：正0~180 转换成 正负0~90 的角度
        /// </summary>
        /// <param name="Angle">要转换角度</param>
        /// <returns>return ： 转换成 正负0~180 的角度</returns>
        static public float Angle_PN180_To_PN90(float Angle)
        {
            Angle = Mathf.Abs(Angle);
            return (Angle >= 90) ? Angle - 180 : Angle;
        }

        

        /// <summary>
        /// 欧拉角转换：正负无限 转换成 正负0~180 的欧拉角
        /// </summary>
        /// <param name="EulerAngles">要转换的欧拉角</param>
        /// <returns>return ： 转换成 正负0~180 的欧拉角</returns>
        static public Vector3 EulerAngle_PN_To_PN180(Vector3 EulerAngles)
        {
            EulerAngles.x = Angle_PN_To_PN180(EulerAngles.x);
            EulerAngles.y = Angle_PN_To_PN180(EulerAngles.y);
            EulerAngles.z = Angle_PN_To_PN180(EulerAngles.z);
            return EulerAngles;
        }

        /// <summary>
        /// 欧拉角转换：正负无限 转换成 正0~360 的欧拉角
        /// </summary>
        /// <param name="EulerAngles">要转换的欧拉角</param>
        /// <returns>return ： 转换成 正0~360 的欧拉角</returns>
        static public Vector3 EulerAngle_PN_To_P360(Vector3 EulerAngles)
        {
            EulerAngles.x = Angle_PN_To_P360(EulerAngles.x);
            EulerAngles.y = Angle_PN_To_P360(EulerAngles.y);
            EulerAngles.z = Angle_PN_To_P360(EulerAngles.z);
            return EulerAngles;
        }
        /// <summary>
        /// 欧拉角转换：正0~360 转换成 正负0~180 的欧拉角
        /// </summary>
        /// <param name="EulerAngles">要转换的欧拉角</param>
        /// <returns>return ： 转换成 正负0~180 的欧拉角</returns>
        static public Vector3 EulerAngle_P360_To_PN180(Vector3 EulerAngles)
        {
            EulerAngles.x = Angle_P360_To_PN180(EulerAngles.x);
            EulerAngles.y = Angle_P360_To_PN180(EulerAngles.y);
            EulerAngles.z = Angle_P360_To_PN180(EulerAngles.z);
            return EulerAngles;
        }



        /// <summary>
        /// 角度转换为二维向量（x为横，Y为竖）
        /// </summary>
        /// <param name="Angle_Z">要转换的角度</param>
        /// <returns>return ： 转换的二维向量</returns>
        static public Vector2 Get_Vector2_In_Angle(float Angle_Z)
        {
            float NewAngle = Angle_PN_To_PN180(Angle_Z);

            float Angle_Y = Mathf.Abs(Angle_PN180_To_PN90(NewAngle));//计算Y轴需要的角度
            float Angle_X = Mathf.Abs(Angle_Y - 90);    //计算X轴需要的角度

            float Diameter = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, 1);//得到外接圆直径

            float Edge_Y = SS_TriangleSolutions.GetEdge_Angle_Diameter(SS_TriangleSolutions.Get_A_Angle_AAA(Angle_Y, 90), Diameter);//获得Y轴长度
            float Edge_X = SS_TriangleSolutions.GetEdge_Angle_Diameter(SS_TriangleSolutions.Get_A_Angle_AAA(Angle_X, 90), Diameter);//获得X轴长度

            Edge_Y = (Mathf.Abs(NewAngle) > 90) ? -Edge_Y : Edge_Y;//判断正负
            Edge_X = (Mathf.Abs((NewAngle - 90)) > 90) ? -Edge_X : Edge_X;//判断正负

            return new Vector2(Edge_X, Edge_Y);//返回最终向量
        }

        /// <summary>
        /// 二维向量转换为角度
        /// </summary>
        /// <param name="vector2">要转换的向量</param>
        /// <returns>return ： 转换角度</returns>
        static public float Get_Angle_In_Vector2(Vector2 vector2)
        {

            float Edge_X = Mathf.Abs(vector2.x);
            float Edge_Y = Mathf.Abs(vector2.y);

            float Edge_A = SS_TriangleSolutions.Get_A_Edge_EAE(90, Edge_X, Edge_Y);//获取向量长度
            float Diameter = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, Edge_A);//获得外接圆直径
            float Angle = SS_TriangleSolutions.GetAngle_Edge_Diameter(Edge_X, Diameter);//获取夹角

            //向量方位判断
            if (vector2.x < 0 && vector2.y >= 0) Angle = -Angle;
            if (vector2.x >= 0 && vector2.y < 0) Angle = 180 - Angle;
            if (vector2.x < 0 && vector2.y < 0) Angle = Angle - 180;

            return Angle;//返回最终角度
        }


        /// <summary>
        /// 向量转换为欧拉角
        /// </summary>
        /// <param name="AngleVector3">指向向量</param>
        /// <returns>return : 欧拉角</returns>
        static public Vector3 Get_EulerAngle_In_Vector3(Vector3 AngleVector3)
        {
            return Quaternion.LookRotation(AngleVector3).eulerAngles;
        }

        /// <summary>
        /// 欧拉角转换为向量
        /// </summary>
        /// <param name="EulerAngles">欧拉角</param>
        /// <returns>return : 向量</returns>
        static public Vector3 Get_Vector3_In_EulerAngle(Vector3 EulerAngles)
        {

            float Edge_Y = -Get_Vector2_In_Angle(EulerAngles.x).x;//向量Y轴 = - 单角度转二维向量（欧拉角.X轴角度）.X轴向量

            float Diameter = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, 1);//立体投影三角形外接圆直径 = 解三角.获取外接圆直接（直角，对边长=向量长度）

            float PN_Angle_X = Angle_PN_To_PN180(EulerAngles.x);//X轴角度转换 ： +-无限转换+-180度：用于判断向量方位
            float Angle_X = Mathf.Abs(Angle_PN180_To_PN90(PN_Angle_X));//角度转换 ：+-180转换+90度 ：用于解三角计算

            float PN_Angle_Y = Angle_PN_To_PN180(EulerAngles.y);//Y轴角度转换 ： +-无限转换+-180度：用于判断向量方位
            float Angle_Y = Mathf.Abs(Angle_PN180_To_PN90(PN_Angle_Y));//角度转换 ：+-180转换+90度 ：用于解三角计算

            //向量投影长度= 解三角.获取对边（ 180 -（X轴角度+90），立体投影三角形外接圆直径 ）
            float EdgePro = SS_TriangleSolutions.GetEdge_Angle_Diameter(180 - (Angle_X + 90), Diameter);

            //平面投影三角形外接圆直径 = 解三角.获取外接圆直接（直角，对边长=向量投影长度）
            float DiameterPro = SS_TriangleSolutions.GetDiameter_Edge_Angle(90, EdgePro);

            float Edge_X = SS_TriangleSolutions.GetEdge_Angle_Diameter(Angle_Y, DiameterPro);//X轴向量 = 解三角.获取对边（Y轴角度，平面投影三角形外接圆直径）
            float Edge_Z = SS_TriangleSolutions.GetEdge_Angle_Diameter(90 - Angle_Y, DiameterPro);//Z轴向量 = 解三角.获取对边（直角-Y轴角度，平面投影三角形外接圆直径）     

            Edge_X = (Mathf.Abs(PN_Angle_X) < 90 && Angle_PN_To_P360(EulerAngles.y) < 180) ? Edge_X : -Edge_X;//向量X轴 = 三目(X轴角度 < 90 与 欧拉角.y<180)?正：负;
            Edge_Z = (Mathf.Abs(PN_Angle_X) < 90 && Mathf.Abs(PN_Angle_Y) < 90) ? Edge_Z : -Edge_Z;//向量Z轴 = 三目(X轴角度 < 90 与 Y轴角度<90)?负：正;

            return new Vector3(Edge_X, Edge_Y, Edge_Z);//返回最终向量

        }

        /// <summary>
        /// 获取点绕某轴旋转x度后的位置
        /// </summary>
        /// <param name="position">要旋转的点</param>
        /// <param name="center">旋转的中心点</param>
        /// <param name="axis">旋转轴的方向</param>
        /// <param name="angle">要旋转角度（顺时针为正）</param>
        /// <returns>旋转后的位置</returns>
        static public Vector3 Get_Vector3_RotateRound(Vector3 position, Vector3 center, Vector3 axis, float angle)
        {
            Vector3 point = Quaternion.AngleAxis(angle, axis) * (position - center); //算出旋转后的向量
            Vector3 resultVec3 = center + point;        //加上旋转中心位置得到旋转后的位置
            return resultVec3;
        }

        /// <summary>
        /// 获取点绕某轴旋转x度后的位置
        /// </summary>
        /// <param name="position">要旋转的点</param>
        /// <param name="center">旋转的中心点</param>
        /// <param name="axis">旋转轴的方向</param>
        /// <param name="angle">一次旋转多少角度（顺时针为正）</param>
        /// <returns>旋转后的位置</returns>
        static public Vector2 Get_Vector2_RotateRound(Vector2 position, Vector2 center, int axis, float angle)
        {
            Vector3 point = Quaternion.AngleAxis(angle, Vector3.forward * axis) * (new Vector3(position.x, 0, position.y) - new Vector3(center.x, 0, center.y)); //算出旋转后的向量
            Vector2 resultVec3 = center + new Vector2(point.x, point.z);        //加上旋转中心位置得到旋转后的位置
            return resultVec3;
        }


        /// <summary>
        /// 获得两个二维向量的角度差，顺时针为正
        /// </summary>
        /// <param name="firstVector2">第一个向量</param>
        /// <param name="secondVector2">第二个向量</param>
        /// <param name="Direction">轴方向：true 为轴向自己（从前往后看）2d一般为false</param>
        /// <returns>return : 返回正负180度角</returns>
        static public float Get_Angle_In_Vector2Deviation(Vector2 firstVector2, Vector2 secondVector2, bool Direction)
        {
            float direction = Vector3.Cross(firstVector2, secondVector2).z;   //根据两个向量判断左右方向

            float angle = Vector3.Angle(firstVector2, secondVector2);         //根据两个向量算出角度

            if ((direction < 0 && !Direction) || (direction > 0 && Direction))
            {
                angle = -angle;
            }
            return angle;
        }

        /// <summary>
        /// 获得两个三维向量的角度差，顺时针为正
        /// </summary>
        /// <param name="firstVector3">第一个向量</param>
        /// <param name="secondVector3">第二个向量</param>
        /// <returns>第一位为左右角度，第二位为俯仰角，第三位为实际偏差角</returns>
        static public Vector3 Get_Angle_In_Vector3Deviation(Vector3 firstVector3, Vector3 secondVector3)
        {
            Vector3 firstEulerAngles = Get_EulerAngle_In_Vector3(firstVector3);
            Vector3 secondEulerAngles = Get_EulerAngle_In_Vector3(secondVector3);

            float Angle_Y = Mathf.DeltaAngle(firstEulerAngles.y, secondEulerAngles.y);//获得+-180差值

            float Angle_X = Mathf.DeltaAngle(firstEulerAngles.x, secondEulerAngles.x);//获得+-180差值

            float Angle = Vector3.Angle(firstVector3, secondVector3);

            return new Vector3(Angle_Y, Angle_X, Angle);
        }

        /// <summary>
        /// 获得目标位置位于Transform的方位角度
        /// </summary>
        /// <param name="isTransform">Transform</param>
        /// <param name="TargetVector3">目标点世界坐标位置</param>
        /// <returns>return : 方位角度 </returns>
        static public Vector3 Get_Angle_In_Transform(Transform isTransform, Vector3 TargetVector3)
        {
            return EulerAngle_P360_To_PN180(Get_EulerAngle_In_Vector3(isTransform.InverseTransformPoint(TargetVector3)));
        }

    }
}