罗罗编程学习记录
本页内容 展开查看

13.2.1 引擎核心对象与场景

所属:全栈开发面试题库 / 13 游戏开发与实时渲染 / 13.2 Unity

覆盖范围

  • GameObject 与 Component 关系
  • Transform 与层级
  • Prefab 预制体
  • Scene 场景管理
  • ScriptableObject 数据容器
  • 实例化与销毁

高频题速览

编号 题目 难度 频率
13.2.1-001 GameObject 和 Component 的关系是什么? 基础 ★★★★★
13.2.1-002 Transform 的父子层级怎么影响坐标? 基础 ★★★★
13.2.1-003 Prefab 实例化和原始预制体的关系? 进阶 ★★★★
13.2.1-004 ScriptableObject 和普通类有什么区别? 进阶 ★★★★
13.2.1-005 Scene 管理怎么加载和卸载? 基础 ★★★★
13.2.1-006 FindObjectOfType 为什么慢? 进阶 ★★★
13.2.1-007 DontDestroyOnLoad 怎么用? 基础 ★★★
13.2.1-008 Prefab Variant 是什么? 进阶 ★★★

13.2.1-001 GameObject 和 Component 的关系是什么?

一句话结论

GameObject 是容器,Component 是挂在容器上的功能模块;GameObject 本身没有行为,所有行为由 Component 提供(Transform、MeshRenderer、Rigidbody、脚本)。

概念解释

  • GameObject:场景中的实体,有名字、层级、Tag、Layer;本身只是一个空容器。
  • Component:挂在 GameObject 上的功能模块,如 Transform(位置)、MeshRenderer(渲染)、Rigidbody(物理)、MonoBehaviour(脚本)。
  • 组合优于继承:通过组合不同 Component 得到不同行为,而不是继承复杂的类层级。
  • 一个 GameObject 只能有一个同类型 Component(如只能有一个 Transform)。

原理流程

  1. 创建 GameObject:空容器。
  2. 挂 Component:Transform(必挂)、MeshFilter、MeshRenderer、Rigidbody、自定义脚本。
  3. Component 之间通过 GetComponent 互相引用。
  4. 销毁 GameObject:所有 Component 一起销毁。

代码或图示

// 创建 GameObject 并挂组件
GameObject go = new GameObject("Player");
go.AddComponent<BoxCollider>();
go.AddComponent<Rigidbody>();
PlayerController pc = go.AddComponent<PlayerController>();

// 获取组件
Rigidbody rb = go.GetComponent<Rigidbody>();

常见误区

  • 误区:GameObject 就是类;正解:GameObject 是空容器,行为全靠 Component;脚本是 MonoBehaviour Component。
  • 误区:一个 GameObject 可以挂多个同类型组件;正解:Transform 等只能有一个;自定义脚本可以多个同类型。

追问

  • 为什么 MonoBehaviour 要继承 Component?答:脚本是组件,挂在 GameObject 上;生命周期由引擎调度。
  • 什么是 ExecuteInEditMode?答:让脚本在编辑模式下也执行 Update,用于编辑器工具。

13.2.1-002 Transform 的父子层级怎么影响坐标?

一句话结论

Transform 有 localPosition(相对于父节点)和 position(世界坐标),父节点移动/旋转/缩放会影响所有子节点的世界坐标;子节点 localPosition 不变,世界坐标随父节点变化。

概念解释

  • localPosition:相对于父节点的位置。
  • position:世界坐标。
  • 父子层级:子节点继承父节点的变换(位置、旋转、缩放)。
  • lossyScale:世界缩放,只读。

原理流程

  1. 父节点在 (0, 0, 0),子节点 localPosition = (1, 0, 0),子节点世界坐标 = (1, 0, 0)。
  2. 父节点移动到 (5, 0, 0),子节点 localPosition 不变,世界坐标 = (6, 0, 0)。
  3. 父节点旋转 90°,子节点世界坐标随旋转变化。

代码或图示

Transform parent = transform.parent;
Vector3 localPos = transform.localPosition;  // 相对父节点
Vector3 worldPos = transform.position;        // 世界坐标

// 父节点移动,子节点跟随
parent.position = new Vector3(5, 0, 0);
// 子节点 localPosition 不变,世界坐标自动更新

常见误区

  • 误区:设置 position 就是设置 localPosition;正解:position 是世界坐标,localPosition 是相对父节点;设置 position 会反算 localPosition。
  • 误区:缩放不会影响子节点;正解:父节点缩放会影响子节点的世界缩放和位置。

