ECS架构

1 简介

在当今快速发展的软件开发领域，游戏开发、实时模拟等场景对系统的性能、灵活性和可扩展性提出了极高的要求。传统的面向对象架构在面对复杂且动态变化的实体时，往往会出现代码耦合度高、扩展性差等问题。

ECS（Entity - Component - System，实体 - 组件 - 系统）架构作为一种新兴的DOD架构模式，凭借其独特的设计理念，能够有效解决这些难题，在众多领域得到了广泛的应用。本文将对 ECS 架构进行全面、深入的技术剖析。

ECS 架构核心概念：

实体（Entity）。实体是 ECS 架构中最基础的概念，它代表着游戏或应用中的一个独立个体，例如游戏中的一个角色、一件物品、一个敌人等。从本质上来说，实体本身并没有任何实际的行为和属性，它更像是一个标识符或者说是一个容器，用于关联各个组件。
在实现上，实体通常可以用一个唯一的 ID 来表示，这个 ID 就如同实体的 “身份证”，系统通过这个 ID 来识别和管理不同的实体。
组件（Component）。组件是用于存储数据的结构，它只包含数据，不包含任何行为逻辑。每个组件都对应着实体的某一种特定属性或状态，比如位置组件可以存储实体的坐标信息，速度组件可以存储实体的移动速度，生命值组件可以存储实体的健康状况等。一个实体可以拥有多个不同的组件，这些组件共同构成了实体的完整特征。例如，一个游戏角色实体可以同时拥有位置组件、速度组件、生命值组件和武器组件等。
系统（System）。系统是 ECS 架构中负责处理行为逻辑的部分，它通过操作实体所拥有的组件数据来实现各种功能。系统不会直接作用于实体本身，而是根据实体所拥有的组件类型来筛选出需要处理的实体，并对这些实体的组件数据进行操作。
比如，移动系统会筛选出拥有位置组件和速度组件的实体，然后根据速度组件中的数据来更新位置组件中的坐标信息；碰撞检测系统会筛选出拥有位置组件和碰撞体积组件的实体，通过计算它们的位置和碰撞体积来判断是否发生碰撞。

ECS 架构的工作流程可以简单概括为以下几个步骤：

创建实体：根据业务需求创建相应的实体，并为每个实体分配唯一的 ID。
添加组件：为实体添加所需的组件，组件中包含了实体的具体数据。一个实体可以添加多个不同的组件，以描述其各种属性和状态。
系统处理：各个系统按照自身的逻辑，对拥有特定组件组合的实体进行处理。系统会遍历所有符合条件的实体，读取或修改它们组件中的数据，从而实现各种功能，如移动、碰撞检测、渲染等。
动态更新：在应用运行过程中，可以动态地为实体添加或移除组件，实体的属性和行为也会随之发生变化。同时，系统也可以根据需要进行动态的加载或卸载，以适应不同的场景需求。

2 ECS vs OOP

在传统的面向对象架构中，一个对象通常同时包含数据和行为。例如，一个 “角色” 类会包含角色的位置、生命值等数据，以及移动、攻击等方法。这种架构的优点是符合人们的直觉思维，便于理解和设计简单的系统。然而，当系统变得复杂时，传统面向对象架构会暴露出一些问题。一方面，类之间的继承关系会导致代码耦合度高，一旦父类发生变化，子类可能会受到很大影响，不利于系统的维护和扩展。另一方面，当需要对对象的行为进行修改时，往往需要修改类的内部实现，违反了封装原则。而相比之下ECS 架构优势：

