【Unity知识扫盲】架构师/引擎级的顶级概念

架构师/引擎级知识体系架构介绍

1. Unity引擎源码级理解

MonoBehaviour底层机制

// Unity不是真正调用虚方法，而是通过反射缓存+快速调用
// 理解这个可以避免很多性能陷阱

public class UnityInternals {
    // Unity内部类似这样的结构（伪代码）
    class MonoBehaviourCallbackCache {
        private Dictionary<Type, MethodInfo> updateMethods = new Dictionary<Type, MethodInfo>();
        
        public void CacheCallbacks(MonoBehaviour behaviour) {
            Type type = behaviour.GetType();
            
            // 在添加组件时，Unity会检查是否有这些方法
            MethodInfo update = type.GetMethod("Update", 
                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            
            if (update != null) {
                updateMethods[type] = update;
            }
        }
        
        public void InvokeUpdate(MonoBehaviour behaviour) {
            Type type = behaviour.GetType();
            if (updateMethods.TryGetValue(type, out MethodInfo method)) {
                method.Invoke(behaviour, null);  // 实际使用更快的调用方式
            }
        }
    }
    
    // 这就是为什么：
    // 1. 空Update()也有开销（Unity仍然会调用）
    // 2. private Update()也能工作
    // 3. virtual Update()不会被子类覆盖（Unity只看当前类）
}

// 深入理解组件查找
public class ComponentLookup {
    // GetComponent的真实成本
    void PerformanceAnalysis() {
        // 每次都遍历组件列表 - O(n)
        GetComponent<Rigidbody>();
        
        // Unity内部使用类似这样的结构
        // Dictionary<Type, Component> componentCache
        // 但仍有字典查找开销
        
        // 最优：缓存引用 - O(1)
        Rigidbody cachedRb;
    }
    
    // GetComponentInChildren的真实成本
    void DeepSearch() {
        // 递归遍历整个子树！
        // 时间复杂度：O(n * m) 其中n是节点数，m是平均组件数
        GetComponentInChildren<Animator>();
        
        // 如果你有1000个子节点，每个10个组件
        // 最坏情况：10,000次类型检查！
    }
}

Transform底层与矩阵

public class TransformInternals {
    // Transform实际上维护两套数据：
    // 1. local: position/rotation/scale
    // 2. world: 通过矩阵计算得出
    
    // 每次修改transform.position时，Unity会：
    void SetPosition(Vector3 newPosition) {
        // 1. 标记为"脏"
        // 2. 在渲染前统一计算矩阵（避免频繁计算）
        // 3. 通知所有子节点也变脏
    }    
    // 理解这个可以优化：
    void OptimizedTransformUpdate() {
        // 糟糕：每帧修改父节点
        void Update_Bad() {
            parentTransform.position += Vector3.up * Time.deltaTime;
            // 导致所有子节点矩阵重新计算！
        }        
        // 更好：只修改叶子节点
        void Update_Good() {
            leafTransform.position += Vector3.up * Time.deltaTime;
            // 不影响其他节点
        }        
        // 最优：批量更新
        void Update_Best() {
            // 一次性修改多个Transform
            // 然后调用Physics.SyncTransforms()
            // Unity会批量更新物理引擎
        }
    }    
    // Transform层级的真实成本
    void HierarchyDepthMatters() {
        // 深度为10的层级：
        // transform.position getter需要：
        // 1. 检查是否脏
        // 2. 如果脏，递归计算所有父节点的世界矩阵
        // 3. 最终计算自己的世界矩阵
        
        // 建议：关键性能路径上避免深层级（<5层）
    }
}

2. 内存布局与缓存一致性

using System.Runtime.InteropServices;

// 理解内存对齐对性能的影响
[StructLayout(LayoutKind.Sequential)]
public struct AlignedStruct {
    // 差的布局（24字节，带padding）
    public byte a;      // 1字节
                        // +7字节padding
    public long b;      // 8字节
    public int c;       // 4字节
                        // +4字节padding
}

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct PackedStruct {
    // 紧凑布局（13字节，无padding）
    public byte a;      // 1字节
    public long b;      // 8字节
    public int c;       // 4字节
}

[StructLayout(LayoutKind.Sequential)]
public struct OptimalStruct {
    // 最优布局（16字节，自然对齐）
    public long b;      // 8字节
    public int c;       // 4字节
    public byte a;      // 1字节
                        // +3字节padding（但总大小更优）
}

// 缓存友好的数据结构（SoA vs AoS）
public class CacheFriendlyData {
    // Array of Structures（AoS）- 缓存不友好
    public struct Entity {
        public Vector3 position;
        public Vector3 velocity;
        public float health;
        public int id;
    }
    Entity[] entities = new Entity[10000];
    