追问

  • 什么是 lossyScale?答:世界缩放,只读,因为父节点多级缩放后实际缩放是各级乘积。
  • 怎么让子节点不受父节点缩放影响?答:取消父子关系,或在子节点反向缩放。

13.2.1-003 Prefab 实例化和原始预制体的关系?

一句话结论

Prefab 是模板资源,Instantiate 生成实例;实例与 Prefab 保持关联(Override),修改 Prefab 会影响所有实例,实例上的修改是 Override 不会回写 Prefab。

概念解释

  • Prefab:模板资源,存为 .prefab 文件,包含 GameObject 层级和 Component 设置。
  • 实例化:Instantiate(prefab) 在场景中生成一个 Prefab 的副本。
  • Override:实例上修改某属性(如改颜色),该属性标记为 Override,不再跟随 Prefab。
  • Apply:把实例的修改回写到 Prefab,影响所有实例。

原理流程

  1. 创建 Prefab:把场景中的 GameObject 拖到 Project 窗口,保存为模板。
  2. 实例化:Instantiate(prefab) 生成副本,与 Prefab 关联。
  3. 修改 Prefab:改 Prefab 的颜色 → 所有实例颜色更新。
  4. 修改实例:改某个实例的颜色 → 该实例颜色标记 Override,不影响其他实例和 Prefab。
  5. Apply:把实例修改回写到 Prefab,所有实例同步。

代码或图示

// 实例化 Prefab
GameObject enemyPrefab = Resources.Load<GameObject>("Enemy");
GameObject enemy = Instantiate(enemyPrefab, spawnPos, Quaternion.identity);

// Override:改实例属性不影响 Prefab
enemy.GetComponent<Enemy>().level = 10;  // 这个实例等级 10

常见误区

  • 误区:实例修改会自动回写 Prefab;正解:实例修改是 Override,不回写;要 Apply 才回写。
  • 误区:Prefab 不能嵌套;正解:Prefab 可以嵌套(Prefab 里有 Prefab),修改内层 Prefab 影响所有外层实例。

追问

  • 什么是 Prefab Variant?答:基于另一个 Prefab 创建变体,只修改差异部分;修改父 Prefab 时变体跟随,除非 Override。
  • 怎么批量修改所有实例?答:修改 Prefab,所有实例自动更新(未 Override 的属性)。

13.2.1-004 ScriptableObject 和普通类有什么区别?

一句话结论

ScriptableObject 是可序列化的数据容器资源,存为 .asset 文件,可在编辑器配置、被多个对象共享;普通类是运行时对象,不序列化到资产,不共享。

概念解释

  • ScriptableObject:继承自 ScriptableObject,可序列化字段,存为 .asset 资源。
  • 数据共享:多个 MonoBehaviour 引用同一个 ScriptableObject 资源,数据共享。
  • 配置资产:游戏配置(敌人属性、道具表)存为 ScriptableObject,策划在编辑器配置。
  • 不随场景销毁:ScriptableObject 是资产,场景切换不销毁。

原理流程

  1. 定义 ScriptableObject:[CreateAssetMenu] 标记,可在菜单创建资产。
  2. 创建资产:Project 窗口创建 .asset,配置字段(敌人血量、攻击力)。
  3. 引用:MonoBehaviour 字段类型为 EnemyConfig,拖拽引用资产。
  4. 数据共享:所有敌人引用同一个配置资产,改资产所有敌人同步。

代码或图示

[CreateAssetMenu(fileName = "EnemyConfig", menuName = "Config/Enemy")]
public class EnemyConfig : ScriptableObject {
    public string enemyName;
    public int maxHp;
    public float moveSpeed;
}

// 在 MonoBehaviour 中引用
public class Enemy : MonoBehaviour {
    public EnemyConfig config;  // 拖拽引用资产
    void Start() {
        Debug.Log(config.enemyName);  // 读资产数据
    }
}

常见误区

  • 误区:ScriptableObject 就是单例;正解:ScriptableObject 是资产,可创建多个实例;单例是设计模式。
  • 误区:ScriptableObject 数据运行时修改会保存;正解:运行时修改只在内存,退出播放后还原;要保存需写文件。

追问

  • ScriptableObject 怎么存游戏数据?答:运行时修改后用 JSON 序列化到文件,加载时反序列化;或用 PlayerPrefs。
  • ScriptableObject 和 JSON 配置的区别?答:SO 有类型安全和编辑器可视化,JSON 灵活但无类型;SO 适合策划配置,JSON 适合外部数据。

