Unity笔记

2025-01-26

字数统计: 8.3k字 | 阅读时长≈ 32分

Unity 笔记

编辑器

热键	功能描述
鼠标左键	选择或操作组件。
鼠标滚轮	启用手型工具，可拖拽界面（平移视图）。
鼠标右键	旋转视角，配合 `WASD` 键可自由移动相机（飞行模式）。
Q	手形工具：平移整个 Scene 视图。
W	移动工具：移动选中的游戏对象。
E	旋转工具：按任意角度旋转选中的游戏对象。
R	缩放工具：调整选中对象的大小（整体或单轴缩放）。

补充说明

组合操作
- Shift + 鼠标右键：加速相机移动。
- Alt + 鼠标左键：围绕选中物体旋转视角。
视图操作技巧
- 双击 Hierarchy 中的对象：快速聚焦到选中对象。
- F 键：在 Scene 视图中聚焦到当前选中对象。
- Ctrl/Cmd + Z：撤销操作（适用于场景修改）。
工具切换小技巧
- 可以在工具栏的 Transform Gizmo 中快速切换 移动、旋转、缩放 工具（对应快捷键：W、E、R）。

Prefab

1. 创建预制体

将 Hierarchy 中的物体拖动到 Project 面板，即可创建一个预制体（Prefab）。

2. 修改预制体

对 Project 中的预制体进行修改，会同步更新 Scene 中所有引用该预制体的实例。

3. 修改 Scene 中的预制体实例

如果直接修改 Scene 中引用预制体的实例，其对应的原始预制体不会改变。
如果需要将修改同步到预制体，可以通过以下两种方式：
- 在 Inspector 面板中点击相应组件的 “Add Component” 并选择 “Add to Prefab”。
- 点击 Override 菜单中的 Apply 按钮，同步更改到预制体。

4. 创建预制体的变体（Prefab Variant）

如果需要创建预制体的副本，可以将修改后的预制体再次拖动到 Project 面板。
在弹出的选项中选择 “Create a Variant from the existing Prefab”。
这样创建的变体（Variant）会依赖于原始预制体，其组件属性与原始预制体保持关联，修改原始预制体时变体会同步更新。

Vector类

1. 创建向量

使用 Vector3 创建一个向量，可以表示位置、方向、缩放等。

1	Vector3 v = new Vector3(1, 1, 1);

2. 常用快捷向量

Unity 提供了一些预定义的向量，便于快速使用。

Vector3 v;
v = Vector3.zero;     // (0, 0, 0) 零向量
v = Vector3.one;      // (1, 1, 1) 单位向量
v = Vector3.forward;  // (0, 0, 1) Z 轴正方向
v = Vector3.back;     // (0, 0, -1) Z 轴反方向
v = Vector3.up;       // (0, 1, 0) Y 轴正方向
v = Vector3.down;     // (0, -1, 0) Y 轴反方向
v = Vector3.left;     // (-1, 0, 0) X 轴反方向
v = Vector3.right;    // (1, 0, 0) X 轴正方向

3. 修改向量

可以直接修改向量的各个分量。

1
2
3

v.x = 0;
v.y = 1;
v.z = 2;

4. 向量运算

Unity 提供了许多常用的向量计算方法：

操作	代码	说明
向量夹角（度）	`Vector3.Angle(v, v2)`	返回两个向量之间的夹角（以度为单位）。
向量距离	`Vector3.Distance(v, v2)`	返回两点之间的距离（v 和 v2）。
点乘	`Vector3.Dot(v, v2)`	计算两个向量的点积，结果为一个标量，反映向量的方向关系。
叉乘	`Vector3.Cross(v, v2)`	计算两个向量的叉积，结果为一个垂直于两个向量的向量。
线性插值	`Vector3.Lerp(v, v2, t)`	在向量 v 和 v2 之间进行线性插值，t 取值范围为 [0, 1]。(v2-v)*t
向量的模	`v.magnitude`	计算向量的长度（模）。
向量规范化	`v.normalized`	返回单位向量（方向相同，长度为 1）。

5. 示例代码

public class VectorExample : MonoBehaviour
{
    void Start()
    {
        Vector3 v = new Vector3(1, 2, 3);
        Vector3 v2 = new Vector3(4, 5, 6);

        Debug.Log($"夹角: {Vector3.Angle(v, v2)}");       // 计算夹角
        Debug.Log($"距离: {Vector3.Distance(v, v2)}");    // 计算距离
        Debug.Log($"点乘: {Vector3.Dot(v, v2)}");        // 计算点乘
        Debug.Log($"叉乘: {Vector3.Cross(v, v2)}");      // 计算叉乘
        Debug.Log($"差值: {Vector3.Lerp(v, v2, 0.5f)}"); // 计算线性插值
        Debug.Log($"向量的模: {v.magnitude}");           // 获取向量的长度
        Debug.Log($"规范化: {v.normalized}");            // 获取单位向量
    }
}

旋转

在 Unity 中，旋转通常通过 欧拉角 或 四元数 来实现。两者各有优缺点，适用于不同的场景。四元数能够避免欧拉角的 万向节锁 问题，因此在处理复杂或连续旋转时更为常用。