    void UpdatePositions_Bad() {
        // 每次访问都加载整个Entity（64字节）
        // 但只使用position和velocity（24字节）
        // 缓存命中率低！
        for (int i = 0; i < entities.Length; i++) {
            entities[i].position += entities[i].velocity * Time.deltaTime;
        }
    }
    
    // Structure of Arrays（SoA）- 缓存友好
    Vector3[] positions = new Vector3[10000];
    Vector3[] velocities = new Vector3[10000];
    float[] healths = new float[10000];
    int[] ids = new int[10000];
    
    void UpdatePositions_Good() {
        // 连续访问内存，缓存命中率高！
        // CPU可以预取数据
        for (int i = 0; i < positions.Length; i++) {
            positions[i] += velocities[i] * Time.deltaTime;
        }
    }
}

// SIMD优化（Single Instruction Multiple Data）
using Unity.Mathematics;
using Unity.Burst;

[BurstCompile]
public static class SIMDOptimization {
    // 使用Burst编译器和数学库实现SIMD
    public static void MultiplyVectors(float3[] a, float3[] b, float3[] result) {
        for (int i = 0; i < a.Length; i++) {
            // Burst会自动向量化这个循环
            // 同时处理4个float3（SSE）或8个（AVX）
            result[i] = a[i] * b[i];
        }
    }
    
    // 手动SIMD控制
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static float DotProduct(float3 a, float3 b) {
        // 使用math库的优化实现
        return math.dot(a, b);  // 编译为单条SIMD指令
    }
}

3. 协程的底层实现与状态机

// !!!协程本质上是编译器生成的状态机
public class CoroutineInternals {
    // 你写的代码：
    IEnumerator MyCoroutine() {
        Debug.Log("Start");
        yield return new WaitForSeconds(1f);
        Debug.Log("After 1 second");
        yield return null;
        Debug.Log("Next frame");
    }
    
    // 编译器生成的状态机（简化版）：
    class MyCoroutineStateMachine : IEnumerator {
        private int state = 0;
        private float timer;
        
        public bool MoveNext() {
            switch (state) {
                case 0:
                    Debug.Log("Start");
                    timer = 1f;
                    state = 1;
                    return true;  // yield return                    
                case 1:
                    timer -= Time.deltaTime;
                    if (timer <= 0) {
                        Debug.Log("After 1 second");
                        state = 2;
                    }
                    return true;                    
                case 2:
                    Debug.Log("Next frame");
                    state = 3;
                    return true;                    
                case 3:
                    return false;  // 协程结束
            }
            return false;
        }
        
        public object Current { get; private set; }
        public void Reset() { }
    }
    
    // 理解这个后，你可以：
    // 1. 避免协程的GC（使用对象池）
    // 2. 理解为什么协程有开销
    // 3. 知道何时用协程，何时用Update
    
    // 高性能替代方案
    class ManualStateMachine {
        private enum State { Idle, Waiting, Processing, Done }
        private State currentState = State.Idle;
        private float timer;
        