13.2.1-005 Scene 管理怎么加载和卸载?

一句话结论

SceneManager.LoadScene 加载场景(单场景替换或多场景叠加),LoadSceneAsync 异步加载不卡顿;多场景管理用 Additive 模式叠加,卸载用 UnloadSceneAsync。

概念解释

  • 单场景模式:当前场景替换为新场景,旧场景销毁。
  • 多场景叠加(Additive):新场景叠加在旧场景上,不销毁旧场景。
  • 异步加载:LoadSceneAsync 后台加载,不卡顿主线程,可显示加载进度。
  • SceneManager:场景管理 API。

原理流程

  1. 单场景:SceneManager.LoadScene("Battle") → 当前场景销毁,战斗场景加载。
  2. 多场景:LoadScene("UI", LoadSceneMode.Additive) → UI 场景叠加,主场景保留。
  3. 异步:LoadSceneAsync("Battle") → 后台加载,progress 显示进度,完成后自动切换。
  4. 卸载:UnloadSceneAsync("UI") → 卸载叠加的 UI 场景。

代码或图示

// 单场景加载
SceneManager.LoadScene("Battle");

// 异步加载
async void LoadBattle() {
    AsyncOperation op = SceneManager.LoadSceneAsync("Battle");
    while (!op.isDone) {
        Debug.Log(op.progress);  // 显示进度
        await Task.Yield();
    }
}

// 多场景叠加
SceneManager.LoadScene("UI", LoadSceneMode.Additive);

常见误区

  • 误区:LoadScene 立即切换;正解:LoadScene 在当前帧结束后切换,不是立即;要立即切换用 LoadSceneAsync 并 allowSceneActivation = false 再手动激活。
  • 误区:多场景叠加会自动卸载;正解:Additive 加载的场景要手动 UnloadSceneAsync。

追问

  • 什么是 Scene 生命周期?答:场景加载时 Awake/OnEnable,卸载时 OnDisable/OnDestroy;多场景时各场景独立。
  • 怎么在场景间传数据?答:用静态变量、单例、ScriptableObject,或通过 SceneManager.sceneLoaded 事件。

13.2.1-006 FindObjectOfType 为什么慢?

一句话结论

FindObjectOfType 遍历场景中所有 GameObject 和 Component 查找类型匹配,每帧调用会遍历整个场景,CPU 开销大;应该在 Start/Awache 时缓存引用,而不是每帧查找。

概念解释

  • FindObjectOfType:遍历场景所有对象查找指定类型组件,O(n) 复杂度。
  • FindObjectsOfType:查找所有匹配对象,更慢。
  • 缓存引用:在 Start/Awake 时找到引用,存为字段,后续直接用。
  • 性能:每帧 FindObjectOfType 在 1000 个对象的场景中就是 1000 次遍历。

原理流程

  1. 错误:Update 里 FindObjectOfType<Player>() 每帧遍历。
  2. 正确:Start 里 player = FindObjectOfType<Player>(),缓存到字段。
  3. 更好:用 SerializeField 拖拽引用,编译期就知道,运行时零开销。

代码或图示

// 错误:每帧查找
void Update() {
    Player player = FindObjectOfType<Player>();  // 每帧遍历
    player.Move();
}

// 正确:Start 缓存
Player player;
void Start() {
    player = FindObjectOfType<Player>();
}
void Update() {
    player.Move();  // 直接用缓存
}

// 最佳:SerializeField 拖拽
[SerializeField] private Player player;  // 编辑器拖拽

常见误区

  • 误区:FindObjectOfType 很便宜;正解:它遍历整个场景,对象多时慢;只在初始化时用。
  • 误区:单例可以替代所有引用;正解:单例是全局访问,但拖拽引用更明确、更易维护。

追问

  • 怎么批量查找?答:FindObjectsOfType 一次找所有,比循环 FindObjectOfType 快;但仍只在初始化用。
  • 什么是 Object.FindObjectsByType?答:新版 API,支持查找参数(包括 inactive 对象),比旧 API 灵活。

13.2.1-007 DontDestroyOnLoad 怎么用?

一句话结论

DontDestroyOnLoad 让 GameObject 在场景切换时不销毁,用于跨场景保留的对象(如游戏管理器、音频管理器);但要防重复(如果已存在就销毁新实例)。

