跳至主要內容

3. 2.5D性能优化

EVOCOSMOS2026/4/14大约 6 分钟

2.5D 性能优化

性能优化不是"让游戏跑得更快"，而是"在目标设备上稳定运行"。本章系统介绍 2.5D 游戏的性能优化策略，从渲染到内存，覆盖最常见的性能瓶颈。

3.1 性能分析：先测量，再优化

优化的第一步是找到真正的瓶颈。Godot 内置了强大的性能分析工具。

使用 Godot Profiler

在编辑器中按 F6 运行游戏，然后打开 调试 > 性能监视器，关注以下指标：

指标说明警戒值
FPS帧率< 60 需要优化
Draw Calls每帧绘制调用次数> 500 需要合批
Vertices顶点数量> 100万需要 LOD
Video RAM显存占用> 设备显存 80%

代码性能测量

C#
using Godot;

public partial class PerformanceMonitor : Node
{
    private float _fpsUpdateTimer = 0f;
    private const float FPS_UPDATE_INTERVAL = 0.5f;

    public override void _Process(double delta)
    {
        _fpsUpdateTimer += (float)delta;
        if (_fpsUpdateTimer >= FPS_UPDATE_INTERVAL)
        {
            _fpsUpdateTimer = 0f;
            LogPerformance();
        }
    }

    private void LogPerformance()
    {
        // 获取各项性能指标
        double fps = Performance.GetMonitor(Performance.Monitor.TimeFps);
        double drawCalls = Performance.GetMonitor(Performance.Monitor.RenderTotalDrawCallsInFrame);
        double videoRam = Performance.GetMonitor(Performance.Monitor.RenderVideoMemUsed);
        double objectCount = Performance.GetMonitor(Performance.Monitor.ObjectCount);

        GD.Print($"FPS: {fps:F1} | DrawCalls: {drawCalls} | VRAM: {videoRam / 1024 / 1024:F1}MB | Objects: {objectCount}");
    }

    // 测量特定代码块的执行时间
    public static void MeasureTime(string label, System.Action action)
    {
        var sw = System.Diagnostics.Stopwatch.StartNew();
        action();
        sw.Stop();
        GD.Print($"[Perf] {label}: {sw.ElapsedMilliseconds}ms");
    }
}

3.2 合批渲染（Batching）

合批渲染是减少 Draw Call 最有效的方法。Draw Call 是 CPU 向 GPU 发出的绘制指令，每次调用都有固定开销。将多个使用相同材质的物体合并成一次绘制，可以大幅提升性能。

MultiMeshInstance3D：大量相同物体的最优解

当场景中有大量相同的物体（如草地、硬币、敌人群）时，MultiMeshInstance3D 是最佳选择。

C#
using Godot;

public partial class CoinField : Node3D
{
    [Export] private Mesh _coinMesh;
    [Export] private int _coinCount = 500;

    private MultiMeshInstance3D _multiMesh;

    public override void _Ready()
    {
        _multiMesh = new MultiMeshInstance3D();
        var mm = new MultiMesh();
        mm.Mesh = _coinMesh;
        mm.TransformFormat = MultiMesh.TransformFormatEnum.Transform3D;
        mm.InstanceCount = _coinCount;

        // 随机放置硬币
        for (int i = 0; i < _coinCount; i++)
        {
            float x = GD.Randf() * 40f - 20f;
            float z = GD.Randf() * 40f - 20f;
            var transform = Transform3D.Identity.Translated(new Vector3(x, 0, z));
            mm.SetInstanceTransform(i, transform);
        }

        _multiMesh.Multimesh = mm;
        AddChild(_multiMesh);
    }

    // 收集硬币（隐藏指定实例）
    public void CollectCoin(int index)
    {
        // 将硬币缩放为 0 来"隐藏"它（比修改 InstanceCount 更高效）
        var transform = Transform3D.Identity.Scaled(Vector3.Zero);
        _multiMesh.Multimesh.SetInstanceTransform(index, transform);
    }
}

3.3 对象池（Object Pool）

频繁创建和销毁节点（如子弹、特效、敌人）会导致内存碎片和 GC 卡顿。对象池预先创建一批对象，用完后归还而不是销毁。

C#
using Godot;
using System.Collections.Generic;

public partial class ObjectPool<T> : Node where T : Node
{
    private readonly PackedScene _scene;
    private readonly Queue<T> _available = new();
    private readonly List<T> _active = new();
    private readonly int _initialSize;

    public ObjectPool(PackedScene scene, int initialSize = 20)
    {
        _scene = scene;
        _initialSize = initialSize;
    }

    public override void _Ready()
    {
        // 预热：提前创建对象
        for (int i = 0; i < _initialSize; i++)
        {
            var obj = CreateNew();
            obj.ProcessMode = ProcessModeEnum.Disabled;
            _available.Enqueue(obj);
        }
    }

