Unity笔记：DOTS入门示例

Unity推出的DOTS技术，通过ECS架构来提高CPU的缓冲命中率，Job System提供方便的多线程代码编写，Burst Compiler编译生成高性能代码。

下面我们分别用普通的方式和DOTS的方式来实现10000个运动的Cube同屏渲染的例子来看下其性能区别。

普通方式

1. 先创建OPPMoveScript.cs来实现Cube的随机旋转和移动：

using UnityEngine;

public class OPPMoveScript : MonoBehaviour
{
    private Vector3 _rotateSpeed;
    private Vector3 _moveSpeed;
    private float _moveDistance;

    private Vector3 _origin;
    private float _distanceSqr;

    void Start()
    {
        _rotateSpeed.x = Random.value * 360;
        _rotateSpeed.y = Random.value * 360;
        _rotateSpeed.z = Random.value * 360;

        _moveSpeed.x = Random.Range(0.5f, 1f);
        _moveSpeed.z = Random.Range(0.5f, 1f);
        _moveSpeed.y = Random.Range(0.5f, 1f);

        _moveDistance = Random.Range(0.5f, 1f) * 5;

        _origin = transform.position;
        _distanceSqr = _moveDistance * _moveDistance;
    }

    void Update()
    {
        transform.Rotate(_rotateSpeed * Time.deltaTime);
        transform.Translate(_moveSpeed * Time.deltaTime);

        if (Vector3.SqrMagnitude(transform.position - _origin) > _distanceSqr)
        {
            _moveSpeed = -_moveSpeed;
        }
    }
}

2. 再创建OPPCreateScript.cs来生成10000个Cube：

using UnityEngine;

public class OPPCreateScript : MonoBehaviour
{
    public int MaxCount = 10000;

    public float RandomNum = 10f;

    void Start()
    {
        GameObject go = Resources.Load<GameObject>("OPP/Prefabs/OPPCube");

        for (int i = 0; i < MaxCount; i++)
        {
            Vector3 pos = new Vector3();
            pos.x = Random.value * RandomNum * 2 - RandomNum;
            pos.y = Random.value * RandomNum * 2 - RandomNum;
            pos.z = Random.value * RandomNum * 2 - RandomNum;
            GameObject.Instantiate(go, pos, Quaternion.LookRotation(Vector3.forward));
        }
    }
}

最终效果如下：

整体的实现非常简单，需要注意的是Material里开启GPU Instancing，这样可以对Cube进行合批。

可以看到在我的机器上CPU的开销大概在100ms左右。

DOTS方式

在开始实现效果之前，我们需要先知道该如何使用DOTS在场景中创建一个Cube。

尽管在ECS中，提供了ConvertToEntity的脚本，只要简单的挂到普通的GameObject之上，就可以将其转换为对应的Entity对象，但是由于其内部使用了大量的反射导致存在性能问题所以在实际项目中基本上不会采用该方式来开发。

所以下面我们会使用ECS的方式来创建该Cube。

创建一个Cube

ECS中，Component是存放数据的地方，所以我们需要将Cube的信息添加到Component里，而System是处理所有数据的地方。由于我们只是要显示一个Cube，Unity已经提供了我们所需要的Component和System，所以我们只要创建一个Entity并且设置好对应的数据即可。

注：DOTS中显示一个3D对象至少需要LocalToWorld、RenderMesh和RenderBounds这3个Component。

LocalToWorld存放的是旋转和位置数据，RenderMesh存放渲染所需的mesh和material等数据，RenderBounds则存放AABB盒的信息。

其中mesh和material需要从资源中获取，所以我们提前编写一个类AssetHolder，并且创建对应的Prefab将mesh和material设置好。

using UnityEngine;

public class AssetHolder : MonoBehaviour
{
    public Mesh mesh;

    public Material material;
}

接下来我们创建一个脚本用来添加Cube：

using Unity.Entities;
using Unity.Mathematics;
using Unity.Rendering;
using Unity.Transforms;
using UnityEngine;

public class SimpleECSCreateScript : MonoBehaviour
{
    void Start()
    {
        AssetHolder assetHolder = Resources.Load<GameObject>("AssetHolder").GetComponent<AssetHolder>();
        Mesh mesh = assetHolder.mesh;
        Material material = assetHolder.material;

        //获取默认的World和EntityManager
        World world = World.DefaultGameObjectInjectionWorld;
        EntityManager entityManager = world.EntityManager;
        //创建Cube需要的所有Component对应的类型集合
        EntityArchetype archetype = entityManager.CreateArchetype(
            ComponentType.ReadOnly<LocalToWorld>(),
            ComponentType.ReadOnly<RenderMesh>(),
            ComponentType.ReadWrite<RenderBounds>()
        );
        //创建Entity
        Entity entity = entityManager.CreateEntity(archetype);
        //为Entity设置数据
        entityManager.SetComponentData(entity, new LocalToWorld()
        {
            Value = new float4x4(rotation: quaternion.identity, translation: new float3(0, 0, 0))
        });
        entityManager.SetSharedComponentData(entity, new RenderMesh()
        {
            mesh = mesh,
            material = material
        });
        entityManager.SetComponentData(entity, new RenderBounds()
        {
            Value = new AABB()
            {
                Center = new float3(0, 0, 0),
                Extents = new float3(0.5f, 0.5f, 0.5f)
            }
        });
    }
}

运行起来后，可以在Game和Scene中看到一个红色的Cube，但是在Hierarchy中是看不到的，因为Entity不是GameObject。

实现10000个Cube同屏运动

知道怎么创建一个Cube并显示后，就可以实现10000个Cube同屏运动的效果了，在此之前，有几个需要注意的地方先说一下：

