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倍。