1. 欧拉角与四元数概述

欧拉角

（Euler Angles）：
- 由绕 X、Y、Z 轴的旋转角度表示，直观且易于理解。
- 旋转的顺序会影响结果，容易出现 万向节锁，即某些角度之间的旋转失效。
四元数

（Quaternion）：
- 四元数是一种更为复杂的数学结构，避免了欧拉角的万向节锁问题。
- 适用于高效、稳定的旋转计算，特别是在连续的旋转或插值时表现优异。

2. 代码示例

public class RotateTest : MonoBehaviour
{
    // Start is called once before the first execution of Update after the MonoBehaviour is created
    void Start()
    {
        // 示例1：使用欧拉角与四元数进行旋转
        Vector3 rotate = new Vector3(0, 30, 0); // 定义一个欧拉角（绕 Y 轴旋转 30 度）
        Quaternion quaternion = Quaternion.identity; // 创建一个无旋转的四元数（单位四元数）

        // 将欧拉角转换为四元数
        quaternion = Quaternion.Euler(rotate); // 通过欧拉角创建四元数
        Debug.Log($"通过欧拉角创建的四元数：{quaternion}");

        // 四元数转换为欧拉角
        rotate = quaternion.eulerAngles; // 将四元数转换回欧拉角
        Debug.Log($"四元数对应的欧拉角：{rotate}");

        // 示例2：让物体看向一个目标
        // 假设目标位置为原点（0, 0, 0），我们让物体的前方看向该点
        quaternion = Quaternion.LookRotation(Vector3.zero); // 让物体看向 (0, 0, 0)
        Debug.Log($"看向目标的四元数：{quaternion}");
    }
}

Debug类

日志

1
2
3

Debug.Log("test");              // 输出一般信息
Debug.LogWarning("test2");      // 输出警告信息，通常用于提示潜在问题
Debug.LogError("test3");        // 输出错误信息，用于报告严重问题

Debug.Log()：输出常规日志信息，通常用于显示一些状态或调试信息。
Debug.LogWarning()：输出警告信息，适用于告警性的提示，通常不影响程序运行，但可能指示潜在的问题。
Debug.LogError()：输出错误信息，通常用于报告严重错误，可能会中断程序的正常流程。

调试图形

1
2

csharp复制编辑Debug.DrawLine(Vector3.zero, Vector3.one);  // 在 Scene 视图中绘制一条从 (0, 0, 0) 到 (1, 1, 1) 的线段
Debug.DrawRay(Vector3.zero, Vector3.forward);  // 从原点 (0, 0, 0) 绘制一条朝前的射线

Debug.DrawLine()：在 Scene 视图中绘制一条线段。常用于可视化物体之间的连接关系、方向等。
Debug.DrawRay()：在 Scene 视图中绘制一条射线。常用于调试物体的朝向、射线检测等。

MonoBehaviourScript类

MonoBehaviour

MonoBehaviour 是 Unity 中所有脚本的基类。通过继承 MonoBehaviour，脚本可以被挂载到游戏物体上，从而控制游戏物体的行为和属性。它提供了大量生命周期函数（如 Start、Update），以及与 Unity 游戏物体和组件交互的方法。

获取游戏物体

获取挂载的物体

当前脚本挂载的物体可以通过以下方式获取：

1	GameObject go = this.gameObject; // "this" 可以省略

在代码中也可以直接使用 gameObject，无需额外获取。

常见属性：

1
2
3

Debug.Log(gameObject.name);   // 获取物体名称
Debug.Log(gameObject.tag);    // 获取物体标签
Debug.Log(gameObject.layer);  // 获取物体所在层

获取场景中的其他物体

通过 Inspector 绑定物体
- 声明一个 public 的 GameObject 变量，并在 Inspector 面板中手动拖入物体：
1
public GameObject cube; // 在 Inspector 中绑定
通过名字或标签查找物体
1
2
GameObject test = GameObject.Find("Test"); // 按名称查找
GameObject test2 = GameObject.FindWithTag("Test"); // 按标签查找
缺点：
- 如果物体不存在，会返回 null。
- 如果场景中有多个物体匹配名字或标签，只会返回第一个找到的物体。

激活状态

检查物体是否被激活：

1 2	Debug.Log(cube.activeSelf); // 自身是否被激活 Debug.Log(cube.activeInHierarchy); // 实际是否被激活（父物体未激活时，子物体即使自身激活，仍为非激活状态）

操作组件

获取组件

获取 Transform 组件（所有游戏物体默认都有 Transform）：
1
Transform trans = this.transform; // 当前物体的 Transform

获取其他组件：

1
2
3

BoxCollider collider = GetComponent<BoxCollider>();       // 获取当前物体的组件
Collider childCollider = GetComponentInChildren<Collider>(); // 获取子物体的指定组件
Collider parentCollider = GetComponentInParent<Collider>();  // 获取父物体的指定组件

添加组件

动态为物体添加组件：

1	gameObject.AddComponent<AudioSource>(); // 添加 AudioSource 组件

实例化和销毁物体

声明一个 public 的 GameObject 变量用于指定预制体：
1
public GameObject PreFab; // 在 Inspector 中指定

使用代码实例化物体：

