Unity on 水元素长弓

Addressables的认识与使用

Tue, 29 Sep 2026 18:54:55 +0800

什么是 Addressables

Addressables 是 Unity 官方推出的动态资源管理系统，它允许你通过一个简单的"地址"字符串来加载资源，无论该资源是打包在应用本地，还是存放在远程服务器上。

一句话概括：Addressables = 官方在 AssetBundle 之上封装的一套"按地址加载资源"的完整方案，帮你自动处理打包、依赖、加载、卸载、远程更新等繁琐细节。

下面从"为什么需要它"讲起，逐步深入到能真正上手开发。

一、为什么需要 Addressables

在 Addressables 出现之前，Unity 加载资源主要有两种方式，它们各有明显缺陷。

1.1 Resources 文件夹

把资源放进 Assets/Resources，然后用 Resources.Load 加载。

1
2


var prefab = Resources.Load<GameObject>("Prefabs/Player");
Instantiate(prefab);

优点：简单，不用打包配置。

缺点（也是它被官方劝退的原因）：

问题	说明
全部打进包	`Resources` 里所有资源都会被无条件打进安装包，导致包体臃肿
无法热更新	资源在构建后就固定了，不能在线替换
启动变慢	游戏启动时要加载整个 Resources 索引，文件夹越大越慢
内存僵硬	缺少引用计数，加载后难以精确卸载
路径字符串硬编码	拼错只有运行时才报错，难以维护

Unity 官方文档明确建议：新项目不要使用 Resources 文件夹，改用 Addressables。

1.2 AssetBundle（AB 包）

AssetBundle 是 Unity 底层的资源打包格式，功能强大但非常"原始"。

痛点：

要自己规划哪些资源打进哪个包
要自己处理依赖关系（A 包依赖 B 包，必须先加载 B）
要自己管理加载 / 卸载和引用计数
要自己实现版本号、Catalog、下载、校验
极易出现"资源重复打包"“内存泄漏"“依赖丢失"等问题

1.3 Addressables 的定位

Addressables 把上面这些脏活累活封装起来：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


 ┌─────────────────────────────────────────┐
 │ 你的游戏代码 │
 │ Addressables.LoadAssetAsync<T>("地址") │
 └───────────────────┬─────────────────────┘
 │
 ┌───────────────────▼─────────────────────┐
 │ Addressables 系统 │
 │ · 地址解析 · 依赖分析 · 引用计数 │
 │ · 分组打包 · 远程下载 · 目录管理 │
 └───────────────────┬─────────────────────┘
 │
 ┌───────────────────▼─────────────────────┐
 │ AssetBundle │
 └─────────────────────────────────────────┘

三种方式对比：

维度	Resources	AssetBundle	Addressables
上手难度	极低	高	中低
按需加载	差	好	好
依赖管理	自动但僵硬	手动	自动
热更新	不支持	支持（自己实现）	支持（内置）
引用计数	无	手动	内置
包体控制	差	好	好
官方推荐	否	底层可选	是

二、核心概念

理解这几个名词，就理解了 Addressables 的骨架。

概念	英文	说明
地址	Address	加载资源用的字符串 key，如 `"Player"`、`"UI/Login"`
资源条目	Asset Entry	标记为 Addressable 的一个资源
组	Group	资源的集合，一个组会打成一个或多个 Bundle
标签	Label	给资源打的标记，可按标签批量加载
配置档案	Profile	一组路径变量（本地/远程构建与加载路径）
目录	Catalog	记录所有地址、依赖、Bundle 位置的清单文件
加载句柄	AsyncOperationHandle	异步操作的句柄，用于获取结果和释放
资源引用	AssetReference	可序列化的资源引用，避免直接硬引用

它们的关系：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


Address "Player"
 │ 属于
 ▼
 Asset Entry ──标记──> Label "character"
 │ 归属
 ▼
 Group "Characters" ──打包──> Bundle (.bundle)
 │ 记录在
 ▼
 Catalog (catalog.json)
 │ 存放位置由
 ▼
 Profile 变量（本地 / 远程）

关键点：地址（Address）不是资源路径。 它是一个逻辑名字，你完全可以把 Assets/Prefabs/Player.prefab 的地址设为 "Player"。地址可以任意修改，而不用改代码里的资源位置。

三、安装与初始化

3.1 安装包

打开 Window > Package Manager
选择 Unity Registry
搜索 Addressables，点击 Install

或直接编辑 Packages/manifest.json：

1
2
3
4
5


{
 "dependencies": {
 "com.unity.addressables": "1.21.21"
 }
}

不同 Unity 版本对应的 Addressables 版本不同，2021 LTS 常用 1.19~1.21，Unity 6 开始有 2.x。以包管理器推荐的版本为准。

3.2 初始化设置

安装后打开 Window > Asset Management > Addressables > Groups。

第一次打开会提示创建 Addressable 设置文件，它会生成：

1
2
3
4
5


Assets/AddressableAssetsData/
├── AddressableAssetSettings.asset # 系统总配置
├── AssetGroups/ # 默认资源组
├── DataBuilders/ # 打包脚本
└── ...

这个文件夹必须提交到版本控制（它是配置，不是产物）。

3.3 Play Mode 脚本

Groups 窗口顶部有一个 Play Mode Script 下拉框，决定编辑器里运行时的加载方式：

模式	作用	使用场景
`Use Asset Database (fastest)`	直接读 Asset 数据库，不打包	日常开发，迭代最快
`Simulate Groups (advanced)`	模拟打包，但资源仍从 Asset 读	测试打包布局和依赖
`Use Existing Build (requires built groups)`	用上次真实构建的 Bundle	测试真机行为、远程下载

新手最常见的困惑：“我刚标记了资源，运行时却加载不到”——多半是这里选了 Use Existing Build 但没重新 Build。开发期请用 Use Asset Database。

四、快速上手

4.1 把一个资源标记为 Addressable

两种方式：

选中资源，在 Inspector 顶部勾选 Addressable
直接把它拖进 Addressables Groups 窗口

标记后，资源会出现在 Groups 窗口中，并自动生成一个地址（默认就是资源路径）。

建议：手动把地址改成语义化的短名字，例如 "Player" 而不是 "Assets/Prefabs/Player.prefab"。

4.2 加载资源

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class LoadExample : MonoBehaviour
{
 async void Start()
 {
 // 异步加载（推荐）：await 等待完成，拿到资源
 AsyncOperationHandle<GameObject> handle =
 Addressables.LoadAssetAsync<GameObject>("Player");

 await handle.Task;

 if (handle.Status == AsyncOperationStatus.Succeeded)
 {
 GameObject prefab = handle.Result;
 Instantiate(prefab);
 }

 // 用完释放（重要！）
 Addressables.Release(handle);
 }
}

也可以不用 async/await，用回调：

1
2
3
4
5
6


var handle = Addressables.LoadAssetAsync<GameObject>("Player");
handle.Completed += op =>
{
 if (op.Status == AsyncOperationStatus.Succeeded)
 Instantiate(op.Result);
};

4.3 直接实例化

如果只是想生成一个 Prefab 实例，用 InstantiateAsync 更省事（它内部帮你加载 + 实例化）：

1
2
3
4
5
6
7
8
9


AsyncOperationHandle<GameObject> handle =
 Addressables.InstantiateAsync("Player", parent: transform);

await handle.Task;

GameObject go = handle.Result;

// 销毁实例并释放引用
Addressables.ReleaseInstance(go);

ReleaseInstance 会销毁这个由 Addressables 实例化的对象，并递减引用计数。不要用普通的 Destroy，否则引用计数不会释放，造成内存泄漏。

4.4 加载图标 / 文本等非 GameObject 资源

1
2
3
4
5
6
7
8
9


// 加载 Sprite
var spriteHandle = Addressables.LoadAssetAsync<Sprite>("Icon_Coin");
await spriteHandle.Task;
image.sprite = spriteHandle.Result;

// 加载 TextAsset（配置文本）
var textHandle = Addressables.LoadAssetAsync<TextAsset>("config_level");
await textHandle.Task;
string json = textHandle.Result.text;

五、加载 API 详解

5.1 主要加载接口

API	说明
`LoadAssetAsync<T>(key)`	加载单个资源，返回 `AsyncOperationHandle<T>`
`LoadAssetsAsync<T>(key, callback, mergeMode)`	按 key 或标签批量加载
`InstantiateAsync(key, parent, ...)`	加载并实例化 Prefab
`LoadSceneAsync(key, loadMode)`	加载场景
`DownloadDependenciesAsync(key)`	只下载依赖（远程资源）
`GetDownloadSizeAsync(key)`	查询需要下载的大小

5.2 AsyncOperationHandle

AsyncOperationHandle<T> 是 Addressables 异步操作的核心对象。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


var handle = Addressables.LoadAssetAsync<GameObject>("Player");

// 1. 检查状态
handle.Status; // None / Succeeded / Failed
handle.IsValid(); // 句柄是否有效
handle.IsDone; // 是否完成

// 2. 获取进度
handle.PercentComplete; // 0.0 ~ 1.0

// 3. 取结果
handle.Result;

// 4. 注册回调（可注册多个）
handle.Completed += OnLoaded;

// 5. 同步等待（阻塞当前线程，谨慎使用！）
handle.WaitForCompletion();

// 6. 释放
Addressables.Release(handle);

WaitForCompletion() 会卡住主线程直到加载完成，会造成掉帧。只在初始化等确实需要同步的场景使用，普通游戏逻辑一律用异步。

5.3 批量加载

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 方式一：多个地址一次加载
var keys = new List<string> { "Icon_Coin", "Icon_Gem", "Icon_Heart" };
var handle = Addressables.LoadAssetsAsync<Sprite>(keys, null, MergeMode.Union);
await handle.Task;
foreach (var sprite in handle.Result) { /* ... */ }
Addressables.Release(handle);

// 方式二：按标签批量加载
var labelHandle = Addressables.LoadAssetsAsync<Sprite>("ui_icon", null);
await labelHandle.Task;
Addressables.Release(labelHandle);

MergeMode（合并模式）用于多个 key 的结果合并方式：

模式	含义
`UseFirst`	使用第一个 key 的结果
`Union`	并集（默认），所有 key 的结果都包含
`Intersection`	交集，只包含被所有 key 命中的资源

5.4 引用计数与释放

Addressables 用引用计数管理资源生命周期，这是最容易出错的地方。

规则：

每 Load 一次，引用计数 +1
每 Release 一次，引用计数 -1
引用计数归零时，资源才真正从内存卸载

1
2
3
4
5
6
7


var h1 = Addressables.LoadAssetAsync<GameObject>("Player"); // 计数 = 1
var h2 = Addressables.LoadAssetAsync<GameObject>("Player"); // 计数 = 2

Addressables.Release(h1); // 计数 = 1，资源仍在内存
Addressables.Release(h2); // 计数 = 0，资源被卸载

// 如果忘记 Release，资源会一直留在内存中 —— 内存泄漏！

实例化的释放规则不同：

1
2
3
4
5
6


var go = await Addressables.InstantiateAsync("Enemy").Task;
// 用 ReleaseInstance 销毁实例并释放
Addressables.ReleaseInstance(go);

// 如果第二个参数 trackHandle 传 false，则 InstantiateAsync 不跟踪句柄，
// 此时用普通的 Destroy(go) 即可，但要自己确保资源加载句柄被释放

口诀：Load 配对 Release；InstantiateAsync 配对 ReleaseInstance。

六、资源组与打包策略

6.1 Group 的关键设置

在 Groups 窗口选中一个组，Inspector 里可配置：

设置	说明
`Include In Build`	是否参与构建（远程组本地测试时可能临时关掉）
`Bundle Mode`	一个组打成几个 Bundle
`Compression`	压缩方式（Uncompressed / LZ4 / LZMA）
`Content Update Restriction`	内容更新限制策略
`Asset Load Mode`	加载粒度（按需 / 整包）

6.2 Bundle Mode（打包方式）

模式	说明	适用
`Pack Together`	整个组打成一个 Bundle	资源少、总是一起用
`Pack Separately`	每个资源单独一个 Bundle	大资源、需要独立更新
`Pack Together By Label`	按标签分 Bundle	按用途分类

6.3 Compression（压缩方式）

方式	特点	场景
`Uncompressed`	不压缩，加载最快，包最大	本地频繁加载
`LZ4`	分块压缩，可随机读取，速度快	本地资源首选
`LZMA`	压缩率最高，需整包解压，加载慢	远程下载首选（省流量）

经验：本地组用 LZ4，远程组用 LZMA。远程包下载到本地缓存后会解压。

6.4 打包策略建议

按使用场景分组：把总是一起出现的资源放同一组（如"登录界面"“新手村”）
控制粒度：Bundle 太多会导致 IO 次数多、Catalog 大；太少会导致加载冗余、更新不灵活
大资源拆开：视频、大图单独成包，避免牵连无关资源重新下载
避免重复：多个 Bundle 依赖同一资源时，Addressables 会自动把公共依赖提到共享 Bundle，但要检查 Check Duplicate Bundle Dependencies

七、远程资源与热更新

这是 Addressables 最有价值的部分，也是游戏上线后运营的核心能力。

7.1 Profile 与路径变量

打开 Window > Asset Management > Addressables > Profiles，可以看到路径变量。

内置变量（不同版本略有差异）：

变量	含义
`Local.BuildPath`	本地资源的构建输出目录
`Local.LoadPath`	运行时本地资源的读取路径
`Remote.BuildPath`	远程资源的构建输出目录
`Remote.LoadPath`	运行时远程资源的下载地址（如 CDN）

默认值类似：

1
2
3
4


Local.BuildPath = [UnityEngine.AddressableAssets.Addressables.BuildPath]/[BuildTarget]
Local.LoadPath = {UnityEngine.AddressableAssets.Addressables.RuntimePath}/[BuildTarget]
Remote.BuildPath = ServerData/[BuildTarget]
Remote.LoadPath = http://localhost/[BuildTarget]

7.2 把组切到远程

选中 Group，在 Content Packing & Loading > Build & Load Paths 里把：

Build Path 设为 Remote
Load Path 设为 Remote

这样该组就会打包到远程目录，运行时从 Remote.LoadPath 下载。

7.3 构建与部署

Window > Asset Management > Addressables > Groups
菜单 Build > New Build > Default Build Script
产物在 ServerData/[BuildTarget]/ 下：

1
2
3
4
5


ServerData/StandaloneWindows64/
├── catalog.json # 目录清单
├── catalog_xxx.hash # 目录哈希
├── catalog_xxx.bundle
└── *.bundle # 资源包

把 ServerData 里的内容上传到 CDN / 服务器，与 Remote.LoadPath 对应。

7.4 运行时检查与下载

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

async void CheckUpdate()
{
 // 1. 检查 Catalog 是否有更新
 AsyncOperationHandle<List<string>> checkHandle =
 Addressables.CheckForCatalogUpdates();
 await checkHandle.Task;
 List<string> catalogs = checkHandle.Result;

 if (catalogs != null && catalogs.Count > 0)
 {
 // 2. 更新本地 Catalog
 AsyncOperationHandle<List<IResourceLocator>> updateHandle =
 Addressables.UpdateCatalogs(catalogs);
 await updateHandle.Task;
 }

 // 3. 查询某个资源需要下载多少字节
 long size = await Addressables.GetDownloadSizeAsync("Chapter_02").Task;
 Debug.Log($"需要下载 {size / 1024f / 1024f:F2} MB");

 if (size > 0)
 {
 // 4. 下载依赖
 var downloadHandle =
 Addressables.DownloadDependenciesAsync("Chapter_02");
 while (!downloadHandle.IsDone)
 {
 Debug.Log($"下载进度：{downloadHandle.PercentComplete:P0}");
 await System.Threading.Tasks.Task.Yield();
 }
 Addressables.Release(downloadHandle);
 }
}

7.5 热更新的原理与限制

本地 Catalog 更新：游戏自带的 Catalog 版本旧了，启动时从服务器拉最新 Catalog，就能知道新资源在哪
资源内容更新：只需上传改动过的 Bundle + 新 Catalog，玩家按需下载
不能更新代码：Addressables 只能热更资源。逻辑代码的热更需要 Lua（xLua/ToLua）、ILRuntime 等方案配合

Content Update 工作流（增量更新）：

首次发布：Build > New Build
内容改动后：先把现有构建结果设为基线 Build > Update a Previous Build
选择上一次构建的 addressables_content_state.bin
生成增量 Bundle

这个 addressables_content_state.bin 文件必须妥善保存，每次增量更新都基于它，丢了就只能全量重发。

八、依赖与引用

8.1 自动依赖分析

Addressables 会自动分析资源依赖，并把公共依赖提取到共享 Bundle。

例如 Player.prefab 引用了 Weapon.mat，若把 Player.prefab 设为 Addressable，Weapon.mat 会被自动包含进依赖 Bundle。

重要副作用：如果你只想加载 Weapon.mat，它可能因为依赖关系被连带打包。此时应显式把 Weapon.mat 也标记为 Addressable，并设置好地址，避免加载 Player 才能拿到材质。

8.2 用 AssetReference 替代硬引用

问题：如果某个 MonoBehaviour 脚本里直接 public GameObject prefab; 并用 Inspector 拖拽，那么该资源会被硬引用，无法动态加载，也会被强制打进包。

解决：用 AssetReference。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


using UnityEngine;
using UnityEngine.AddressableAssets;

public class Spawner : MonoBehaviour
{
 // 在 Inspector 中通过 AssetReference 选择一个 Addressable 资源
 public AssetReferenceGameObject enemyRef;

 async void Spawn()
 {
 // 通过引用加载，而非硬引用
 AsyncOperationHandle<GameObject> handle = enemyRef.InstantiateAsync();
 await handle.Task;
 // ...
 }

 void OnDestroy()
 {
 enemyRef.ReleaseInstance(); // 释放该引用实例化的对象
 }
}

AssetReference 家族：

类型	用途
`AssetReference`	通用
`AssetReferenceGameObject`	GameObject/Prefab
`AssetReferenceSprite`	Sprite
`AssetReferenceAtlasedSprite`	图集 Sprite
`AssetReferenceT<T>`	泛型自定义

好处：

不产生硬引用，资源可动态加载
Inspector 中只能选择 Addressable 资源，避免误拖
可序列化，支持 ID 引用，资源改名不影响

九、标签（Label）的使用

标签用于给资源分类，便于批量加载和更新管理。

添加标签：在 Groups 窗口中选中资源条目，Inspector 里 Labels 一栏添加，如 character、ui_icon。

按标签加载：

1
2
3
4
5


var handle = Addressables.LoadAssetsAsync<GameObject>("character", null);
await handle.Task;
foreach (var go in handle.Result)
 Instantiate(go);
Addressables.Release(handle);

典型用途：

一次性加载某类资源（所有语言文本、所有 UI 图标）
按标签打包（Pack Together By Label）
资源更新时按标签定位

标签是字符串，没有命名空间强制约束，建议团队约定命名规范，如 ui_、char_、audio_ 前缀。

十、场景加载

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;

// 加载场景（单场景模式，替换当前场景）
AsyncOperationHandle<SceneInstance> handle =
 Addressables.LoadSceneAsync("Level_01", LoadSceneMode.Single);
await handle.Task;

// 叠加加载（Additive）
var addHandle = Addressables.LoadSceneAsync("UI_HUD", LoadSceneMode.Additive);
await addHandle.Task;

// 卸载场景
await Addressables.UnloadSceneAsync(addHandle).Task;

要点：

场景也要先标记为 Addressable 才能加载
单场景模式会卸载当前场景再加载新场景
叠加模式适合把 UI、加载页作为独立场景
卸载用 UnloadSceneAsync，不要用普通 SceneManager.UnloadSceneAsync 混用，否则引用计数对不上

十一、常见问题与陷阱

11.1 内存泄漏

症状：反复进出某界面，内存持续上涨。

原因：加载了资源却忘记 Release / ReleaseInstance。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// 错误：加载后没有释放
void ShowIcon()
{
 Addressables.LoadAssetAsync<Sprite>("Icon").Completed += op =>
 img.sprite = op.Result;
}

// 正确：保存句柄，关闭界面时释放
AsyncOperationHandle<Sprite> _iconHandle;

async void ShowIcon()
{
 _iconHandle = Addressables.LoadAssetAsync<Sprite>("Icon");
 await _iconHandle.Task;
 img.sprite = _iconHandle.Result;
}

void OnDestroy()
{
 if (_iconHandle.IsValid())
 Addressables.Release(_iconHandle);
}

11.2 编辑器能跑，真机报错

原因：Play Mode Script 选了 Use Asset Database，编辑器不打包；真机需要真实 Bundle。

解决：发布前务必用 Build > New Build 构建，并用 Use Existing Build 验证一次。

11.3 地址拼错

地址是字符串，拼错只有运行时才报 Failed。

缓解：

地址集中定义为常量或配置
使用 AssetReference 代替字符串
统一命名规范

1
2
3
4
5


public static class Addresses
{
 public const string Player = "Player";
 public const string LoginUI = "UI/Login";
}

11.4 资源被重复打包 / 包体异常大

排查：Window > Asset Management > Addressables > Analyze，运行以下分析：

Check Duplicate Bundle Dependencies：检查重复依赖
Check Bundle Duplicate Assets：检查 Bundle 中的重复资源

11.5 `Destroy` 与 `ReleaseInstance` 混用

InstantiateAsync 创建的对象若用 Destroy 销毁，引用计数不归零 → 泄漏。反之，若 trackHandle: false，则只能用 Destroy。要么统一用 Addressables 管理，要么统一手动管理，不要混。

11.6 远程资源加载失败

常见原因：Remote.LoadPath 地址错误、服务器未开启跨域（CORS）、HTTPS 证书问题、Catalog 未更新。先在浏览器直接访问 .bundle 地址验证。

十二、性能与最佳实践

加载性能

优先异步，避免 WaitForCompletion 卡主线程
预加载：在加载界面提前 DownloadDependenciesAsync / LoadAssetAsync
使用 DownloadDependenciesAsync 提前把远程包下到本地缓存

内存

严格的 Load/Release 配对，界面关闭时清理
用 Profiler 的 Addressables 模块查看引用计数
大资源用完立即释放，不要长时间驻留

打包

本地 LZ4，远程 LZMA
按使用场景分组，避免大杂烩组
定期跑 Analyze 检查重复依赖
固定 Catalog 命名，做好版本管理

工程规范

地址用常量管理，不散落魔法字符串
优先 AssetReference 而非硬引用
封装一个加载管理器，统一处理句柄生命周期

一个简单的加载管理器示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public static class ResLoader
{
 // 记录句柄，统一在合适时机释放
 static readonly Dictionary<string, AsyncOperationHandle> _handles = new();

 public static async System.Threading.Tasks.Task<T> LoadAsync<T>(string address)
 {
 if (_handles.TryGetValue(address, out var cached) && cached.IsValid())
 return (T)cached.Result;

 var handle = Addressables.LoadAssetAsync<T>(address);
 await handle.Task;

 if (handle.Status == AsyncOperationStatus.Succeeded)
 {
 _handles[address] = handle;
 return handle.Result;
 }

 Debug.LogError($"加载失败：{address}");
 Addressables.Release(handle);
 return default;
 }

 public static void Release(string address)
 {
 if (_handles.TryGetValue(address, out var handle))
 {
 if (handle.IsValid()) Addressables.Release(handle);
 _handles.Remove(address);
 }
 }

 public static void ReleaseAll()
 {
 foreach (var kv in _handles)
 if (kv.Value.IsValid()) Addressables.Release(kv.Value);
 _handles.Clear();
 }
}

十三、完整实战流程

从零到跑通一个加载的完整步骤：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


1. 安装 Addressables 包
 │
2. Window > Asset Management > Addressables > Groups
 │
3. 创建分组：Local / Remote
 │
4. 拖入资源，设置语义化地址（如 "Player"）
 │
5. 配置 Play Mode Script = Use Asset Database（开发期）
 │
6. 代码加载：
 Addressables.InstantiateAsync("Player", parent);
 │
7. 用完 ReleaseInstance / Release
 │
8. 发布前 Build > New Build，切 Use Existing Build 验证
 │
9. 上传 ServerData 到 CDN，配置 Remote.LoadPath
 │
10. 运行时 CheckForCatalogUpdates → DownloadDependencies → 加载

最小可运行示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class AddressablesDemo : MonoBehaviour
{
 public string address = "Player";
 GameObject _instance;
 AsyncOperationHandle<GameObject> _handle;

 async void Start()
 {
 // 加载并实例化
 _handle = Addressables.InstantiateAsync(address, transform);
 await _handle.Task;

 if (_handle.Status == AsyncOperationStatus.Succeeded)
 {
 _instance = _handle.Result;
 Debug.Log("加载成功：" + address);
 }
 else
 {
 Debug.LogError($"加载失败：{address}，{_handle.OperationException}");
 }
 }

 void OnDestroy()
 {
 // 销毁实例并释放
 if (_instance != null)
 Addressables.ReleaseInstance(_instance);
 }
}

十四、面试高频问答

14.1 Addressables 和 AssetBundle 的关系？

Addressables 是构建在 AssetBundle 之上的更高层抽象。底层仍然打包成 Bundle，但 Addressables 帮你自动完成依赖分析、引用计数、Catalog 管理、远程下载、版本更新等。你可以把它理解成"官方维护的、带引用计数的 AssetBundle 管理器”。

14.2 Addressables 和 Resources 的区别？

	Resources	Addressables
打包	全部无条件打进包	按组按需打包
热更新	不支持	支持
卸载	无引用计数	引用计数精确卸载
路径	固定文件夹	任意地址，可远程
官方推荐	否	是

14.3 为什么加载了资源一定要 Release？

Addressables 用引用计数管理内存。Load/Instantiate 使计数 +1，Release/ReleaseInstance 使计数 -1，只有归零时资源才卸载。不 Release 会导致计数永远大于 0，资源常驻内存，即内存泄漏。

14.4 Bundle Mode 有哪几种？

Pack Together：整组一个 Bundle
Pack Separately：每个资源一个 Bundle
Pack Together By Label：按标签分组打包

14.5 三种压缩方式的区别？

Uncompressed：不压缩，加载最快，体积最大
LZ4：分块压缩，支持随机读取，速度与体积平衡，适合本地
LZMA：压缩率最高，需整包解压，加载慢但省流量，适合远程下载

14.6 Play Mode Script 三种模式的区别？

Use Asset Database：直接从编辑器资源数据库加载，不打包，最快
Simulate Groups：模拟打包，仍从数据库读，用于测试打包布局
Use Existing Build：使用真实构建的 Bundle，最接近真机

14.7 如何实现资源热更新？

启动时 CheckForCatalogUpdates 检查 Catalog 更新
UpdateCatalogs 拉取新 Catalog
GetDownloadSizeAsync 查询下载大小
DownloadDependenciesAsync 下载依赖
正常加载资源

资源改动后只需上传增量 Bundle + 新 Catalog。注意：Addressables 只能热更资源，代码热更需要 Lua / ILRuntime 等。

14.8 什么是 Catalog？

Catalog 是 Addressables 生成的清单文件（catalog.json），记录了所有地址到资源、依赖关系、Bundle 位置和哈希的映射。运行时通过它把"地址"解析为"具体要加载的 Bundle 和资源”。它是远程更新能否生效的关键。

14.9 为什么建议用 AssetReference 而不是直接引用？

直接用 public GameObject 会产生硬引用，导致资源被强制打进包且无法动态卸载。AssetReference 通过 ID 序列化引用，不产生硬引用，资源可动态加载/释放，且只能选择 Addressable 资源，更安全。

14.10 如何避免 Bundle 重复依赖？

用 Analyze > Check Duplicate Bundle Dependencies 检测
把公共依赖单独成组
合理划分 Group，避免多个组独立引用同一大资源
关注 Include in Build 与依赖提取设置

十五、学习路线建议

阶段	目标	重点内容
入门	能加载一个 Prefab	安装、标记地址、`InstantiateAsync`、`ReleaseInstance`
熟练	掌握异步与内存	句柄、引用计数、批量加载、标签
进阶	远程与分组	Profile、Group 配置、Compression、Build
高级	热更新与工程化	Catalog 更新、增量 Build、加载管理器封装
实战	上线运营	CDN 部署、版本管理、性能分析、内存泄漏排查

推荐练习：

把一个 Resources.Load 的项目改成 Addressables
搭建本地远程服务器（http-server 或 Python http.server）测试远程加载
做一个带"检查更新 → 显示下载大小 → 下载进度 → 进入游戏"的启动流程
用 Unity Profiler 观察 Release 前后的内存变化

本文系统梳理了 Unity Addressables 的核心概念与实际使用，从 Resources/AssetBundle 的痛点讲起，覆盖加载 API、资源组、远程热更新、依赖管理与最佳实践。示例基于 Unity 2021 LTS + Addressables 1.21 编写，不同版本 API 基本兼容。学习时建议边看边在项目中动手实验，尤其要亲手验证"引用计数与释放"这一最容易踩坑的部分。

Unity渲染相关

Thu, 04 Jun 2026 15:53:47 +0800

一、Unity 渲染管线对比

1.1 内置渲染管线（Built-in Render Pipeline）

固定功能管线：渲染流程是 Unity 官方预先编写好的一套固定流程，开发者只能通过开关选项调整，无法改变核心运作方式。

特点：

“一个管线应对所有场景”——试图用一套逻辑兼顾从手机到 PC 的所有平台
在任何特定场景下都不是最优的——为了兼容性而显得臃肿
对开发者来说像一个黑盒，灵活性差

1.2 可编程渲染管线（SRP: Scriptable Render Pipeline）

Unity 提供底层 API（ScriptableRenderContext）和框架，允许用 C# 脚本编写和控制整个渲染流程。URP 和 HDRP 是官方基于这套 API 写好的两套预设。

“为特定目标量身定制”：URP 和 HDRP 是为特定目标从头编写的、极其专注和优化的管线。

1.3 URP vs HDRP 详细对比

特性维度	URP（通用渲染管线）	HDRP（高清渲染管线）
核心目标	效率、灵活性、跨平台	极致图形保真度、物理正确性
目标平台	移动端、PC（中低端）、WebGL	高性能 PC、高端主机（PS5/Xbox）
渲染路径	前向渲染（默认），可选延迟渲染	延迟渲染（默认且强大），也支持前向
光照模型	简化版 PBR，优化保证性能	完全基于物理的 PBR，更复杂精确
光源数量	每物体 2-4 个像素光，性能友好	大量像素光，延迟渲染高效处理成百上千光源
Shader 复杂度	相对简单，有限但高效	极其复杂，大量 3A 级效果模块
后处理效果	Bloom、SSAO、色彩调整等常用效果	体积光、SSR、精确景深等电影级效果
高级特性	不支持或简化版	光线追踪、体积雾、基于物理的相机、毛发/布料着色器
性能开销	低	非常高

1.4 为什么 SRP（URP/HDRP）性能更好

SRP Batcher（CPU 性能提升）：

传统方式（Built-in）：每个使用不同材质的物体，即使材质用同一个 Shader 只是参数不同，也会导致 GPU 中断渲染流程、切换 Shader 状态，产生巨大的 CPU 开销。

SRP Batcher：将所有使用同类 Shader 的物体的材质数据保存在 GPU 显存的特定区域。渲染时只需快速更新材质数据指针，无需进行昂贵的状态切换。

结果：渲染大量使用不同材质但共享同一 Shader 的物体时，CPU 开销大幅降低，帧率显著提升。

更清晰的工作流：URP/HDRP 的渲染流程用 C# 清晰定义，每条管线只包含目标所需的功能，无比精简高效。

二、完整图形渲染管线

图形渲染管线是实时渲染的核心组件。功能是将 3D 场景通过给定虚拟相机、光源等要素渲染为 2D 图像。

管线五大阶段总览

1

准备阶段（CPU）→ 几何阶段（GPU）→ 光栅化阶段（GPU）→ 像素处理阶段（GPU）→ 输出与后处理

类比：

准备阶段：摄影师布景、调整灯光
几何阶段：把模特和景物投影到相机胶片上
光栅化：把胶片成像冲印成照片
像素处理：给照片调色、加滤镜
输出与后处理：照片装裱、展览

2.1 第一阶段：准备阶段（CPU）

CPU 为 GPU 准备好所有需要渲染的数据和指令，是渲染流水线的指挥官。

（1）剔除（Culling）：

视锥体剔除（Frustum Culling）：剔除完全在摄像机视野之外的物体。这是最基础的优化。

遮挡剔除（Occlusion Culling）：剔除被其他物体完全挡住的物体（即使在视野内）。算法更复杂，但能极大提升性能。

（2）排序与合批（Sorting & Batching）：

渲染排序：按材质、渲染状态（透明/不透明）排序，减少 GPU 状态切换开销。

动态合批（Dynamic Batching）：CPU 将多个小模型的顶点数据合并成一个，用一次 Draw Call 绘制。节省开支但有限制。

静态合批（Static Batching）：对不会移动的物体进行预处理合批，大幅减少 Draw Call。

（3）设置渲染状态：材质（Shader、纹理）、混合模式、深度测试等。

（4）构建渲染命令列表：生成一系列 Draw Call 命令。

2.2 第二阶段：几何阶段（GPU）

GPU 接收到 Draw Call 命令和顶点数据后，开始处理每个顶点。

（1）顶点着色器（Vertex Shader）：

核心任务：处理每个顶点的位置，完成 MVP 变换，将 3D 顶点坐标转换到 2D 屏幕坐标。

完整坐标变换流程：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


局部坐标（Local）
 ↓ 模型矩阵（Model Matrix）
世界坐标（World）
 ↓ 观察矩阵（View Matrix）
观察坐标（View）
 ↓ 投影矩阵（Projection Matrix）
裁剪坐标（Clip）
 ↓ 透视除法（Perspective Division）
NDC（归一化设备坐标）
 ↓ 视口变换（Viewport Transformation）
屏幕坐标（Screen）

Model 矩阵：将物体从局部坐标系变换到世界坐标系，包含平移、旋转、缩放。

View 矩阵：将世界坐标变换到以相机为原点的观察坐标系。

Projection 矩阵：将观察坐标变换到裁剪坐标（齐次裁剪空间）。两种投影方式：

正交投影：视锥体为长方体，物体大小与距离无关，适合 2D 游戏、UI、小地图。

透视投影：视锥体为台体，近大远小，适合 3D 游戏。通过近平面（Near）、远平面（Far）、垂直视场角（FOV）、屏幕宽高比（Aspect Ratio）四个参数定义。

（2）曲面细分着色器（Tessellation Shader）（可选）：动态增加模型的三角形数量，让表面更平滑细腻（用于地面、角色皮肤等）。

（3）几何着色器（Geometry Shader）（可选）：可以一次处理整个图元（三角形），甚至生成或销毁图元。用法相对小众。

（4）裁剪（Clipping）：将超出屏幕（视锥体）范围的三角形进行裁剪，只保留屏幕内的部分。

完全位于视锥体外的图元被裁剪掉，部分在视锥体内的图元需要裁剪操作。常见裁剪算法：Cohen-Sutherland 算法、Liang-Barsky 算法、Sutherland-Hodgman 多边形裁剪算法。

（5）背面剔除（Back Face Culling）：剔除背对摄像机的图元，可减少约 50% 的渲染图元。

注意：背面剔除默认不开启。半透明物体不能使用背面剔除，否则会出现穿帮的情况。

（6）屏幕映射（Screen Mapping）：将裁剪空间坐标转换到最终的屏幕坐标。

透视除法：除以 w 分量得到 NDC（归一化设备坐标），实现近大远小的视觉效果。

视口变换：NDC 坐标转换为窗口坐标（Window Coordinates）。

2.3 第三阶段：图元装配（Primitive Assembly）

连接顶点处理和光栅化的桥梁。

输入：顶点着色器处理后的一堆离散顶点。

处理过程：根据 Draw Call 指令（图元类型和索引缓冲区），将离散顶点连接成具体的几何图元（三角形）。

输出：完整的、连接好的三角形，每个三角形由三个顶点及其所有插值后的属性组成。

2.4 第四阶段：光栅化阶段（GPU）

将连续的几何图形（三角形）离散化为一个个的像素片段。

三角形组装（Triangle Setup）：对顶点的输入数据（颜色、法线、纹理坐标）进行插值，得到各个片段对应的数据值。

三角形遍历（Triangle Traversal）/ 扫描转换（Scan Conversion）：检查每个像素的中心是否在三角形内。如果是，就为该像素生成一个片段（Fragment）。片段包含了插值后的数据（颜色、法线、深度、UV 等）。

对于透视投影，需要使用**透视校正插值（Perspective-Correct Interpolation）**来正确插值片段的颜色、纹理等信息。

2.5 判断点在三角形内部的方法

方法一：重心坐标法（Barycentric Coordinates）—— GPU 实际使用的方法

任何三角形内的点 P 可以表示为三个顶点 A、B、C 的加权和：

1
2


P = u * A + v * B + w * C
其中 u + v + w = 1，且 u >= 0, v >= 0, w >= 0

计算权重（基于面积比）：

计算整个三角形面积的两倍：area_ABC = (B - A) × (C - A)
计算子三角形面积：area_PBC = (B - P) × (C - P)
归一化：u = area_PBC / area_ABC, v = area_PCA / area_ABC
w = 1 - u - v

判断条件：如果 u >= 0 且 v >= 0 且 w >= 0（即 u + v <= 1），则点 P 在三角形内部。

为什么 GPU 喜欢这个方法？ 重心坐标不仅是判断工具，更是完美的插值权重：

1

fragment_color = u * color_A + v * color_B + w * color_C

方法二：同向法（叉积法）

计算边向量和点 P 到顶点向量的三次叉积，如果三次结果的符号相同，则点在三角形内部。

2.6 锯齿与抗锯齿

锯齿产生原因：3D 场景中的物体是连续的，而屏幕像素是离散的。用离散像素表示连续物体时丢失了连续信息。

SSAA（超级采样抗锯齿）：将屏幕渲染到更高分辨率的缓冲区（如 4xSSAA 将 800×600 渲染到 1600×1200），然后下采样。效果好但计算量极大（光栅化和片段着色器都是 4 倍）。

MSAA（多重采样抗锯齿）：每个片段使用多个采样点，计算三角面覆盖的采样点数量（覆盖率），片段着色器只计算一次颜色，最终颜色乘以覆盖率。

1

4xMSAA：4 个采样点中覆盖了 2 个 → 颜色乘以 0.5 → 浅红色

MSAA 的问题：与延迟渲染（Deferred Rendering）不兼容，因为光照阶段无法通过 G-Buffer 获取片段覆盖率信息。

重心采样（Centroid Sampling）：解决 MSAA 中采样点位于三角面外部的问题。GPU 通过覆盖的采样点确定采样的重心点。

其他抗锯齿技术：CSAA（覆盖采样抗锯齿）、CFAA（可编程过滤抗锯齿）、FXAA（快速近似抗锯齿）、TXAA（时间样本抗锯齿）、MFAA（多帧采样抗锯齿）、MLAA（形态抗锯齿）、SMAA（亚像素形态抗锯齿）。

2.7 第五阶段：像素处理阶段（GPU）

这是最复杂、最灵活的阶段，现代图形学的很多特效都在这里发生。

（1）片段着色器（Fragment Shader）/ 像素着色器（Pixel Shader）：

核心任务：计算每个片段的最终颜色。

工作原理：使用从顶点着色器插值过来的数据（如 UV），进行纹理采样，并应用光照模型进行计算。

纹理贴图（Texture Mapping）：将图像信息映射到三角形网格上，增加物体表面细节。纹理上的每个像素称为纹素（Texel）。

常见纹理技术：

凹凸贴图（Bump Mapping）：通过光照信息产生视觉错觉
法线贴图（Normal Mapping）：直接存储表面法线，改变光照计算结果（性能更好）
高度贴图（Height Mapping）：存储高度信息，需要计算法线扰动
视差贴图（Parallax Mapping）：模拟表面凹凸的深度感
位移贴图（Displacement Mapping）：实际移动顶点的位置
立方体贴图（Cubemap）：用于环境反射
阴影贴图（Shadowmap）：存储光源视角的深度信息

（2）逐片段操作（Per-Fragment Operations）：

深度测试（Depth Test）：比较片段深度值和深度缓冲区（Z-Buffer）中的值，丢弃被遮挡的片段。这是解决可见性问题的关键技术。

模板测试（Stencil Test）：利用模板缓冲区（Stencil Buffer）标记特定区域，实现轮廓、镜子等特效。

混合（Blending）：处理片段颜色和帧缓冲区中已有颜色的混合，主要用于渲染透明物体（玻璃、火焰）。

2.8 第六阶段：输出与后处理

输出到帧缓冲区（Frame Buffer）：通过所有测试的片段，将其颜色值写入帧缓冲区。

后处理（Post-Processing）：对整张渲染好的图像进行屏幕空间的特效处理。后处理通常通过在全屏四边形上执行一个特殊的 Shader 来实现。

常见后处理效果：

Bloom：泛光效果，让明亮区域扩散出光芒
色调映射（Tone Mapping）：将 HDR 颜色转换到屏幕能显示的 LDR
颜色校正（Color Grading）：调整整体颜色和氛围
景深（Depth of Field）：模拟相机焦点清晰、背景模糊的效果
SSAO（屏幕空间环境光遮蔽）：在屏幕空间计算细微阴影，增加立体感
SSR（屏幕空间反射）：在屏幕空间计算反射效果

三、光照模型

3.1 Phong 模型

计算光照最常用的经验模型，参数信息都是经验得到的，没有实际的物理意义。将光照分为三个部分：

漫反射分量：光线照射到粗糙表面后向各个方向均匀反射
镜面高光：光线照射到光滑表面后沿反射方向集中反射
环境光：模拟场景中其他物体反射的间接光照，在光照信息上叠加一个较小的常量

3.2 Blinn-Phong 模型

对 Phong 模型的改进。Phong 模型在处理高光时，当观察方向和反射光线夹角大于 90 度时，镜面反射分量会被消除，导致高光不连续。

Blinn-Phong 引入了半角向量（Halfway Vector）：

1

H = (L + V) / |L + V| // 光线方向 L 和观察方向 V 的中间位置

