（一）向量模长和单位向量

// Vector3中提供了获取向量模长的成员属性
// magnitude
print(AB.magnitude);
Vector3 C = new Vector3(5, 6, 7);
print(C.magnitude);

print(Vector3.Distance(A, B));

// Vector3中提供了获取单位向量的成员属性
// normalized
print(AB.normalized);
print(AB / AB.magnitude);

（二）调试画线

// 画线段 
// 前两个参数 分别是 起点 终点
Debug.DrawLine(this.transform.position, this.transform.position + this.transform.forward, Color.red);

// 画射线
// 前两个参数 分别是 起点 方向
Debug.DrawRay(this.transform.position, this.transform.forward, Color.white);

（三）向量点乘

public Transform target;

// 得到两个向量的点乘结果
// 向量 a 点乘 AB 的结果
float dotResult = Vector3.Dot(transform.forward, target.position - transform.position);
if (dotResult >= 0) print("它在我前方");
else                print("它在我后方");

// 通过点乘推导公式算出夹角

// 1.用单位向量算出点乘结果
dotResult = Vector3.Dot(transform.forward, (target.position - transform.position).normalized);
// 2.用反三角函数得出角度
print(Mathf.Acos(dotResult) * Mathf.Rad2Deg);
// Vector3中提供了 得到两个向量之间夹角的方法 
print(Vector3.Angle(transform.forward, target.position - transform.position));

（四）向量叉乘

// 假设向量 A和B 都在 XZ平面上
// 向量A 叉乘 向量 B
// y大于0 证明 B在A右侧
// y小于0 证明 B在A左侧

Vector3 C = Vector3.Cross(B.position, A.position);
if (C.y > 0) print("A在B的右侧");
else         print("A在B的左侧");

（五）向量插值运算

1. 线性插值

public Transform target;    // 目标物体位置
public Transform A;         // 先快后慢移动到 Target
public Transform B;         // 匀速运动到 Target

private Vector3 nowTarget;  // 当前 B 的位置

private Vector3 startPos;   // 每次运行时 B 的起始位置
private float   time;

// Start is called before the first frame update
private void Start() {
    startPos = B.position;
}

// Update is called once per frame
private void Update() {
    // result = start + (end - start) * t

    // 1.先快后慢 每帧改变start位置 位置无限接近 但不会得到end位置
    A.position = Vector3.Lerp(A.position, target.position, Time.deltaTime);

    // 2.匀速 每帧改变时间  当t>=1时 得到结果
    // 这种匀速移动 当time>=1时  我改变了 目标位置后  它会直接瞬移到我们的目标位置
    if (nowTarget != target.position) {
        nowTarget = target.position;
        time      = 0;
        startPos  = B.position;
    }
    time       += Time.deltaTime;
    B.position =  Vector3.Lerp(startPos, nowTarget, time);
}

1. 球形插值

position = Vector3.Slerp(Vector3.right * 10, Vector3.left * 10 + Vector3.up * 0.1f, time * 0.01f);

（一）欧拉角

​ 由三个角度 (x, y, z) 组成 ，在特定坐标系下用于描述物体的旋转量

​ 空间中的任意旋转都可以分解成绕三个互相垂直轴的三个旋转角组成的序列

​ heading-pitch-bank 是一种最常用的旋转序列约定，即 Y - X - Z 约定

​ heading：物体绕自身的对象坐标系的 Y 轴，旋转的角度

​ pitch：物体绕自身的对象坐标系的 X 轴，旋转的角度

​ ban：物体绕自身的对象坐标系的 Z 轴，旋转的角度

​ Inspector 窗口中调节的 Rotation 就是欧拉角

​ this.transform.eulerAngles 得到的就是欧拉角角度

• 优点：

  • 直观、易理解

  • 存储空间小（三个数表示）

  • 可以进行从一个方向到另一个方向旋转大于180度的角度

• 缺点：

  • 同一旋转的表示不唯一

    例如，Rotation(x, y, z) = Rotation(x + 360, y + 360, z + 360)

  • 万向节死锁

（二）万向节死锁

​ 万向节死锁的意义就是在 X 轴转 90度的情况下，后面左乘 Z（绕基坐标下 Z）与右乘 Y（绕自身 Y，实际与基坐标 Z 一样了）实际效果是相同的，丧失了自由度。

​ 例如，在 Unity 中，将 Rotation 中的 X 设置为 90，之后调节 Y 和调节 Z 的大小，物体的转动都会是沿一个角度的。

（三）四元数简介

​ 四元数是简单的超复数，由实数加上三个虚数单位组成 主要用于在三维空间中表示旋转

​ 四元数原理包含大量数学相关知识，较为复杂，比如：复数、四维空间等等

