游戏客户端架构 / 系统课时

哪些接口可以保持跨引擎一致

哪些接口可以保持跨引擎一致

跨引擎迁移对象池时,真正值得保留的不是某个引擎的对象类型,而是池本身稳定的行为语义。把获取、归还、状态重置、容量准备和清理抽成固定接口,业务层就能在更换引擎后继续使用同一套调用方式。

学习目标

  • 判断哪些对象池能力适合作为跨引擎稳定接口
  • 用统一生命周期约束获取、归还与状态重置
  • 区分业务接口与只应留在池内部的实现细节

先固定行为语义,而不是引擎类型

Unity 的对象可能是 GameObject,其他引擎可能使用节点、实体、Actor 或自定义句柄。若接口直接暴露某个引擎的类型、场景树操作或销毁函数,迁移时上层代码仍然要整体重写。

更稳定的抽象是描述对象池自身能做什么:Acquire 获取可用对象,Release 归还对象,EnsureCapacity 提前准备容量,Clear 清理池;对象自身再通过统一生命周期接口完成取出与归还时的状态重置。

跨引擎对象池稳定接口与对象生命周期关系

用一套接口覆盖稳定能力

下面示例使用 C# 构造一个不依赖具体游戏引擎的最小对象池。示例可以直接作为控制台程序运行,重点观察业务代码只使用池接口,而不会调用任何引擎 API。

csharp
using System;
using System.Collections.Generic;

public interface IPoolResettable
{
    void ResetForAcquire();
    void ResetForRelease();
}

public interface IObjectPool<T> where T : class, IPoolResettable
{
    T Acquire();
    void Release(T instance);
    void EnsureCapacity(int minimumCapacity);
    void Clear();
    int InactiveCount { get; }
}

public sealed class ObjectPool<T> : IObjectPool<T> where T : class, IPoolResettable
{
    private readonly Stack<T> inactive = new();
    private readonly Func<T> factory;

    public ObjectPool(Func<T> factory, int initialCapacity)
    {
        this.factory = factory;
        EnsureCapacity(initialCapacity);
    }

    public int InactiveCount => inactive.Count;

    public T Acquire()
    {
        T instance = inactive.Count > 0 ? inactive.Pop() : factory();
        instance.ResetForAcquire();
        return instance;
    }

    public void Release(T instance)
    {
        instance.ResetForRelease();
        inactive.Push(instance);
    }

    public void EnsureCapacity(int minimumCapacity)
    {
        while (inactive.Count < minimumCapacity)
            inactive.Push(factory());
    }

    public void Clear()
    {
        inactive.Clear();
    }
}

public sealed class Bullet : IPoolResettable
{
    public int Id { get; init; }
    public bool Active { get; private set; }
    public int Damage { get; private set; }

    public void ResetForAcquire()
    {
        Active = true;
        Damage = 100;
    }

    public void ResetForRelease()
    {
        Active = false;
        Damage = 0;
    }
}

public static class Program
{
    public static void Main()
    {
        int nextId = 0;
        var pool = new ObjectPool<Bullet>(
            () => new Bullet { Id = ++nextId },
            initialCapacity: 1);

        pool.EnsureCapacity(2);
        Bullet bullet = pool.Acquire();
        Console.WriteLine($"acquire #{bullet.Id} active={bullet.Active} damage={bullet.Damage}");

        pool.Release(bullet);
        Console.WriteLine($"released active={bullet.Active} damage={bullet.Damage}");
        Console.WriteLine($"inactive={pool.InactiveCount}");

        pool.Clear();
        Console.WriteLine($"after clear inactive={pool.InactiveCount}");
    }
}

预期输出:

text
acquire #2 active=True damage=100
released active=False damage=0
inactive=2
after clear inactive=0

这里的 ResetForAcquire 和 ResetForRelease 很重要。对象池只负责生命周期调度,不需要知道子弹究竟要重置血量、动画、物理速度还是临时引用,因此这些业务状态不会反向污染池实现。

扩容接口只表达目标容量

跨引擎接口应尽量描述“目标”,不要规定底层“怎样扩”。例如 EnsureCapacity(50) 表示希望至少准备 50 个空闲对象,但具体实现可以一次创建完,也可以根据平台性能预算分帧创建。

同样,不宜把 Instantiate、Destroy、SetActive、SpawnActor 等名字提升为公共池接口。它们描述的是某个引擎怎样创建或激活对象,而不是对象池对业务提供的稳定能力。

清池必须明确清理范围

Clear 看似简单,却最容易在不同实现里产生语义偏差。推荐把它定义为“清理当前池中已经归还的空闲对象”,正在使用中的对象仍由持有者负责归还。这样调用方不会因为一次清池突然失去仍在运行的对象。

如果项目还需要“立即销毁全部对象”“场景退出后禁止再次归还”等更强的能力,应另外定义明确的生命周期操作,而不要让同一个 Clear 在不同引擎中表现不同。

最终应该稳定的是获取、归还、重置、容量准备和清理这些业务可观察的行为契约。至于实例怎样创建、怎样挂入场景、怎样隐藏以及最终怎样销毁,都属于下一层的引擎实现细节,不应成为业务代码迁移时必须修改的部分。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

哪些接口可以保持跨引擎一致

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通