用半角向量 H 和法线 N 的夹角来计算镜面反射。无论观察者在哪个方向，半角向量和法线夹角都不会超过 90 度，不会出现高光不连续的问题。

3.3 PBR（基于物理的渲染）

目标：物理正确——材质参数具有真实的物理意义，在任何光照环境下都能表现出一致的行为。

核心参数：

金属度（Metallic）：材质的金属特性
粗糙度（Roughness）：表面的光滑程度
AO（环境光遮蔽）：环境光照下的遮蔽信息

图像-Based Lighting（IBL）：使用环境贴图来模拟全局光照，配合 PBR 参数实现逼真的光照效果。

四、渲染路径（Rendering Path）

4.1 前向渲染（Forward Rendering）

原理：在每个物体的片段着色器中，对所有影响该片段的光源进行循环计算。

流程：

1

物体 → 顶点着色器 → 片段着色器（计算所有光照）→ 输出

优点：

MSAA 等抗锯齿支持好
Shader 编写直观

缺点：

光源数量多时性能下降极快
复杂度 = O(物体数 × 光源数)

适用场景：移动平台、光源数量较少的场景。

4.2 延迟渲染（Deferred Rendering）

核心思想：将几何和光照计算完全分离。“延迟"了昂贵的光照计算。

Pass 1：几何通道（G-Buffer Pass）

不计算任何光照，只存储所有物体的几何信息到多个渲染目标（MRT）中。这些渲染目标集合称为 G-Buffer（Geometry Buffer）。

G-Buffer 通常包含：

漫反射颜色（Albedo）
世界空间法线（World Normal）
世界空间位置（World Position）/ 深度
金属度 / 粗糙度等 PBR 参数

Pass 2：光照通道（Lighting Pass）

利用 G-Buffer 中的信息计算光照。不再绘制任何场景物体，针对每个光源在屏幕上绘制代表其影响范围的形状，对覆盖的每个像素从 G-Buffer 中读取信息进行光照计算。

核心优势：复杂度变为 O(N)，只与屏幕像素数和光源数量有关，与场景几何复杂度无关。渲染 1000 个三角形和 100000 个三角形，如果最终屏幕像素数和光源数相同，光照计算开销是一样的。

缺点：

与 MSAA 不兼容
对透明物体处理困难
G-Buffer 占用大量显存带宽

适用场景：光源数量多、场景复杂的 PC/主机游戏。

4.3 前向 +（Forward+）

现代引擎（如 URP/HDRP）提供的混合方案。将屏幕分块（Tile），每块记录影响该块的光源列表，在片段着色器中只计算当前块的光源。

五、阴影（Shadows）

5.1 Shadowmap 原理

阴影贴图技术是一种渲染到纹理的技术。原理非常简单：

第一步：从光源位置渲染一遍场景，将深度信息写入阴影贴图。

第二步：正常渲染场景，用阴影贴图判断每个片段是否落在阴影中。

1
2
3
4
5


从光源视角看，像素 p 的深度值为 d(p)
阴影贴图中离光源最近的深度值为 s(p)

如果 d(p) > s(p) → 有物体挡住 → p 在阴影中
如果 d(p) = s(p) → 没有被挡 → p 不在阴影中

5.2 阴影粉刺（Shadow Acne）

由于 Shadowmap 精度问题，平面上的某些像素深度比深度贴图大，某些比深度贴图小，导致某些地方有阴影、某些没有的粉刺现象。

解决方案：使用**偏移量（Bias）**对阴影贴图中的深度值进行调整。

1
2


调整前：有些像素比深度贴图大，有些比深度贴图小
调整后：所有像素都比深度贴图大，没有粉刺

注意：偏移量过大会导致阴影偏离物体的失真现象（Peter Panning）。偏移量大小与平面倾斜度有关，平面越倾斜，需要的偏移量越大。

5.3 阴影走样（Aliasing）

阴影边缘出现锯齿。可以提升 Shadowmap 分辨率来降低走样影响，但同时也增大了显存消耗。

5.4 软阴影

理想化的点光源（体积无限小）会产生硬阴影，因为光线要么完全被挡住（全阴影），要么完全没被挡住。

软阴影的本质是模拟光源的体积，计算片元对光源的可见覆盖率。覆盖率从 0%（本影）到 100%（完全照亮）的连续变化形成半影的过渡区域。

5.5 PCF（百分比渐近过滤）

传统硬阴影：对阴影贴图采样一次，结果非 0 即 1。

PCF：在当前采样点周围取一个区域（如 3×3 的 kernel），进行多次深度比较，得到多个非 0 即 1 的结果，然后取平均值。

1

例如 9 次采样，5 次在阴影中 → 阴影亮度 = 5/9 ≈ 0.55

这个平均值不再是二元的 0 或 1，而是介于 0 到 1 之间的灰度值，在视觉上产生边缘模糊效果。

5.6 PCSS（百分比渐近软阴影）

PCSS 是比 PCF 更高级的软阴影技术，很多引擎的标配：

Blocker Search：在当前片段位置，搜索区域内有多少深度值比当前片段小（遮挡物），计算平均深度
Penumbra Size Estimation：根据光源大小、遮挡物平均深度和当前片段深度，计算半影宽度（基于相似三角形原理）
PCF Filtering：用上一步计算出的动态半影宽度决定 PCF 滤波的 Kernel 大小

1
2


半影宽 → 用大的 Kernel 采样
半影窄 → 用小的 Kernel 采样

六、Draw Call

6.1 什么是 Draw Call

Draw Call 是 CPU 调用图形 API（OpenGL、DirectX）向 GPU 发起的绘制命令。每个 Draw Call 命令都包含了绘制一个或多个图形对象所需的所有信息（顶点数据、纹理、Shader 等）。

6.2 Draw Call 过多为什么会影响性能

每个 Draw Call 都有CPU 开销：

CPU 准备渲染数据
CPU 调用图形 API
驱动处理和验证命令
GPU 执行命令

当 Draw Call 过多时，CPU 忙于提交命令，无法处理其他逻辑，成为CPU-Bound瓶颈。

6.3 影响 Draw Call 数量的因素

因素	说明
对象数量	每个对象至少需要一次 Draw Call
材质数量	每个材质需要一次 Draw Call
纹理贴图	纹理切换需要额外 Draw Call
Shader 复杂度	复杂 Shader 可能需要多个 Pass

示例：

100 个立方体 + 同一材质 → 100 个 Draw Call
100 个立方体 + 不同材质 → 大于 100 个 Draw Call（因为材质和纹理不同）
复杂角色模型 + 多个纹理和材质 → 多个 Draw Call（模型本身 + 每个纹理）

七、合批（Batching）

合批将多个物体的渲染数据合并，用一次 Draw Call 绘制，极大减轻 CPU 负担。

7.1 静态合批（Static Batching）

原理：将不会移动的静态物体在运行前合并成一个大的顶点/索引缓冲区。

工作原理：

预处理：Unity 编辑器在构建时将所有标记为 Static 且使用相同材质的物体的网格数据合并
渲染：合并后只需一次 Draw Call 全部绘制

优点：性能收益巨大，最有效的减少 Draw Call 手段之一。

缺点：

内存开销增加（合并后的网格额外占内存）
只适用于静态物体（不能再移动、旋转、缩放）

7.2 动态合批（Dynamic Batching）

原理：Unity 运行时每帧自动将小型动态物体的网格数据合并。

工作原理：

CPU 每帧遍历使用同一材质且满足条件的小型动态物体
将顶点数据从本地空间变换到世界空间（CPU 上完成！）
将变换后的顶点数据合并到一个公共的顶点缓冲区
发起一次 Draw Call

优点：适用于动态物体。

限制条件（极易被打断）：

条件	说明
顶点数限制	通常不超过 300 个
同一材质	必须是完全相同的材质实例
统一缩放	不能有非统一缩放（如 (1,2,1)）
多 Pass	不能包含多个 Pass 的 Shader

7.3 GPU Instancing

原理：在一次渲染调用中同时绘制多个相同模型的实例。

优点：

减少 CPU 开销
适合大量相同物体（草地、人群、粒子）

注意：与动态合批互斥。如果材质开启了 GPU Instancing，物体不会尝试动态合批。

7.4 合批被打断的常见情况

使用不同的材质实例（最常见！）：两个材质球即使看起来一样，只要是不同的资产，就会被视为不同的材质实例，中断合批。解决方案：共享同一个材质实例，使用 MaterialPropertyBlock 修改属性。
渲染顺序中断：

1
2
3


渲染序列：[物体A(材质1)，物体B(材质1)，物体C(材质2)，物体D(材质1)]
合批结果：[A+B] → [C] → [D] // 共 3 个 Draw Call
// D 无法和 A+B 合并，因为中间插入了 C

不满足动态合批的苛刻条件：顶点超标、非统一缩放、多 Pass Shader。

八、渲染优化技术

8.1 渲染优化核心思路

面试口诀：合并、减面、剔除

技术	原理	效果
LOD	远处物体用低面数模型	减少 GPU 渲染量
视锥剔除	剔除视野外的物体	减少不必要的绘制
遮挡剔除	剔除被挡住的物体	进一步减少绘制
静态合批	合并静态物体	大幅减少 Draw Call
动态合批	合批小型动态物体	减少 Draw Call（有严格限制）
GPU Instancing	一次绘制多个相同模型	减少 CPU 开销
屏幕空间技术	在屏幕空间采样计算	减少场景计算需求
Shader 指令优化	减少不必要的计算和采样	降低 GPU 开销

8.2 LOD（Level of Detail）

LOD 技术在物体远离相机时使用低细节模型，减少多边形数量。

1
2
3
4


LOD 0（近距离）：高面数模型，细节最丰富
LOD 1（中距离）：中面数模型
LOD 2（远距离）：低面数模型
Culled（超出范围）：不渲染

Unity 中通过 LOD Group 组件实现，自动根据物体与相机的距离切换 LOD 级别。

8.3 视锥剔除（Frustum Culling）

检查物体是否在相机的视锥体内，不在则不渲染。

Unity 默认启用视锥剔除，不需要手动设置。

8.4 遮挡剔除（Occlusion Culling）

通过**遮挡剔除数据（Occlusion Data）**预计算场景中的遮挡关系，运行时判断被遮挡的物体不渲染。

需要预先 Bake 遮挡数据（Window → Rendering → Occlusion Culling）。

8.5 屏幕空间技术

SSAO（屏幕空间环境光遮蔽）：在屏幕空间计算像素间的遮挡关系，产生细微的环境阴影
SSR（屏幕空间反射）：利用屏幕空间的颜色和深度信息计算反射效果
SSGI（屏幕空间全局光照）：近似全局光照效果

屏幕空间技术的共同特点：只在屏幕空间采样计算，不涉及场景几何体，性能开销相对可控。

8.6 Shader 优化建议

减少纹理采样次数
使用精度更低的变量（half 代替 float）
避免在片段着色器中做复杂计算（移到顶点着色器）
使用宏控制 Shader 变体数量
避免使用 if 分支（GPU 不擅长分支预测）

8.7 常用渲染分析工具

工具	用途
Unity Profiler	分析 CPU/GPU/内存瓶颈
Frame Debugger	逐帧查看 Draw Call
RenderDoc	深度 GPU 调试和分析
GPU Profiler	分析 GPU 各阶段耗时
Memory Profiler	分析纹理和网格内存占用

本文涵盖 Unity 渲染的核心知识体系，从渲染管线对比到完整图形渲染管线流程，再到光照模型、阴影、合批、优化技术等，适合 Unity 开发者和图形学学习者系统性复习。

Unity知识梗概

Thu, 04 Jun 2026 15:34:53 +0800

一、MonoBehaviour 生命周期

1.1 生命周期执行顺序

Unity 中每个 MonoBehaviour 脚本从唤醒到销毁有固定的执行顺序：

1

Awake → OnEnable → Start → FixedUpdate → Update → LateUpdate → OnDisable → OnDestroy

详细执行流程：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


编辑器
 ↓
Reset（编辑器模式下点击 Reset 按钮时调用）
 ↓
Awake（对象加载时调用，仅一次）
 ↓
OnEnable（每次启用时调用，可多次）
 ↓
Start（第一次 Update 前调用，仅一次）
 ↓
物理引擎更新
 ├── FixedUpdate（固定时间间隔，0.02s 一次）
 └── 物理碰撞检测
 ↓
Update（每帧调用，频率与帧率相关）
 ↓
LateUpdate（所有 Update 完成后调用）
 ↓
渲染
 ↓
OnDisable（对象禁用时调用）
 ↓
OnDestroy（对象销毁时调用）

1.2 各方法详解

Awake：用于初始化自身状态，不依赖其他对象。在所有对象初始化完成后调用，可安全使用 GameObject.FindWithTag。不可用于协程。

Start：在 Awake 之后、第一次 Update 之前调用。适合做依赖其他对象的初始化（如获取其他组件引用）。

OnEnable：每次对象被激活时调用。与 OnDisable 成对出现，可在同一生命周期中反复发生。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


public class Player : MonoBehaviour
{
 private Rigidbody rb;
 private int score;

 void Awake()
 {
 // 初始化自身，不依赖其他对象
 rb = GetComponent<Rigidbody>();
 }

 void Start()
 {
 // 依赖其他对象的初始化
 score = GameManager.Instance.InitialScore;
 }

 void OnEnable()
 {
 // 每次激活时注册事件
 InputManager.OnJump += Jump;
 }

 void OnDisable()
 {
 // 每次禁用时取消注册
 InputManager.OnJump -= Jump;
 }
}

1.3 Update、FixedUpdate、LateUpdate 的区别

方法	执行频率	用途	特点
FixedUpdate	固定 0.02s（可配置）	物理相关（刚体力、碰撞）	时间间隔固定，不受帧率影响，一帧内可能调用多次
Update	每帧一次（约 0.0167s @60FPS）	非物理逻辑（输入检测、状态更新）	执行间隔不固定，受帧率波动影响
LateUpdate	Update 全部完成后	依赖其他对象更新后的逻辑（摄像机跟随）	确保所有对象的移动和状态已更新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


public class PlayerController : MonoBehaviour
{
 private Rigidbody rb;
 private float moveInput;

 void Start() => rb = GetComponent<Rigidbody>();

 void Update()
 {
 // Update：处理输入检测
 moveInput = Input.GetAxis("Horizontal");
 }

 void FixedUpdate()
 {
 // FixedUpdate：处理物理移动
 rb.AddForce(Vector3.right * moveInput * 10f);
 }
}

public class CameraFollow : MonoBehaviour
{
 public Transform target;

 void LateUpdate()
 {
 // LateUpdate：在所有移动完成后跟随
 transform.position = target.position + new Vector3(0, 5, -10);
 }
}

二、协程（Coroutine）

2.1 协程的本质

协程是 Unity 中分段执行代码逻辑的机制。它通过 yield return 将方法拆分为多个片段，在特定条件满足后恢复执行。

协程不是多线程：协程完全运行在主线程上，只是通过分帧执行模拟"并行"效果。

协程的底层原理：基于 C# 的迭代器特性。调用 StartCoroutine() 时，Unity 将协程包装为状态机，在每帧的 Update 之后检查 yield 条件是否满足，满足则通过 MoveNext() 推动协程执行到下一个 yield 或结束。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


public class CoroutineExample : MonoBehaviour
{
 void Start()
 {
 // 启动协程
 StartCoroutine(DelaySpawnEnemy());
 StartCoroutine(LoadSceneAsync());
 }

 // 延迟执行
 IEnumerator DelaySpawnEnemy()
 {
 yield return new WaitForSeconds(3); // 等待3秒
 Instantiate(enemyPrefab, spawnPoint.position, Quaternion.identity);
 }

 // 分帧加载资源
 IEnumerator LoadSceneAsync()
 {
 AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("Level2");
 while (!asyncLoad.isDone)
 {
 float progress = asyncLoad.progress;
 UpdateLoadingUI(progress);
 yield return null; // 每帧更新进度
 }
 }

 // 序列动画
 IEnumerator FadeOut(SpriteRenderer renderer)
 {
 Color color = renderer.color;
 while (color.a > 0)
 {
 color.a -= Time.deltaTime * 0.5f;
 renderer.color = color;
 yield return null; // 每帧更新透明度
 }
 }
}

2.2 常用 yield 指令

指令	作用
`yield return null`	等待下一帧
`yield return new WaitForSeconds(n)`	等待 n 秒
`yield return new WaitForEndOfFrame()`	等待帧结束
`yield return new WaitForFixedUpdate()`	等待物理帧更新
`yield return new WaitUntil(() => 条件)`	等待条件为 true
`yield return new WaitWhile(() => 条件)`	等待条件为 false
`yield return StartCoroutine(Other())`	等待另一个协程完成

2.3 协程的注意事项

生命周期：协程依附于 MonoBehaviour，对象销毁时协程自动停止
性能：协程本身开销极低，但频繁 yield return new 会产生 GC 垃圾
优化：复用 WaitForSeconds 对象，避免每次创建

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// ❌ 每次创建新对象，产生 GC
IEnumerator Bad()
{
 yield return new WaitForSeconds(1f);
}

// ✅ 缓存复用，减少 GC
private WaitForSeconds wait = new WaitForSeconds(1f);

IEnumerator Good()
{
 yield return wait;
}

三、对象池（Object Pool）

3.1 为什么需要对象池

频繁 Instantiate 和 Destroy 会产生大量的 GC 压力和内存碎片。对象池通过复用对象来避免这个问题。典型场景：子弹、敌人、特效。

3.2 自定义对象池

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


public class ObjectPool : MonoBehaviour
{
 [SerializeField] private GameObject prefab;
 private Queue<GameObject> pool = new Queue<GameObject>();

 // 从池中获取对象
 public GameObject Get()
 {
 if (pool.Count > 0)
 {
 GameObject obj = pool.Dequeue();
 obj.SetActive(true);
 return obj;
 }
 // 池中没有可用对象，创建新对象
 return Instantiate(prefab);
 }

 // 将对象归还池中
 public void Return(GameObject obj)
 {
 obj.SetActive(false);
 pool.Enqueue(obj);
 }
}

3.3 使用 Unity 内置对象池（UnityEngine.Pool）

Unity 提供了 ObjectPool<T> 泛型类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


using UnityEngine.Pool;

public class BulletPool : MonoBehaviour
{
 [SerializeField] private GameObject bulletPrefab;
 private ObjectPool<Bullet> pool;

 void Start()
 {
 pool = new ObjectPool<Bullet>(
 createFunc: () => Instantiate(bulletPrefab).GetComponent<Bullet>(),
 actionOnGet: (bullet) => bullet.gameObject.SetActive(true),
 actionOnRelease: (bullet) => bullet.gameObject.SetActive(false),
 actionOnDestroy: (bullet) => Destroy(bullet.gameObject),
 collectionCheck: true,
 defaultCapacity: 10,
 maxSize: 100
 );
 }

 public Bullet GetBullet() => pool.Get();

 public void ReturnBullet(Bullet bullet) => pool.Release(bullet);
}

核心方法：

Get()：从池中获取对象
Release(T)：将对象放回池中

注意事项：

在 actionOnGet 中重置对象状态（位置、速度等）
确保每个 Get() 都有对应的 Release()

四、动态加载资源的方式

4.1 三种加载方式对比

方式	说明	适用场景
Instantiate	直接实例化预制体	最简单，运行时动态生成
Resources.Load	从 Resources 文件夹加载	简单项目，但所有资源都会被打包
AssetBundle	将资源打成 AB 包	大型项目，支持热更新
Addressables	基于 AB 的高级管理系统	官方推荐，支持按需加载

4.2 Resources.Load

1
2
3
4
5
6
7
8


// 同步加载
GameObject prefab = Resources.Load<GameObject>("Prefabs/Player");
Instantiate(prefab);

// 异步加载（不阻塞主线程）
ResourceRequest request = Resources.LoadAsync<GameObject>("Prefabs/Player");
yield return request;
Instantiate(request.asset);

Resources 的缺点：

所有 Resources 文件夹中的资源都会被打入安装包
无法减小包体
已过时，推荐用 Addressables

4.3 Instantiate

1
2
3


// 最简单的动态加载
GameObject bullet = Instantiate(bulletPrefab);
GameObject enemy = Instantiate(enemyPrefab, spawnPosition, Quaternion.identity);

4.4 AssetBundle

1
2
3
4
5
6
7
8


// 从服务器下载 AB 包
using (UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(url))
{
 yield return request.SendWebRequest();
 AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(request);
 GameObject prefab = bundle.LoadAsset<GameObject>("Player");
 Instantiate(prefab);
}

4.5 Addressables

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

// 异步加载资源
AsyncOperationHandle<GameObject> handle =
 Addressables.LoadAssetAsync<GameObject>("Player");
handle.Completed += (op) =>
{
 Instantiate(op.Result);
};

// 释放资源
Addressables.Release(handle);

Addressables 核心特性：

按地址加载，逻辑与物理路径解耦
自动管理依赖
支持本地和远程资源
引用计数自动卸载

五、UGUI 与适配

5.1 Canvas 的三种渲染模式

Screen Space - Overlay（默认）：UI 始终在 3D 元素前面，与摄像机无关。

Screen Space - Camera：UI 通过指定摄像机渲染，支持 3D 效果（如粒子在 UI 前）。

