Flecs项目中的系统(Systems)详解：从基础到高级应用-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00997/article/details/148464955

Flecs项目中的系统(Systems)详解：从基础到高级应用

flecs flecs是一个高性能、轻量级的C和C++实体组件系统框架，适用于游戏开发和其他需要组织大量数据和行为的应用。它提供了一种模块化的方式构建复杂应用，并优化了CPU缓存利用率。项目地址: https://gitcode.com/gh_mirrors/fl/flecs

什么是Flecs系统？

在Flecs实体组件系统(ECS)框架中，系统(System)是核心的执行单元，它结合了查询(Query)和功能函数(Function)，可以手动运行或作为管道(Pipeline)的一部分被调度执行。系统是ECS架构中"逻辑"部分的实现载体，负责处理匹配特定组件组合的实体。

系统基础用法

系统定义与声明

系统由两部分组成：查询条件和处理函数。以下是一个移动系统的示例，它会遍历所有具有Position和Velocity组件的实体：

// C语言示例
void Move(ecs_iter_t *it) {
    Position *p = ecs_field(it, Position, 0);
    Velocity *v = ecs_field(it, Velocity, 1);

    for (int i = 0; i < it->count; i++) {
        p[i].x += v[i].x;
        p[i].y += v[i].y;
    }
}

// 系统声明
ECS_SYSTEM(world, Move, EcsOnUpdate, Position, [in] Velocity);

在C++中，系统定义更加简洁：

// C++示例
world.system<Position, const Velocity>("Move")
    .each([](Position& p, const Velocity &v) {
        p.x += v.x;
        p.y += v.y;
    });

系统运行方式

系统可以手动运行或自动调度：

// 手动运行系统
ecs_run(world, ecs_id(Move), delta_time, NULL);

// C++中手动运行
sys.run();

或者作为管道的一部分自动运行：

// 运行整个管道
ecs_progress(world, delta_time);

// C++中运行管道
world.progress();

系统迭代机制

系统内部使用查询机制来遍历匹配的实体，迭代方式与普通查询类似但更高效：

// 系统迭代示例
void Move(ecs_iter_t *it) {
    Position *p = ecs_field(it, Position, 0);
    Velocity *v = ecs_field(it, Velocity, 1);

    for (int i = 0; i < it->count; i++) {
        p[i].x += v[i].x * it->delta_time;
        p[i].y += v[i].y * it->delta_time;
    }
}

在C++中，系统提供了两种迭代方式：

// 方式1：each函数，每个实体调用一次
world.system<Position, const Velocity>("Move")
    .each([](Position& p, const Velocity &v) { /* ... */ });

// 方式2：run函数，每个匹配表调用一次
world.system<Position, const Velocity>("Move")
    .run([](flecs::iter& it) {
        while (it.next()) {
            auto p = it.field<Position>(0);
            auto v = it.field<const Velocity>(1);
            for (auto i : it) {
                p[i].x += v[i].x * it.delta_time();
                p[i].y += v[i].y * it.delta_time();
            }
        }
    });

两种方式在性能上没有显著差异，编译器都能进行向量化优化。

时间管理与帧间隔

系统提供了delta_time参数，表示自上一帧以来的时间间隔：

// 使用delta_time实现帧率无关的移动
p[i].x += v[i].x * it->delta_time;
p[i].y += v[i].y * it->delta_time;

在C++中：

world.system<Position, const Velocity>("Move")
    .each([](flecs::iter& it, size_t, Position& p, const Velocity &v) {
        p.x += v.x * it.delta_time();
        p.y += v.y * it.delta_time();
    });

如果progress函数不提供delta_time参数，它会自动测量并计算时间间隔：

world.progress();  // 自动计算delta_time

任务系统(Tasks)

任务系统是不匹配任何实体的特殊系统，适合执行与实体无关的逻辑：

// 打印时间的任务系统
world.system("PrintTime")
    .kind(flecs::OnUpdate)
    .run([](flecs::iter& it) {
        printf("Time: %f\n", it.delta_time());
    });

任务系统也可以查询单例(Singleton)组件：

world.system<Game>("PrintTime")
    .term_at(0).singleton()
    .each([](Game& g) {
        printf("Time: %f\n", g.time);
    });

管道(Pipelines)与系统调度

管道是系统的有序集合，决定了系统执行的顺序和同步点。Flecs提供了内置管道和自定义管道两种方式。

内置管道

内置管道通过阶段(Phase)和依赖关系(DependsOn)来组织系统：

// 系统将依赖于OnUpdate阶段
ECS_SYSTEM(world, Move, EcsOnUpdate, Position, Velocity);

在C++中：

world.system<Position, Velocity>("Move")
    .kind(flecs::OnUpdate)
    .each([](Position& p, Velocity& v) { /* ... */ });

管道会自动分析系统的读写依赖，在适当位置插入同步点，确保数据一致性。

系统执行顺序

默认情况下，系统按实体ID顺序执行以保证确定性。虽然通常系统按声明顺序执行，但不建议依赖此行为。更可靠的方式是：

避免在系统创建期间删除实体
使用自定义管道和显式排序

高级主题

系统分组与排序

可以通过group_by函数对系统进行分组排序：

world.system<Position, Velocity>("GroupedSystem")
    .group_by([](flecs::world_t *world, flecs::entity_t, void *) {
        // 自定义分组逻辑
    });

系统间依赖

系统可以通过读写相同的组件建立隐式依赖关系，Flecs会自动处理这些依赖：

// 系统A写入Position
world.system<Position>("SystemA")
    .write<Position>()
    .each([](Position& p) { /* 修改位置 */ });

// 系统B读取Position，会自动在A之后执行
world.system<const Position>("SystemB")
    .read<Position>()
    .each([](const Position& p) { /* 读取位置 */ });