1
2
3

GameObject go = Instantiate(PreFab); // 简单实例化一个物体
Instantiate(PreFab, transform);      // 作为当前物体的子物体实例化
Instantiate(PreFab, Vector3.zero, Quaternion.identity); // 放置到原点，初始旋转为 0

销毁物体：

1	Destroy(go); // 销毁实例化的物体

Time 类

public class TimeTest : MonoBehaviour
{
    float timer = 0;

    void Start()
    {
        // 游戏运行至当前的总时间（以秒为单位）
        Debug.Log(Time.time);

        // 时间缩放值（默认 1，可用于控制游戏整体速度）
        Debug.Log(Time.timeScale);

        // 物理引擎更新的固定时间间隔（默认 0.02s，可用于 FixedUpdate）
        Debug.Log(Time.fixedDeltaTime);
    }

    void Update()
    {
        // 记录上一帧到当前帧的时间间隔（单位：秒）
        // 在 60 FPS 下，deltaTime 约为 1/60 ≈ 0.0167s
        Debug.Log(Time.deltaTime);

        // 计时器逻辑：累加经过的时间
        timer += Time.deltaTime;
        
        if (timer > 3)
        {
            // 当时间累计超过 3 秒后重置
            timer = 0;
        }
    }
}

说明：

Time.time：游戏启动到当前的总时间（单位：秒）。
Time.timeScale：时间缩放系数，默认为 1，可用于加速或暂停游戏（0 代表暂停）。
Time.fixedDeltaTime：固定更新间隔，影响 FixedUpdate 的调用频率（默认 0.02s，即 50Hz）。
Time.deltaTime：当前帧与上一帧的时间间隔，常用于帧率无关的计时或动画计算。

Application类

Application.dataPath

描述: 获取游戏数据文件的存储路径。
详细说明: 该路径指向项目的 Assets 文件夹，是只读的。在游戏打包后，该路径下的文件会被加密压缩，无法直接访问。

Application.persistentDataPath

描述: 获取持久化文件的存储路径。
详细说明: 这是由操作系统提供的用户信息存储路径，适合存储需要长期保存的数据，如用户配置、存档等。该路径下的数据不会被加密，且在应用更新时不会被删除。

Application.streamingAssetsPath

描述: 获取 StreamingAssets 文件夹的路径。
详细说明: 该路径下的文件是只读的，但在打包后不会被加密压缩。通常用于存放配置文件、资源文件等需要在运行时读取的内容。

Application.temporaryCachePath

描述: 获取临时文件的存储路径。
详细说明: 这是由操作系统提供的临时文件路径，适合存储一些短期使用的数据。该路径下的文件可能会被系统自动清理。

Application.runInBackground

描述: 控制游戏是否在后台运行。
详细说明: 设置为 true 时，即使游戏窗口失去焦点，游戏仍会继续运行；设置为 false 时，游戏会在窗口失去焦点后暂停。

Application.OpenURL("url")

描述: 打开指定的 URL。
详细说明: 可以用于打开网页链接、调用系统应用（如邮件客户端）等。例如，Application.OpenURL("https://www.example.com") 会打开指定的网页。

Application.Quit()

描述: 退出游戏。
详细说明: 在编辑器模式下调用此方法不会生效，只有在打包后的游戏中才会真正退出应用。

Scene

unity结构：

graph LR
    A[游戏] --> B[场景1]
    A --> C[场景2]
    A --> D[...]
    B --> E[游戏物体1]
    B --> F[游戏物体2]
    B --> G[...]
    E --> H[脚本组件1]
    E --> I[脚本组件2]
    E --> J[...]
    F --> K[脚本组件1]
    F --> L[脚本组件2]
    F --> M[...]
    C --> N[游戏物体1]
    C --> O[游戏物体2]
    C --> P[...]
    N --> Q[脚本组件1]
    N --> R[脚本组件2]
    N --> S[...]
    O --> T[脚本组件1]
    O --> U[脚本组件2]
    O --> V[...]

SceneManager 类

使用 SceneManager 类需要导入以下命名空间：

1	using UnityEngine.SceneManagement;

场景跳转（加载场景）

1	SceneManager.LoadScene("MyScene");

说明: 加载指定名称的场景。
重载方法:
1
SceneManager.LoadScene("MyScene", LoadSceneMode mode);
- LoadSceneMode.Single: 关闭当前场景并加载新场景（默认模式）。
- LoadSceneMode.Additive: 保留当前场景，同时加载新场景。

获取当前场景

1	Scene scene = SceneManager.GetActiveScene();

说明: 获取当前激活的场景对象。

获取已加载场景的数量

1	int count = SceneManager.sceneCount;

说明: 返回当前已加载场景的数量。

创建新场景

1	Scene newScene = SceneManager.CreateScene("NewScene");

说明: 创建一个名为 NewScene 的新场景并返回该场景对象。

卸载场景

1	SceneManager.UnloadSceneAsync(newScene);

说明: 异步卸载指定场景。

Scene 类

场景名称

1	string name = scene.name;

说明: 获取场景的名称。

场景是否已加载

1	bool isLoaded = scene.isLoaded;

说明: 返回一个布尔值，表示场景是否已加载。

场景路径

1	string path = scene.path;

说明: 获取场景的资源路径。

场景索引

1	int index = scene.buildIndex;

说明: 获取场景在构建设置中的索引值。

获取所有根物体

1	GameObject[] gos = scene.GetRootGameObjects();

说明: 返回场景中所有根物体的数组（即直接挂在场景下的物体，不包括子物体）。

以下是润色后的代码和说明，内容更加清晰、结构化，并补充了一些注释和优化建议：

异步场景加载

代码实现

using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;

public class SceneTest : MonoBehaviour
{
    private AsyncOperation operation; // 异步操作对象
    private float timer = 0;         // 计时器

    void Start()
    {
        // 启动协程加载场景
        StartCoroutine(LoadScene());
    }

    IEnumerator LoadScene()
    {
        // 异步加载场景，场景索引为1
        operation = SceneManager.LoadSceneAsync(1);

        // 设置加载完成后不自动跳转
        operation.allowSceneActivation = false;

        // 等待加载完成
        yield return operation;
    }

    void Update()
    {
        // 打印加载进度（0 到 0.9）
        Debug.Log("加载进度: " + operation.progress);

        // 计时器累加
        timer += Time.deltaTime;

        // 5秒后允许场景跳转
        if (timer > 5)
        {
            operation.allowSceneActivation = true;
        }
    }
}

代码说明

AsyncOperation:
- 用于管理异步操作的对象。
- operation.progress 可以获取加载进度，范围为 0 到 0.9（1.0 表示完成，但需要手动激活场景）。
operation.allowSceneActivation:
- 设置为 false 时，场景加载完成后不会自动跳转。
- 设置为 true 时，允许场景跳转。
StartCoroutine:
- 启动协程 LoadScene()，用于异步加载场景。
timer:
- 用于延迟场景跳转的计时器。
- 在 Update() 中累加时间，5秒后允许场景跳转。

Transform 类

Transform 是 Unity 中用于控制 GameObject 的坐标位置、缩放、旋转的核心组件，同时也负责管理 GameObject 的父子关系。可以通过 transform 属性直接访问当前物体挂载的 Transform 组件。

位置、旋转、缩放

获取位置

1 2	transform.position; // 相对于世界坐标的位置 transform.localPosition; // 相对于父物体的位置

获取旋转

transform.rotation;         // 相对于世界坐标的旋转（四元数）
transform.localRotation;    // 相对于父物体的旋转（四元数）
transform.eulerAngles;      // 相对于世界坐标的旋转（欧拉角）
transform.localEulerAngles; // 相对于父物体的旋转（欧拉角）

获取缩放

1	transform.localScale; // 物体的缩放比例

向量

1
2
3

transform.forward; // Z 轴方向（物体前方）
transform.right;   // X 轴方向（物体右方）
transform.up;      // Y 轴方向（物体上方）

看向某个点

1	transform.LookAt(Vector3.zero); // 让物体看向世界坐标原点

应用场景: 可以在 Update 方法中调用，实现物体实时看向某个目标。

旋转

1	transform.Rotate(Vector3.up, 1); // 绕 Y 轴旋转 1 度

绕着某个点旋转

1	transform.RotateAround(Vector3.zero, Vector3.up, 1); // 绕世界坐标原点旋转

移动

1	transform.Translate(Vector3.forward * 0.1f); // 沿 Z 轴移动 0.1 个单位

父子关系

获取父物体

1	GameObject parent = transform.parent.gameObject; // 获取父物体

子物体个数

1	int count = transform.childCount; // 获取子物体数量

获取子物体

1 2	Transform child = transform.Find("Child"); // 通过名称查找子物体 child = transform.GetChild(0); // 通过索引获取子物体

判断是否是子物体

1	bool isChild = child.IsChildOf(transform); // 判断 child 是否是当前物体的子物体

设置父物体

1	child.SetParent(transform); // 将 child 的父物体设置为当前物体

性能优化:
- 频繁调用 transform.Find 可能会影响性能，建议在 Start 或 Awake 中缓存子物体的引用。
- 例如：
  1
  2
  3
  4
  5
  private Transform cachedChild;
  void Start()
  {
  cachedChild = transform.Find("Child");
  }
动态父子关系:
- 在设置父物体时，可以保留子物体的世界坐标位置：
  1
  child.SetParent(transform, false); // 保留子物体的世界坐标

键盘鼠标输入

在 Unity 中，键盘和鼠标的点击事件需要在每一帧进行监听，因此相关代码通常写在 Update 方法中。

鼠标输入

鼠标点击

描述: 检测鼠标按键的按下事件。

代码示例:

if (Input.GetMouseButtonDown(0)) {
    // 按下鼠标左键
}
if (Input.GetMouseButtonDown(1)) {
    // 按下鼠标右键
}
if (Input.GetMouseButtonDown(2)) {
    // 按下鼠标滚轮
}

参数说明:
- 0: 鼠标左键
- 1: 鼠标右键
- 2: 鼠标滚轮

持续按下鼠标

描述: 检测鼠标按键是否被持续按下。

代码示例:

1
2
3

if (Input.GetMouseButton(0)) {
    // 持续按下鼠标左键
}