概念解释

  • DontDestroyOnLoad:标记 GameObject 场景切换不销毁。
  • 用途:跨场景保留的管理器(GameManager、AudioManager、NetworkManager)。
  • 防重复:新场景加载时如果已有实例,销毁新实例,避免重复。

原理流程

  1. 管理器 GameObject 调 DontDestroyOnLoad,场景切换保留。
  2. 新场景也有一个管理器(从 Start 场景带过来),Awake 时检查是否已有实例。
  3. 如果已有,销毁当前实例,保留旧实例。

代码或图示

public class GameManager : MonoBehaviour {
    public static GameManager Instance;
    void Awake() {
        if (Instance == null) {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        } else {
            Destroy(gameObject);  // 已有实例,销毁重复
        }
    }
}

常见误区

  • 误区:DontDestroyOnLoad 的对象永远不销毁;正解:切换到其他场景不销毁,但退出 Play 模式或应用退出时销毁。
  • 误区:所有管理器都要 DontDestroyOnLoad;正解:只跨场景需要的才用;只在单场景用的不要。

追问

  • DontDestroyOnLoad 的对象在哪个场景?答:在特殊的 DontDestroyOnLoad 场景里,不是任何普通场景。
  • 怎么清理 DontDestroyOnLoad 的对象?答:Destroy(gameObject) 显式销毁;或 SceneManager.UnloadScene 不影响它。

13.2.1-008 Prefab Variant 是什么?

一句话结论

Prefab Variant 基于另一个 Prefab 创建变体,只记录差异(Override 的属性),父 Prefab 修改时变体跟随,变体上修改的属性不跟随;适合在基础 Prefab 上做变体。

概念解释

  • Prefab Variant:继承自另一个 Prefab,只存差异。
  • 父 Prefab 修改:变体未 Override 的属性跟随父 Prefab。
  • 变体 Override:变体上修改的属性不跟随父 Prefab。
  • 用途:基础敌人 Prefab,变体做不同颜色/属性的敌人。

原理流程

  1. 基础 Prefab:Enemy(血量 100,速度 5)。
  2. Variant:Enemy_Red(继承 Enemy,Override 颜色红色,血量 150)。
  3. 修改父 Prefab 速度到 6:Variant 速度变为 6(未 Override),血量仍 150(Override)。

代码或图示

基础 Prefab: Enemy
  maxHp = 100, moveSpeed = 5, color = white

Variant: Enemy_Red
  maxHp = 150 (Override)
  color = red (Override)
  moveSpeed = 跟随父 Prefab (未 Override)

修改父 Prefab moveSpeed = 6:
  Variant moveSpeed = 6 (自动跟随)

常见误区

  • 误区:Variant 是 Prefab 的副本;正解:Variant 只存差异,不复制整个 Prefab,节省空间。
  • 误区:Variant 不能再嵌套;正解:Variant 可以再做 Variant,多级继承。

追问

  • Variant 和直接修改 Prefab 实例的区别?答:Variant 是资产,可重复实例化;实例 Override 是场景中的修改,不存为资产。
  • 怎么取消 Override?答:在 Inspector 里 Revert 该属性,恢复跟随父 Prefab。

13.2.1-009 Prefab Variant 和 Prefab Instance 的区别?

一句话结论

Prefab Instance 是实例化模板,修改不影响源;Prefab Variant 继承自源 Prefab,可覆盖部分属性,源 Prefab 改动自动同步。

概念解释

  • Prefab Instance:从 Prefab 实例化,独立修改,不影响源。
  • Prefab Variant:继承 Prefab,可覆盖属性,源改动同步。
  • 适合:基础怪物 Prefab + 变体(不同颜色、属性)。

原理流程

  1. Instance:实例化后独立。
  2. Variant:继承源 Prefab,覆盖属性。
  3. 源 Prefab 改动 → Variant 自动同步。

代码或图示

Prefab Instance:
  Prefab → 实例化 → 独立修改(不影响源)
Prefab Variant:
  Prefab → 继承 → 覆盖属性
  源改动 → Variant 自动同步

常见误区

  • 误区:Variant 和 Instance 一样;正解:Variant 继承,Instance 独立。
  • 误区:Variant 覆盖全部属性;正解:Variant 只覆盖需要改的属性。

追问

  • 什么是 Prefab?答:可复用的游戏对象模板。
  • 什么是嵌套 Prefab?答:Prefab 里嵌套另一个 Prefab。

待整理清单

  • [ ] Unity 新版 Object Find API 变化
  • [ ] Prefab 嵌套和 Variant 的最佳实践
  • [ ] 多场景在开放世界中的应用