World Space：UI 成为场景中的 3D 物体，可用于怪物血条、VR 开发。

5.2 Canvas Scaler 缩放模式

模式	说明
Constant Pixel Size	UI 保持固定像素大小
Scale With Screen Size	根据参考分辨率动态缩放（推荐）
Constant Physical Size	根据物理尺寸（英寸）缩放

5.3 UI 自适应方案

锚点（Anchors）：定义 UI 元素相对于父容器的定位方式。

锚点预设	效果
居中	元素始终居中
拉伸	元素随父容器拉伸

Rect Transform：UI 元素的变换组件，包含锚点、轴心、偏移量等属性。

布局组件：

Horizontal/Vertical Layout Group：自动排列子元素
Content Size Fitter：根据内容动态调整大小
Aspect Ratio Fitter：保持宽高比

5.4 Image 和 RawImage 的区别

	Image	RawImage
支持类型	Sprite（精灵）	Texture（原始纹理）
九宫格缩放	支持	不支持
填充模式	支持（进度条）	不支持
UV 调整	不支持	支持
动态纹理	不支持	支持（摄像头、RenderTexture）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// RawImage 适用于动态纹理
public class ModelInUI : MonoBehaviour
{
 public Camera modelCamera;
 public RawImage modelDisplay;

 void Start()
 {
 RenderTexture rt = new RenderTexture(512, 512, 24);
 modelCamera.targetTexture = rt;
 modelDisplay.texture = rt;
 }
}

5.5 摇杆实现（不依赖插件）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


public class JoystickController : MonoBehaviour, IDragHandler, IPointerDownHandler, IPointerUpHandler
{
 [SerializeField] private RectTransform joystickBG;
 [SerializeField] private RectTransform joystickHandle;
 private Vector2 inputDirection;

 public Vector2 InputDirection => inputDirection;

 public void OnDrag(PointerEventData eventData)
 {
 Vector2 pos;
 RectTransformUtility.ScreenPointToLocalPointInRectangle(
 joystickBG, eventData.position, eventData.pressEventCamera, out pos
 );
 pos = pos / joystickBG.sizeDelta; // 归一化
 inputDirection = pos.magnitude > 1 ? pos.normalized : pos;
 joystickHandle.anchoredPosition = inputDirection * joystickBG.sizeDelta;
 }

 public void OnPointerUp(PointerEventData eventData)
 {
 inputDirection = Vector2.zero;
 joystickHandle.anchoredPosition = Vector2.zero;
 }
}

// 摇杆控制角色移动
public class PlayerController : MonoBehaviour
{
 public JoystickController joystick;
 public float moveSpeed = 5f;

 void Update()
 {
 Vector2 input = joystick.InputDirection;
 Vector3 movement = new Vector3(input.x, 0, input.y) * moveSpeed * Time.deltaTime;
 transform.Translate(movement);
 }
}

六、鼠标交互与事件系统

6.1 射线检测（Raycast）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


public class ClickInteraction : MonoBehaviour
{
 private Camera mainCamera;

 void Start() => mainCamera = Camera.main;

 void Update()
 {
 if (Input.GetMouseButtonDown(0))
 {
 Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
 RaycastHit hit;

 // 3D 物体检测
 if (Physics.Raycast(ray, out hit))
 {
 Debug.Log("点击了: " + hit.collider.gameObject.name);
 }

 // 2D 物体检测
 RaycastHit2D hit2D = Physics2D.Raycast(ray.origin, ray.direction);
 if (hit2D.collider != null)
 {
 Debug.Log("点击了 2D 物体: " + hit2D.collider.name);
 }
 }
 }
}

6.2 OnMouseDown 方法

1
2
3
4
5
6
7


public class SimpleClick : MonoBehaviour
{
 private void OnMouseDown()
 {
 Debug.Log("点击了: " + gameObject.name);
 }
}

6.3 事件系统（Event System）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


using UnityEngine.EventSystems;

// UI 物体点击
public class UIClickHandler : MonoBehaviour, IPointerClickHandler
{
 public void OnPointerClick(PointerEventData eventData)
 {
 Debug.Log("点击了 UI: " + gameObject.name);
 }
}

// 3D 物体点击（需添加 Physics Raycaster 到摄像机）
public class ObjectClickHandler : MonoBehaviour
{
 void Start()
 {
 EventTrigger trigger = gameObject.AddComponent<EventTrigger>();
 EventTrigger.Entry entry = new EventTrigger.Entry();
 entry.eventID = EventTriggerType.PointerClick;
 entry.callback.AddListener((data) => OnClick());
 trigger.triggers.Add(entry);
 }

 void OnClick()
 {
 Debug.Log("点击了物体: " + gameObject.name);
 }
}

七、委托与事件

7.1 委托（Delegate）

委托是方法的类型安全容器，支持多播（+= 注册多个方法）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 定义委托
public delegate void DeathHandler(string message);

public class Player
{
 public DeathHandler OnDeath;

 public void Die()
 {
 OnDeath?.Invoke("玩家死亡！");
 }
}

// 订阅
player.OnDeath += (msg) => Debug.Log(msg);

7.2 事件（Event）

事件是委托的封装，通过 event 关键字限制外部只能 += / -=，不能直接触发。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 定义事件
public class Enemy
{
 public event Action OnEnemyDeath; // 使用 Action 简化

 public void Die()
 {
 OnEnemyDeath?.Invoke(); // 只能在类内部触发
 }
}

// 订阅
enemy.OnEnemyDeath += HandleEnemyDeath;
// enemy.OnEnemyDeath?.Invoke(); // 编译错误！外部不能触发

委托 vs 事件的核心区别：

	委托	事件
外部触发	可以	不可以
外部赋值 (=)	可以（会覆盖其他订阅）	不可以
使用场景	回调、方法参数	发布-订阅模式

八、Unity GC 与优化

8.1 GC 工作机制

Unity 的 GC 采用分代回收策略：

代	特点
Gen 0	新分配的小对象，回收最频繁
Gen 1	Gen 0 幸存对象，回收次之
Gen 2	长期存活对象（如单例），极少回收

GC 触发条件：Gen 0 空间不足时自动触发，或手动调用 System.GC.Collect()（不推荐）。

GC 执行时主线程暂停，导致帧率骤降。

8.2 常见 GC 陷阱

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void Update()
{
 // ❌ 每帧产生新对象 → 频繁 GC
 Debug.Log("Position: " + transform.position); // 字符串拼接

 // ❌ 装箱
 object boxed = 123;

 // ❌ 每帧 GetComponent
 GetComponent<Rigidbody>().AddForce(Vector3.up);
}

8.3 GC 优化策略

（1）减少堆内存分配：

使用对象池管理高频创建的对象
避免装箱：用泛型集合替代非泛型
缓存组件引用

1
2
3
4


// ✅ 缓存组件引用
private Rigidbody rb;
void Start() => rb = GetComponent<Rigidbody>();
void Update() => rb.AddForce(Vector3.up);

（2）控制字符串操作：

1
2
3
4


// ✅ 使用 StringBuilder
StringBuilder sb = new StringBuilder(256);
sb.Append("HP: ").Append(currentHp);
string result = sb.ToString();

（3）使用非分配 API：

1
2
3
4
5


// ❌ 分配内存
Collider[] colliders = Physics.OverlapSphere(center, radius);

// ✅ 无分配
int count = Physics.OverlapSphereNonAlloc(center, radius, colliderBuffer);

（4）使用结构体代替类：

1
2
3
4
5


public struct BulletData // 值类型，不参与 GC
{
 public Vector3 Position;
 public float Speed;
}

8.4 背包系统设计概要

数据结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 静态数据（ScriptableObject 存储物品属性）
public abstract class ItemBase : ScriptableObject
{
 public int ItemID;
 public string ItemName;
 public Sprite Icon;
 public int MaxStack = 1;
 public ItemType Type; // Weapon, Consumable, Material...
}

// 动态数据（物品实例）
[System.Serializable]
public class ItemInstance
{
 public int ItemID;
 public int Count;
 public float Durability;
}

优化方向：

数据分离：静态属性与动态数据解耦
对象池：复用 UI 格子
虚拟列表：仅渲染可视区域内的物品
异步加载：图标按需加载

九、协程与异步

9.1 协程 vs async/await vs Awaitable

方式	GC 开销	适用场景
Coroutine	有	简单延迟、分帧操作
async/await	有（Task 分配）	网络请求、复杂异步
Awaitable（Unity 2022+）	无	性能敏感场景

9.2 async/await 在 Unity 中的使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


using System.Threading.Tasks;

public class AsyncExample : MonoBehaviour
{
 async void Start()
 {
 string data = await LoadDataAsync();
 Debug.Log(data);
 }

 async Task<string> LoadDataAsync()
 {
 using var request = UnityWebRequest.Get("https://api.example.com");
 await request.SendWebRequest();
 return request.downloadHandler.text;
 }
}

async/await 的核心价值：

替代回调/协程，避免"回调地狱"
主线程友好：await 后自动回到主线程
无需手动检查状态

9.3 Unity 中的多线程

Unity 主线程独占 Unity API，子线程中不能调用 GameObject.Instantiate、Transform.position 等操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


using System.Threading;
using System.Threading.Tasks;

public class ThreadExample : MonoBehaviour
{
 void Start()
 {
 // 子线程执行耗时操作
 Thread thread = new Thread(() =>
 {
 int result = HeavyCalculation();
 // 子线程中不能调用 Unity API
 });
 thread.Start();
 }

 // Task 异步
 async void LoadData()
 {
 string data = await Task.Run(() =>
 {
 return System.IO.File.ReadAllText("data.txt");
 });
 // 回到主线程更新 UI
 Debug.Log(data);
 }
}

Unity 自动使用的多线程：

Job System：多线程并行计算
Burst Compiler：将代码编译为高度优化的机器码
物理引擎：默认在子线程处理碰撞检测
资源加载：Addressables 异步加载

十、Shader 基础

10.1 Shader 的概念

Shader 是一种运行在 GPU 上的程序，用来描述物体表面的外观，控制光照与渲染效果。GPU 并行处理大量顶点和像素，Shader 就是告诉 GPU"怎么画"的指令集。

Unity 渲染管线流程：

1

顶点数据 → 顶点着色器(Vertex) → 几何着色器 → 光栅化 → 片段着色器(Fragment) → 输出合并

Unity 中的 Shader 类型：

Surface Shader：Unity 特有的简化写法，自动处理光照计算。开发者只需定义属性（颜色、纹理等），Unity 自动生成完整的 Vertex/Fragment 代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// Surface Shader 示例
Shader "Custom/SimpleSurface"
{
 Properties
 {
 _MainTex ("Texture", 2D) = "white" {}
 _Glossiness ("Smoothness", Range(0,1)) = 0.5
 _Metallic ("Metallic", Range(0,1)) = 0.0
 }
 SubShader
 {
 Tags { "RenderType"="Opaque" }
 CGPROGRAM
 #pragma surface surf Standard fullforwardshadows
 // ... 表面函数
 ENDCG
 }
}

Vertex/Fragment Shader：提供精细控制，开发者自定义顶点和片段处理，适合复杂视觉效果（如溶解、扭曲、热浪）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


// 最简单的 Vertex/Fragment Shader
Shader "Custom/UnlitColor"
{
 Properties
 {
 _Color ("Color", Color) = (1,1,1,1)
 }
 SubShader
 {
 Pass
 {
 CGPROGRAM
 #pragma vertex vert
 #pragma fragment frag

 fixed4 _Color;

 struct appdata
 {
 float4 vertex : POSITION;
 };

 struct v2f
 {
 float4 position : SV_POSITION;
 };

 v2f vert(appdata v)
 {
 v2f o;
 o.position = UnityObjectToClipPos(v.vertex);
 return o;
 }

 fixed4 frag(v2f i) : SV_Target
 {
 return _Color;
 }
 ENDCG
 }
 }
}

10.2 四元数与旋转

四元数是 Unity 中表示旋转的数学工具，使用四个分量（x, y, z, w）表示三维空间中的旋转。

为什么不用欧拉角：

万向锁：当某个轴旋转 90 度时，另外两个轴失去自由度，导致旋转异常
插值不平滑：欧拉角插值会产生不自然的旋转路径

四元数的优点：

可进行增量旋转（旋转叠加）
避免万向锁
插值平滑（Slerp 球形插值）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 四元数常见操作
// 欧拉角 → 四元数
transform.rotation = Quaternion.Euler(0, 45, 0);

// 看向目标
transform.rotation = Quaternion.LookRotation(target.position - transform.position);

// 平滑旋转插值（Slerp = Spherical Linear Interpolation）
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 5f);

// 绕轴旋转
transform.rotation *= Quaternion.AngleAxis(90, Vector3.up);

// 获取当前旋转的欧拉角
Vector3 angles = transform.rotation.eulerAngles;

// 从旋转中提取方向向量
Vector3 forward = transform.rotation * Vector3.forward;

十一、寻路系统（NavMesh）

11.1 烘焙导航网格

NavMesh（Navigation Mesh）是 Unity 的自动寻路系统，通过将可行走区域烘焙为网格，让 AI 角色自动规划路径。

操作步骤：

标记场景中所有静态障碍物为 Navigation Static
打开 Window/AI/Navigation 面板
调整参数：
- Agent Radius：角色半径（决定能通过的最小通道）
- Agent Height：角色高度
- Max Slope：最大可爬坡度数
- Step Height：最大可跨越台阶高度
点击 Bake 生成 NavMesh

11.2 NavMeshAgent 组件

NavMeshAgent 是控制角色寻路的组件，提供路径计算、移动、避障等功能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


public class AIController : MonoBehaviour
{
 private NavMeshAgent agent;
 public Transform target;

 void Start()
 {
 agent = GetComponent<NavMeshAgent>();

 // 配置参数
 agent.speed = 5f; // 移动速度
 agent.angularSpeed = 120f; // 旋转速度
 agent.acceleration = 8f; // 加速度
 agent.stoppingDistance = 1.5f; // 停止距离（攻击范围）

 agent.SetDestination(target.position);
 }

 void Update()
 {
 // 状态检测
 if (!agent.pathPending && agent.remainingDistance <= agent.stoppingDistance)
 {
 // 到达目标，执行攻击逻辑
 Attack();
 }

 // 动态更新目标
 if (target.hasChanged)
 {
 agent.SetDestination(target.position);
 }
 }

 // 暂停/恢复寻路
 public void Pause() => agent.isStopped = true;
 public void Resume() => agent.isStopped = false;

 // 判断是否到达
 public bool HasReached => !agent.pathPending && agent.remainingDistance < 0.1f;
}

11.3 NavMeshAgent 参数详解

参数	作用
`speed`	最大移动速度
`angularSpeed`	旋转速度（度/秒）
`acceleration`	最大加速度
`stoppingDistance`	距离目标多远停止
`autoBraking`	到达时是否自动减速
`radius`	角色半径（用于避障）
`height`	角色高度
`obstacleAvoidanceType`	避障等级（NoObstacleAvoidance ~ All)

11.4 动态障碍物

场景中可移动的障碍物（如门、箱子）使用 NavMeshObstacle 组件：

静态障碍物：在烘焙时被纳入 NavMesh
动态障碍物：运行时通过 NavMeshObstacle 实时阻挡
- Carve：启用后动态切割 NavMesh，物体移走后恢复

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public class DynamicDoor : MonoBehaviour
{
 private NavMeshObstacle obstacle;

 void Start()
 {
 obstacle = GetComponent<NavMeshObstacle>();
 obstacle.carving = true; // 启用动态切割
 }

 public void Open()
 {
 obstacle.carving = false; // 门打开，通行
 // 播放开门动画
 }

 public void Close()
 {
 obstacle.carving = true; // 门关闭，阻挡
 // 播放关门动画
 }
}

11.5 多层 NavMesh（跳跃/下落）

对于不同高度的平台，Unity 支持多层 NavMesh：

在 Navigation 面板添加 Layer（如"Ground"、“Roof”）
为不同高度的物体分配不同 Layer
AI 角色设置 agent.areaMask 控制可走区域

1
2


// 控制 AI 可走的区域（位掩码）
agent.areaMask = (1 << NavMesh.GetAreaFromName("Ground")); // 只能走地面

十二、相机系统

12.1 相机参数详解

Clear Flags：决定屏幕中未渲染区域的处理方式

Skybox：用天空盒填充（3D 场景默认）
Solid Color：用纯色填充（2D 游戏，适合像素风）
Depth Only：仅清除深度缓冲（用于多相机叠加，如主相机 + 武器相机）
Don’t Clear：不清除任何内容（需谨慎使用，会产生拖影效果）

Projection：投影模式

Perspective：透视投影，近大远小，适合 3D 游戏
- Field of View（FOV）：视野角度，默认 60°，FPS 游戏通常用 90°
Orthographic：正交投影，无视距离，适合 2D 游戏、UI 相机
- Size：视野高度的一半（单位：unity 单位）

Clipping Planes：

Near：近剪裁面，过小会导致物体被"挖穿"（z-fighting）
Far：远剪裁面，过大影响性能（深度精度下降）

进阶参数：

Viewport Rect：定义相机渲染的屏幕区域（分屏合作游戏）
- X=0, Y=0, W=0.5, H=1 → 左半屏（玩家1）
- X=0.5, Y=0, W=0.5, H=1 → 右半屏（玩家2）
Culling Mask：每层 32 位掩码，选择渲染哪些 Layer 的物体
Target Texture：将相机画面渲染到 Render Texture（小地图、监控摄像头）

12.2 多相机叠加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class WeaponCamera : MonoBehaviour
{
 private Camera weaponCam;

 void Start()
 {
 weaponCam = GetComponent<Camera>();
 // 武器相机：只渲染武器层，不清理背景
 weaponCam.clearFlags = CameraClearFlags.DepthOnly;
 weaponCam.cullingMask = 1 << LayerMask.NameToLayer("Weapon");
 }
}

12.3 相机常见实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


// 第三人称跟随
public class ThirdPersonCamera : MonoBehaviour
{
 public Transform target;
 public float distance = 10f;
 public float height = 5f;
 public float smoothSpeed = 5f;

 void LateUpdate()
 {
 Vector3 targetPos = target.position + Vector3.up * height - target.forward * distance;
 transform.position = Vector3.Lerp(transform.position, targetPos, smoothSpeed * Time.deltaTime);
 transform.LookAt(target.position + Vector3.up * 2f);
 }
}

// 第一人称相机
public class FirstPersonCamera : MonoBehaviour
{
 public Transform playerBody;
 public float mouseSensitivity = 100f;
 private float xRotation = 0f;

 void Start()
 {
 Cursor.lockState = CursorLockMode.Locked;
 }

 void Update()
 {
 float mouseX = Input.GetAxis("Mouse X") * mouseSensitivity * Time.deltaTime;
 float mouseY = Input.GetAxis("Mouse Y") * mouseSensitivity * Time.deltaTime;

 xRotation -= mouseY;
 xRotation = Mathf.Clamp(xRotation, -90f, 90f);

 transform.localRotation = Quaternion.Euler(xRotation, 0, 0);
 playerBody.Rotate(Vector3.up * mouseX);
 }
}

十三、Unity 常用架构

13.1 传统 MonoBehaviour 架构（面向对象）

每个脚本继承 MonoBehaviour，通过组件挂载到 GameObject 上，对象独立处理逻辑。

优点：直观易用，适合中小规模项目。

缺点：

性能瓶颈：大量 GameObject 的 Update 逐个执行，导致主线程卡顿
内存碎片化：频繁创建/销毁引发 GC
耦合度高：对象间引用关系复杂时难以维护

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class Player : MonoBehaviour
{
 public float speed = 5f;

 void Update()
 {
 float h = Input.GetAxis("Horizontal");
 transform.Translate(h * speed * Time.deltaTime, 0, 0);
 }
}

13.2 MVC 架构

将数据（Model）、显示（View）、逻辑（Controller） 分离，降低耦合度。

适用场景：UI 系统、网络同步、需要严格分层的项目。

1
2
3
4
5


用户输入 → Controller（逻辑控制）
 ↓
 Model（数据存储）→ 数据变更通知
 ↓
 View（界面更新）→ 反馈用户

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


// Model：纯数据，无 MonoBehaviour
[System.Serializable]
public class PlayerModel
{
 public int Health = 100;
 public Vector3 Position = Vector3.zero;
}

// View：只负责显示，不存数据
public class PlayerView : MonoBehaviour
{
 public void UpdatePosition(Vector3 pos) => transform.position = pos;
 public void UpdateHealthBar(int health) { /* UI 更新 */ }
}

// Controller：协调 Model 和 View
public class PlayerController : MonoBehaviour
{
 [SerializeField] private PlayerView view;
 private PlayerModel model = new PlayerModel();

 public void TakeDamage(int damage)
 {
 model.Health -= damage;
 view.UpdateHealthBar(model.Health);
 }

 public void Move(Vector3 delta)
 {
 model.Position += delta;
 view.UpdatePosition(model.Position);
 }
}

13.3 事件驱动架构

通过事件解耦模块间的通信，适合成就系统、音效触发等需要低耦合的场景。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


// 定义事件参数类（携带数据）
public class EnemyDiedEventArgs
{
 public Vector3 Position;
 public EnemyType Type;
 public int ScoreValue;
}

