UE5 Mass集群系统详解 — 大规模人群模拟解决方案

前言#

在游戏开发中，渲染大量独立个体（如城市人群、动物群体、昆虫群落）一直是性能优化的难题。传统方式下，每个AI角色都是独立的Actor，大规模场景下Draw Call和物理计算会成为灾难。

UE5给出的答案是——Mass。

Mass是Epic官方推出的Entity Component System (ECS) 架构的人群模拟框架，专为大规模集群设计。本文带你从零理解Mass的设计思想，并手把手实现一个简单的集群效果。

什么是Mass？#

Mass是UE5内置的大规模实体模拟框架，核心特点是：

特性	说明
ECS架构	数据与逻辑分离，缓存友好
GPU Driven	支持GPU实例化渲染
可扩展	自定义Fragment处理复杂行为
高性能	单帧可处理数万个实体

简单来说：Mass让你能渲染数万个同时运行的AI单位，而且帧率稳定。

Mass核心概念#

1. Entity（实体）#

一个唯一的ID，标识一个集群单位。不存储任何数据，只是一个Handle。

2. Fragment（片段）#

存储实体的数据，比如：

FTransformFragment — 位置、旋转、缩放
FStaticMeshHashMeshVISet — 渲染数据
自定义Fragment存储AI状态

3. Trait（特征）#

给Entity附加的行为逻辑，比如：

移动行为
状态机
渲染表现

4. Processing（处理）#

每个系统（System）处理特定的Fragment数据，按阶段顺序执行。

项目配置#

启用Mass插件#

在 Edit > Plugins 中启用：

MassEntity — 核心框架
MassSmartObject — 智能物体交互
MassCrowd — 人群可视化（可选）

重启编辑器后生效。

创建Mass处理器的模块#

Mass处理器需要在C++模块中注册。如果你的项目没有Gameplay框架，需要先创建：

1
// .uproject 添加依赖
2
"MassEntity": { "Enabled": true },
3
"MassCrowd": { "Enabled": true }

实战：创建一个简单的集群效果#

步骤1：定义Fragment#

1
#pragma once
2
#include "CoreMinimal.h"
3
#include "MassEntityTypes.h"
4
#include "MyMassFragments.generated.h"
5

6
// 位置和移动数据
7
USTRUCT()
8
struct FMyMovementFragment : public FMassFragment
9
{
10
    GENERATED_BODY()
11

12
    FVector Velocity = FVector::ZeroVector;
13
    float Speed = 100.f;
14
};
15

16
// 外观数据
17
USTRUCT()
18
struct FMyVisualFragment : public FMassFragment
19
{
20
    GENERATED_BODY()
21

22
    UStaticMesh* Mesh = nullptr;
23
    FLinearColor Color = FLinearColor::White;
24
};

步骤2：创建System#

1
#pragma once
2
#include "CoreMinimal.h"
3
#include "MassEntityTypes.h"
4
#include "MassProcessor.h"
5
#include "MyMassSystem.generated.h"
6

7
// 移动处理系统
8
UCLASS()
9
class UMyMovementSystem : public UMassProcessor
10
{
11
    GENERATED_BODY()
12

13
public:
14
    UMyMovementSystem();
15

16
protected:
17
    virtual void ConfigureQueries() override;
18
    virtual void Execute(UMassEntitySubsystem& EntitySubsystem, FMassExecutionContext& Context) override;
19

20
    FMassEntityQuery EntityQuery;
21
};

1
#include "MyMassSystem.h"
2
#include "MyMassFragments.h"
3

4
UMyMovementSystem::UMyMovementSystem()
5
{
6
    ExecutionOrder.ExecuteInGroup = EMassFragmentAccessAlgorithm::Linear;
7
    EntityQuery.AddRequirement<FMyMovementFragment>(EMassFragmentAccess::ReadWrite);
8
}
9

10
void UMyMovementSystem::ConfigureQueries()
11
{
12
    EntityQuery.AddTagRequirement<FMyMovementFragment>(EMassFragmentPresence::All);
13
}
14

15
void UMyMovementSystem::Execute(UMassEntitySubsystem& EntitySubsystem, FMassExecutionContext& Context)
16
{
17
    EntityQuery.ForEachEntityChunk(EntitySubsystem, Context, [this](FMassExecutionContext& Context)
18
    {
19
        TArrayView<FMyMovementFragment> MovementList = Context.GetMutableFragments<FMyMovementFragment>();
20

21
        for (int32 i = 0; i < MovementList.Num(); ++i)
22
        {
23
            FMyMovementFragment& Movement = MovementList[i];
24

25
            // 简单示例：让实体向前移动
26
            FVector Direction = FVector(1.f, 0.f, 0.f);
27
            Movement.Velocity = Direction * Movement.Speed;
28
        }
29
    });
30
}

步骤3：Spawn实体#