低耦合高内聚：ECS 架构将数据和行为分离，组件只负责存储数据，系统只负责处理行为，实体只是组件的集合。这种分离使得各部分之间的耦合度大大降低，每个部分可以独立地进行开发、测试和维护，提高了代码的内聚性。
更好的可扩展性：在 ECS 架构中，当需要添加新的功能时，只需要添加相应的组件和系统即可，不需要修改现有的实体和其他系统。例如，要给游戏角色添加 “魔法” 属性，只需创建一个 “魔法值” 组件，并为需要的实体添加该组件，再创建一个处理魔法相关行为的系统即可，不会对现有的移动、攻击等系统产生影响。
高效的性能：由于系统只处理拥有特定组件的实体，避免了对无关实体的处理，提高了处理效率。此外，组件的数据存储方式通常是连续的，有利于 CPU 缓存，减少了缓存未命中的情况，从而提升了系统的性能，尤其在处理大量实体的场景下，优势更加明显。
更好的并行性：ECS 架构中，不同的系统处理不同的组件组合，且系统之间没有直接的依赖关系，这使得多个系统可以并行执行，充分利用多核 CPU 的性能，提高系统的运行效率。

实体组件架构（ECS）作为游戏开发等领域常用的架构模式，虽在灵活性和性能方面有一定优势，但也存在不少缺点：

学习和理解门槛较高。相比传统的面向对象架构，ECS 的思维模式有很大差异，它将实体、组件、系统进行了明确分离，这种分离式的设计理念对于习惯了类继承和对象封装的开发者来说，需要花费较多时间去适应和掌握。开发者不仅要理解三者各自的职责，还要搞清楚它们之间的交互机制，比如系统如何通过组件来操作实体，实体如何动态添加或移除组件等，这无疑增加了团队的学习成本，尤其是对于新手开发者，可能需要更长时间才能熟练运用；
调试和排查问题难度大。在 ECS 中，实体的状态由多个组件共同决定，而系统则是对组件进行操作的逻辑单元。当某个实体出现异常行为时，问题可能并非集中在某一个地方，而是分散在多个相关的组件和系统中。例如，一个角色移动异常，可能是移动组件的数据错误，也可能是物理系统的计算出现问题，还可能是输入系统传递的指令有误。开发者需要逐一检查相关的组件数据和系统逻辑，这比在面向对象架构中直接跟踪一个对象的方法调用要复杂得多，大大增加了调试的时间和难度。
可能存在缓存利用率低的问题。在 ECS 中，组件通常是按照类型进行存储的，系统在处理实体时，需要遍历具有特定组件组合的实体集合。如果实体的组件分布较为零散，或者系统需要频繁访问不同类型的组件，就可能导致 CPU 缓存命中率降低。因为 CPU 缓存是基于局部性原理工作的，当数据在内存中不连续时，缓存加载会变得频繁且低效，从而影响系统的运行性能。尤其是在大型项目中，实体和组件数量众多，这种缓存问题可能会更加明显，需要开发者进行大量的优化工作才能缓解。
对复杂行为的支持不足。虽然 ECS 架构在处理简单的实体行为时非常高效，但对于一些复杂的行为逻辑，可能需要设计多个系统来协同工作，这会导致系统之间的依赖关系变得复杂。比如，一个角色的攻击行为可能涉及到输入系统、动画系统、碰撞检测系统等多个系统的配合，这种多系统协作的方式在设计和实现上都比较繁琐，容易引入错误。
对小型项目来说可能过于复杂。对于一些功能简单、实体和逻辑较少的小型项目，ECS 架构可能显得过于重量级。采用 ECS 需要设计大量的组件和系统，搭建相应的框架结构，这会增加不必要的开发工作量。相比之下，传统的面向对象架构能够以更简洁的方式实现项目需求，开发效率更高，因此在小型项目中，ECS 的优势难以体现，反而会暴露其复杂性的缺点。

3 实战

用ECS实现2D场景下物体移动效果，效果如下图所示，下图中红色小球是通过键盘控制移动的，其他物体是自由下落循环播放。
在这里插入图片描述

Demo地址 Github-ECS

实体
ECS中的Entity只是一个标记记号，用来标识不同的实体，实际中的具体实例是Entity标记和Component共同组成的。

using Entity = std::uint32_t;
constexpr static inline std::size_t kMaxEntities = 4096;using ComponentType = std::uint8_t;
constexpr static inline ComponentType kMaxComponents = 128;
using Signature = std::bitset<kMaxComponents>;

组件
组件就是具体的属性，通常只是一个简单的数据结构。我们的场景中要处理物体的移动，键盘响应等事件，那么对应的组件就有：