抬起鼠标

描述: 检测鼠标按键的抬起事件。

代码示例:

1
2
3

if (Input.GetMouseButtonUp(0)) {
    // 抬起鼠标左键
}

键盘输入

按下键盘按键

描述: 检测键盘按键的按下事件。

代码示例:

1
2
3

if (Input.GetKeyDown(KeyCode.A)) {
    // 按下 A 键
}

持续按下键盘

描述: 检测键盘按键是否被持续按下。

代码示例:

1
2
3

if (Input.GetKey(KeyCode.A)) {
    // 持续按下 A 键
}

抬起键盘按键

描述: 检测键盘按键的抬起事件。

代码示例:

1
2
3

if (Input.GetKeyUp(KeyCode.A)) {
    // 抬起 A 键
}

虚拟轴与虚拟按键

在 Unity 中，虚拟轴和虚拟按键可以增加游戏的兼容性，使输入逻辑更加灵活。通过虚拟轴和虚拟按键，开发者可以轻松地映射不同的输入设备（如键盘、手柄等）到同一套逻辑中。

虚拟轴

虚拟轴的值是一个介于 -1 到 1 之间的浮点数，常用于控制角色的移动或视角的旋转。

水平轴

描述: 获取水平方向的输入值（例如，A/D 键或左右方向键）。

代码示例:

1	float horizontal = Input.GetAxis("Horizontal");

说明:
- 值为 -1 表示向左，1 表示向右，0 表示无输入。

垂直轴

描述: 获取垂直方向的输入值（例如，W/S 键或上下方向键）。

代码示例:

1	float vertical = Input.GetAxis("Vertical");

说明:
- 值为 -1 表示向下，1 表示向上，0 表示无输入。

虚拟按键

虚拟按键允许开发者将不同的按键映射到同一个逻辑上，例如将空格键或手柄的 A 键都映射为“跳跃”。

按下虚拟按键

描述: 检测虚拟按键的按下事件。

代码示例:

1
2
3

if (Input.GetButtonDown("Jump")) {
    // 按下跳跃键（例如空格键）
}

持续按下虚拟按键

描述: 检测虚拟按键是否被持续按下。

代码示例:

1
2
3

if (Input.GetButton("Jump")) {
    // 持续按下跳跃键
}

抬起虚拟按键

描述: 检测虚拟按键的抬起事件。

代码示例:

1
2
3

if (Input.GetButtonUp("Jump")) {
    // 抬起跳跃键
}

配置虚拟轴与虚拟按键

在 Unity 中，可以通过以下路径配置虚拟轴和虚拟按键：

打开菜单栏：Edit -> Project Settings -> Input Manager。
在 Axes 中可以看到默认的虚拟轴（如 Horizontal、Vertical、Jump 等）。
可以修改或添加新的虚拟轴/虚拟按键，并为其绑定不同的输入设备按键。

触摸输入

Unity 提供了对触摸输入的支持，可以处理单点触摸和多点触摸。以下是如何在 Unity 中实现触摸输入的相关代码和说明。

单点触摸

判断单点触摸

描述: 检测屏幕上是否有一个触摸点。

代码示例:

if (Input.touchCount == 1) {
    // 获取触摸对象
    Touch touch = Input.GetTouch(0);
    
    // 输出触摸位置
    Debug.Log("Touch Position: " + touch.position);
    
    // 根据触摸阶段处理逻辑
    switch (touch.phase) {
        case TouchPhase.Began:
            // 触摸开始
            break;
        case TouchPhase.Moved:
            // 触摸移动
            break;
        case TouchPhase.Stationary:
            // 触摸静止
            break;
        case TouchPhase.Ended:
            // 触摸结束
            break;
        case TouchPhase.Canceled:
            // 触摸取消
            break;
    }
}

触摸阶段说明:

TouchPhase.Began: 手指刚刚触摸屏幕。
TouchPhase.Moved: 手指在屏幕上移动。
TouchPhase.Stationary: 手指在屏幕上静止不动。
TouchPhase.Ended: 手指离开屏幕。
TouchPhase.Canceled: 触摸被系统取消（例如来电中断）。

多点触摸

开启多点触摸

描述: 启用多点触摸支持。
代码示例:
1
Input.multiTouchEnabled = true;

判断多点触摸

描述: 检测屏幕上是否有多个触摸点。

代码示例:

if (Input.touchCount == 2) {
    // 获取两个触摸对象
    Touch touch1 = Input.GetTouch(0);
    Touch touch2 = Input.GetTouch(1);
    
    // 输出触摸位置
    Debug.Log("Touch 1 Position: " + touch1.position);
    Debug.Log("Touch 2 Position: " + touch2.position);
    
    // 根据触摸阶段处理逻辑
    switch (touch1.phase) {
        case TouchPhase.Began:
            // 触摸1开始
            break;
        case TouchPhase.Moved:
            // 触摸1移动
            break;
        case TouchPhase.Stationary:
            // 触摸1静止
            break;
        case TouchPhase.Ended:
            // 触摸1结束
            break;
        case TouchPhase.Canceled:
            // 触摸1取消
            break;
    }
    
    switch (touch2.phase) {
        case TouchPhase.Began:
            // 触摸2开始
            break;
        case TouchPhase.Moved:
            // 触摸2移动
            break;
        case TouchPhase.Stationary:
            // 触摸2静止
            break;
        case TouchPhase.Ended:
            // 触摸2结束
            break;
        case TouchPhase.Canceled:
            // 触摸2取消
            break;
    }
}