// 发布者
public class Enemy : MonoBehaviour
{
 // 使用 C# Action 事件
 public static event System.Action<EnemyDiedEventArgs> OnAnyEnemyDied;

 void Die()
 {
 OnAnyEnemyDied?.Invoke(new EnemyDiedEventArgs
 {
 Position = transform.position,
 Type = enemyType,
 ScoreValue = score
 });
 Destroy(gameObject);
 }
}

// 订阅者 1：成就系统
public class AchievementSystem : MonoBehaviour
{
 private int killCount;

 void OnEnable() => Enemy.OnAnyEnemyDied += OnEnemyKilled;
 void OnDisable() => Enemy.OnAnyEnemyDied -= OnEnemyKilled;

 void OnEnemyKilled(EnemyDiedEventArgs args)
 {
 killCount++;
 if (killCount >= 100)
 UnlockAchievement("百人斩");
 }
}

// 订阅者 2：音效系统
public class AudioManager : MonoBehaviour
{
 void OnEnable() => Enemy.OnAnyEnemyDied += (args) => PlayDeathSound();
 void OnDisable() => Enemy.OnAnyEnemyDied -= (args) => PlayDeathSound();
}

// 订阅者 3：UI 系统
public class ScoreUI : MonoBehaviour
{
 void OnEnable() => Enemy.OnAnyEnemyDied += (args) =>
 UpdateScore(args.ScoreValue);
}

13.4 ECS 架构（Entity-Component-System）

ECS 是数据导向的架构，将面向对象的"对象 = 数据 + 行为"拆分为纯数据和纯逻辑。

为什么需要 ECS：

传统 OOP 中，10000 个敌人各自执行 Update，CPU 缓存命中率低
ECS 将同类数据连续存储，CPU 遍历时按顺序读取，性能提升数倍

核心概念：

概念	说明	类比 OOP
Entity（实体）	唯一 ID，无数据无方法	GameObject
Component（组件）	纯数据结构	类的字段
System（系统）	处理特定组件组合的逻辑	类的方法

Archetype 与 Chunk：

Archetype：具有相同组件组合的 Entity 归为一类（如 Position+Velocity）
Chunk：每个 Archetype 的数据存储在连续的内存块中（每个 Chunk 16KB）

1
2
3
4
5
6
7


Archetype (Position + Velocity)
┌─────────────────────────────────┐
│ Chunk 1 │
│ [P1][V1] [P2][V2] [P3][V3] ... │ ← 连续内存，CPU 缓存友好
│ Chunk 2 │
│ [P11][V11][P12][V12] ... │
└─────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


using Unity.Entities;
using Unity.Burst;
using Unity.Jobs;
using Unity.Mathematics;

// Component：纯数据结构
public struct Position : IComponentData
{
 public float3 Value;
}

public struct Velocity : IComponentData
{
 public float3 Value;
}

// System：每帧处理所有具有 Position + Velocity 的 Entity
[BurstCompile]
public partial struct MovementSystem : ISystem
{
 [BurstCompile]
 public void OnUpdate(ref SystemState state)
 {
 // 查询所有拥有 Position 和 Velocity 的 Entity
 foreach (var (position, velocity) in
 SystemAPI.Query<RefRW<Position>, RefRO<Velocity>>())
 {
 // 更新位置：position += velocity * deltaTime
 position.ValueRW.Value += velocity.ValueRO.Value * SystemAPI.Time.DeltaTime;
 }
 }
}

// 创建 Entity 并添加组件
public class GameManager : MonoBehaviour
{
 void Start()
 {
 var world = World.DefaultGameObjectInjectionWorld;
 var entityManager = world.EntityManager;

 // 批量创建 10000 个移动实体
 for (int i = 0; i < 10000; i++)
 {
 Entity entity = entityManager.CreateEntity();
 entityManager.AddComponentData(entity, new Position { Value = float3.zero });
 entityManager.AddComponentData(entity, new Velocity { Value = new float3(1, 0, 0) });
 }
 }
}

ECS 性能优势：

特性	原理	效果
连续内存	同类型组件连续存储	CPU 缓存命中率提高 10x
多线程 Job System	自动将 System 逻辑分发到多核	充分利用多核 CPU
Burst Compiler	C# 编译为高度优化的原生代码	性能提升 5-10 倍

对比：100000 个移动物体

架构	CPU 耗时	GC 分配
MonoBehaviour	35ms	高频
ECS + Jobs + Burst	2ms	几乎为零

十四、Unity 移动射击动画融合

14.1 动画层（Animation Layers）

实现"边跑边射击"的核心技术是动画分层。将身体分为上下两层，分别播放不同动画。

实现步骤：

在 Animator Controller 中创建两个 Layer：
- Base Layer：处理移动动画（走、跑、跳跃）
- Upper Body Layer：处理上身动画（射击、换弹、投掷）
为 Upper Body Layer 设置 Avatar Mask：
- 创建 Avatar Mask 资产
- 仅勾选上半身骨骼（Spine、Chest、Left/Right Arm、Head）
- 下半身骨骼交由 Base Layer 控制
代码控制 Layer 权重：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


public class PlayerAnimator : MonoBehaviour
{
 private Animator animator;

 // 动画层索引
 private readonly int baseLayer = 0;
 private readonly int upperLayer = 1;

 void Start() => animator = GetComponent<Animator>();

 void Update()
 {
 // Base Layer：根据速度切换走/跑
 float speed = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical")).magnitude;
 animator.SetFloat("Speed", speed);

 // Upper Body Layer：射击时启用
 if (Input.GetButtonDown("Fire1"))
 {
 // 将 Upper Body 权重设为 1（完全覆盖上半身）
 animator.SetLayerWeight(upperLayer, 1f);
 animator.Play("Shoot", upperLayer, 0f);
 }

 // 射击结束后逐渐恢复权重为 0
 if (Input.GetButtonUp("Fire1"))
 {
 StartCoroutine(FadeOutLayer(upperLayer, 0.2f));
 }
 }

 IEnumerator FadeOutLayer(int layer, float duration)
 {
 float elapsed = 0;
 while (elapsed < duration)
 {
 elapsed += Time.deltaTime;
 animator.SetLayerWeight(layer, Mathf.Lerp(1, 0, elapsed / duration));
 yield return null;
 }
 animator.SetLayerWeight(layer, 0);
 }
}

14.2 动画参数与混合

常用动画参数类型：

参数类型	方法	用途
Float	`SetFloat("Speed", 5.5f)`	移动速度、转向角度
Int	`SetInteger("State", 2)`	状态枚举
Bool	`SetBool("IsGrounded", true)`	条件切换
Trigger	`SetTrigger("Jump")`	一次性触发（自动复位）

Blend Tree 混合：根据一个或多个参数平滑过渡动画（如根据速度混合 Idle → Walk → Run）。

1
2
3
4
5
6


// 1D Blend Tree 示例：Idle(0) → Walk(2) → Run(6)
animator.SetFloat("Speed", currentSpeed);

// 2D Blend Tree 示例：根据横向和纵向输入混合
animator.SetFloat("Horizontal", moveX);
animator.SetFloat("Vertical", moveY);

14.3 Animator 性能优化

减少层数：每增加一层都会额外计算
减少参数数量：参数变更会触发状态机重评估
使用 HasExitTime：确保动画播完再过渡，避免频繁打断
优化 Avatar Mask：只在需要的骨骼上启用遮罩

十五、Unity 序列化

15.1 什么是序列化

序列化将对象状态转换为可存储或可传输的格式（二进制、JSON、XML），反序列化则逆向还原。

Unity 中的序列化场景：

场景	说明
场景和预制体保存	Inspector 中修改的 `public` 变量自动序列化到 `.unity` / `.prefab` 文件
Inspector 面板显示	`[SerializeField]` 让私有变量显示在 Inspector 并序列化
ScriptableObject	创建可复用配置数据，保存为 `.asset` 文件
JSON 存档	使用 `JsonUtility` 序列化游戏存档
网络传输	序列化对象状态发送到服务器或其他客户端

15.2 序列化规则

Unity 自动序列化以下类型：

基本类型：int, float, string, bool, enum
Unity 结构体：Vector2/3/4, Quaternion, Color, Rect, Bounds
引用类型：GameObject, Component, ScriptableObject（序列化引用而非内容）
数组和 List<T>（T 必须是可序列化类型）
自定义类/结构体：需标记 [System.Serializable]

不会被序列化的成员：

静态变量
属性（Property，有 get/set 的成员）
委托和事件
接口类型
字典 Dictionary（需手动处理）

15.3 控制序列化的特性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


[System.Serializable]
public class SaveData
{
 public int level;
 public float positionX;
 public List<string> unlockedItems = new List<string>();
}

public class Player : MonoBehaviour
{
 [SerializeField] private int health; // 私有字段显示在 Inspector

 [HideInInspector] public int debugValue; // 公开字段不在 Inspector 显示

 [NonSerialized] public int tempValue; // 不被序列化（不保存）

 [Range(0, 100)] public float speed; // Inspector 滑动条

 [Tooltip("当前角色等级")]
 public int level; // 鼠标悬停提示

 [Header("战斗属性")] // 分组标题
 public int attack;
 public int defense;
}

// ScriptableObject（可复用配置数据）
[CreateAssetMenu(menuName = "Game/ItemData")]
public class ItemData : ScriptableObject
{
 public int itemID;
 public string itemName;
 public Sprite icon;
 public int maxStack = 1;
}

// 使用 ScriptableObject
ItemData sword = ScriptableObject.CreateInstance<ItemData>();
sword.itemName = "铁剑";
AssetDatabase.CreateAsset(sword, "Assets/Data/Items/IronSword.asset");

15.4 JSON 序列化（存档）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


// 存档数据结构
[System.Serializable]
public class GameSaveData
{
 public int level;
 public float playerHealth;
 public Vector3 playerPosition;
 public List<string> inventoryItems;
 public Dictionary<string, int> stats; // 需要 ISerializationCallbackReceiver
}

// 保存存档
public class SaveManager : MonoBehaviour
{
 public void SaveGame(GameSaveData data)
 {
 string json = JsonUtility.ToJson(data, true); // true = 格式化输出
 File.WriteAllText(Application.persistentDataPath + "/save.json", json);
 }

 public GameSaveData LoadGame()
 {
 string path = Application.persistentDataPath + "/save.json";
 if (File.Exists(path))
 {
 string json = File.ReadAllText(path);
 return JsonUtility.FromJson<GameSaveData>(json);
 }
 return null;
 }
}

JsonUtility vs Newtonsoft.Json：

特性	JsonUtility	Newtonsoft.Json
性能	快（Unity 原生）	较慢
支持类型	MonoBehaviour、ScriptableObject	任意 .NET 类型
字典支持	不支持	支持
多态	不支持	支持
安装	内置	需安装 Package

15.5 ISerializationCallbackReceiver

用于序列化前后执行自定义逻辑，典型用途是处理字典序列化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


public class Inventory : MonoBehaviour, ISerializationCallbackReceiver
{
 // Dictionary 不会被 Unity 自动序列化
 [NonSerialized] public Dictionary<string, int> items = new Dictionary<string, int>();

 // 用列表中转存储
 [SerializeField] private List<string> _keys = new List<string>();
 [SerializeField] private List<int> _values = new List<int>();

 // 序列化前：字典 → 列表
 public void OnBeforeSerialize()
 {
 _keys.Clear();
 _values.Clear();
 foreach (var pair in items)
 {
 _keys.Add(pair.Key);
 _values.Add(pair.Value);
 }
 }

 // 反序列化后：列表 → 字典
 public void OnAfterDeserialize()
 {
 items.Clear();
 for (int i = 0; i < _keys.Count; i++)
 items[_keys[i]] = _values[i];
 }
}

15.6 序列化方案对比

方案	优点	缺点
Unity 默认序列化	自动处理组件引用、Inspector 显示	不支持字典、接口
JsonUtility	轻量、易读、支持 MonoBehaviour	性能较低、不支持多态
BinaryFormatter	高效、体积小	安全性差（已弃用）
第三方（MessagePack）	高性能、跨平台	需额外集成

十六、高性能开发建议

16.1 CPU 性能优化

（1）减少 Update 中的开销：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// ❌ 不好：每帧 GetComponent 和字符串拼接
void Update()
{
 GetComponent<Rigidbody>().AddForce(Vector3.up);
 Debug.Log("位置: " + transform.position);
}

// ✅ 好：缓存引用 + StringBuilder
private Rigidbody rb;
private StringBuilder sb = new StringBuilder(64);

void Start() => rb = GetComponent<Rigidbody>();

void Update()
{
 rb.AddForce(Vector3.up);
 sb.Clear();
 sb.Append("位置: ").Append(transform.position);
}

（2）使用对象池代替频繁 Instantiate/Destroy：

子弹、敌人、粒子特效等高频创建的对象使用对象池
避免 GC 压力，降低 CPU 峰值

（3）减少 Mono 调用：

每帧调用 Unity API（如 transform.position）有 native/managed 边界开销
缓存频繁访问的 Transform、Renderer 等组件引用

（4）LOD（Level of Detail）：

远处的物体使用低面数模型
Unity LOD Group 组件自动切换

16.2 GPU 性能优化

（1）合批（Batching）：

方式	条件	效果
Static Batching	标记为 Static 的物体	减少 Draw Call
Dynamic Batching	小物体（<900顶点）	CPU 换 GPU
GPU Instancing	相同 Mesh + Material 的物体	一次绘制多个

（2）减少 Draw Call：

使用图集（Sprite Atlas）合并纹理
尽可能共用材质
使用 Shader 变体控制功能开关

（3）纹理优化：

使用合适的纹理格式（ASTC/ETC2）
开启 Mipmap（远处用低分辨率）
控制最大纹理尺寸（手机 2048 足够）

16.3 内存优化

（1）资源管理：

1
2
3
4
5
6


// 不再使用的资源手动卸载
Resources.UnloadAsset(myTexture);
Resources.UnloadUnusedAssets();

// Addressables 引用计数自动管理
Addressables.Release(handle);

（2）音频优化：

短音效用 Decompress On Load（立即播放）
背景音乐用 Streaming（边播边加载）
合理设置 Force To Mono（立体声转单声道减半）

（3）避免内存泄漏：

事件订阅后记得取消（OnEnable 注册，OnDisable 注销）
协程在对象销毁后自动停止
DontDestroyOnLoad 对象谨慎使用

16.4 渲染性能 Profiling 工具

工具	用途
Profiler	分析 CPU/GPU/内存瓶颈
Frame Debugger	逐帧查看 Draw Call
Memory Profiler	分析内存分配详情
RenderDoc	深度 GPU 调试
Physics Debugger	碰撞体可视化

16.5 Unity 常用特性关键字

特性	作用
`[SerializeField]`	私有字段显示在 Inspector
`[Range(min, max)]`	滑动条限制数值范围
`[Tooltip("说明")]`	Inspector 中鼠标悬停提示
`[Header("标题")]`	Inspector 中分组标题
`[HideInInspector]`	公开字段不在 Inspector 显示
`[RequireComponent(typeof(X))]`	自动添加依赖组件
`[ExecuteInEditMode]`	编辑模式下也执行脚本
`[DisallowMultipleComponent]`	禁止挂载多个相同组件

本文涵盖 Unity 引擎从基础到进阶的核心知识点，适合 Unity 开发者系统复习和快速查阅。

对战斗系统进行一个基础的拆解

Fri, 29 May 2026 15:49:00 +0800

一、项目概述

一个从空白 Unity 工程开始搭建的 3D 动作战斗原型。约 6,800 行 C#，88 个脚本文件，覆盖 13 个模块。所有系统从零设计实现，不使用战斗中间件或现成框架。

已实现的战斗功能：

基于连招链的轻攻击（左键）和技能/大招（E/Q 键）
Shift 闪避→冲刺链路，支持闪避中触发的特殊攻击（闪A）
双角色切换（Tab 普通切换 / QTE 连携切人）
霸体/耐力值分支的受击与格挡动画
自动敌人锁定与攻击判定（SphereCast + 距离角度过滤）

已实现的辅助系统：

Cinemachine + Timeline 技能相机（Dolly 路径推近变焦）
ComboData→ComboContainerData→PlayerComboSOData 三层 ScriptableObject 数据驱动
事件系统解耦伤害链路
VFX/SFX 对象池
Timer 对象池计时器
CinemachineImpulse 震屏 + Animator.speed 顿帧（实现但调用被注释）

二、架构总览

设计核心理念

两个相互独立的有限状态机并行运转：

1
2
3


Player (MonoBehaviour)
 ├── movementStateMachine ← 移动 FSM（待机/行走/奔跑/冲刺/闪避/转身…）
 └── comboStateMachine ← 连招 FSM（Null/ATKIng/Skill）

两者通过 OnAnimationTranslation（Unity StateMachineBehaviour）联动，但互不包含引用——联动仅通过 Player 层的 OnAnimationTranslateEvent 中转。

事件系统的角色

所有伤害判定、特效、音效通过 GameEventManager（类型安全的泛型 Action 封装）广播。攻击者只管发事件，不管谁接。敌人 Health 组件监听 "触发伤害" 事件，做伤害、动画、特效、音效四件事。

数据流向

1
2
3
4
5


输入 → 状态机 → ComboData取值 → CrossFade动画
 ↓
 动画事件ATK() → 伤害判定 → GameEventManager → 敌人Health → 受击反馈
 动画事件PlayComboFX() → SFX_PoolManager → 音效
 CameraSwitcher + SkillTimelineManager → 相机控制

三、输入系统

文件

文件	行数	说明
`Input/CharacterInput.inputactions`	—	Input Action Asset，定义所有输入绑定
`Input/CharacterInput.cs`	720	自动生成的 C# 包装类，内嵌 JSON 绑定定义
`Input/CharacterInputSystem.cs`	127	单例，封装 `PlayerMove`、`L_Atk`、`R_Atk`、`Run` 等属性访问

按键绑定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


Player Action Map:
 L_AtK → <Mouse>/leftButton 轻攻击
 R_Atk → <Mouse>/rightButton 重攻击（代码未接线）
 Movement → WASD / 左摇杆 移动
 Run → <Keyboard>/shift 闪避/冲刺
 Execute → <Keyboard>/e 技能
 FinishSkill → <Keyboard>/q 终极大招

SwitchSkill Action Map:
 L → <Mouse>/leftButton QTE选左
 R → <Mouse>/rightButton QTE选右

上下文切换

QTE 切人时，TriggerSwitchSkill() 第 142 行禁用 Player Action Map，CharacterCombo.StartSwitchSkill() 第 166 行注册 SwitchSkill Map。左键从攻击变为选人，右键同理。取消或完成切人后恢复 Player 映射。

按键到事件链路

1
2
3
4
5


按下左键 → Input System → L_AtK.started
 → PlayerComboState.OnAttackInput(InputAction.CallbackContext)
 → 当前角色校验 → CanBaseComboInput(检查canInput + 不在Hit/Parry/Skill)
 → 冲刺/闪避中? → DodgeComboInput
 → 普通状态 → LightComboInput

四、动画状态机与事件路由

文件

文件	说明
`OnAnimationTranslation.cs`	挂在 Animator Controller 每个动画状态上，负责进入/退出时通知 Player
`Player.cs`	`OnAnimationTranslateEvent` 根据枚举分发到 movement / combo FSM

OnAnimationTranslation 设计

1
2
3
4
5
6
7


public enum OnEnterAnimationPlayerState
{
 Idle, Walk, Run, Sprint,
 Dash, DashBack, TurnBack,
 Switch, SwitchOut,
 ATK, Null
}

每个 Animator 动画状态上挂一个 OnAnimationTranslation，Inspector 中选对应的枚举值：

Dash / DashBack → 闪避动画
ATK → 普通攻击动画
Null → 技能动画（进入时不触发任何逻辑，退出时走 default 分支两者都调）
Switch / SwitchOut → 切人进出场

OnStateExit 分流逻辑（最终版）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


switch (onEnterAnimationState)
{
 case Dash / DashBack / TurnBack / Switch / SwitchOut
 / Idle / Walk / Run / Sprint:
 player.OnMovementAnimationExitEvent(); // 只调 movement
 break;

 case ATK:
 player.OnMovementAnimationExitEvent(); // 调 movement（恢复移动）
 player.OnComboAnimationExitEvent(); // 调 combo（退出攻击状态）
 break;

 default: // 含 Null（技能动画）
 player.OnAnimationExitEvent(); // 两者都调（向后兼容）
 break;
}

踩过的坑

中间版本 ATK 分支只调了 combo 忘了调 movement → 攻击结束卡死在 PlayerMovementNullState 无法移动。修复后发现翻滚退出也同时触发了 combo FSM → 技能被打断。最终版加 default 分支向后兼容 Null 状态的技能动画，Dash 系列只调 movement。

五、连招系统

核心文件

文件	行数	职责
`CharacterComboBase.cs`	330	核心连招逻辑：输入处理、动画播放、伤害触发
`CharacterCombo.cs`	241	角色特殊逻辑：闪A、技能、QTE、敌人检测
`ComboContainerData.cs`	194	ScriptableObject，多段连招容器
`ComboData.cs`	50	ScriptableObject，单段攻击数据
`PlayerComboSOData.cs`	14	角色五类攻击的顶层入口
`PlayerComboReusableData.cs`	24	运行时状态（comboIndex、canInput、canATK等）