        public void Update() {
            switch (currentState) {
                case State.Idle:
                    StartProcess();
                    break;                    
                case State.Waiting:
                    timer -= Time.deltaTime;
                    if (timer <= 0) {
                        currentState = State.Processing;
                    }
                    break;                    
                case State.Processing:
                    Process();
                    currentState = State.Done;
                    break;
            }
        }        
        void StartProcess() {
            timer = 1f;
            currentState = State.Waiting;
        }        
        void Process() {
            // 处理逻辑
        }
    }
}

4. 渲染管线深度优化

// 理解GPU指令流水线
public class RenderingOptimization {
    // GPU工作原理：
    // CPU → 命令队列 → GPU驱动 → GPU执行
    //       (延迟1-3帧)
    
    // 减少Draw Call的高级技巧
    void AdvancedBatching() {
        // 1. GPU Instancing（同材质同Mesh）
        MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
        Matrix4x4[] matrices = new Matrix4x4[1000];
        
        for (int i = 0; i < 1000; i++) {
            matrices[i] = Matrix4x4.TRS(
                new Vector3(i % 32, 0, i / 32),
                Quaternion.identity,
                Vector3.one
            );
        }
        
        // 1000个对象 = 1次Draw Call
        Graphics.DrawMeshInstanced(mesh, 0, material, matrices);
        
        // 2. 动态合批（不同材质）
        // 使用Texture Array
        Material batchMaterial = new Material(shader);
        Texture2DArray textureArray = new Texture2DArray(256, 256, 100, TextureFormat.RGBA32, false);
        batchMaterial.SetTexture("_MainTexArray", textureArray);
        
        // 3. 手动合并Mesh
        CombineInstance[] combine = new CombineInstance[meshes.Length];
        for (int i = 0; i < meshes.Length; i++) {
            combine[i].mesh = meshes[i];
            combine[i].transform = transforms[i].localToWorldMatrix;
        }
        
        Mesh combinedMesh = new Mesh();
        combinedMesh.CombineMeshes(combine, true, true);
    }
    
    // 遮挡剔除的实现原理
    void CustomOcclusionCulling() {
        // Unity的遮挡剔除使用PVS（Potentially Visible Set）
        // 离线预计算每个区域能看到哪些对象
        
        // 运行时实现（简化）：
        Camera camera = Camera.main;
        Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(camera);
        
        foreach (Renderer renderer in allRenderers) {
            Bounds bounds = renderer.bounds;            
            // 1. 视锥剔除
            if (!GeometryUtility.TestPlanesAABB(frustumPlanes, bounds)) {
                renderer.enabled = false;
                continue;
            }            
            // 2. 距离剔除
            float distance = Vector3.Distance(camera.transform.position, bounds.center);
            if (distance > maxRenderDistance) {
                renderer.enabled = false;
                continue;
            }            
            // 3. 遮挡查询（需要GPU反馈）
            // 使用上一帧的深度缓冲判断是否被遮挡
            
            renderer.enabled = true;
        }
    }
    
    private Renderer[] allRenderers;
    private float maxRenderDistance;
    private Mesh mesh;
    private Material material;
    private Mesh[] meshes;
    private Transform[] transforms;
    private Shader shader;
}

// CommandBuffer高级技巧
public class AdvancedCommandBuffer : MonoBehaviour {
    private CommandBuffer commandBuffer;
    private RenderTexture tempRT;
    
    void Setup() {
        commandBuffer = new CommandBuffer();
        commandBuffer.name = "Custom Effects";        
        // 1. 获取临时RT（自动管理大小）
        int screenCopyID = Shader.PropertyToID("_ScreenCopy");
        commandBuffer.GetTemporaryRT(screenCopyID, -1, -1, 0, FilterMode.Bilinear);        
        // 2. 复制屏幕内容
        commandBuffer.Blit(BuiltinRenderTextureType.CameraTarget, screenCopyID);        
        // 3. 自定义渲染
        commandBuffer.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
        commandBuffer.DrawMesh(fullscreenQuad, Matrix4x4.identity, customMaterial, 0, 0);        
        // 4. 多Pass渲染
        for (int i = 0; i < 5; i++) {
            commandBuffer.Blit(screenCopyID, screenCopyID, blurMaterial, 0);  // 水平模糊
            commandBuffer.Blit(screenCopyID, screenCopyID, blurMaterial, 1);  // 垂直模糊
        }        
        // 5. 合成
        commandBuffer.Blit(screenCopyID, BuiltinRenderTextureType.CameraTarget, compositeMaterial);        
        // 6. 清理
        commandBuffer.ReleaseTemporaryRT(screenCopyID);        
        // 7. 注册到相机
        Camera.main.AddCommandBuffer(CameraEvent.AfterForwardOpaque, commandBuffer);
    }    
    void OnDestroy() {
        if (commandBuffer != null) {
            Camera.main.RemoveCommandBuffer(CameraEvent.AfterForwardOpaque, commandBuffer);
            commandBuffer.Release();
        }
    }
    
    private Mesh fullscreenQuad;
    private Material customMaterial;
    private Material blurMaterial;
    private Material compositeMaterial;
}

5. Native Plugin开发

// C++ Plugin（NativePlugin.cpp）
#include <cstring>

// 从C#调用的函数必须使用C链接
extern "C" {
    // 导出函数
    #ifdef _WIN32
        #define EXPORT_API __declspec(dllexport)
    #else
        #define EXPORT_API
    #endif
    
    // 高性能数据处理
    EXPORT_API void ProcessVertices(float* vertices, int count, float scale) {
        // 使用SIMD优化
        #ifdef __AVX__
        __m256 scaleVec = _mm256_set1_ps(scale);
        
        for (int i = 0; i < count; i += 8) {
            __m256 data = _mm256_loadu_ps(&vertices[i]);
            data = _mm256_mul_ps(data, scaleVec);
            _mm256_storeu_ps(&vertices[i], data);
        }
        #else
        // 降级版本
        for (int i = 0; i < count; i++) {
            vertices[i] *= scale;
        }
        #endif
    }
    
    // 回调到C#
    typedef void (*DebugCallback)(const char* message);
    static DebugCallback gDebugCallback = nullptr;
    
    EXPORT_API void SetDebugCallback(DebugCallback callback) {
        gDebugCallback = callback;
    }    
    EXPORT_API void TriggerEvent() {
        if (gDebugCallback) {
            gDebugCallback("Event from native code!");
        }
    }
    
    // 异步操作
    #include <thread>
    #include <queue>
    #include <mutex>
    
    struct Task {
        float* data;
        int count;
        void (*callback)(float* result, int count);
    };
    
    static std::queue<Task> taskQueue;
    static std::mutex queueMutex;
    static std::thread workerThread;
    static bool running = true;
    
    void WorkerThreadFunc() {
        while (running) {
            Task task;
            {
                std::lock_guard<std::mutex> lock(queueMutex);
                if (!taskQueue.empty()) {
                    task = taskQueue.front();
                    taskQueue.pop();
                } else {
                    continue;
                }
            }            
            // 处理任务
            ProcessVertices(task.data, task.count, 2.0f);
            
            // 回调（注意：不能直接调用Unity API！）
            if (task.callback) {
                task.callback(task.data, task.count);
            }
        }
    }    
    EXPORT_API void InitNativePlugin() {
        workerThread = std::thread(WorkerThreadFunc);
    }    
    EXPORT_API void ShutdownNativePlugin() {
        running = false;
        if (workerThread.joinable()) {
            workerThread.join();
        }
    }
}

// C# 调用Native Plugin
using System.Runtime.InteropServices;
using AOT;

public class NativePluginWrapper {
    // Windows
    #if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
        const string DLL_NAME = "NativePlugin";
    // macOS
    #elif UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
        const string DLL_NAME = "NativePlugin.bundle";
    // Linux
    #elif UNITY_EDITOR_LINUX || UNITY_STANDALONE_LINUX
        const string DLL_NAME = "NativePlugin.so";
    // iOS
    #elif UNITY_IOS
        const string DLL_NAME = "__Internal";
    // Android
    #elif UNITY_ANDROID
        const string DLL_NAME = "NativePlugin";
    #endif
    
    // 导入函数
    [DllImport(DLL_NAME)]
    private static extern void ProcessVertices(float[] vertices, int count, float scale);    
    [DllImport(DLL_NAME)]
    private static extern void SetDebugCallback(DebugCallbackDelegate callback);    
    [DllImport(DLL_NAME)]
    private static extern void InitNativePlugin();    
    [DllImport(DLL_NAME)]
    private static extern void ShutdownNativePlugin();
    
    // 委托定义
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void DebugCallbackDelegate(string message);
    
    // 必须用MonoPInvokeCallback标记（IL2CPP需要）
    [MonoPInvokeCallback(typeof(DebugCallbackDelegate))]
    private static void OnDebugCallback(string message) {
        Debug.Log($"Native: {message}");
    }    
    void Start() {
        InitNativePlugin();
        SetDebugCallback(OnDebugCallback);
    }    
    void OnDestroy() {
        ShutdownNativePlugin();
    }
    
    // 使用Native代码处理数据
    void ProcessMeshData() {
        Mesh mesh = GetComponent<MeshFilter>().mesh;
        Vector3[] vertices = mesh.vertices;
        float[] flatVertices = new float[vertices.Length * 3];
        
        // 展平数据
        for (int i = 0; i < vertices.Length; i++) {
            flatVertices[i * 3 + 0] = vertices[i].x;
            flatVertices[i * 3 + 1] = vertices[i].y;
            flatVertices[i * 3 + 2] = vertices[i].z;
        }
        
        // 调用Native处理（比C#快5-10倍）
        ProcessVertices(flatVertices, flatVertices.Length, 2.0f);
        
        // 恢复数据
        for (int i = 0; i < vertices.Length; i++) {
            vertices[i].x = flatVertices[i * 3 + 0];
            vertices[i].y = flatVertices[i * 3 + 1];
            vertices[i].z = flatVertices[i * 3 + 2];
        }
        
        mesh.vertices = vertices;
        mesh.RecalculateBounds();
    }
}

6. 编辑器工具链开发

#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;

// 自定义构建流程
public class CustomBuildProcessor : IPreprocessBuildWithReport, IPostprocessBuildWithReport {
    public int callbackOrder => 0;
    
    public void OnPreprocessBuild(BuildReport report) {
        Debug.Log($"开始构建: {report.summary.platform}");        
        // 1. 检查资源
        ValidateAssets();        
        // 2. 生成配置文件
        GenerateConfig(report.summary.platform);        
        // 3. 代码注入
        InjectCode();        
        // 4. 资源优化
        OptimizeAssets();
    }
    
    public void OnPostprocessBuild(BuildReport report) {
        Debug.Log($"构建完成: {report.summary.totalTime}");       
        // 1. 生成版本文件
        GenerateVersionFile(report);        
        // 2. 上传到服务器
        if (report.summary.result == BuildResult.Succeeded) {
            UploadBuild(report.summary.outputPath);
        }
    }
    
    void ValidateAssets() {
        // 检查所有材质是否有丢失的纹理
        string[] materials = AssetDatabase.FindAssets("t:Material");
        foreach (string guid in materials) {
            string path = AssetDatabase.GUIDToAssetPath(guid);
            Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
            
            if (mat.mainTexture == null) {
                Debug.LogError($"材质缺少纹理: {path}");
            }
        }
    }
    