触摸位置

在 Unity 中，Touch.position 返回的是触摸点在屏幕上的像素坐标（以屏幕左下角为原点 (0, 0)，右上角为 (Screen.width, Screen.height)）。如果需要将屏幕坐标转换为世界坐标，可以使用 Camera.ScreenToWorldPoint 方法。

if (Input.touchCount > 0) {
    Touch touch = Input.GetTouch(0);
    
    // 获取触摸点的屏幕坐标
    Vector2 touchPosition = touch.position;
    
    // 将屏幕坐标转换为世界坐标
    Vector3 worldPosition = Camera.main.ScreenToWorldPoint(new Vector3(touchPosition.x, touchPosition.y, cameraDistance));
    
    Debug.Log("World Position: " + worldPosition);
}

参数说明

touchPosition: 触摸点的屏幕坐标。
cameraDistance: 相机到触摸点的距离（通常为相机的 z 坐标值）。
- 如果使用的是正交相机（Orthographic Camera），cameraDistance 可以是任意值，因为正交相机没有透视效果。
- 如果使用的是透视相机（Perspective Camera），cameraDistance 需要根据场景中的物体位置来设置，通常为相机到目标平面的距离。

灯光

Unity 中的灯光系统是场景渲染的重要组成部分，提供了多种灯光类型和设置选项。以下是关于灯光及其相关功能的说明。

烘焙（Bake）

描述: 烘焙是一种提前渲染灯光的技术，将光照信息预先计算并存储到光照贴图（Lightmap）中，运行时不再实时计算光照，从而提升性能。
适用场景: 适用于静态物体（如场景中的墙壁、地面等），不适用于动态物体。
使用方法:
1. 将场景中的静态物体标记为 Static。
2. 在 Lighting 窗口（Window -> Rendering -> Lighting）中配置烘焙设置。
3. 点击 Generate Lighting 开始烘焙。

灯光类型

Directional Light（定向光）

描述: 平行光线，模拟太阳光的效果。光线从无穷远的地方照射，方向由灯光物体的旋转决定。
特点:
- 光线方向一致，不受位置影响。
- 适用于室外场景的主光源。

示例:

1 2	Light directionalLight = GameObject.Find("Directional Light").GetComponent<Light>(); directionalLight.type = LightType.Directional;

Spot Light（聚光灯）

描述: 类似于手电筒的效果，光线从一个点发出，呈锥形照射。
特点:
- 可以调整光照范围（Range）和锥形角度（Spot Angle）。
- 适用于局部照明，如舞台灯光或手电筒效果。

示例:

Light spotLight = GameObject.Find("Spot Light").GetComponent<Light>();
spotLight.type = LightType.Spot;
spotLight.range = 10; // 光照范围
spotLight.spotAngle = 45; // 锥形角度

Point Light（点光源）

描述: 从一个点向四周均匀发射光线，光线强度随距离衰减。
特点:
- 可以调整光照范围（Range）。
- 适用于灯泡、蜡烛等局部光源。

示例:

1
2
3

Light pointLight = GameObject.Find("Point Light").GetComponent<Light>();
pointLight.type = LightType.Point;
pointLight.range = 5; // 光照范围

Area Light（区域光，仅烘焙）

描述: 从一个平面或矩形区域发射光线，仅支持烘焙。
特点:
- 光线从一个面均匀发射，适合模拟窗户光或灯箱效果。
- 需要将物体标记为 Static 并启用烘焙。

示例:

1
2
3

Light areaLight = GameObject.Find("Area Light").GetComponent<Light>();
areaLight.type = LightType.Area;
areaLight.range = 10; // 光照范围

Culling Mask（剔除遮罩）

描述: 通过选择图层，使光源对特定图层无作用。
使用方法:
1. 在 Light 组件的 Culling Mask 中选择需要剔除的图层。
2. 未被选中的图层将不受该光源的影响。
适用场景: 用于控制光源的照射范围，例如只让某个光源影响特定物体。

摄像机

Unity 中的摄像机（Camera）是渲染场景的核心组件，用于决定玩家看到的画面。以下是关于摄像机的类型、背景设置和优先级的详细说明。

摄像机类型

1. 透视摄像机（Perspective Camera）

描述: 模拟人眼的视觉效果，具有近大远小的透视效果。
特点:
- 适合 3D 场景，能够表现深度和距离感。
- 通过调整 Field of View（视野）控制视角范围。

示例:

1
2
3

Camera mainCamera = Camera.main;
mainCamera.orthographic = false; // 设置为透视模式
mainCamera.fieldOfView = 60; // 设置视野角度

2. 正交摄像机（Orthographic Camera）

描述: 忽略透视效果，物体无论远近大小一致。
特点:
- 适合 2D 游戏或平面物体渲染。
- 通过调整 Orthographic Size 控制显示范围。

示例:

1
2
3