1. 由于是我们自己的效果，就得编写自己的Component和System来实现逻辑；
2. System类只要存在，就默认会自己创建并添加到World中执行，也就是说我们只需要创建System类并编写好代码即可，游戏一运行该System类就会自己创建并执行；但是一般来说，我们还是希望自己控制System的生命周期，所以我们一般会添加不自动创建的标签[DisableAutoCreation]来取消其自动创建的特性；
3. World中会存在默认的几个System，我们自己实现的System如果要执行OnUpdate方法，就必须添加到这几个默认的System中的某一个里，这里我们会添加到SimulationSystemGroup中；

好了，下面直接上代码：

1. ECSMoveData.cs，这里记录我们会用到的数据信息：

using Unity.Entities;
using Unity.Mathematics;

public struct ECSMoveData : IComponentData
{
    public float3 rotateSpeed;
    public float3 moveSpeed;
    public float moveDistance;

    public float3 origin;
    public float distanceSqr;
}

2. ECSMoveSystem.cs，这里包含了所有Entity的创建和运动的逻辑：

using Unity.Entities;
using Unity.Mathematics;
using Unity.Rendering;
using Unity.Transforms;
using UnityEngine;
using Random = UnityEngine.Random;

[DisableAutoCreation]
public class ECSMoveSystem : SystemBase
{
    private Mesh _mesh;
    private Material _material;

    private EntityManager _entityManager;
    private EntityArchetype _archetype;

    private Entity[] _entities;

    protected override void OnCreate()
    {
        base.OnCreate();

        AssetHolder assetHolder = Resources.Load<GameObject>("AssetHolder").GetComponent<AssetHolder>();
        _mesh = assetHolder.mesh;
        _material = assetHolder.material;

        World world = World.DefaultGameObjectInjectionWorld;
        _entityManager = world.EntityManager;

        _archetype = _entityManager.CreateArchetype(
            ComponentType.ReadOnly<LocalToWorld>(),
            ComponentType.ReadOnly<RenderMesh>(),
            ComponentType.ReadWrite<RenderBounds>(),
            ComponentType.ReadOnly<Translation>(),
            ComponentType.ReadOnly<Rotation>(),
            ComponentType.ReadOnly<ECSMoveData>()
        );
    }

    public void CreateAllEntity(int maxCount, float randomNum)
    {
        _entities = new Entity[maxCount];
        for (int i = 0; i < maxCount; i++)
        {
            float x = Random.value * randomNum * 2 - randomNum;
            float y = Random.value * randomNum * 2 - randomNum;
            float z = Random.value * randomNum * 2 - randomNum;
            _entities[i] = CreateEntity(x, y, z);
        }
    }

    private Entity CreateEntity(float x, float y, float z)
    {
        Entity entity = _entityManager.CreateEntity(_archetype);
        _entityManager.SetComponentData(entity, new LocalToWorld()
        {
            Value = new float4x4(rotation: quaternion.identity, translation: new float3(0, 0, 0))
        });
        _entityManager.SetSharedComponentData(entity, new RenderMesh()
        {
            mesh = _mesh,
            material = _material
        });
        _entityManager.SetComponentData(entity, new RenderBounds()
        {
            Value = new AABB()
            {
                Center = new float3(0, 0, 0),
                Extents = new float3(0.5f, 0.5f, 0.5f)
            }
        });
        _entityManager.SetComponentData(entity, new Translation()
        {
            Value = new float3(x, y, z)
        });
        _entityManager.SetComponentData(entity, new Rotation()
        {
            Value = quaternion.identity
        });
        float moveDistance = Random.Range(0.5f, 1f) * 5;
        _entityManager.SetComponentData(entity, new ECSMoveData()
        {
            rotateSpeed = new float3(Random.value * math.PI * 2, Random.value * math.PI * 2, Random.value * math.PI * 2),
            moveSpeed = new float3(Random.Range(0.5f, 1f), Random.Range(0.5f, 1f), Random.Range(0.5f, 1f)),
            moveDistance = moveDistance,
            origin = new float3(x, y, z),
            distanceSqr = moveDistance * moveDistance
        });
        return entity;
    }

    protected override void OnUpdate()
    {
        float deltaTime = Time.DeltaTime;
        Entities.ForEach((ref ECSMoveData moveData, ref Translation translation, ref Rotation rotation) =>
        {
            rotation.Value = math.mul(math.normalize(rotation.Value),
                quaternion.AxisAngle(moveData.rotateSpeed, deltaTime));

            translation.Value += new float3(moveData.moveSpeed.x * deltaTime, moveData.moveSpeed.y * deltaTime,
                moveData.moveSpeed.z * deltaTime);

            if (math.distancesq(translation.Value, moveData.origin) > moveData.distanceSqr)
            {
                moveData.moveSpeed = -moveData.moveSpeed;
            }
        }).Schedule();
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();

        for (int i = 0; i < _entities.Length; i++)
        {
            _entityManager.DestroyEntity(_entities[i]);
        }
    }
}

3. ECSCreateScript.cs，这里创建System并添加到World中执行：

using Unity.Entities;
using UnityEngine;

public class ECSCreateScript : MonoBehaviour
{
    public int MaxCount = 10000;

    public float RandomNum = 10f;

    void Start()
    {
        World world = World.DefaultGameObjectInjectionWorld;
        ECSMoveSystem moveSystem = world.GetOrCreateSystem<ECSMoveSystem>();
        moveSystem.CreateAllEntity(MaxCount, RandomNum);
        SimulationSystemGroup systemGroup = world.GetOrCreateSystem<SimulationSystemGroup>();
        systemGroup.AddSystemToUpdateList(moveSystem);
    }
}

最终效果如下：

可以看到，通过DOTS的实现，同样的效果CPU开销只有12ms左右，性能提升是上面普通方式实现的10倍。