普攻流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


左键 → LightComboInput()
 ├── currentCombo = comboData.lightCombo ← 设为轻攻击链
 ├── ResetComboDates() ← 恢复第一段（防止闪A残留）
 └── ExecuteBaseCombo()
 ├── hasATKCommand = true ← 攻击指令排队
 └── canInput = false ← 锁输入

下一帧 UpdateComboAnimation() 消费指令:
 ├── comboName = currentCombo.GetComboName(comboIndex)
 ├── CrossFade(comboName, 0.111f) ← 播放动画
 ├── PlayCharacterVoice / PlayWeaponSound ← 播放音效
 └── comboIndex++, hasATKCommand=false, canATK=false

预输入窗口

动画事件的 EnablePreInput 在攻击动画结束前设 canInput=true。玩家在这个窗口内再按左键 → comboIndex++ → 下一段攻击。DisableLinkCombo 在最后一段攻击中关闭 canLink=false → 连招链终止。

三层数据驱动

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


ComboData.asset → 单段攻击的所有参数
 ├── comboName: "ATK_01"
 ├── comboDamage: 15
 ├── hitName[]: "Hit_Front", "Hit_Back"
 ├── parryName[]: "Parry"
 ├── ATKCount: 2
 └── shakeForceList: [0.3, 0.5]

ComboContainerData.asset → 多段连招链
 └── comboDates[]: [ComboData_01, ComboData_02, ...]
 └── DodgeATKData: 闪A替换第一段

PlayerComboSOData → 角色的五类攻击
 ├── lightCombo
 ├── heavyCombo
 ├── executeCombo
 ├── skillCombo
 ├── finishSkillCombo
 └── switchSkill

comboIndex 和 ATKIndex

comboIndex：当前连招段索引（0→1→2→0 循环）
ATKIndex：段内伤害判定序号（从 1 开始），用于读取 ShakeForceList 和 PauseFrameTimeList。每次 ATK() 动画事件触发时 UpdateATKIndex() 自增。comboIndex 变化时通过 BindableProperty.OnValueChanged 自动回调 ReSetATKIndex 清零。

闪A

闪避/冲刺中按左键 → PlayerComboState.OnAttackInput 检测 currentMovementState == "Sprinting" || AnimationAtTag("Dodge") → DodgeComboInput() → ComboContainerData.SwitchDodgeATK() 把第一段攻击替换为 DodgeATKData。

六、技能系统

流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


按 E → OnSkill()
 → CanSkillInput() ← 不在Hit/Parry/Skill/ATK中
 → SkillInput()
 → currentSkill = comboData.skillCombo
 → ExecuteSkill()
 → ReSetATKIndex(0) ← 手动清零伤害判定序号
 → PlayCharacterVoice(currentSkill) / PlayWeaponSound(currentSkill)
 → CrossFadeInFixedTime(comboName, 0.1f)
 → ChangeState(SkillState)

SkillState.Enter:
 → movement → playerMovementNullState ← 禁止移动
 → CameraSwitcher.ActiveStateCamera ← 激活技能相机
 → SkillTimelineManager.PlaySkillTimeline ← 播放 Timeline 推近变焦

动画播完 → OnAnimationExitEvent → ChangeState(NullState) → 恢复

与普攻共用 AttackTrigger

1
2
3
4


AttackTrigger():
 if animTag("ATK") → AttackDetection(currentCombo) → 普通攻击
 elif animTag("Skill") → SkillDetection(currentSkill) → 技能
 else → AttackDetection(executeCombo) → 处决

技能和普攻共用同一个 ATK() 动画事件方法。Animator 的 Tag 区分当前是什么类型的动画，走不同的检测和数据源。

七、相机系统

核心文件

文件	说明
`CameraSwitcher.cs`	单例，管理 VCam Priority（激活/关闭）
`SkillTimelineManager.cs`	单例，管理 (角色, 技能类型) → PlayableDirector 映射
`CameraHitFeel.cs`	震屏、顿帧、慢动作
`VCamDollyHelper.cs`	暴露 Dolly 的 PathPosition 给 Animation Track
`OnAnimationTranslation.cs`	技能动画退出时通知状态机
`PlayerSkillState.cs`	进入/退出技能时调 CameraSwitcher + SkillTimelineManager

CameraSwitcher 设计

1
2
3
4
5


stateCameraPool[CharacterNameList][AttackStyle] → CinemachineVirtualCameraBase

ActiveStateCamera(Skikk) → Priority = 20
UnActiveStateCamera() → Priority = 0
UnActiveAllStateCameras() → 遍历该角色全部VCam → Priority=0（切人时用）

StateCameraInfo.stateCamera 最终使用基类 CinemachineVirtualCameraBase，支持直接拖入普通 VCam 或 CinemachineStateDrivenCamera。

Timeline 方案演进

整个过程走了六种方案，每种都有具体的失败原因：

尝试	方案	失败原因
1	Cinemachine Track（编辑器）	`Signal Emitter` 在 Animator State 上搜不到
2	Animation Event + Object 参数	动画事件的 `Object` 字段不支持拖场景对象
3	Prefab Mode + Animation Track	`ExposedReferences` 在 Prefab 上下文丢失
4	场景多 Director + 动画事件	同上，场景对象引用在 `.anim` 的 AnimationEvent 中不可序列化
5	PlayableDirector 放角色 Prefab + VCam 子物体	`GetGenericBinding` 返回 NULL，Prefab 实例化后绑定丢失
6	SkillTimelineManager 运行时自动补绑	✅ 最终方案

最终方案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// SkillTimelineManager.PlaySkillTimeline():
foreach (var track in timeline.GetOutputTracks())
{
 if (track is AnimationTrack && director.GetGenericBinding(track) == null)
 {
 var vcam = playerRoot.GetComponentInChildren<CinemachineVirtualCameraBase>();
 if (vcam != null)
 director.SetGenericBinding(track, vcam.gameObject);
 }
}

VCam 必须是场景中角色实例的子物体，名字无所谓。GetComponentInChildren 自动找到第一个，SetGenericBinding 补绑。CameraSwitcher 管 Priority 激活，Timeline Animation Track 管 PathPosition（Dolly 路径位置，一个 float 曲线）。

切人应急复位

SwitchCharacter.ExecuteSwitchCharacter 最前面两行：

1
2


SkillTimelineManager.MainInstance.StopAllForCharacter(旧角色);
CameraSwitcher.MainInstance.UnActiveAllStateCameras(旧角色);

先停 Timeline 不再写值，再强制 Priority=0 覆盖。

震屏兼容

每个技能 VCam 额外挂 CinemachineImpulseListener 组件，确保切到技能相机后 CameraHitFeel.CameraShake 的脉冲信号仍被接收。

八、角色切换系统

核心文件

文件	说明
`SwitchCharacter.cs`	单例，管理所有角色实例、候补列表、切人演出

两种切人

Tab 普通切人：

1
2
3
4
5
6


SwitchInput()
 → 旧角色名移入 waitingCharacterList，新角色移出
 → ExecuteSwitchCharacter(新角色, isSwitchATK=false)
 → 新角色在旧角色侧面 spawn → Play("SwitchIn")
 → 旧角色：攻击中? → 等播完 → CrossFade("SwitchOut") → 非攻击 → 立即退场
 → switchOutCharacterTime 后 SetActive(false) 旧角色

QTE 连携切人：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


连招满足条件 → TriggerSwitchSkill()
 → 禁用 Player Input
 → 激活切人相机 CameraSwitcher.ActiveSwitchCamera(true)
 → 0.3s后 Time.timeScale = 0.06（慢动作）
 → 0.2s后 StartSwitchSkill()
 → 3秒倒计时
 → 弹出 SwitchTimeUI（候补角色头像 + 定时）
 → 注册 SwitchSkill.L/R 输入
 → 玩家选人 → SwitchSkill(角色名)
 → CameraSwitcher.ActiveSwitchCamera(false)
 → 恢复时间 → 恢复输入
 → ExecuteSwitchCharacter(新角色, isSwitchATK=true)
 → 新角色从敌人生成位置登场 → 播切人大招动画

WaitAttackFinishAndExit 协程

1
2
3
4
5
6
7
8


IEnumerator WaitAttackFinishAndExit(SwitchCharacterInfo info, string switchOutAnim)
{
 while (info.animator.AnimationAtTag("ATK") || info.animator.AnimationAtTag("Skill"))
 yield return null; // 每帧检查，攻击播完再继续

 info.animator.CrossFadeInFixedTime(switchOutAnim, 0.1f);
 StartDeactivateCoroutine(); // 延迟 switchOutCharacterTime 后隐藏
}

同时做了防护：如果同一角色被切出去后又切回来，ExecuteSwitchCharacter 中检查 waitAttackExitTarget == newCharacterInfo.character → StopCoroutine 取消旧协程，防止把退场动画覆盖到新登场动画上。

候补列表维护

1
2
3
4
5
6


// newCharacterName 变化时（BindableProperty.OnValueChanged）
OnSetWaitingCharacterList(newValue):
 waitingCharacterList.Remove(newValue); // 新上场的角色移出
 waitingCharacterList.Add(currentCharacterName); // 旧角色移入（如果不在列表中）

// 效果：waitingCharacterList 永远只存"不在场"的角色

Collider 互忽略

1
2
3
4


IgnoreAllPlayerCollisions():
 遍历 switchCharacterInfos 所有两两组合
 GetComponentsInChildren<Collider>() × 2
 Physics.IgnoreCollision(ca, cb); // 一对永久忽略

在 Start() 中调一次，Physics.IgnoreCollision 生命周期内有效。

九、伤害与霸体系统

核心文件

文件	说明
`CharacterComboBase.cs`	`AttackTrigger()` → 距离角度判定 → 发事件
`GameEventManager.cs`	类型安全泛型事件调度
`CharacterHealthBase.cs`	`OnCharacterHitEventHandler` → 调子类的动画/伤害分支
`CharacterHeath.cs`	`CharacterHitAction` → 霸体判断 → 播受击或格挡

完整链路

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


动画关键帧 ATK() 事件触发
 → Player.ATK()
 → PlayerATKIngState.ATK()
 → CharacterComboBase.ATK()
 → AttackTrigger()

AttackTrigger():
 判断 animTag:
 "ATK":
 AttackDetection(距离<comboDistance && 角度<80°)
 → 取得 hitName/parryName（ComboData 数组中随机取一个字符串）
 → GameEventsManager.CallEvent("触发伤害",
 damage, hitName, parryName, attacker, bearer, combo)

GameEventManager → EventHandler<float,string,string,Transform,Transform,ComboBase>.CallBack
 → Action.Invoke(damage, hitName, parryName, attacker, bearer, combo)

CharacterHealthBase.OnCharacterHitEventHandler:
 if (Bearer != this.transform) return; ← 过滤：只处理被击中的那个敌人
 → CharacterHitAction(Damage, HitName, ParryName)
 → CharacterHeath.CharacterHitAction():
 if (hasStrength) → animator.CrossFade(parryName) ← 格挡动画
 else → animator.CrossFade(hitName) ← 受击动画
 → OnCharacterDamageAction → TakeDamage/TakeStrength
 → SetHitFVX → VFX_PoolManager.GetVFX(Enemy, "Hit", 命中点)
 → SetHitSFX（被注释）

霸体=耐力槽

1
2
3
4
5
6
7


HasStrength = true:
 → TakeStrength(damage) ← 扣耐力值
 → 播 parryName 格挡动画

HasStrength = false:
 → TakeDamage(damage) ← 扣血量
 → 播 hitName 受击动画

耐力归零时触发 "达到QTE条件" 事件 → 通知攻击者可以 QTE 切人。

震屏与顿帧

代码已实现，调用在 AttackTrigger 中被注释（第 255、267、290、294、312 行）：

1
2


// CameraHitFeel.MainInstance.CameraShake(shakeForce[ATKIndex-1]);
// CameraHitFeel.MainInstance.PF(pauseFrameTime);

恢复后，ComboData.ShakeForceList[] 和 PauseFrameTimeList[] 与 ATKCount 长度对齐。每次 ATK() 动画事件 → ATKIndex 自增 → 读取数组对应位置。

十、特效系统

核心文件

文件	说明
`VFX_PoolManager.cs`	单例，三级字典对象池
`EffectItem.cs`	挂预制体上，播放→定时回收
`PoolItemBase.cs`	池对象基类，`OnEnable→Spawn` / `OnDisable→ReSycle`
`VFXItemData.cs`	MonoBehaviour，定义角色特效列表
`VFXManager.cs`	全局粒子速度控制器

三级字典结构

1
2
3
4


effectPool[CharacterNameList][VFXNameString] → Queue<GameObject>

例: effectPool[Seele]["Slash"] → Queue(刀光×3)
 effectPool[Enemy]["Hit"] → Queue(火花×5)

EffectItem 生命周期（已修复）

1
2
3
4
5
6
7
8


TryGetVFX → Dequeue(不活跃) → Init(角色,特效名) → SetActive(true)
 → OnEnable → Spawn → StartPlay
 → ParticleSystem.Play()
 → TimerManager.GetOneTimer(playTime, StartReCycle)

playTime到期 → StartReCycle → ReturnVFX(角色,特效名,go)
 → SetActive(false) → OnDisable → ReSycle → ParticleSystem.Stop()
 → Enqueue(回池)

修复过的 Bug

早期版本 Dequeue 后立即 Enqueue 回去——池中实例全部活跃时再次 Dequeue 拿到活跃对象，SetActive(true) 是空操作，粒子不启动。修复方案：对象只在播放完毕 ReturnVFX 时才回池，队列只含未活跃实例。

双 API

1
2
3
4
5


// 有父级（刀光附着武器骨骼，不改位置）
VFX_PoolManager.TryGetVFX(Seele, "Slash");

// 无父级（世界坐标生成火花）
VFX_PoolManager.GetVFX(Enemy, "Hit", worldPos, rotation);

受击特效点计算

1
2


Vector3 hitDir = (attacker.position - hitter.position).normalized;
Vector3 targetPos = hitter.position + hitDir * 0.8f + Vector3.up * 1f;

十一、音效系统

核心文件

文件	说明
`SFX_PoolManager.cs`	单例，两套词典（普通/按角色名分池）
`SoundItem.cs`	池化预制体组件，Spawn 时从 SoundData 取 Clip
`ComboSFXtem.cs`	池化预制体组件，Spawn 时从 ComboData 取 Clip
`SoundData.cs`	ScriptableObject，Clip 总库
`CharacterComboBase.cs`	`PlayOneShot` + `PlayComboFX`

两套播放路径

直配 PlayOneShot（语音+武器声）：

在 UpdateComboAnimation() / ExecuteSkill() 中自动调用，从 ComboData._characterVoice[] 和 _weaponSound[] 随机取 Clip，通过角色 GameObject 上的 AudioSource.PlayOneShot 播放。ComboData 资产填好数组即可，不需要动画事件。

池化 SFX_PoolManager（3D 空间音效）：

通过动画关键帧上的 PlayComboFX 事件触发，从 soundCenter 或 bigSoundCenter 取出 SoundItem 预制体激活，播完自动回池。需配置：

ComboData 勾选 App Audio Prefab + 设 Universal Sound（SoundStyle 枚举值）
SFX_PoolManager.Sound Pools 列表中注册对应 SoundStyle + Sound Prefab + Sound Count
动画关键帧上加 PlayComboFX() 事件

PlayComboFX 技能支持

普通攻击读 currentCombo，技能读 currentSkill。修复后的回退逻辑：

1
2
3
4


if (currentCombo != null) → 取 currentCombo.GetComboSoundStyle()
else if (currentSkill != null && currentSkill.AppAudioPrefab)
 → 取 currentSkill.universalSound
else → return（静默）

池化路径的并发 Bug

早期 TryGetSoundPool 也是 Dequeue→SetActive→立即 Enqueue，和 VFX 同样 Bug。已添加 Count == 0 守卫防止队列耗尽时报错。更深层的并发修复与 VFX 同理，尚未完全同步改造。

十二、辅助系统

TimerManager（计时器对象池）

文件	说明
`TimerManager.cs`	单例，管理 `_notWorkTimers` 队列 + `_isWorkingTimers` 列表
`GameTimer.cs`	单个计时器，支持 deltaTime / unscaledDeltaTime

Update 中倒序遍历工作中的计时器，完成时回收：

1
2
3
4


GetOneTimer(float time, Action task) // 受 timeScale 影响
GetTimer(float time, Action task) // 同上，返回引用供取消
GetRealTimer(float time, Action task) // 不受 timeScale 影响
UnregisterTimer(GameTimer timer) // 手动取消

使用场景：闪避冷却 0.5s、QTE 超时 3s、缓冲到 Idle 0.15s、攻击动画退出后延时 0.2s 回 NullState。

GameBlackboard（全局黑板）

单例，存当前锁定敌人 BindableProperty<Transform> enemy 和所有角色引用 Dictionary<string, Player>。SetEnemy(Transform) 触发 OnValueChanged，Player 监听更新 Inspector 显示。

BindableProperty（响应式属性）

1
2
3
4
5


public class BindableProperty<T>
{
 public T Value { get; set; }
 public event Action<T> OnValueChanged;
}

使用处：enemy（黑板更新）、newCharacterName（候补列表维护）、currentIndex（comboIndex 变化时清零 ATKIndex）

自动追踪敌人

CharacterCombo.UpdateEnemy() 每帧 Physics.SphereCast(detectionOrigin, radius, dir, out hit, length, WhatIsEnemy) 扇形扫描，命中 → 更新 GameBlackboard.SetEnemy。

UpdateDetectionDir() 综合相机朝向 × 玩家移动输入计算扫描方向。UpdateAttackLookAtEnemy() 攻击中缓动朝向敌人（<6.5m 且 >0.09m）。

十三、ScriptableObject 数据体系

完整配置层次

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


PlayerSO.asset ← 角色总资产
 └── PlayerMovementData
 ├── bufferToIdleTime: 0.15s
 ├── turnBackAngle: 135°
 ├── PlayerDashData: 闪避动画名、冷却0.5s、淡入12帧
 ├── PlayerSprintData: 移动倍率3x
 ├── PlayerRunData / WalkData / IdleData
 ├── PlayerReturnRunData
 └── PlayerCameraRecenteringData: 相机居中角度范围

 └── PlayerComboData
 └── PlayerComboSOData
 ├── lightCombo: ComboContainerData.asset
 ├── heavyCombo: ComboContainerData.asset
 ├── executeCombo: ComboContainerData.asset
 ├── skillCombo: ComboData.asset (Skikk)
 ├── finishSkillCombo: ComboData.asset (FinishiSkill)
 └── switchSkill: ComboData.asset (SwitchSkill)

ComboContainerData.asset:
 comboDates[]: List<ComboData> 按顺序排列的攻击段
 DodgeATKData: ComboData 闪A替换第一段
 BackDodgeATKData: ComboData 后闪A替换第一段

ComboData.asset (每一段):
 动画: _comboName
 伤害: _comboDamage, _attackDistance, _comboOffset
 受击: _hitName[], _parryName[]
 音效: _weaponSound[], _characterVoice[], _universalSound, appAudioPrefab
 打击: _ATKCount, _shakeForceList[], _pauseFrameTime, _pauseFrameTimeList[]
 类型: attackStyle (Skikk/FinishiSkill/SwitchSkill)

运行时映射关系

1
2


comboIndex → comboDates[comboIndex] → ComboData → comboName → CrossFade
ATKIndex → ShakeForceList[ATKIndex-1] / PauseFrameTimeList[ATKIndex-1]

十四、UI 系统

核心文件

文件	说明
`UIManager.cs`	单例，自动查找子 UI
`StateBarUI.cs`	血条，World→Screen 定位 + fillAmount 更新
`BloodPos.cs`	挂在敌人上，每帧调 ShowAt 定位
`SwitchTimeUI.cs`	QTE 倒计时 + 候补角色头像 + 滑入滑出动画
`SwitchTimeCountDownUI.cs`	空类，未实现

血条绑定

1
2
3
4
5
6
7
8


UIManager.Awake → transform.Find("UIRoot/State Bar") → StateBarUI

BloodPos.LateUpdate → UIManager.stateBarUI.ShowAt(敌人位置)
 → Camera.WorldToScreenPoint → UI 定位 + 距离缩放

CharacterHealthBase.OnUpdatePH → stateBarUI.UpdateBlood(HP/maxHP)
 → GreenBloodBar.fillAmount = percentage
 → Update(): if(Green < Red) Red -= Time.deltaTime * 0.05（红条缓退）

QTE 倒计时选人 UI

1
2
3
4
5
6
7
8
9


// ActiveImage(List<CharacterNameList>, float time)
// 1人: R_Image 隐藏，只显示 L
// 2人: 双头像显示
// 0人: 直接 return

// MatchImage(CharacterNameList) → 返回 Sprite（Seele/Stick）

// UnActive() → 协程 MoveUI 滑出 → SetActive(false)
// MoveUI(Vector3 src, Vector3 dst, float speed, bool canUnActive)

修复过：旧版 ActiveImage 固定取 waitingCharacterList[0] 和 [1]，单角色时越界崩溃。改版为接收 List 参数，调用方 StartSwitchSkill 检查 Count 后再传。