1
// 在GameInstance或Actor中
2
void USpawnerComponent::SpawnCluster()
3
{
4
    UWorld* World = GetWorld();
5
    UMassEntitySubsystem* MassSystem = UWorld::GetSubsystem<UMassEntitySubsystem>(World);
6

7
    const int32 ClusterCount = 1000;
8
    FMassEntityManager& EntityManager = MassSystem->GetEntityManager();
9

10
    for (int32 i = 0; i < ClusterCount; ++i)
11
    {
12
        FMassEntityHandle Entity = EntityManager.CreateEntity();
13

14
        FMyMovementFragment Movement;
15
        Movement.Speed = 100.f + FMath::Rand() % 50.f;
16

17
        EntityManager.SetFragmentData(Entity, Movement);
18
    }
19
}

Mass与渲染#

使用InstancedStaticMesh#

最常见的渲染方式是配合 InstancedStaticMeshComponent：

1
// 渲染系统示例
2
void UMyRenderSystem::Execute(UMassEntitySubsystem& EntitySubsystem, FMassExecutionContext& Context)
3
{
4
    TArray<FMatrix> InstanceMatrices;
5
    // ... 填充矩阵数据
6

7
    if (InstancedMesh)
8
    {
9
        InstancedMesh->SetStaticMesh(YourMesh);
10
        InstancedMesh->BuildRuntimeMeshIfNeeded();
11

12
        for (int32 i = 0; i < InstanceMatrices.Num(); ++i)
13
        {
14
            InstancedMesh->SetMatrixAtIndex(i, InstanceMatrices[i]);
15
        }
16
        InstancedMesh->MarkRenderStateDirty();
17
    }
18
}

MassCrowd插件#

如果你只需要简单的人群渲染，可以启用 MassCrowd 插件，它提供了开箱即用的：

基础移动AI
状态机（行走、站立、奔跑）
动画绑定

集群算法：Reynolds’ Boids#

要让集群行为自然，通常使用Boids算法，三条核心规则：

1. 分离（Separation）#

避免碰撞，保持个体间距：

1
FVector Separation(const FMyMovementFragment& Self, const TArray<FMyMovementFragment>& Neighbors)
2
{
3
    FVector Force = FVector::ZeroVector;
4
    for (const auto& Other : Neighbors)
5
    {
6
        float Distance = FVector::Dist(Self.Position, Other.Position);
7
        if (Distance < MinSeparationDistance && Distance > 0)
8
        {
9
            FVector Away = (Self.Position - Other.Position).GetSafeNormal();
10
            Force += Away / Distance;
11
        }
12
    }
13
    return Force;
14
}

2. 对齐（Alignment）#

与邻居速度方向一致：

1
FVector Alignment(const FMyMovementFragment& Self, const TArray<FMyMovementFragment>& Neighbors)
2
{
3
    FVector AverageVelocity = FVector::ZeroVector;
4
    int32 Count = 0;
5
    for (const auto& Other : Neighbors)
6
    {
7
        if (FVector::Dist(Self.Position, Other.Position) < NeightborRadius)
8
        {
9
            AverageVelocity += Other.Velocity;
10
            ++Count;
11
        }
12
    }
13
    return Count > 0 ? (AverageVelocity / Count).GetSafeNormal() : FVector::ZeroVector;
14
}

3. 内聚（Cohesion）#

向邻居中心移动：

1
FVector Cohesion(const FMyMovementFragment& Self, const TArray<FMyMovementFragment>& Neighbors)
2
{
3
    FVector Center = FVector::ZeroVector;
4
    int32 Count = 0;
5
    for (const auto& Other : Neighbors)
6
    {
7
        if (FVector::Dist(Self.Position, Other.Position) < NeightborRadius)
8
        {
9
            Center += Other.Position;
10
            ++Count;
11
        }
12
    }
13
    return Count > 0 ? ((Center / Count) - Self.Position).GetSafeNormal() : FVector::ZeroVector;
14
}

性能优化建议#

优化项	方法
空间分区	使用Grid或Octree减少邻居搜索范围
LOD	远处实体用简化模型或2D sprite
批处理	Fragment数据布局连续，利于缓存命中
Job System	Mass内部已用TaskGraph，可并行处理
GPU计算	对于简单逻辑，考虑使用GPU Buffer

常见问题#

Q: Mass和Niagara有什么区别？#

A: Niagara是粒子特效系统，适合数千个简单粒子。Mass是通用ECS框架，适合需要独立AI逻辑的实体。

Q: 支持动画吗？#

A: 支持！可以用 MassAnimationInstance 配合 Animation Blueprint，或者使用 MassCrowd 的内置动画。

Q: 如何调试？#

A: 启用 MassVisualizer 插件，可以在Editor中可视化实体位置、速度等信息。

总结#

Mass是UE5解决大规模集群问题的利器。核心思想：

ECS架构 — 数据与逻辑分离，利于并行
Fragment自定义 — 灵活扩展，满足各种需求
批量处理 — 利用TaskGraph最大化性能

建议从官方 MassCrowd 插件开始体验，熟悉后再深入自定义System和Fragment。