​ 因此此处我们只对其基本构成和基本公式进行讲解，如想深入了解数学原理请从数学层面去查找资料了解它

1. 四元数的构成

​ 一个四元数包含一个标量和一个 3D 向量

​ [w, v]，w为标量，v为 3D 向量，即[w, (x, y, z)]

​ 对于给定的任意一个四元数： 表示 3D 空间中的一个旋转量

1. 轴角对

   在 3D 空间中，任意旋转都可以表示绕着某个轴旋转一个旋转角得到

   对于给定旋转，假设为绕着 n 轴，旋转 β 度，n 轴为 (x, y, z)

   那么可以构成四元数为

   四元数 Q = [cos(β / 2), n · sin(β / 2)]

   四元数 Q = [cos(β / 2), x · sin(β / 2), y · sin(β / 2), z · sin(β / 2)]

   四元数 Q 则表示绕着轴 n，旋转 β 度的旋转量

2. Unity 中的 Quaternion

   Quaternion 是 Unity 中表示四元数的结构体

// 轴角对公式初始化 
// 四元数 Q = [cos(β/2), sin(β/2)x, sin(β/2)y, sin(β/2)z] 
Quaternion q = new Quaternion(sin(β/2)x, sin(β/2)y, sin(β/2)z, cos(β/2));
    
// 轴角对方法初始化 
// 四元数Q = Quaternion.AngleAxis(角度, 轴); 
Quaternion q = Quaternion.AngleAxis(60, Vector3.right);

3.四元数和欧拉角转换

// 1.欧拉角转四元数
Quaternion q2 = Quaternion.Euler(60, 0, 0);

// 2.四元数转欧拉角
print(q2.eulerAngles);

（四）常用方法

1. 单位四元数

   单位四元数表示没有旋转量（角位移）

   当角度为 0 或者 360 度时，对于给定轴都会得到单位四元数

   [1, (0, 0, 0)]和[-1, (0, 0, 0)] 都是单位四元数，表示没有旋转量

// 单位四元数
print(Quaternion.identity);

2.插值运算

四元数中同样提供如同 Vector3 的插值运算：Lerp 和 Slerp

在四元数中 Lerp 和 Slerp 只有一些细微差别，由于算法不同，Slerp 的效果会好一些

Lerp 的效果相比 Slerp 更快但是如果旋转范围较大效果较差，所以建议使用 Slerp 进行插值运算

public Transform target;
public Transform A;
public Transform B;
private Quaternion start;
private float time;

start = B.transform.rotation;

// 无限接近 先快后慢
A.transform.rotation = Quaternion.Slerp(A.transform.rotation, target.rotation, Time.deltaTime);

// 匀速变化 time>=1 到达目标
time                 += Time.deltaTime;
B.transform.rotation =  Quaternion.Slerp(start, target.rotation, time);

3.方向转四元数

Quaternino.LookRotation(面朝向量);

LookRoataion 方法可以将传入的面朝向量转换为对应的四元数角度信息

当人物面朝向想要改变时，只需要把目标面朝向传入该函数，便可以得到目标四元数角度信息，之后将人物四元数角度信息改为得到的信息即可达到转向

Quaternion q = Quaternion.LookRotation(lookB.position - lookA.position);
lookA.rotation = q;

（五）实现缓慢看向目标

public  Transform  target;
private float      roundTime;
public  float      roundSpeed;
private Quaternion startQ;
private Quaternion targetQ;

// 用目标的位置 减去 摄像机的位置 得到新的面朝向向量
targetQ = Quaternion.LookRotation(target.position - this.transform.position);

//先快后慢
this.transform.rotation = Quaternion.Slerp(this.transform.rotation, targetQ, Time.deltaTime* roundSpeed);

//匀速旋转
if (targetQ != Quaternion.LookRotation(target.position - transform.position)) {
    targetQ   = Quaternion.LookRotation(target.position - transform.position);
    roundTime = 0;
    startQ    = transform.rotation;
}
roundTime          += Time.deltaTime;
transform.rotation =  Quaternion.Slerp(startQ, targetQ, roundTime * roundSpeed);

（六）四元数计算

1. 四元数乘四元数

   q3 = q1 * q2

   两个四元数相乘得到一个新的四元数，代表两个旋转量的叠加，相当于旋转

   注意：旋转相对的坐标系是物体自身坐标系

Quaternion q = Quaternion.AngleAxis(20, Vector3.up);
transform.rotation *= q;

2.四元数乘向量

v2 = q1 * v1（顺序不能反）

四元数乘向量返回一个新向量，可以将指定向量旋转对应四元数的旋转量，相当于旋转向量

Vector3 v = Vector3.forward;
print(v);
v = Quaternion.AngleAxis(45, Vector3.up) * v;
print(v);