Player 组件: 存储玩家的状态，场景比较简单，因此只创建一个空组件用来标识玩家。

struct Player{};

Transform 组件: 存储实体的位置、旋转和缩放。

struct Transform{glm::vec3 position;glm::vec3 rotation;glm::vec3 scale;
};

Velocity 组件: 存储实体的速度。

struct Velocity {glm::vec3 speed;
};

Keyboard组件：存储玩家的键盘输入状态。键盘组件可有可无，根据场景需要来定，也可通过其他方式实现。

using KeyType = unsigned int;
struct KeyBoard {//simply a key codeKeyType keyCode;
};

Render组件：存储实体的渲染信息。当前场景只需要处理颜色相关数据。

struct RenderColor{float r;float g;float b;float a;
};

系统
系统就是处理具体事件的地方，和具体的事务强绑定。根据目标简单的拆解，相关的系统有：

窗口管理系统 (WindowSystem):负责创建和管理窗口。
键盘输入系统 (KeyboardSystem):处理键盘输入，控制玩家（红色小球）的移动。
渲染系统 (RenderSystem):负责渲染所有实体，包括玩家和自由下落的物体。
玩家控制系统 (PlayerControlSystem):处理红色小球的移动逻辑。
自由下落系统 (FallingObjectSystem):处理其他物体的下落逻辑。

这里的实现只是简单的利用set不考虑内存优化。

class SystemStoratge{
protected:std::set<Entity> _entities;
};class ISystem{
public:virtual void init() = 0;virtual void tick(float dt) = 0;virtual ~ISystem() = default;virtual bool isRunning() const = 0;virtual void destroy() = 0;virtual void erase(Entity entity) = 0;virtual void insert(Entity entity) = 0;
};class System : public SystemStoratge, public ISystem{
public:virtual bool isRunning() const {return true;}virtual void init() override {}virtual void tick(float dt) override {}virtual void destroy() override {}virtual void erase(Entity entity) override {_entities.erase(entity);}virtual void insert(Entity entity) override {_entities.insert(entity);}};

系统具体实现中，通常会遍历所有实体，根据实体的组件来判断是否需要处理。