十五、已知薄弱点

代码层

问题	影响	修复方向
重攻击未接线	`R_Atk.started += OnHeavyAttackInput` 没有在 `AddInputActionEvent` 中注册	注册回调一行即通
震屏/顿帧调用被注释	`AttackTrigger` 中 5 处 `CameraHitFeel` 调用被注释	取消注释，确认 `CinemachineImpulseListener` 挂到所有 VCam
SFX 池并发 Bug	`TryGetSoundPool` 还保留了立即 Enqueue 的设计，池耗尽后失效	参照 VFX 的修复方案，加 `ReturnSFX` 延迟回池
Timeline 绑定依赖代码补绑	每次 Play 前 `SetGenericBinding` 遍历查找	可接受但不够优雅，Inspector 绑定可直接解决
硬编码枚举	`CharacterNameList` 和 `AttackStyle` 写死，加角色需改代码	改为 ScriptableObject 配置表
`CameraHitFeel.PF/SlowMotion` 依赖 `CharacterManager`	单例可能在初始化时未就绪	改为事件回调或 `Start` 中延迟初始化
`SkillCombo.cs` 的 `DodgeComboInput` 用 switch 逐角色判断	加角色需补 case	合并为统一逻辑

架构层

问题	影响	修复方向
Movement 和 Combo FSM 无显式协调协议	靠 `Player` 层中转，隐式依赖正确	引入状态协调接口
Timeline 和 CameraSwitcher 各管一半	理解成本高，配置易遗漏	封装为一个 `SkillCameraController`
对象池缺少预热/扩容机制	高并发时特效/音效静默失败	加 `EnsureCapacity` 自动扩容或返回警告

功能层

问题	说明
仅支持 2 角色切换	加角色需改枚举、补 CameraSwitcher、补 `DodgeComboInput` 分支等
无网络/多人	单机 Demo
无存档	所有数据在内存
无战斗 UI 完整实现	`SwitchTimeUI.MatchImage` 只有 2 个角色头像映射
闪避冷却无视慢动作	`GetOneTimer` 受 `timeScale` 影响，0.06x 时冷却几乎永久
血条不支持多敌人	只有一个 `StateBarUI`，多敌人无法各自显示

十六、配置清单（附录）

必须的 Inspector 配置

组件	位置	配置项
Player	Player Prefab	`PlayerSO`, `PlayableDirector`（如用 Timeline）, `Animator`
PlayerSO	`Player.Script`	`MovementData`, `ComboData` 拖入对应 SO 资产
ComboData	每个攻击段	`AttackStyle`, `ComboName`, `ComboDamage`, `HitName[]`, `ParryName[]`, `ATKCount`, `ShakeForceList[]`, 音效数组
ComboContainerData	每个连招链	`comboDates[]`顺序拖入，`DodgeATKData`, `BackDodgeATKData`
CameraSwitcher	场景单例	`State Camera Info List`: `CharacterName` + `AttackStyle` + `State Camera`(VCam)
SkillTimelineManager	场景单例	`Entries`: `CharacterName` + `AttackStyle` + `Director`
PlayableDirector	每个技能	`playableAsset` = `.timeline` 文件
Timeline	`.timeline` 资产	Animation Track → VCam → 录制 `PathPosition` 曲线
VCam	Player 子物体	`Body=Tracked Dolly`, `Path=SmoothPath`, `VCamDollyHelper`, `CinemachineImpulseListener`
SFX_PoolManager	场景单例	`Sound Pools`: `SoundStyle` + `SoundPrefab` + `Count`
VFX_PoolManager	场景单例	`Effect Dates`: `Style` + `VFXItemData`
VFXItemData	场景对象	`effectItems`: `VFXName` + `VFXPrefab` + `count` + `applyParentPos`
SwitchCharacter	场景单例	`SwitchCharacterInfos[]`: `CharacterName` + `Character` + `AimAtPos` + `FollowAtPos` + `SpawnDistance`
UIManager	场景单例	子路径 `UIRoot/State Bar` + `UIRoot/Switch Time` 存在
SwitchTimeUI	UIManager 子物体	`SeeleImage`, `StickImage` 拖入 Sprite
Enemy	敌人 Prefab	`CharacterHeath`, `BloodPos`, `CharacterHealthInfo`
Animator Controller	角色/敌人 Animator	每个动画状态挂 `OnAnimationTranslation` 选对应枚举，Tag 设好（`ATK`/`Skill`/`Hit`/`Parry`/`Dodge`/`Movement`）

项目持续迭代中。当前版本（2026-06）核心战斗循环完整可运行，相机系统 Timeline 方案稳定，切人、伤害、特效、音效路径闭环。已知薄弱点见第十五节。欢迎提 Issue 或直接 PR。

十七、补充细节

根运动（Root Motion）复用

CharacterMoveControllerBase.OnAnimatorMove() 根据当前动画 Tag 决定位移倍率：

1
2
3


if (AnimationAtTag("Movement")) → Move(dir * deltaTime * moveMult)
elif (AnimationAtTag("Dodge")) → Move(dir * deltaTime * dodgeMult)
// 其他 Tag 不移动

同一个移动逻辑通过 Tag 复用，不需要每个状态单独写一段位移代码。闪避动画设 "Dodge" Tag 走 dodge 倍率，步行/奔跑/冲刺动画设 "Movement" Tag 走各自的 inputMult 倍率。

ExpandClass.AnimationAtTag 扩展方法

整个项目中最高频的辅助方法，一行代码：

1
2


public static bool AnimationAtTag(this Animator animator, string tagName, int layerIndex = 0)
 => animator.GetCurrentAnimatorStateInfo(layerIndex).IsTag(tagName);

出现在：CanBaseComboInput 的不在 Hit/Parry/Skill 中才能攻击判断、AttackTrigger 的三路分支、PlayerMovementNullState.CheckStateExit 的"攻击中不能退出"守卫、CharacterHealthBase.LookAtAttacker 的"受击中才转脸"判断。Tag 在 Animator Controller 中设，不写在代码枚举里，加新 Tag 改 Animator 即可。

AnimatorID 参数哈希

1
2
3


public static readonly int MovementID = Animator.StringToHash("Movement");
public static readonly int HasInputID = Animator.StringToHash("HasInput");
public static readonly int TurnBackID = Animator.StringToHash("TurnBack");

字符串哈希避免每帧字符串比较的 GC。MovementID 被 HandInput() 每帧 SetFloat 驱动 Blend Tree；HasInputID 切换待机/移动动画混合；TurnBackID 触发转身动画。

PlayerMovementNullState.CheckStateExit 守卫

攻击/技能中，这个守卫防止动画退出时误切移动状态：

1
2
3
4
5
6
7
8


void CheckStateExit()
{
 if (AnimationAtTag("ATK") || AnimationAtTag("Skill"))
 return; // 攻击还没播完，不退

 if (PlayerMove != zero) → ChangeState(runningState)
 else → ChangeState(idlingState)
}

没有这个守卫，每次攻击动画退出过渡都会触发移动状态迁移，导致攻击连不上下一段。

移动状态链

1
2
3
4


Idle ←→ Walk ←→ Run ←→ Sprint
 ↑ ↑
 └── Dash退出有方向 ────┘
 └── Dash退出无方向 → Idle

各状态通过 inputMult 控制 Blend Tree 的 Movement 参数（Walk=1, Run=2, Sprint=3），同一个混合树复用不同速度。

VFXManager 全局粒子速度控制

1
2
3


public void PauseVFX() → 所有粒子 simulationSpeed = 0 ← 顿帧用
public void SetVFXSpeed(f) → 所有粒子 simulationSpeed = f ← 慢动作用
public void ResetVXF() → 所有粒子恢复 speedMult ← 恢复

EffectItem.Awake() 把自己挂载的 ParticleSystem 注册到 VFXManager.allParticleSystems 列表。全局速度控制不用遍历场景，直接用列表批量设。

相机水平居中（Recentering）

PlayerCameraUtility.EnableRecentering(float waitTime, float recenteringTime) 操作 CinemachinePOV.m_HorizontalRecentering。PlayerMovementState 根据 WASD 方向 + 相机垂直角度查 PlayerCameraRecenteringData 配置表，决定是否启用居中。松键时 Movement.canceled 停用。

相机遮挡避免

TP_CameraController_Pus.cs：射线检测角色到相机的路径，被遮挡时拉近相机避免穿模。

CharacterComboBase.AttackDetection 三条件

1
2
3
4


GetEnemy() == null → return false
距离 > comboDistance → return false
角度 > 80° → return false
全部通过 → return true

和敌人检测（SphereCast 锁定）不是同一个方法。检测负责"找到敌人"，判定负责"当前能不能打到"。两者独立，一个在 UpdateEnemy 扫描，一个在 AttackTrigger 过滤。

Unity中的提示词用法

Fri, 15 May 2026 22:10:42 +0800

Unity AI 提示词实战：5种主流写法（附可直接复制模板）

在Unity开发中，合理运用AI生成代码可显著提升开发效率，但实际应用中常出现代码风格混乱、不符合项目规范、逻辑存在漏洞、需大量返工等问题。

除基础的Zero-shot（零样本）和Few-shot（少样本）写法外，本文整理了Unity开发中5种实用且常用的AI提示词写法，每种写法均包含核心思想、适用场景、实战示例、核心优势及相关注意事项，文末附上可直接复制的通用模板，便于实际应用。

1. Role-prompt 角色设定提示词（人设法）

核心思想

不提供任何示例代码，先为AI设定具体、专业的身份及明确的行为准则，使AI以资深Unity开发者的视角生成代码。

适用场景

复杂系统架构设计（状态机、对象池、事件系统等）
对代码质量、可维护性要求较高的核心模块开发
团队协作中需统一专业代码写法的场景

实战示例

1
2
3
4
5
6
7
8
9


你是拥有10年经验的资深Unity手游客户端开发工程师，精通C#、UGUI、Addressables、DOTween。
写代码必须严格遵守以下规范：
1. 面向对象设计，低耦合高内聚
2. 所有可配置参数公开并添加[Header]和[Tooltip]特性
3. 关键逻辑添加清晰注释，避免冗余内容
4. 优先使用Unity官方推荐的最佳实践
5. 不使用过时的API（如弃用的GUI系统）

现在帮我设计一个可扩展的玩家状态机架构，包含待机、移动、攻击、死亡四种基础状态。

核心优势

无需准备示例代码，上手便捷
AI可自动采用专业Unity代码写法，规避新手常见错误
生成代码结构合理，可扩展性与可维护性较强

注意事项

身份设定需具体，避免过于宽泛（如避免仅设定为“程序员”，应明确为“Unity手游客户端开发工程师”）
设定身份的同时需明确代码规范，明确告知AI禁止的写法（如“不能使用全局静态变量”）
可根据实际需求，添加“优先使用XX插件”“遵循XX团队规范”等个性化要求

2. 结构化约束提示词（规则约束法）

核心思想

不依赖示例代码，通过逐条列出硬性规则，明确代码的格式、写法、功能边界及输出要求，确保代码标准化。

适用场景

需严格统一代码格式与命名规范的场景
功能明确、不允许AI自由发挥的工具类脚本开发
团队多人协作，需实现代码标准化输出的场景

实战示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


严格按照以下要求写Unity C#脚本：
1. 脚本名：EnemyPatrol
2. 必须继承自MonoBehaviour
3. 公开可调节参数：巡逻速度、巡逻点数组、检测玩家距离
4. 私有变量使用驼峰命名法，前缀加下划线（如_enemyRb）
5. 函数拆分清晰，每个函数仅实现单一功能
6. 添加必要的空值判断，避免空引用异常
7. 仅实现巡逻和检测玩家功能，不包含攻击逻辑

写一个Unity 3D敌人巡逻AI脚本。

核心优势

无需准备Few-shot示例，节省大量Token
代码输出高度标准化，无需后期调整格式
可有效限制AI自由发挥，避免生成无关代码

注意事项

规则数量控制在10条以内，避免规则过多导致AI混乱或遗漏
规则表述需具体明确，避免模糊化描述（如避免“写得规范一些”等表述）
可明确禁止特定写法（如“不使用协程”“不使用单例”）

3. CoT 思维链提示词（Chain of Thought）

核心思想

强制AI先输出思考过程与实现步骤，再生成最终代码，将隐性逻辑显性化，减少代码逻辑漏洞与错误。

适用场景

复杂游戏逻辑开发（战斗计算、掉落规则、关卡生成等）
算法相关功能开发（寻路、碰撞检测、AI行为树等）
边界条件复杂、易出现逻辑错误的场景

实战示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


请先逐步分析实现逻辑，列出详细的实现步骤，再编写最终的C#代码。
需求：实现一个Unity 2D平台游戏的玩家跳跃功能。
思考步骤要求：
1. 分析跳跃功能所需组件（刚体、碰撞器等）
2. 列出跳跃完整流程（按下跳跃键→检测是否在地面→施加向上的力）
3. 说明地面检测的实现方式
4. 说明多段跳的处理方式
5. 说明跳跃过程中移动的处理方式

按照以上步骤思考，然后写出完整的代码。

核心优势

大幅减少复杂逻辑的错误与漏洞
可清晰查看AI思考过程，便于排查问题
生成代码逻辑严谨，边界条件处理完善

注意事项

明确指定AI的思考步骤与方向，避免AI自由思考导致逻辑偏差
可要求AI先列出可能遇到的问题及对应解决方案
对于极复杂的逻辑，可要求AI分阶段输出思考过程与代码

4. 模板仿写提示词（One-shot / 单样本）

核心思想

提供1个标准样板代码，让AI严格模仿样板的结构、命名、风格及注释格式，生成新的代码。该方法是Unity开发中应用广泛、性价比较高的提示词写法。

适用场景

项目已有成熟基类、管理器、UI框架的场景
需新增与现有代码风格完全一致的脚本开发
团队协作中需统一代码风格的场景

实战示例

首先提供项目中已有的标准样板代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// UI面板基类
public class UIBase : MonoBehaviour
{
 [Header("基础设置")]
 public string panelName;
 public bool isShowOnStart;

 protected virtual void Awake()
 {
 if (isShowOnStart)
 Show();
 else
 Hide();
 }

 public virtual void Show()
 {
 gameObject.SetActive(true);
 OnShow();
 }

 public virtual void Hide()
 {
 gameObject.SetActive(false);
 OnHide();
 }

 protected virtual void OnShow() { }
 protected virtual void OnHide() { }
}

然后编写提示词：

1
2
3
4
5
6
7


完全仿照上述UIBase基类的写法、结构、命名规范、注释格式及代码风格。
新建一个背包UI面板类UIBag，继承自UIBase。
需实现的功能：
1. 显示背包格子列表
2. 刷新背包数据
3. 点击格子显示物品详情
严格保持与样板代码一致的缩进、命名及注释风格。

核心优势

仅需1个样板代码，相比Few-shot更节省Token
生成代码与项目现有风格完全统一
无需后期调整代码格式与风格

注意事项

样板代码需规范、无漏洞，避免AI模仿错误写法
优先选择项目中最标准、最规范的代码作为样板
明确要求AI“严格模仿”，禁止AI对样板结构进行优化或修改

5. 分层任务提示词（拆解任务法）

核心思想

将复杂的大型功能拆解为多个独立小模块，让AI分模块、分步骤生成代码，避免一次性生成完整系统导致的代码混乱。

适用场景

大型系统开发（背包系统、技能系统、存档系统、战斗系统等）
代码量较大、结构复杂的功能开发
需逐步调试、验证功能正确性的场景

实战示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


开发一个Unity 2D游戏的背包系统，分三个部分逐步生成代码：

第一部分：背包数据结构
- 定义物品数据类ItemData，包含id、名称、描述、图标、数量、类型
- 定义背包数据类InventoryData，包含物品列表、背包容量

第二部分：背包管理器
- 实现单例模式
- 实现添加物品、移除物品、查询物品、保存/加载背包数据的功能

第三部分：背包UI展示
- 实现背包格子UI
- 实现背包面板UI的刷新逻辑

请先编写第一部分的代码，确认无误后再编写后续部分。

核心优势

代码结构分层清晰，便于维护与调试
避免AI生成冗长、难以阅读和修改的代码
可逐步验证每个模块的正确性，及时调整开发需求

注意事项

模块拆分不宜过细，避免增加对话轮次、浪费Token
模块拆分也不宜过粗，单个模块代码量建议控制在200行以内
可先让AI输出整体架构设计，确认后再分模块生成代码

汇总：Unity AI 提示词六大流派对比

除上述5种写法外，结合基础的Zero-shot和Few-shot，共六种主流提示词写法，具体对比如下：

流派	核心思想	适用场景	优点	缺点	Token 消耗
Zero-shot 零样本	直接下达指令，不提供任何示例	简单通用功能、快速原型开发	效率高、操作便捷	代码风格随机、质量不稳定	最低
Few-shot 少样本	提供2~3个示例，让AI模仿生成	需严格统一风格的复杂场景	输出稳定、符合预期要求	准备示例繁琐、消耗Token较多	高
Role 角色设定	为AI设定专业身份及行为准则	复杂系统架构、高质量代码需求	代码专业、无需准备示例	对身份描述的专业性要求较高	低
结构化约束	逐条列出硬性规则，规范输出	标准化工具类、团队协作场景	输出标准化、节省Token	规则过多易导致AI混乱	低
CoT 思维链	先思考步骤，再编写代码	复杂逻辑、算法、边界条件多的场景	逻辑严谨、错误率低	思考过程消耗Token	中
One-shot 单样本	提供1个样板，让AI模仿生成	项目已有成熟框架、新增同类脚本	风格统一、节省Token、性价比高	需具备标准样板代码	中

附录：可直接复制的通用提示词模板

1. 角色设定模板

1
2
3
4
5
6
7


你是拥有[X]年经验的资深Unity[领域]开发工程师，精通[技术栈]。
写代码必须严格遵守以下规范：
1. [规范1]
2. [规范2]
3. [规范3]

现在帮我[具体需求]。

2. 结构化约束模板

1
2
3
4
5
6
7
8
9


严格按照以下要求写Unity C#脚本：
1. 脚本名：[脚本名]
2. 必须继承自[父类]
3. 公开参数：[参数列表]
4. 命名规范：[命名要求]
5. 功能要求：[具体功能]
6. 禁止：[禁止的写法]

写一个[功能描述]脚本。

3. 思维链模板

1
2
3
4
5
6
7
8


请先逐步分析实现逻辑，列出详细的实现步骤，再编写最终的C#代码。
需求：[具体需求]
思考步骤要求：
1. [步骤1]
2. [步骤2]
3. [步骤3]

按照以上步骤思考，然后写出完整的代码。

4. 单样本仿写模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


完全仿照下面这个样板代码的写法、结构、命名规范、注释格式、代码风格。
[样板代码]

新建一个[新脚本名]，继承自[父类]。
需要实现的功能：
1. [功能1]
2. [功能2]
3. [功能3]

严格保持和样板代码一致的风格，不要修改样板的结构。

5. 分层任务模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


我们要开发一个[系统名称]，分[X]个部分逐步生成代码：

第1部分：[模块1名称]
- [功能点1]
- [功能点2]

第2部分：[模块2名称]
- [功能点1]
- [功能点2]

第3部分：[模块3名称]
- [功能点1]
- [功能点2]

请先写第1部分的代码。

总结

不同提示词写法适用于不同场景，需根据实际需求选择：

快速开发简单功能，可采用Zero-shot
项目已有标准样板，可采用One-shot
开发复杂系统架构，可采用角色设定写法
需实现代码标准化，可采用结构化约束写法
开发复杂逻辑、避免错误，可采用思维链写法
开发大型系统，可采用分层任务写法

选择合适的提示词写法，可显著提升AI生成代码的质量，减少返工，提升开发效率。

基于unity开发的简易任务列表

Sat, 03 Jan 2026 21:21:31 +0800

基于unity开发的简易任务列表

前言

这是我在系统性学完c#基础与核心之后，完全由自己构思，编写的作品。其中的很多内容是较为劣质低效的，而且有很多不需要的步骤。同时因为是对自己基础的一次检验，有许多不必要的语法和方式被故意使用。所以不建议当作正常的学习参考。

前期构建

ScriptableObject（SO）

先简单说一下SO是什么和SO的使用场景

ScriptableObject 是 Unity 特有的可序列化资产，数据存储在项目面板（Assets 文件夹）中，独立于场景对象，支持可视化编辑、多脚本共享引用，且非运行时实例化（内存占用低），这些特性决定了它的适用边界。

当你需要在多个脚本（跨场景、跨对象）中共享通用数据，且数据无需永久保存（游戏重启后恢复默认值）时，SO 是首选。

典型用途：

游戏全局配置：玩家初始血量 / 蓝量、移动速度、重力参数、音效音量默认值、关卡解锁规则；
全局状态标识：当前游戏难度（简单 / 中等 / 困难）、是否开启音效 / 震动、当前关卡编号；
通用常量集合：层掩码（LayerMask）、标签（Tag）、UI 显示层级、技能冷却时间常量等。

为什么不用其他方案：