Camera mainCamera = Camera.main;
mainCamera.orthographic = true; // 设置为正交模式
mainCamera.orthographicSize = 5; // 设置显示范围

背景设置（Background Type）

摄像机的背景设置决定了场景中未被物体填充的部分显示什么内容。

清除标志（Clear Flags）

Solid Color: 使用纯色填充背景。
Skybox: 使用天空盒作为背景（默认选项）。
Depth Only: 仅清除深度信息，用于多摄像机叠加渲染。
Don’t Clear: 不清除任何内容，可能导致画面残留。

设置背景

纯色背景:

1
2
3

Camera mainCamera = Camera.main;
mainCamera.clearFlags = CameraClearFlags.SolidColor;
mainCamera.backgroundColor = Color.blue; // 设置背景为蓝色

天空盒背景:

1 2	Camera mainCamera = Camera.main; mainCamera.clearFlags = CameraClearFlags.Skybox;

优先级（深度）

当场景中有多个摄像机时，可以通过设置 Depth 属性来控制摄像机的渲染顺序。

深度值越高，摄像机渲染的优先级越高。
深度值较低的摄像机会被深度值较高的摄像机覆盖。

示例:

Camera camera1 = GameObject.Find("Camera1").GetComponent<Camera>();
Camera camera2 = GameObject.Find("Camera2").GetComponent<Camera>();

camera1.depth = 0; // 低优先级
camera2.depth = 1; // 高优先级，camera2 的画面会覆盖 camera1

其他常用设置

视口矩形（Viewport Rect）:
- 控制摄像机渲染画面在屏幕上的位置和大小。
- 例如，可以用于实现分屏效果。
  1
  2
  Camera mainCamera = Camera.main;
  mainCamera.rect = new Rect(0, 0, 0.5f, 1); // 渲染画面占据屏幕左半部分

裁剪平面（Clipping Planes）:

Near 和 Far 分别控制摄像机渲染的最近和最远距离。

超出该范围的物体不会被渲染。

1
2
3

Camera mainCamera = Camera.main;
mainCamera.nearClipPlane = 0.3f; // 最近裁剪距离
mainCamera.farClipPlane = 1000; // 最远裁剪距离

音频系统

Unity 的音频系统允许开发者在游戏中播放背景音乐和音效。以下是关于音频监听器、音频源以及通过脚本控制音频播放的详细说明。

音频监听器（Audio Listener）

描述: 音频监听器是接收场景中所有音频的组件，通常附加在主摄像机上。
注意事项:
- 一个场景中只需要一个音频监听器。
- 如果场景中有多个摄像机，确保只有一个摄像机附加了 Audio Listener 组件。

音频源（Audio Source）

描述: 音频源是用于播放音频的组件，可以附加到任何游戏对象上。
使用方法:
1. 在场景中选择一个游戏对象。
2. 在 Inspector 窗口中，点击 Add Component，搜索并添加 Audio Source 组件。
3. 配置音频源的属性，如音频片段（AudioClip）、音量（Volume）、循环（Loop）等。

脚本控制音频

背景音乐控制

描述: 通过脚本控制背景音乐的播放、暂停和继续。

代码示例:

public AudioClip music; // 通过拖动绑定音频片段
private AudioSource player;

void Start() {
    player = GetComponent<AudioSource>();
    player.clip = music; // 设置播放的音频片段
    player.loop = true;  // 设置循环播放
    player.volume = 0.5f; // 设置音量
    player.Play(); // 开始播放
}

void Update() {
    // 按空格键切换播放和暂停
    if (Input.GetKeyDown(KeyCode.Space)) {
        if (player.isPlaying) {
            player.Pause(); // 暂停播放
        } else {
            player.UnPause(); // 继续播放
        }
    }
}

音效控制

描述: 通过脚本控制音效的播放，适合短促的声音效果。

代码示例:

public AudioClip se; // 通过拖动绑定音效片段
private AudioSource player;

void Start() {
    player = GetComponent<AudioSource>();
}

void Update() {
    // 按鼠标左键播放音效
    if (Input.GetMouseButtonDown(0)) {
        player.PlayOneShot(se); // 播放音效
    }
}

常用属性和方法

Audio Source 属性

clip: 设置要播放的音频片段。
loop: 是否循环播放。
volume: 音量大小（0 到 1 之间）。
playOnAwake: 是否在游戏启动时自动播放。

Audio Source 方法

Play(): 开始播放音频。
Pause(): 暂停播放。
UnPause(): 继续播放。
Stop(): 停止播放。
PlayOneShot(AudioClip clip): 播放一次音效，适合短促的声音。

视频播放

Unity 支持在游戏中播放视频，可以通过 Video Player 组件实现。以下是关于视频播放的设置和脚本控制的详细说明。

视频播放设置

方法一：通过渲染器纹理（Render Texture）