void PlayerSystem::tick(float dt) {for(const auto& entity : _entities) {try {auto& player = g_worldManager->getComponent<Player>(entity);auto& transform = g_worldManager->getComponent<Transform>(entity);auto& keyboard = g_worldManager->getComponent<KeyBoard>(entity);if(keyboard.keyCode != 0){if (keyboard.keyCode == GLFW_KEY_W) {transform.position.y += 0.1f; // Move forward} else if (keyboard.keyCode == GLFW_KEY_S) {transform.position.y -= 0.1f; // Move backward} else if (keyboard.keyCode == GLFW_KEY_A) {transform.position.x -= 0.1f; // Move left} else if (keyboard.keyCode == GLFW_KEY_D) {transform.position.x += 0.1f; // Move right}LOGI("Player {} moved to position[{}, {}, {}]", (int)entity, transform.position.x, transform.position.y, transform.position.z);keyboard.keyCode = 0; // Reset key code after processing}//LOGI("Player {} moved to position[{}, {}, {}]", entity, transform.position.x, transform.position.y, transform.position.z);} catch (const std::exception& e) {LOGE("Error processing entity {}: {}", (int)entity, e.what());}}
}

Manager
到此为止我们只是定义了ECS架构中最基本的组件，似乎还是没办法很清晰的认识到不同组件的作用。为了方便管理不同System-Entity，我们引入ComponentManager,EntityManager,SystemManager来分别管理组件，实体，系统，最后使用WorldManager统一管理三者。

EntityManager 类负责管理实体的生命周期和组件签名。它允许创建和销毁实体，并为每个实体存储其组件的签名，以便于系统识别实体的特性。其中签名是一个bitset用来标识当前Entity包含哪些组件。

Entity EntityManager::createEntity() {if (!availableEntities.empty()) {Entity entity = availableEntities.front();availableEntities.pop();return entity;}if (currentEntity >= kMaxEntities) {throw std::runtime_error("Maximum number of entities reached.");}return currentEntity++;
}void EntityManager::destroyEntity(Entity entity) {if (entity >= currentEntity) {throw std::runtime_error("Entity does not exist.");}signatures[entity].reset(); // 清除该实体的签名availableEntities.push(entity); // 将实体加入可用池
}void EntityManager::setSignature(Entity entity, Signature signature) {if (entity >= currentEntity) {throw std::runtime_error("Entity does not exist.");}signatures[entity] = signature;
}Signature EntityManager::getSignature(Entity entity) const {if (entity >= currentEntity) {throw std::runtime_error("Entity does not exist.");}return signatures[entity];
}

ComponentArray 类负责管理组件数组。用来存储当前组件都有哪些Entity持有，同时保存正反向索引来加速访问。

template<typename T>
class ComponentArray : public IComponentArray {
public:void insert(Entity entity, T component) {assert(_entityToIndexMap.find(entity) == _entityToIndexMap.end() && "Component added to the same entity more than once.");// Put new entry at endsize_t newIndex = _size;_entityToIndexMap[entity] = newIndex;_indexToEntityMap[newIndex] = entity;_componentArray[newIndex] = component;++_size;}//省略部分代码......private:std::array<T, kMaxEntities> _componentArray{};std::unordered_map<Entity, size_t> _entityToIndexMap{};std::unordered_map<size_t, Entity> _indexToEntityMap{};size_t _size{0}; // 当前存储的大小
};

ComponentManager 类负责管理组件类型。用来注册组件类型，同时根据组件类型获取对应的ComponentArray。

class ComponentManager {
public:template<typename T>void registerComponent(){static_assert(std::is_standard_layout_v<T>, "Component must be standard layout.");static_assert(sizeof(T) > 0, "Component must have size.");const char* typeName = typeid(T).name();if (_componentTypes.find(typeName) != _componentTypes.end()) {throw std::runtime_error("Component type already registered.");}_componentTypes[typeName] = _componentTypes.size();_componentStorages[typeName] = std::make_shared<ComponentArray<T>>();}template<typename T>void add(Entity entity, T component){getComponentArray<T>()->insert(entity, component);}//省略部分代码......private:template<typename T>std::shared_ptr<ComponentArray<T>> getComponentArray(){const char* typeName = typeid(T).name();assert(_componentTypes.find(typeName) != _componentTypes.end() && "Component not registered before use.");return std::static_pointer_cast<ComponentArray<T>>(_componentStorages[typeName]);}private:std::unordered_map<const char*, ComponentType> _componentTypes;std::unordered_map<const char*, std::shared_ptr<IComponentArray>> _componentStorages;
};

SystemManager要简单的多主要就是管理系统。

class SystemManager{
public:template<typename T, typename... Args>std::shared_ptr<T> registerSystem(Args&&... args) {const char* typeName = typeid(T).name();assert(_systems.find(typeName) == _systems.end() && "Registering system more than once.");auto system = std::make_shared<T>(std::forward<Args>(args)...);_systems.insert({typeName, system});return system;}template<typename T>void setSignature(Signature signature) {const char* typeName = typeid(T).name();assert(_systems.find(typeName) != _systems.end() && "System used before registered.");_signatures.insert({typeName, signature});}//省略部分代码...............private:std::unordered_map<const char*, std::shared_ptr<ISystem>> _systems;std::unordered_map<const char*, Signature> _signatures; // 系统签名
};

最后是WorldManager，其实现比较简单，只是大多数接口都是调用SystemManager和EntityManager的。

class WorldManager {
public:WorldManager(): _sysManager(std::make_unique<SystemManager>()),_entityManager(std::make_unique<EntityManager>()),_componentManager(std::make_unique<ComponentManager>()) {}~WorldManager() = default;template<typename T, typename... Args>std::shared_ptr<T> registerSystem(Args&&... args) {return _sysManager->registerSystem<T>(std::forward<Args>(args)...);}void initializeAll() {_sysManager->initializeAll();}//省略部分代码...............
private:std::unique_ptr<SystemManager> _sysManager;std::unique_ptr<EntityManager> _entityManager;std::unique_ptr<ComponentManager> _componentManager;
};

比较的组件都有了，下一步需要的就是将他们组合起来。首先是需要注册我们即将用到的System和组件。

void RegisterComponents() {g_worldManager->registerComponent<Player>();g_worldManager->registerComponent<Transform>();g_worldManager->registerComponent<KeyBoard>();g_worldManager->registerComponent<RenderColor>();g_worldManager->registerComponent<Velocity>();
}void RegisterSystems() {//省略部分代码................auto renderSystem = g_worldManager->registerSystem<RenderSystem>();{Signature signature;signature.set(g_worldManager->getComponentType<Transform>());signature.set(g_worldManager->getComponentType<RenderColor>());g_worldManager->setSystemSignature<RenderSystem>(signature);}}

然后是创建实例。

void CreatePlayerEntity() {auto playerSystem = g_worldManager->registerSystem<PlayerSystem>();{Signature signature;signature.set(g_worldManager->getComponentType<Player>());signature.set(g_worldManager->getComponentType<Transform>());signature.set(g_worldManager->getComponentType<KeyBoard>());signature.set(g_worldManager->getComponentType<RenderColor>());g_worldManager->setSystemSignature<PlayerSystem>(signature);}Entity playerEntity = g_worldManager->createEntity();g_worldManager->addComponent(playerEntity, Player{});g_worldManager->addComponent(playerEntity, Transform{ glm::vec3(0.0f), glm::vec3(0.0f), glm::vec3(1.0f) });g_worldManager->addComponent(playerEntity, KeyBoard{ 0 }); // Initialize with a default key codeg_worldManager->addComponent(playerEntity, RenderColor{ 1.0f, 0.0f, 0.0f, 1.0f }); // Red color
}

使用时需要根据Entity来获取当前Entity对应的组件并且根据场景进行读取和更新，比如下面渲染系统中读取Player和非Player实体的transform和color进行渲染。

void RenderSystem::tick(float dt) {// This is where rendering logic would goglClearColor(0.1, 0.1, 0.1, 1.0);GLint viewport[4];// 获取当前视口glGetIntegerv(GL_VIEWPORT, viewport);glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);for(const auto& entity : _entities) {try {// Example: Get a component and log its dataauto& transform = g_worldManager->getComponent<Transform>(entity);auto& color = g_worldManager->getComponent<RenderColor>(entity);if(g_worldManager->hasComponent<Player>(entity)) {//LOGI("Rendering player entity {} at position [{}, {}, {}]", (int)entity, transform.position.x, transform.position.y, transform.position.z);}else{//LOGI("Rendering entity {} at position [{}, {}, {}]", (int)entity, transform.position.x, transform.position.y, transform.position.z);}//LOGI("Rendering entity {} at position [{}, {}, {}]", (int)entity, transform.position.x, transform.position.y, transform.position.z);{glBindVertexArray(_vao);auto projection = glm::perspective<float>(glm::radians(_camera.zoom()), viewport[3] * 1.0f/viewport[2], 0.1f, 100.0f);const auto view = _camera.getViewMatrix();glm::vec3 pos = glm::vec3(transform.position.x,transform.position.y,1);//draw light source{glm::mat4 model = glm::mat4(1.0f); // make sure to initialize matrix to identity matrix firstmodel = glm::translate(model, pos);model = glm::rotate(model, 0.f, glm::vec3(1.0f, 0.f, 0.f));model = glm::scale(model, glm::vec3(0.1, 0.1, 0.1));_glProgram->use();_glProgram->update("projection", projection);_glProgram->update("view", view);_glProgram->update("color", glm::vec4(color.r, color.b, color.b, color.a));_glProgram->update("model", model);glDrawElements(GL_TRIANGLES, _shape.idxSize(), GL_UNSIGNED_INT, 0);glBindVertexArray(0);}}} catch (const std::exception& e) {LOGE("Error processing entity {}: {}", (int)entity, e.what());}}}