替代单例：避免单例的生命周期混乱、难以调试、不易扩展的问题，SO 可直接在 Inspector 中修改参数，无需编译代码；
替代普通类：普通类无法可视化编辑，修改参数需改代码重新编译，SO 可直观调整数值，实时预览效果；
替代 PlayerPrefs：PlayerPrefs 用于本地持久化存储，不适合核心配置（易被篡改），SO 仅存储默认配置，更安全高效。

当项目中有大量同类对象（道具、敌人、技能等），且每个对象有固定属性集合时，用 SO 做模板配置，可实现 “一处定义、多处复用”，大幅提升开发效率。

典型用途：

道具配置：每个道具对应一个 SO，存储道具名称、图标、描述、价格、效果（回血 / 加攻击）、使用次数、预制体引用；
敌人模板：小兵 / 精英 / BOSS 的 SO，存储血量、攻击、防御、移动速度、攻击范围、掉落道具列表、预制体；
技能模板：每个技能对应一个 SO，存储技能名称、冷却时间、消耗蓝量、伤害值、特效预制体、释放动画、命中判定规则；
关卡模板：每个关卡的 SO，存储敌人刷新点、刷新数量、通关条件（消灭所有敌人 / 到达终点）、背景音乐、关卡奖励。

SO 支持自定义 Editor 脚本，可打造可视化、高易用性的编辑界面，解决复杂配置的编辑痛点，提升团队协作效率。

典型用途：

自定义复杂配置界面：比如技能的多段伤害、特效触发时机、条件判定（如 “血量低于 30% 时伤害翻倍”），通过自定义 Editor 将杂乱的参数整理为折叠面板、下拉选择、预览窗口，避免默认 Inspector 的混乱；批量数据管理：创建 “总表 SO”（如《道具总表》），引用所有道具 SO，方便编辑器下批量查找、筛选、导出（如导出 Excel 配置表）；
工具配置载体：将编辑器工具的参数（如批量烘焙光照的参数、资源打包的路径 / 规则、场景批量导出的配置）存储在 SO 中，方便保存和复用工具配置，无需每次打开工具重新设置。

场景中的游戏对象与场景强绑定（删除场景则对象消失，多场景共用需重复复制），而 SO 独立于场景，可有效降低场景耦合。

典型用途：

跨场景共用数据：如背景音乐列表、UI 文本配置（游戏标题、按钮文字）、通用材质库，无需在每个场景中创建对应的管理对象，只需在脚本中引用同一个 SO 即可；版本控制友好：SO 作为单独的文件存储，相比场景文件（.unity），其修改冲突更容易解决（场景文件包含大量对象信息，冲突后难以合并）；
资源解耦：将对象的 “数据” 与 “逻辑 / 视图” 分离，比如敌人的 “属性数据” 存在 SO 中，“移动 / 攻击逻辑” 存在脚本中，“模型 / 动画” 存在预制体中，便于单独修改数据或逻辑，互不影响。

在游戏运行时，需要在多个脚本间实时共享动态修改的数据，且方便编辑器调试时实时查看 / 修改数值，SO 是理想载体。

典型用途：

实时状态共享：当前玩家金币数量、已收集道具列表、任务完成进度，多个脚本（玩家控制器、商店 UI、任务面板）可直接读取 / 修改 SO 中的数据，无需通过消息传递（如 EventSystem）间接通信；
调试便捷性：在编辑器运行模式下，可直接在 Inspector 中修改 SO 的参数（如临时调高玩家血量、修改技能伤害），实时看到游戏效果，无需停止运行修改代码，大幅提升调试效率。

SO是否适用于任务系统

任务信息中的固定不变 / 可复用的静态数据，是 SO 的核心适用场景，这部分数据完全可以存储在 SO 中。
任务信息的「动态运行时状态」：不适合直接存入 SO。

适合的部分

这些数据是任务的「模板属性」，一旦定义后基本无需频繁修改，或修改后需全局生效：

基础标识与描述：任务 ID、任务名称（如 “消灭 10 只野猪”）、任务描述文本、任务类型（主线 / 支线 / 日常 / 限时）、接取等级要求；
任务目标：目标类型（击杀 / 收集 / 护送 / 探索）、目标对象（野猪 SO / 草药 SO/NPC 预制体）、目标数量（10 只 / 5 个）、目标场景（新手村 / 森林副本）；
任务奖励：金币数量、经验值、道具列表（对应道具 SO 数组）、装备 SO、解锁内容（新关卡 / 新技能）；
接取与提交条件：接取 NPC（名称 / 预制体）、提交 NPC、前置任务 SO（需完成某任务才能接取）、特殊条件（如 “血量高于 50% 时接取”）。

不适合的部分

这些数据是每个玩家 / 角色的专属状态，具有唯一性和临时性：

任务进度：是否已接取、当前完成数量（如已消灭 3 只野猪）、是否达成完成条件、是否已提交；
玩家专属标记：接取任务的角色 ID、任务接取时间（日常任务重置用）、是否放弃过该任务。

核心代码

在SO构建时，必须继承ScriptableObject类，且必须手动标注[CreateAssetMenu]特性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;


[CreateAssetMenu(fileName = "NewTaskDate", menuName = "Task/TaskDate")]
public class TaskDate : ScriptableObject
{
 [Header("基础信息")]
 [SerializeField] public string taskId; // 任务唯一ID
 [SerializeField] public string taskTitle; // 任务标题
 [SerializeField] public string taskLittleTitle;
 [SerializeField] public string taskName;
 [SerializeField] public string positionTxte;
 [SerializeField] public string describeText;
 [SerializeField] public Sprite[] images;//奖励
 [SerializeField] public TaskType taskType;
 [SerializeField] public TaskDate[] nextTask;

 [SerializeField] public bool isSecess =false;//不建议将胜利条件写在SO中

 public enum TaskType
 {
 MainStoryline,
 BranchStoryline,
 }

 public enum Task
 {
 CollectItem,
 KillEnemy,
 TriggerTarget,
 Timing
 }
}

保存脚本后，我们就可以在面板中手动创建SO或者在脚本中动态创建。

注：因为我只制作了任务列表的内容，并未添加具体任务类型，所以索性将任务完成的判断条件扔到SO中，在正常游戏开发中不建议这么设计。

稍微介绍一下 CreateAsset Menu中的参数，fileName的内容时创建SO的默认名字，menuName时右键创建的路径。

任务列表UI构建

我们已经可以将任务信息储存到了SO中，此时需要在unity中创建一个UI界面来表示我们的任务信息，这个UI界面必须要包括任务列表与任务细节。

其中任务列表中应该先分出任务类型，如主线任务，支线任务。然后在分出具体的任务。而这个具体的任务，应该有任务名字，任务地点。

至于任务细节，也应该有任务的名字，地点等，同时还需要详细的描述以及任务奖励的Image。

列表框的构建

列表的构建选取了UI系统中的Scroll View，但是由于Scroll View是横向和纵向的，而任务列表中是纵向的，所以要删除横向的Scrollbar Horizontal，同时给Viewport下的Content新增Vertical Layout Group组件，此时Content的子物体会以列表的形式自动排序，但是排序方式可能会略显奇怪，不是我们需要的精密排列。可以调整Vertical Layout Group中的Spacing的值或者Content Size Fitter的选项来达到想要的效果。

一级列表

一级列表代表了任务系统中的主线任务，支线任务这种任务类型的分类。

当不存在支线任务或主线任务是，我们不许要将其一级列表展示出来，而且一级列表之间的复用性很高，所以直接创建一个通用的一级列表预制体，在需要的时候直接实例化即可。

一级列表的功能应该是点击展开二级列表，再次点击收起二级列表，所以我们使用UI组件中的Toggle组件。相较于Botton的点击触发效果，Toggle的勾选与未勾选两种状态可以很好的的区分收起和展开的功能。同时为了美观，要删去Toggle自带的文字，将勾选框也改为列表的样式。

在Toggle下的Background下再创建Text等组件，用于展现基本信息，根据实际情况修改即可。

由于一级列表下存在二级列表，所以我们要仿照列表框中Content的方式，再一级列表下添加Content Size Fitter组件和Vertical Layout Group组件，用以排序二级列表。

相同的操作可以做出多个不同任务类型的预制体，如主线预制体，支线预制体。

二级列表

二级列表一般表示大概任务内容，譬如任务名字，任务地点等等。与一级列表不同的是它在点击后的作用只有显示任务的详细内容。所以我们直接使用Botton而不是Toggle，因为Toggle的两种状态可能出现需要多次点击才会修改内容的情况。

TaskDescribe

任务详细内容UI根据自己喜好拼出即可。

使用脚本将SO与UI联系起来

我们的首要问题是将SO中的初始任务给分配到UI中。

观察到我们SO中有写了任务完成后应该解锁的下一个任务的数组

1
2
3


 ......
 [SerializeField] public TaskDate[] nextTask;
 ......

我们直接创建UIManager脚本，在TaskManager中创建一个数组来随时接受已解锁的任务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


 public static UIManager _instance;


 public static UIManager Instance
 {
 get
 {
 if (_instance == null)
 {
 _instance = FindObjectOfType<UIManager>();
 }
 return _instance;
 }
 }
 [SerializeField] public TaskDate[] allDates;
 ......

我们会在遍历这个allDates数组的时候实例化一级列表和二级列表的预制体，同时要将一级列表放在前面创建的Scroll View下的content下，所以要提前引入所有一级的类型，二级列表预制体，以及content。

1
2
3
4
5
6


 ......
 [SerializeField] private GameObject MainLineMenu;
 [SerializeField] private GameObject content;
 [SerializeField] private GameObject seconedMenu;
 [SerializeField] private GameObject otherMenu;
 ......

一个储存当前任务的List

1
2
3


 ......
 [SerializeField] private List<GameObject> FirstMenuGB;
 ......

我们在写入这些变量后就可以着手写遍历与实例化列表了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43



 private GameObject newFirstMenu;

 private int mainNumber = 0;
 private int branchNumber = 0;

 private void InstantiateMenu(GameObject menu,int i ,ref int number ,TaskDate taskDate)
 {
 if (number == 0)
 {
 newFirstMenu = Instantiate(menu);
 newFirstMenu.transform.SetParent(content.transform, true);
 FirstMenuGB.Add(newFirstMenu);
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);

 }
 else
 {
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);

 }
 number++;
 Debug.Log(number);
 }

 public void CreatMune()
 {
 for (int i = 0; i < allDates.Length; i++)
 {
 switch (allDates[i].taskType)
 {
 case TaskDate.TaskType.MainStoryline:
 InstantiateMenu(MainLineMenu,i,ref mainNumber, allDates[i]);
 break;
 case TaskDate.TaskType.BranchStoryline:
 InstantiateMenu(otherMenu,i,ref branchNumber, allDates[i]);
 break;
 }
 }
 Debug.Log("已刷新列表");
 }

这样我们的脚本就基本具有了实例化其所持有的所有任务了。

列表状态的刷新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32



 [SerializeField] private TMP_Text nameText;
 [SerializeField] private TMP_Text describeText;

 public GameObject imageHolder;

 public void UpdateAllMenu()
 {
 for(int i = FirstMenuGB.Count - 1; i >= 0; i--)
 {
 if(FirstMenuGB[i] != null)
 {
 Destroy(FirstMenuGB[i]);
 }

 FirstMenuGB.RemoveAt(i);
 }
 mainNumber = 0;
 branchNumber = 0;
 UpdatesTaskDescribe();
 CreatMune();
 }
 public void UpdatesTaskDescribe()
 {
 for (int i = imageHolder.transform.childCount - 1; i >= 0; i--)
 {
 Transform childImage = imageHolder.transform.GetChild(i);
 Destroy(childImage.gameObject);
 }
 nameText.text = "";
 describeText.text = "";
 }

新建一个ItemEntity脚本，在这个脚本中我们将处理具体脚本的详细信息，也就是二级列表（任务本体）与任务详细描述。

首先新建所需要的一些变量

1
2
3
4
5
6


 public TaskDate currentTaskData;
 [SerializeField] private TMP_Text TaskName;
 [SerializeField] private TMP_Text PositionName;
 [SerializeField] private TMP_Text taskTitle;
 [SerializeField] private TMP_Text taskLittleTitle;
 [SerializeField] private TMP_Text describeText;

然后就是将UIManager中示例化的时候给预制体新增ItemEntity脚本并且将当前的SO赋值给ItemEntity中的currentTaskDaTa。修改UIManager 中的InstantiateMenu方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


 private void InstantiateMenu(GameObject menu,int i ,ref int number ,TaskDate taskDate)
 {
 if (number == 0)
 {
 newFirstMenu = Instantiate(menu);
 newFirstMenu.transform.SetParent(content.transform, true);
 FirstMenuGB.Add(newFirstMenu);
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);
 ItemEntity itemEntity = newSeconedMenu.GetComponent<ItemEntity>();
 itemEntity.currentTaskData = allDates[i];
 }
 else
 {
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);
 ItemEntity itemEntity = newSeconedMenu.GetComponent<ItemEntity>();
 itemEntity.currentTaskData = allDates[i];
 }
 number++;
 Debug.Log(number);
 }

赋值之后回到ItemEntity中，之后就可以得到的SO的信息放到每个变量中，以及达到选中当前任务显示此任务信息的功能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


 public void UpdateTaskDate()
 {
 if (currentTaskData != null)
 {
 TaskName.text = currentTaskData.taskName;
 PositionName.text = currentTaskData.positionTxte;
 Debug.Log("更新");
 }
 }

 private void Update()
 {
 if (TaskName.text != currentTaskData.taskName&&PositionName.text != currentTaskData.positionTxte)
 {
 UpdateTaskDate();
 }
 if(taskHolder == null)
 {
 UpdateTaskDescribe();
 }
 GetNewTask();
 }

 private void UpdateTaskDescribe()
 {
 taskHolder = GetComponentInParent<TaskHolder>();
 taskHolder.taskTitle.text = currentTaskData.taskTitle;
 taskHolder.taskLittleTitle.text = currentTaskData.taskLittleTitle;
 }

 public void SelectTask()
 {
 taskHolder.describeText.text = currentTaskData.describeText;
 taskHolder.taskName.text = currentTaskData.taskName;
 UpdateImage();
 }

 private void UpdateImage()
 {
 for(int i = imageHolder.transform.childCount -1; i>=0;i--)
 {
 Transform childImage = imageHolder.transform.GetChild(i);
 Destroy(childImage.gameObject);
 }

 for(int i = 0; i<currentTaskData.images.Length; i++)
 {
 GameObject newImagePrefab = Instantiate(imagePrefab);
 newImagePrefab.transform.SetParent(imageHolder.transform,true);
 Image image = newImagePrefab.GetComponent<Image>();
 image.sprite = currentTaskData.images[i];
 }
 }

 private void GetNewTask()
 {
 if(currentTaskData.isSecess == true)
 {
 for(int i = 0; i < UIManager._instance.allDates.Length; i++)
 {
 if(currentTaskData.taskId == UIManager._instance.allDates[i].taskId)
 {
 for(int j = 0; j < currentTaskData.nextTask.Length; j++)
 {
 UIManager._instance.allDates = ScriptArrayTool.AddScript(UIManager._instance.allDates, currentTaskData.nextTask[j]);
 }
 UIManager._instance.allDates = ScriptArrayTool.RemoveScriptByCondition(UIManager._instance.allDates,
 s=>s!=null&& s.taskId == currentTaskData.taskId );
 }
 }
 UIManager._instance.UpdateAllMenu();


 }
 }

外附一个关于数组的功能类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


 public static class ScriptArrayTool
 {
 /// <summary>
 /// 给脚本数组添加单个脚本实例
 /// </summary>
 /// <typeparam name="T">脚本类型（自定义普通类/MonoBehaviour类）</typeparam>
 /// <param name="originalArray">原脚本数组</param>
 /// <param name="newScript">新脚本实例</param>
 /// <returns>添加后的新脚本数组</returns>
 public static T[] AddScript<T>(T[] originalArray, T newScript) where T : class
 {
 if (originalArray == null)
 {
 return new T[] { newScript };
 }

 List<T> scriptList = new List<T>(originalArray);
 if (newScript != null) // 避免添加null实例
 {
 scriptList.Add(newScript);
 }
 return scriptList.ToArray();
 }

 /// <summary>
 /// 按自定义条件移除脚本数组中的元素
 /// </summary>
 /// <typeparam name="T">脚本类型</typeparam>
 /// <param name="originalArray">原脚本数组</param>
 /// <param name="condition">移除条件（Lambda表达式）</param>
 /// <returns>移除后的新脚本数组</returns>
 public static T[] RemoveScriptByCondition<T>(T[] originalArray, System.Predicate<T> condition) where T : class
 {
 if (originalArray == null || originalArray.Length == 0 || condition == null)
 {
 return originalArray;
 }

 List<T> scriptList = new List<T>(originalArray);
 scriptList.RemoveAll(condition);
 return scriptList.ToArray();
 }

 /// <summary>
 /// 按引用移除脚本数组中的单个脚本实例
 /// </summary>
 /// <typeparam name="T">脚本类型</typeparam>
 /// <param name="originalArray">原脚本数组</param>
 /// <param name="targetScript">目标脚本实例</param>
 /// <returns>移除后的新脚本数组</returns>
 public static T[] RemoveScriptByReference<T>(T[] originalArray, T targetScript) where T : class
 {
 if (originalArray == null || originalArray.Length == 0 || targetScript == null)
 {
 return originalArray;
 }

 List<T> scriptList = new List<T>(originalArray);
 scriptList.Remove(targetScript);
 return scriptList.ToArray();
 }
 }

以及一个TaskHolder脚本和TaskManager脚本来方便扩展

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public class TaskHolder : MonoBehaviour
{
 [SerializeField] public TMP_Text taskTitle; // 任务标题
 [SerializeField] public TMP_Text taskLittleTitle;
 [SerializeField] public TMP_Text taskName;
 [SerializeField] public TMP_Text describeText;
 [SerializeField] public Sprite[] images;

 private TaskDate taskDate;

 private void Awake()
 {
 GameObject taskName = GameObject.Find("Name Text");
 GameObject describeText = GameObject.Find("DescribeText");
 this.taskName = taskName.GetComponent<TMP_Text>();
 this.describeText = describeText.GetComponent<TMP_Text>();
 }

}

1
2
3
4


public class TaskManager : MonoBehaviour
{
 public TaskDate[] nowTaskDates;
}

Unity on 水元素长弓

Addressables的认识与使用

什么是 Addressables

一、为什么需要 Addressables

1.1 Resources 文件夹

1.2 AssetBundle（AB 包）

1.3 Addressables 的定位

二、核心概念

三、安装与初始化

3.1 安装包

3.2 初始化设置

3.3 Play Mode 脚本

四、快速上手

4.1 把一个资源标记为 Addressable

4.2 加载资源

4.3 直接实例化

4.4 加载图标 / 文本等非 GameObject 资源

五、加载 API 详解

5.1 主要加载接口

5.2 AsyncOperationHandle

5.3 批量加载

5.4 引用计数与释放

六、资源组与打包策略

6.1 Group 的关键设置

6.2 Bundle Mode（打包方式）

6.3 Compression（压缩方式）

6.4 打包策略建议

七、远程资源与热更新

7.1 Profile 与路径变量

7.2 把组切到远程

7.3 构建与部署

7.4 运行时检查与下载

7.5 热更新的原理与限制

八、依赖与引用

8.1 自动依赖分析

8.2 用 AssetReference 替代硬引用

九、标签（Label）的使用

十、场景加载

十一、常见问题与陷阱

11.1 内存泄漏

11.2 编辑器能跑，真机报错

11.3 地址拼错

11.4 资源被重复打包 / 包体异常大

11.5 Destroy 与 ReleaseInstance 混用

11.6 远程资源加载失败

十二、性能与最佳实践

十三、完整实战流程

十四、面试高频问答

14.1 Addressables 和 AssetBundle 的关系？

14.2 Addressables 和 Resources 的区别？

14.3 为什么加载了资源一定要 Release？

14.4 Bundle Mode 有哪几种？

14.5 三种压缩方式的区别？

14.6 Play Mode Script 三种模式的区别？

14.7 如何实现资源热更新？

14.8 什么是 Catalog？

14.9 为什么建议用 AssetReference 而不是直接引用？

14.10 如何避免 Bundle 重复依赖？

十五、学习路线建议

Unity渲染相关

一、Unity 渲染管线对比

1.1 内置渲染管线（Built-in Render Pipeline）

1.2 可编程渲染管线（SRP: Scriptable Render Pipeline）

1.3 URP vs HDRP 详细对比

1.4 为什么 SRP（URP/HDRP）性能更好

二、完整图形渲染管线

管线五大阶段总览

2.1 第一阶段：准备阶段（CPU）

2.2 第二阶段：几何阶段（GPU）

2.3 第三阶段：图元装配（Primitive Assembly）

2.4 第四阶段：光栅化阶段（GPU）

2.5 判断点在三角形内部的方法

2.6 锯齿与抗锯齿

2.7 第五阶段：像素处理阶段（GPU）

2.8 第六阶段：输出与后处理

三、光照模型

3.1 Phong 模型

3.2 Blinn-Phong 模型

3.3 PBR（基于物理的渲染）

四、渲染路径（Rendering Path）

11.5 `Destroy` 与 `ReleaseInstance` 混用