    void GenerateConfig(BuildTarget platform) {
        // 根据平台生成配置
        string config = $@"{{
            ""platform"": ""{platform}"",
            ""version"": ""{Application.version}"",
            ""timestamp"": ""{System.DateTime.Now}""
        }}";
        
        System.IO.File.WriteAllText("Assets/Resources/BuildConfig.json", config);
        AssetDatabase.Refresh();
    }    
    void InjectCode() {
        // 使用Roslyn进行代码生成/修改
    }    
    void OptimizeAssets() {
        // 自动压缩纹理、优化模型等
    }    
    void GenerateVersionFile(BuildReport report) {
        // 生成版本记录
    }    
    void UploadBuild(string path) {
        // 上传到CDN或应用商店
    }
}

// 自定义资源导入器
public class CustomTextureImporter : AssetPostprocessor {
    void OnPreprocessTexture() {
        TextureImporter importer = (TextureImporter)assetImporter;
        
        // 根据路径自动设置压缩格式
        if (assetPath.Contains("/UI/")) {
            importer.textureType = TextureImporterType.Sprite;
            importer.spritePixelsPerUnit = 100;
            importer.mipmapEnabled = false;
        } else if (assetPath.Contains("/Terrain/")) {
            importer.textureType = TextureImporterType.Default;
            importer.mipmapEnabled = true;
            importer.maxTextureSize = 2048;
        }        
        // 平台特定设置
        var androidSettings = importer.GetPlatformTextureSettings("Android");
        androidSettings.overridden = true;
        androidSettings.format = TextureImporterFormat.ASTC_6x6;
        importer.SetPlatformTextureSettings(androidSettings);
                
        var iosSettings = importer.GetPlatformTextureSettings("iPhone");
        iosSettings.overridden = true;
        iosSettings.format = TextureImporterFormat.ASTC_6x6;
        importer.SetPlatformTextureSettings(iosSettings);
    }
    
    void OnPostprocessTexture(Texture2D texture) {
        // 后处理纹理
        Debug.Log($"导入纹理: {assetPath}, 大小: {texture.width}x{texture.height}");
    }
}

// 批量工具
public class BatchTools : EditorWindow {
    [MenuItem("Tools/批量工具")]
    static void ShowWindow() {
        GetWindow<BatchTools>("批量工具");
    }    
    void OnGUI() {
        if (GUILayout.Button("批量重命名材质")) {
            BatchRenameMaterials();
        }        
        if (GUILayout.Button("生成LOD")) {
            BatchGenerateLODs();
        }        
        if (GUILayout.Button("优化场景")) {
            OptimizeAllScenes();
        }
    }
    
    void BatchRenameMaterials() {
        string[] guids = AssetDatabase.FindAssets("t:Material", new[] { "Assets/Models" });
        
        foreach (string guid in guids) {
            string path = AssetDatabase.GUIDToAssetPath(guid);
            Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
            
            string newName = $"MAT_{mat.shader.name.Replace("/", "_")}_{mat.name}";
            AssetDatabase.RenameAsset(path, newName);
        }
        
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }    
    void BatchGenerateLODs() {
        // 自动生成LOD
    }    
    void OptimizeAllScenes() {
        // 优化所有场景
    }
}
#endif

当然现在编辑器开发都使用Odin

7. 大规模项目架构

// 依赖注入容器
public class DIContainer {
    private Dictionary<Type, object> singletons = new Dictionary<Type, object>();
    private Dictionary<Type, Func<object>> factories = new Dictionary<Type, Func<object>>();
    
    public void RegisterSingleton<T>(T instance) {
        singletons[typeof(T)] = instance;
    }
    
    public void RegisterFactory<T>(Func<T> factory) {
        factories[typeof(T)] = () => factory();
    }
    
    public T Resolve<T>() {
        Type type = typeof(T);
        
        if (singletons.TryGetValue(type, out object singleton)) {
            return (T)singleton;
        }
        
        if (factories.TryGetValue(type, out Func<object> factory)) {
            return (T)factory();
        }
        
        throw new Exception($"未注册类型: {type}");
    }
    