    // 从池中获取一个对象
    public T Get(Vector3 position)
    {
        T obj;
        if (_available.Count > 0)
        {
            obj = _available.Dequeue();
        }
        else
        {
            // 池已空，动态扩容
            GD.PrintErr($"[ObjectPool] Pool empty, creating new instance");
            obj = CreateNew();
        }

        if (obj is Node3D node3d)
            node3d.GlobalPosition = position;

        obj.ProcessMode = ProcessModeEnum.Inherit;
        _active.Add(obj);
        return obj;
    }

    // 归还对象到池中
    public void Return(T obj)
    {
        if (!_active.Contains(obj)) return;
        _active.Remove(obj);
        obj.ProcessMode = ProcessModeEnum.Disabled;
        _available.Enqueue(obj);
    }

    private T CreateNew()
    {
        var obj = _scene.Instantiate<T>();
        AddChild(obj);
        return obj;
    }
}

3.4 遮挡剔除（Occlusion Culling）

遮挡剔除是指不渲染被其他物体完全遮挡的物体。在 2.5D 游戏中，这对于有大量层叠元素的场景非常有效。

Godot 4 支持自动遮挡剔除，只需在场景中添加 OccluderInstance3D 节点：

C#
using Godot;

public partial class OcclusionSetup : Node3D
{
    // 为静态建筑物自动生成遮挡体
    public void SetupOccluders()
    {
        foreach (var child in GetChildren())
        {
            if (child is MeshInstance3D mesh && mesh.IsInGroup("static_building"))
            {
                var occluder = new OccluderInstance3D();
                // 使用简化的盒形遮挡体（比精确网格更高效）
                var boxOccluder = new BoxOccluder3D();
                var aabb = mesh.GetAabb();
                boxOccluder.Size = aabb.Size * 0.9f; // 略小于实际大小，避免误剔除
                occluder.Occluder = boxOccluder;
                occluder.Position = aabb.GetCenter();
                mesh.AddChild(occluder);
            }
        }
    }
}

3.5 LOD（细节层次）

LOD（Level of Detail）根据物体与相机的距离，自动切换到更简单的模型，减少远处物体的渲染开销。

C#
using Godot;

public partial class LodController : Node3D
{
    [Export] private MeshInstance3D _highDetailMesh;
    [Export] private MeshInstance3D _lowDetailMesh;
    [Export] private float _lodDistance = 20.0f;

    private Camera3D _camera;

    public override void _Ready()
    {
        _camera = GetViewport().GetCamera3D();
    }

    public override void _Process(double delta)
    {
        if (_camera == null) return;

        float distance = GlobalPosition.DistanceTo(_camera.GlobalPosition);
        bool useHighDetail = distance < _lodDistance;

        _highDetailMesh.Visible = useHighDetail;
        _lowDetailMesh.Visible = !useHighDetail;
    }
}

3.6 内存优化

纹理压缩

纹理是最大的内存消耗来源。在导入设置中选择合适的压缩格式：

平台推荐格式说明
PCS3TC/BC质量好，PC 显卡原生支持
AndroidETC2Android 设备广泛支持
iOSPVRTC/ASTCApple 设备优化
通用ASTC质量最好，现代设备支持

资源懒加载

C#
using Godot;
using System.Collections.Generic;

// 资源管理器：按需加载，避免一次性加载所有资源
public partial class ResourceManager : Node
{
    private static ResourceManager _instance;
    private readonly Dictionary<string, Resource> _cache = new();

    public static ResourceManager Instance => _instance;

    public override void _Ready()
    {
        _instance = this;
    }

    // 同步加载（小资源）
    public T Load<T>(string path) where T : Resource
    {
        if (_cache.TryGetValue(path, out var cached))
            return cached as T;

        var resource = GD.Load<T>(path);
        _cache[path] = resource;
        return resource;
    }

    // 异步加载（大资源，不阻塞主线程）
    public async void LoadAsync<T>(string path, System.Action<T> onComplete) where T : Resource
    {
        if (_cache.TryGetValue(path, out var cached))
        {
            onComplete(cached as T);
            return;
        }

        ResourceLoader.LoadThreadedRequest(path);
        while (ResourceLoader.LoadThreadedGetStatus(path) == ResourceLoader.ThreadLoadStatus.InProgress)
        {
            await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
        }

        var resource = ResourceLoader.LoadThreadedGet(path) as T;
        _cache[path] = resource;
        onComplete(resource);
    }

    // 释放不再需要的资源
    public void Unload(string path)
    {
        _cache.Remove(path);
    }
}

3.7 性能优化清单

在发布游戏前，检查以下优化项：

性能预算

建议为游戏设定性能预算：如"Draw Call 不超过 300，内存不超过 512MB"。每次添加新功能时检查是否超出预算，而不是等到最后再优化。

最近更新:
贡献者: zefeng.peng,bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS