学习笔记19 10 月, 2026· 约 22 分钟

Unity 运行原理

Unity 运行原理 一、整体架构与主循环 Unity是 C++引擎内核 + C 脚本层 的混合架构。 底层渲染、物理、输入、资源管理全部是C++写;业务逻辑交给C 脚本,C 通过桥接调用底层C++接口。 编辑器和打包后的游戏,是两套运行环境: 编辑器 :C 跑Mono虚拟机 打包发布 :C 跑IL2CPP(AOT编译


Unity 运行原理

一、整体架构与主循环

Unity是C++引擎内核 + C#脚本层的混合架构。 底层渲染、物理、输入、资源管理全部是C++写;业务逻辑交给C#脚本,C#通过桥接调用底层C++接口。

编辑器和打包后的游戏,是两套运行环境:

  • 编辑器:C#跑Mono虚拟机
  • 打包发布:C#跑IL2CPP(AOT编译)

1. 整体分层

  1. 最底层:原生C++内核(Unity Core)

    • 渲染管线:URP/HDRP,调用DX11/Vulkan/Metal/OpenGL
    • 物理引擎:PhysX(碰撞、刚体)
    • 资源管理:GameObject、Component、Transform、资源加载、对象销毁
    • 输入系统、音频、动画、粒子、AI导航、文件IO
    • GameObject、Transform这些核心对象本质是C++对象,C#只是拿到C++对象的包装句柄。
  2. 中间层:脚本交互桥(C++ ↔ C#互操作) C#代码不能直接访问C++内存。Unity生成绑定代码,C#调用API时,会跨层跳到C++内核执行,再把结果返回C#。

    比如gameObject.SetActive(false),C#这行只是调用桥函数,真正做关闭物体是C++内核完成。

  3. 上层:C#用户脚本层

    • 你写的脚本,继承MonoBehaviour挂载GameObject。
    • 由引擎C++驱动回调你的C#函数(Awake/Start/Update)。

2. 游戏主循环(GameLoop,最核心原理)

游戏运行本质就是一个无限循环,每一帧重复执行一套固定流程。

打包后游戏启动,C++内核启动主循环,不是C#写while循环。

简化主循环流程:

游戏启动初始化 → 进入while(true)主循环
{
    1.处理系统输入(键盘、触摸、鼠标)
    2.处理FixedUpdate:按固定时间步进跑物理PhysX
    3.调用脚本 Awake / OnEnable / Start
    4.调用所有脚本 Update()
    5.调用所有脚本 LateUpdate()
    6.处理动画、协程
    7.物理碰撞检测,触发OnCollision/OnTrigger回调
    8.渲染管线:把场景物体提交GPU绘制画面
    9.处理Unity内部GC回收、资源管理
    10.交换缓冲区,屏幕显示画面
}
退出循环 → 游戏关闭

关键点

  1. Update是C++主动调用C#,不是C#自己跑循环。 C++遍历场景所有激活的MonoBehaviour组件,逐个调用Update。
  2. FixedUpdate不和帧率绑定,按固定时间片(默认0.02s,50次/秒)运行物理,帧率高低不影响物理结果。
  3. 渲染发生在Update之后:你在Update修改transform位置,这一帧画面才会刷新。

3. GameObject & Component 的本质

  • GameObject:C++对象,只是一个容器,本身几乎没有逻辑。 它只持有名字、active状态、一组Component组件列表。
  • Transform是特殊组件,每个GameObject必有Transform,维护位置旋转缩放父子层级。
  • 所有脚本MonoBehaviour也是Component子类。

你在C#拿到的GameObject go,不是完整对象,只是C++对象的一个C#包装代理。C#这边存的是对象ID,真正数据全部在C++内存。

C++/C#对象关系示例

GameObject go = new GameObject("Cube");
// C#层创建一个代理对象;真正物体实例在C++堆内存
go.SetActive(false);
// C#调用桥接函数,通知C++内核,把C++对象标记禁用

坑:C#代理可以被C#GC回收,但不会销毁C++内核物体;必须调用Destroy(gameObject),通知C++内核销毁原生对象。 如果丢了C#引用,C++物体还存在场景,就造成内存泄漏。

4. 容易混淆的几个误区

  1. ❌“Unity游戏是C#写的”

大部分底层内核是C++;C#只写业务逻辑。

  1. ❌“Update是C#自己循环调用”

Update是C++主循环遍历组件列表回调C#函数。

  1. ❌C#销毁引用等于销毁游戏物体

C#GC只能回收C#托管对象;GameObject真正销毁必须调用Destroy通知C++内核。

  1. ❌协程=多线程

协程完全在主线程执行,只是分段延迟执行。

如果你需要,我可以画一张简化架构框图,或者举一个从点击运行游戏,到执行第一帧Update完整流程。

5. 补充与易错点

  • 完整生命周期顺序:Awake → OnEnable → Start → (每帧)FixedUpdate → Update → LateUpdate → OnDisable → OnDestroy。Awake 在物体实例化时立即调用,Start 在第一次 Update 之前调用一次。
  • 同一帧内:FixedUpdate 可能执行 0 次或多次(取决于帧时长与固定步长),Update 与 LateUpdate 每帧各一次。
  • 执行顺序可调:Edit → Project Settings → Script Execution Order 可以指定脚本间的相对顺序,但同一优先级内的顺序不保证——不要依赖"谁先谁后"。
  • 协程的执行时机:yield return null 在本帧 Update 之后、LateUpdate 之前恢复,不是"下一帧开头"。
  • PlayerLoop 可以定制:Unity 2019+ 开放了 PlayerLoopSystem,可以插入自定义的系统级更新阶段(常用于替代大量 Update)。
  • LateUpdate 的意义:摄像机跟随必须写在 LateUpdate,否则会读到本帧尚未更新完的目标位置,产生抖动。

二、脚本后端:Mono、IL2CPP 与 CLR

C# 是高级语言,不能直接跑在 CPU 上,必须由虚拟机或编译器转成机器码。Unity 提供两套脚本后端(Scripting Backend):Mono 和 IL2CPP,二者互斥二选一。

1. 标准 .NET 运行链路

C# 源码 → 编译器 → IL 中间语言 → CLR 虚拟机(JIT 即时编译)→ 机器码
  • IL(中间语言):C# 编译器输出的跨平台字节码,类汇编但不直接跑 CPU;Mono 和 IL2CPP 都以 IL 作为输入。
  • CLR:.NET 虚拟机,职责包括 JIT 即时编译、GC 垃圾回收、类型安全校验、线程管理、异常处理。
  • JIT(Just-In-Time 即时编译):程序跑起来之后,才在设备上把 IL 翻译成 CPU 机器码。优点是灵活,可以动态加载新代码;缺点是 iOS 不允许。
  • AOT(Ahead-Of-Time 提前编译):打包时一次性全部编译成机器码,运行时只执行已经编译好的二进制,不能动态编译新 IL。

2. Mono

Mono 是 .NET 的开源跨平台实现,自带 JIT + 解释器。

流程:C# → 编译成 IL → 运行时由 JIT 在设备上实时编译成机器码执行。

特点:运行时可动态加载 dll、动态编译新代码,Assembly.Load() 加载的 dll 可以直接跑。

3. IL2CPP

全称 IL-to-C++,Unity 自研的 AOT 后端,用来替代 CLR 虚拟机。

C# 源码 → IL 中间代码 → IL2CPP 转换器 → C++ 源代码 → 平台原生编译器 → 原生机器码

平台编译器按目标平台选择:Android 用 clang、iOS 用 Xcode、Windows 用 MSVC。

所有 C# 逻辑最终都变成原生机器码,运行时不再有 IL。

⚠️ AOT:全部编译发生在打包阶段,设备运行时不再做任何编译。设备上只有编译好的机器码,没有 IL 编译能力。

4. 两者关系

  1. 编辑器 / Windows PC:默认 Mono,跑在 Mono-CLR 虚拟机 + JIT 上;Windows 打包时也可以选 IL2CPP。
  2. Android / iOS / WebGL:强制 IL2CPP,没有 CLR 虚拟机,纯原生代码执行。
  3. iOS 不允许 App 在运行时动态生成可执行机器码(禁止 JIT),Mono 的 JIT 会被系统拦截,所以 iOS 唯一可用后端是 IL2CPP;IL2CPP 的代码在打包时已全部编译完毕,设备不会生成新机器码,符合苹果审核规则。
  4. 新版 Unity 已移除 Mono 打包选项,移动端发布只剩 IL2CPP。

5. 对比表

对比项 Mono IL2CPP
编译模式 JIT 为主,运行时在设备上编译 IL AOT 提前编译,打包时 IL → C++ → 机器码
虚拟机 存在 Mono-CLR 虚拟机 无虚拟机
运行时动态编译 ✅ 支持 JIT,可动态加载 DLL 执行 ❌ 没有 JIT,设备端不能动态编译 IL
动态代码生成 支持 禁止,Emit 不可用
iOS 平台 ❌ 苹果禁止 JIT,不能用于 iOS 发布 ✅ iOS 唯一可用后端
Android 平台 旧版本可选,新版基本废弃 ✅ 现在的默认后端
性能 一般,GC 开销大,部分场景慢 🚀 更高,接近原生 C++,优化更好
内存占用 较高 更低
包体积 小 生成 C++ 代码,包体积会变大一些
Assembly.Load() 直接加载 dll 可以跑 只能拿到元数据,方法调用直接抛异常,这也是 HybridCLR / ILRuntime 存在的原因
GC Mono GC,老版本容易卡顿 IL2CPP 自有 GC(不是 CLR-GC),表现更好

6. IL2CPP 保留 / 丢失的能力

✅ 保留:C# 语法、async/await、委托、泛型、GC(IL2CPP 自带独立 GC)。

❌ 丢失:JIT 动态代码生成;Emit 动态发射代码不可用;反射能力受限。

7. 常见误区

  1. ❌ "IL2CPP 就是 C++,不能写 C#" 不是。照样写 C#,IL2CPP 只是后台把 C# 转成 C++ 再编译,开发层完全无感知。

  2. ❌ "Assembly.Load 在 IL2CPP 可以直接热更" 不行。它只能加载元数据,调用方法直接抛异常——因为没有 JIT 把 IL 变成机器码。

  3. ❌ "Mono 只能用于编辑器" Unity 编辑器本身就跑在 Mono 上;旧版本打包安卓可选 Mono,但 iOS 打包禁用,新版 Unity 打包只剩 IL2CPP。

8. 编辑器和打包是两套运行环境

编辑器 打包发布
后端 Mono 虚拟机 + JIT IL2CPP(AOT)
动态加载 dll 可以 不能

热更方案见《Unity 资源与热更》。

9. 补充与易错点

  • IL2CPP 的泛型是 AOT 的:值类型作为泛型实参时,每种组合都要在打包时生成一份代码;运行时反射创建的新泛型实例(如 MakeGenericType)可能找不到实现而抛异常。这是 AOT 平台最典型的坑。
  • 代码剥离(Stripping)会删掉"没被静态引用"的代码:反射、序列化、SDK 回调用到的类型容易被裁掉,表现为真机闪退、编辑器正常。用 link.xml 保留,或降低剥离等级。
  • GC 不是 CLR 那套:IL2CPP 用的是 Boehm GC,不分代、不压缩(见《内存与 GC》),所以"IL2CPP 性能好"指的是代码执行,不是内存管理。
  • Emit 完全不可用:依赖 System.Reflection.Emit 的库(部分序列化、DI 容器、Mock 框架)在 IL2CPP 下会直接失败。
  • Mono 的 JIT 在编辑器里也只是"够用":编辑器性能不代表真机性能,Mono 与 IL2CPP 的数值计算、GC 表现差异明显,性能结论必须真机验证。
  • WebGL 只能是 IL2CPP:浏览器环境没有 JIT 能力,且不支持多线程(除非开启 SharedArrayBuffer + 特定浏览器配置)。

三、物理系统原理

Unity 3D物理底层是 NVIDIA PhysX(C++编写的专业物理引擎);2D物理使用Box2D。

Unity本身不实现物理计算,C#层的Rigidbody、Collider只是C#代理组件;真正全部物理模拟都跑在底层PhysX C++内部,C#通过桥接调用PhysX接口。

1. 核心组件

  1. Collider(碰撞体) 定义物体物理形状边界,和模型Mesh是两套东西。模型管渲染显示,Collider管碰撞检测。
  • 基础碰撞体:Box、Sphere、Capsule,计算速度很快。
  • MeshCollider:用模型网格做碰撞,性能开销高;动态物体尽量不要用。
  • 勾选Is Trigger → 变为触发器,只检测重叠,无物理阻挡效果。
  1. Rigidbody(刚体) 把物体交给PhysX物理引擎控制;拥有质量、速度、重力、惯性。
  • 没有Rigidbody的物体:属于静态物体,物理引擎认为不会运动,只做碰撞阻挡,不受重力、力影响。
  • IsKinematic:运动刚体,不受力、重力驱动,只能通过代码修改position,但是依然可以参与碰撞交互,适合移动平台、动画物体。

✅碰撞生效必要条件:双方都有Collider,至少一方拥有Rigidbody,否则物理引擎不会产生碰撞回调。

2. 物理系统在游戏主循环的时机

物理是固定时间步模拟,默认FixedTimestep = 0.02s,每秒50次物理步进,和渲染帧率完全解耦。

一帧完整顺序

处理输入
循环执行(如果需要,一帧可多次执行物理步进):
    调用所有脚本 FixedUpdate()      //C#写施加力、修改刚体速度
    PhysX执行完整物理模拟(碰撞检测、求解、更新刚体位置旋转)
    触发 OnCollision / OnTrigger 回调
执行 Update()
执行 LateUpdate()
渲染画面

关键点:物理计算发生在FixedUpdate之后。所有刚体受力操作应该写在FixedUpdate,不要写在普通Update;否则帧率波动会造成物理行为不稳定。

如果设备帧率很低,1帧时间超过0.02s,Unity会连续跑多次FixedUpdate+物理模拟,追赶物理时间;帧率很高时,某一帧可能一次FixedUpdate都不跑。

3. PhysX物理模拟流水线(单次物理Step)

每一次FixedTimestep,PhysX内部完整跑一遍这套流程:

  1. 收集刚体状态:读取C#层施加的力、冲量、速度、重力。
  2. Broad Phase(粗检测) 用AABB包围盒快速筛选,剔除完全不可能相交的物体对;只留下有可能碰撞的候选对象。快速,粗略,减少后续计算量。
  3. Narrow Phase(精细碰撞检测) 对上一步候选对,做精确几何体相交计算;算出接触点、法线、穿透深度。

高速物体容易发生“穿透”,可开启CCD连续碰撞检测解决,但性能开销上升。

  1. 约束求解器 Solver 根据质量、物理材质(摩擦力、弹性)、关节Joint约束,计算碰撞冲量,处理反弹、摩擦、关节约束。
  2. 积分更新:根据受力,更新刚体速度、位置、旋转。
  3. 同步回Unity:把PhysX内部计算出来的位置写回GameObject的Transform;触发C#脚本OnCollisionXXX / OnTriggerXXX回调。

⚠️Transform是被PhysX改写,不是C#脚本自己修改。如果你直接改transform.position去移动带Rigidbody的物体,会绕过物理引擎,引发抖动、穿透bug;物理物体移动优先用rb.MovePosition() / AddForce()。

4. Collision vs Trigger

项目 OnCollision(实体碰撞) OnTrigger(触发器)
Is Trigger 双方都不勾选 至少一方勾选IsTrigger
物理效果 产生阻挡、反弹、摩擦,物体不能穿透 无物理阻挡,物体直接穿过
回调参数 Collision,包含碰撞点、法线、碰撞速度 Collider,只拿到对方碰撞体引用
Rigidbody条件 双方都有Collider,至少一方有Rigidbody 双方都有Collider,至少一方有Rigidbody
典型场景 撞墙、弹跳、物理打击 拾取道具、传送门、区域检测

回调时机:

  • Enter:刚接触的那一次物理步
  • Stay:每一次物理步持续接触都会调用
  • Exit:分离那一刻调用

5. Rigidbody三种模式

  1. Dynamic动态刚体(默认) PhysX完全控制位置旋转;受重力、力、碰撞影响。适合玩家、抛射物、箱子。
  2. Kinematic运动刚体(IsKinematic=true) 不受重力和外力;只能通过Transform/MovePosition移动;依然可以碰撞推开动态物体。适合移动平台、机关门。
  3. Static静态刚体 没有Rigidbody组件,只有Collider。物理引擎认为永远不动,适合地面、墙体。

❗不要移动静态物体的transform,会触发物理世界重建,严重卡顿。

6. 重要坑点与原理说明

  1. 不要直接修改transform.position操作动态Rigidbody 动态刚体位置由PhysX内部维护。直接写transform会强行覆盖物理计算结果,产生抖动、穿透。 正确方式:rb.velocity / rb.AddForce() / rb.MovePosition()。

  2. 物理回调(OnCollision、OnTrigger)跑在物理步进,不是Update 它的触发频率是50Hz,不是渲染帧率;不要在里面写依赖deltaTime的逻辑。

  3. 物理材质PhysicMaterial 作用于Collider,控制摩擦系数、弹性(Bounciness),决定物体滑动、弹跳效果。

  4. Joint关节 PhysX提供铰链、弹簧、固定关节;在物理求解阶段施加约束,限制两个刚体之间相对运动。

  5. Layer Collision Matrix(层碰撞矩阵) 可以配置哪些层之间允许发生碰撞,直接在物理引擎层过滤,减少碰撞计算量。

  6. CCD连续碰撞检测 普通Discrete离散碰撞是每一步结束检测位置;高速物体在两个物理步之间直接穿过障碍物,发生穿透。开启CCD可以追踪物体运动轨迹检测碰撞,CPU开销明显上升,只给高速物体开启。

7. 性能关键原理

  1. 基础碰撞体Box/Sphere/Capsule计算极快,MeshCollider开销大。
  2. BroadPhase会维护AABB树,大量移动物体,树更新开销上涨。
  3. Solver求解器,物体互相堆叠(大量物体堆一起)开销会急剧上涨。
  4. 触发器也消耗物理计算,不要大规模滥用Trigger。

8. 和C#层的关系总结

  • C#脚本的Rigidbody、Collider只是薄代理对象,真实数据全部存PhysX的C++内存。
  • C#代码只能设置参数、施加力;真正碰撞、运动全部由PhysX完成。
  • FixedUpdate由Unity调用C#,C#修改刚体状态,之后PhysX运行模拟,再把结果同步回来,触发碰撞回调。

如果你需要,我可以对比CharacterController和Rigidbody角色控制器底层原理差异。

9. 补充与易错点

  • FixedUpdate 可能一帧跑多次或零次:Unity 用 Time.maximumDeltaTime 限制单帧最多追赶多少物理时间,防止低帧率下的"死亡螺旋"(越卡越多物理步、越算越慢)。
  • 插值是视觉平滑的关键:Rigidbody 的 Interpolate(插值)让渲染在物理步之间平滑过渡,否则低物理频率下会看到抖动;Extrapolate 则向前预测,延迟更低但可能过冲。
  • 射线与重叠查询也是物理开销:Physics.Raycast / OverlapSphere 每帧大量调用会成为瓶颈,能用 LayerMask 缩小范围就用。
  • CharacterController 与 Rigidbody 是两套模型:前者是"带碰撞的胶囊 + 自己写的移动逻辑",不受物理力驱动、不参与刚体求解;后者完全交给 PhysX。角色控制通常用前者(可控性好),需要被物理推挤时用后者。
  • 静态碰撞体不要移动:移动会触发 PhysX 重建静态 AABB 树,是常见卡顿源;需要移动的物体必须有 Rigidbody(Kinematic)。
  • Physics.Simulate 手动驱动:关闭 Auto Simulation 后可以自己按需步进物理,用于"暂停游戏但仍要查询"或做确定性的定点模拟。