创建渲染器纹理:
- 在项目中右键点击，选择 Create -> Render Texture。
- 设置渲染器纹理的分辨率（如 1920x1080）。
创建平面并添加 Video Player 组件:
- 在场景中创建一个平面（GameObject -> 3D Object -> Plane）。
- 在平面对象上添加 Video Player 组件（Add Component -> Video -> Video Player）。
配置 Video Player:
- 在 Video Clip 中选择要播放的视频文件。
- 将 Render Mode 设置为 Render Texture。
- 将之前创建的渲染器纹理拖到 Target Texture 中。
应用纹理到平面:
- 创建一个材质（Create -> Material），并将其着色器设置为 Unlit/Texture。
- 将渲染器纹理拖到材质的纹理槽中。
- 将材质应用到平面上。

方法二：通过 UI 原始图像

创建 UI 原始图像:
- 在场景中右键点击，选择 UI -> Raw Image。
- 在 Raw Image 组件中，将 Texture 设置为渲染器纹理。
配置 Video Player:
- 在 Video Player 组件中，将 Render Mode 设置为 Render Texture。
- 将渲染器纹理拖到 Target Texture 中。

脚本控制视频播放

以下是通过脚本控制视频播放的示例代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Video;

public class VideoTest : MonoBehaviour {
    private VideoPlayer player;

    void Start() {
        player = GetComponent<VideoPlayer>();
    }

    void Update() {
        // 按鼠标左键控制视频播放
        if (Input.GetMouseButtonDown(0)) {
            if (player.isPlaying) {
                player.Pause(); // 暂停播放
            } else {
                player.Play(); // 开始播放
            }
        }
    }
}

Video Player

属性

Video Clip: 设置要播放的视频文件。
Render Mode: 设置视频渲染模式，如 Render Texture、Camera Far Plane 等。
Target Texture: 当 Render Mode 为 Render Texture 时，指定渲染器纹理。
Loop: 是否循环播放视频。
Play On Awake: 是否在游戏启动时自动播放视频。

方法

Play(): 开始播放视频。
Pause(): 暂停播放。
Stop(): 停止播放。
IsPlaying: 判断视频是否正在播放。

角色控制

在 Unity 中，CharacterController 组件常用于实现玩家角色的移动。以下是关于 CharacterController 的使用笔记，以及 Move 和 SimpleMove 方法的区别和用法。

代码示例

public class PlayerControl : MonoBehaviour {
    private CharacterController player;

    void Start() {
        player = GetComponent<CharacterController>(); // 获取 CharacterController 组件
    }

    void Update() {
        // 获取水平和垂直轴输入
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        // 创建方向向量
        Vector3 dir = new Vector3(horizontal, 0, vertical);

        // 朝向该方向移动
        player.SimpleMove(dir * 2); // 使用 SimpleMove 方法移动
    }
}

`SimpleMove` 和 `Move`

`SimpleMove`

描述: 用于简单的角色移动，自动处理重力。
特点:
- 参数为速度向量（Vector3），单位是米/秒。
- 重力会自动应用，无需手动计算。
- 适用于不需要精确控制垂直速度的场景。
示例:
1
player.SimpleMove(dir * speed);

`Move`

描述: 用于更复杂的角色移动，需要手动处理重力。
特点:
- 参数为位移向量（Vector3），单位是米。
- 需要手动计算重力和其他外力（如跳跃）。
- 适用于需要精确控制移动的场景。

示例:

1
2
3

Vector3 moveDir = dir * speed * Time.deltaTime;
moveDir.y -= gravity * Time.deltaTime; // 手动应用重力
player.Move(moveDir);

本文作者： NICK
本文链接： https://nicccce.github.io/TechNotes/Unity-Note/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！

Unity 笔记

编辑器

Prefab

1. 创建预制体

2. 修改预制体

3. 修改 Scene 中的预制体实例

4. 创建预制体的变体（Prefab Variant）

Vector类

1. 创建向量

2. 常用快捷向量

3. 修改向量

4. 向量运算

5. 示例代码

旋转

1. 欧拉角与四元数概述

2. 代码示例

Debug类

日志

调试图形

MonoBehaviourScript类

MonoBehaviour

获取游戏物体

获取挂载的物体

获取场景中的其他物体

激活状态

操作组件

获取组件

添加组件

实例化和销毁物体

Time 类

Application类

Application.dataPath

Application.persistentDataPath

Application.streamingAssetsPath

Application.temporaryCachePath

Application.runInBackground

Application.OpenURL("url")

Application.Quit()

Scene

SceneManager 类

场景跳转（加载场景）

获取当前场景

获取已加载场景的数量

创建新场景

卸载场景

Scene 类

场景名称

场景是否已加载

场景路径

场景索引

获取所有根物体

异步场景加载

Transform 类

位置、旋转、缩放

获取位置

获取旋转

获取缩放

向量

看向某个点

旋转

绕着某个点旋转

移动

父子关系

获取父物体

子物体个数

获取子物体

判断是否是子物体

设置父物体

键盘鼠标输入

鼠标输入

鼠标点击

持续按下鼠标

抬起鼠标

键盘输入

按下键盘按键

持续按下键盘

抬起键盘按键

虚拟轴与虚拟按键

虚拟轴

水平轴

`Application.dataPath`

`Application.persistentDataPath`

`Application.streamingAssetsPath`

`Application.temporaryCachePath`

`Application.runInBackground`

`Application.OpenURL("url")`

`Application.Quit()`

`SimpleMove` 和 `Move`

`SimpleMove`

`Move`