    // 自动注入
    public void Inject(object target) {
        Type type = target.GetType();
        
        foreach (FieldInfo field in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)) {
            if (field.GetCustomAttribute<InjectAttribute>() != null) {
                object dependency = Resolve(field.FieldType);
                field.SetValue(target, dependency);
            }
        }
    }
}

[AttributeUsage(AttributeTargets.Field)]
public class InjectAttribute : Attribute { }

// 使用示例
public class GameBootstrap : MonoBehaviour {
    private static DIContainer container = new DIContainer();
    
    void Awake() {
        // 注册服务
        container.RegisterSingleton<INetworkService>(new NetworkService());
        container.RegisterSingleton<IDataService>(new DataService());
        container.RegisterFactory<IPoolService>(() => new PoolService());
        
        // 初始化所有系统
        InitializeSystems();
    }
    
    void InitializeSystems() {
        var systems = new ISystem[] {
            new InputSystem(),
            new PhysicsSystem(),
            new RenderSystem(),
            new UISystem()
        };
        
        foreach (var system in systems) {
            container.Inject(system);
            system.Initialize();
        }
    }
}

public class PlayerController : MonoBehaviour {
    [Inject] private INetworkService networkService;
    [Inject] private IDataService dataService;
    
    void Start() {
        // DIContainer自动注入依赖
        FindObjectOfType<GameBootstrap>().GetContainer().Inject(this);
    }
}

// 模块化系统接口
public interface ISystem {
    void Initialize();
    void Update();
    void Shutdown();
}

public interface INetworkService { }
public interface IDataService { }
public interface IPoolService { }

public class NetworkService : INetworkService { }
public class DataService : IDataService { }
public class PoolService : IPoolService { }
public class InputSystem : ISystem {
    public void Initialize() { }
    public void Update() { }
    public void Shutdown() { }
}
public class PhysicsSystem : ISystem {
    public void Initialize() { }
    public void Update() { }
    public void Shutdown() { }
}
public class RenderSystem : ISystem {
    public void Initialize() { }
    public void Update() { }
    public void Shutdown() { }
}
public class UISystem : ISystem {
    public void Initialize() { }
    public void Update() { }
    public void Shutdown() { }
}

---

顶级知识图谱总结

🏆 架构师/引擎级技术
│
├─ 🔬 引擎底层
│ ├─ MonoBehaviour调用机制
│ ├─ Transform矩阵计算
│ ├─ 组件查找原理
│ ├─ 协程状态机实现
│ └─ 对象生命周期管理
│
├─ 💾 底层内存
│ ├─ 内存对齐与布局
│ ├─ 缓存一致性优化
│ ├─ SoA vs AoS
│ ├─ SIMD向量化
│ └─ 栈vs堆的深度理解
│
├─ 🎨 图形深度
│ ├─ 自定义渲染管线
│ ├─ GPU流水线理解
│ ├─ 遮挡剔除算法
│ ├─ Draw Call优化极限
│ └─ CommandBuffer高级技巧
│
├─ 🔧 Native开发
│ ├─ C/C++ Plugin编写
│ ├─ P/Invoke性能优化
│ ├─ 跨平台编译
│ ├─ SIMD汇编优化
│ └─ 多线程同步
│
├─ 🛠️ 工具链
│ ├─ 自定义构建流程
│ ├─ 资源导入管道
│ ├─ 代码生成器
│ ├─ 自动化测试
│ └─ CI/CD集成
│
├─ 🏗️ 企业架构
│ ├─ 依赖注入框架
│ ├─ 模块化设计
│ ├─ 插件系统
│ ├─ 版本管理策略
│ └─ 大型团队协作
│
└─ 🚀 前沿技术
├─ DOTS/ECS深度
├─ 机器学习集成
├─ 光线追踪
├─ 程序化生成
└─ 云游戏架构