EntityComponentSystemSamples进阶篇学习笔记

2020-02-12

前言

Advanced示例相比较HelloCube稍微难一些，HelloCube是一些ECS的入门案例，进阶篇的学习更利于实战开发。

1.FixedTimestepWorkaround

效果图

直观的操作感受就是拖动进度条下面一个发射器发射的”子弹”频率会不同，感觉比之前的案例稍微复杂一些，还有UI的交互了，然后UI的交互也就是改变了某个频率的参数而已，并没有那么唬人。

代码

先看上面一个固定频率发射的例子，VariableSpawner还是跟之前的案例一样挂上了ConvertToEntity组件和自定义的VariableRateSpawnerAuthoring脚本。

VariableSpawner

namespace Samples.FixedTimestepSystem.Authoring
{
    [AddComponentMenu("DOTS Samples/FixedTimestepWorkaround/Variable Rate Spawner")]
    [ConverterVersion("joe", 1)]
    public class VariableRateSpawnerAuthoring : MonoBehaviour, IConvertGameObjectToEntity, IDeclareReferencedPrefabs
    {
        public GameObject projectilePrefab;

        public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
        {
            var spawnerData = new VariableRateSpawner
            {
                Prefab = conversionSystem.GetPrimaryEntity(projectilePrefab), //将Prefab转成Entity
            };
            dstManager.AddComponentData(entity, spawnerData);
        }

        public void DeclareReferencedPrefabs(List<GameObject> referencedPrefabs)
        {
            referencedPrefabs.Add(projectilePrefab);
        }
    }
}

上面的代码还是参考上一篇案例中写的，一模一样，没啥特殊的地方，先声明自己的预设，然后将自身转化为实体，然后在System中利用预设实体来不断生成新的实体。

namespace Samples.FixedTimestepSystem
{
    public struct VariableRateSpawner : IComponentData
    {
        public Entity Prefab;
    }

    /// <summary>
    /// 波动生成系统
    /// </summary>
    public class VariableRateSpawnerSystem : ComponentSystem
    {
        protected override void OnUpdate()
        {
            //遍历所有的带有VariableRateSpawner和Translation组件的实体，发送更新命令，在更新命令中为其添加组件，并把数据交给组件存储
            Entities.ForEach((Entity spawnerEntity, ref VariableRateSpawner spawnerData, ref Translation translation) =>
            {
                var spawnTime = (float)Time.ElapsedTime;
                var newEntity = PostUpdateCommands.Instantiate(spawnerData.Prefab);
                PostUpdateCommands.AddComponent(newEntity, new Parent {Value = spawnerEntity});
                PostUpdateCommands.AddComponent(newEntity, new LocalToParent());
                PostUpdateCommands.SetComponent(newEntity, new Translation {Value = new float3(0, 0.3f * math.sin(5.0f * spawnTime), 0)}); //根据时间设置坐标，主要是设置Y的坐标，会显得有波动感
                PostUpdateCommands.SetComponent(newEntity, new ProjectileSpawnTime{SpawnTime = spawnTime});
            });
        }
    }
}

这里把组件和系统一起写了，因为组件太简单了就一条信息，如果有强迫症的话其实是可以分成两个脚本的。这段代码的大概意思就是遍历spawner实体，然后不断生成新的临时的实体，这些临时的实体会移动，这里用到一个新的功能类PostUpdateCommands，它负责将更新命令发送给处理系统，这些更新命令会按照权重缓存起来，然后在主线程中排队执行，Instantiate是实例化Entity，SetComponent是设置组件数据，Translation组件是移动组件，使得Entity能够移动，这里有添加上两个新的组件Parent和LocalToParent，这两个是之前没有接触过的，我们来新学习一下。

/// <summary>
/// 类似原来的Transform组件
/// </summary>
namespace Unity.Transforms
{
    /// <summary>
    /// 父组件，只储存了实体的父实体
    /// </summary>
    [Serializable]
    [WriteGroup(typeof(LocalToWorld))]
    public struct Parent : IComponentData
    {
        public Entity Value;
    }

    /// <summary>
    /// 前任父组件，储存上一任父实体
    /// </summary>
    [Serializable]
    public struct PreviousParent : ISystemStateComponentData
    {
        public Entity Value;
    }

    /// <summary>
    /// 子实体
    /// </summary>
    [Serializable]
    [InternalBufferCapacity(8)]
    [WriteGroup(typeof(ParentScaleInverse))]
    public struct Child : ISystemStateBufferElementData
    {
        public Entity Value;
    }

}

/// <summary>
/// 发射体的生成时间
/// </summary>
[Serializable]
public struct ProjectileSpawnTime : IComponentData
{
    public float SpawnTime;
}

/// <summary>
/// 相对于父实体的本地坐标
/// </summary>
[Serializable]
[WriteGroup(typeof(LocalToWorld))]
public struct LocalToParent : IComponentData
{
    public float4x4 Value;

    public float3 Right => new float3(Value.c0.x, Value.c0.y, Value.c0.z);
    public float3 Up => new float3(Value.c1.x, Value.c1.y, Value.c1.z);
    public float3 Forward => new float3(Value.c2.x, Value.c2.y, Value.c2.z);
    public float3 Position => new float3(Value.c3.x, Value.c3.y, Value.c3.z);
}

Parent组件会引用父级的LocalToWorld，更多相关内容可以查看官方文档)

下面是生成时间的数据组件

/// <summary>
/// 发射体的生成时间组件
/// </summary>
[Serializable]
public struct ProjectileSpawnTime : IComponentData
{
    public float SpawnTime;
}

/// <summary>
/// 发射体生成时间设置
/// </summary>
[RequiresEntityConversion]
public class ProjectileSpawnTimeAuthoring : MonoBehaviour, IConvertGameObjectToEntity
{
    public float SpawnTime;

    public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        var data = new ProjectileSpawnTime { SpawnTime = SpawnTime };
        dstManager.AddComponentData(entity, data);
    }
}

最后一个就是子弹移动系统MoveProjectilesSystem

using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Transforms;

namespace Samples.FixedTimestepSystem
{
    /// <summary>
    /// 发射体移动系统，负责将发射体不断向前移动，并在超出寿命后摧毁实体
    /// </summary>
    public class MoveProjectilesSystem : JobComponentSystem
    {
        [BurstCompile]
        struct MoveProjectileJob : IJobForEachWithEntity<ProjectileSpawnTime, Translation>
        {
            public EntityCommandBuffer.Concurrent Commands;
            public float TimeSinceLoad;
            public float ProjectileSpeed;

            //超过生命周期的实体进行删除，没有超过时间的则向前移动
            public void Execute(Entity entity, int index, [ReadOnly] ref ProjectileSpawnTime spawnTime, ref Translation translation)
            {
                float aliveTime = (TimeSinceLoad - spawnTime.SpawnTime);
                if (aliveTime > 5.0f)
                {
                    Commands.DestroyEntity(index, entity);
                }
                translation.Value.x = aliveTime * ProjectileSpeed;
            }
        }

        BeginSimulationEntityCommandBufferSystem m_beginSimEcbSystem;
        protected override void OnCreate()
        {
            m_beginSimEcbSystem = World.GetOrCreateSystem<BeginSimulationEntityCommandBufferSystem>();
        }

        protected override JobHandle OnUpdate(JobHandle inputDependencies)
        {
            var jobHandle = new MoveProjectileJob()
            {
                Commands = m_beginSimEcbSystem.CreateCommandBuffer().ToConcurrent(),
                TimeSinceLoad = (float)Time.ElapsedTime,
                ProjectileSpeed = 5.0f,
            }.Schedule(this, inputDependencies);
            m_beginSimEcbSystem.AddJobHandleForProducer(jobHandle); //添加任务到待处理

            return jobHandle;
        }
    }
}

FixedSpawner

手动控制发射频率的案例跟上面案例不同之处就在于可以UI上进度条控制Update的频率

using Unity.Entities;
using UnityEngine;
using UnityEngine.UI;

namespace Samples.FixedTimestepSystem
{
    /// <summary>
    /// FixedUpdate中手动更新创建的系统
    /// </summary>
    [AddComponentMenu("DOTS Samples/FixedTimestepWorkaround/Fixed Timestep Updater")]
    public class FixedTimestepUpdater : MonoBehaviour
    {
        FixedRateSpawnerSystem spawnerSystem;
        public Slider fixedTimestepSlider; //控制更新频率的进度条

        Text sliderLabelText;

        void Start()
        {
            sliderLabelText = fixedTimestepSlider.GetComponentInChildren<Text>();
        }

        void FixedUpdate()
        {
            if (spawnerSystem == null)
            {
                spawnerSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem<FixedRateSpawnerSystem>();
            }
            Time.fixedDeltaTime = fixedTimestepSlider.value; //将进度条上的时间赋值给Time.fixedDeltaTime从而来影响系统的Update时间
            sliderLabelText.text = $"Fixed Timestep: {fixedTimestepSlider.value*1000} ms";
            spawnerSystem.Update();
        }
    }
}

using Unity.Entities;
using Unity.Mathematics;
using Unity.Transforms;

namespace Samples.FixedTimestepSystem
{
    public struct FixedRateSpawner : IComponentData
    {
        public Entity Prefab;
    }

    [DisableAutoCreation] //避免在默认世界的初始化期间来创建本系统
    public class FixedRateSpawnerSystem : ComponentSystem
    {
        EntityQuery m_MainGroup; //找出FixedRateSpawner和Translation的实体群
        protected override void OnCreate()
        {
            m_MainGroup = GetEntityQuery(
                ComponentType.ReadOnly<FixedRateSpawner>(),
                ComponentType.ReadOnly<Translation>());
        }

        protected override void OnUpdate()
        {
            Entities.ForEach((Entity spawnerEntity, ref FixedRateSpawner spawnerData, ref Translation translation) =>
            {
                var spawnTime = UnityEngine.Time.time;
                var newEntity = PostUpdateCommands.Instantiate(spawnerData.Prefab);
                PostUpdateCommands.AddComponent(newEntity, new Parent {Value = spawnerEntity});
                PostUpdateCommands.AddComponent(newEntity, new LocalToParent());
                PostUpdateCommands.SetComponent(newEntity, new Translation {Value = new float3(0, 0.3f * math.sin(5.0f * spawnTime), 0)}); //设置实体Y的坐标
                PostUpdateCommands.SetComponent(newEntity, new ProjectileSpawnTime{SpawnTime = spawnTime});
            });
        }
    }
}

主要的代码还是大同小异，这里有一个搜集指定组件的Entity群。GetEntityQuery也有好几种搜索方式，这是其中一种，添加上ComponentType.ReadOnly搜索效率会高一点。
其他查询相关的知识点:

EntityQueryDesc
这里的Desc我们一般会理解为下降，但这里是描述(describe)的意思

var query = new EntityQueryDesc
{
   None = new ComponentType[]{ typeof(Frozen) },
   All = new ComponentType[]{ typeof(RotationQuaternion), ComponentType.ReadOnly<RotationSpeed>() }
}

查询选项
当你创建一个EntityQueryDesc,你还可以设置他的Options 变量. options变量允许进行一些特殊的查询(通常您不需要设置它们):
- Default — 无设置选项;通常的查询行为.
- IncludePrefab — 包括拥有特殊预制标签组件的原型
- IncludeDisabled — 包括拥有特殊禁用标记组件的原型
- FilterWriteGroup — 考虑任何被查询组件的WriteGroup属性

当你设置了 FilterWriteGroup 选项，如果存在一些组件来自于某一个Write Group（写入组），那么只有它们显式地被包含在查询条件中，对应的实体才会包含在视图中，如果某些实体包含位于同一WriteGroup的任何其他组件，它们将会排除在外。{译者注：也就是每一类WriteGroup来说，尽可能同时只允许一个结构来执行访问}

public struct C1: IComponentData{}

[WriteGroup(C1)]
public struct C2: IComponentData{}

[WriteGroup(C1)]
public struct C3: IComponentData{}

var query = new EntityQueryDesc{
    All = new ComponentType{typeof(C1), ComponentType.ReadOnly<C3>()},
    Options = EntityQueryDescOptions.FilterWriteGroup
};
var m_group = GetEntityQuery(query);

组合查询

var query0 = new EntityQueryDesc
{
   All = new ComponentType[] {typeof(RotationQuaternion)}
};

var query1 = new EntityQueryDesc
{
   All = new ComponentType[] {typeof(RotationSpeed)}
};

EntityQuery m_Group = GetEntityQuery(new EntityQueryDesc[] {query0, query1});

创建EntityQuery

1	EntityQuery m_Group = CreateEntityQuery(typeof(RotationQuaternion), ComponentType.ReadOnly<RotationSpeed>());

筛选出数据变化的组件
- Shared component values —根据共享组件的不同数值样本，来筛选实体集
- Change filter — 根据指定类型的组件是否可能已经发生了变化，来筛选实体集

1 2	m_Group = GetEntityQuery(typeof(LocalToWorld), ComponentType.ReadOnly<Translation>()); m_Group.SetFilterChanged(typeof(Translation));

流程图

2.Boids

这个案例向我们展示了大量鱼群（50000）实体的风采，是不是非常的壮观，简直屌爆了，动态效果图见上图gif，关键还能保持70帧率。

效果图

代码

代码主要选一些跟之前案例不一样的挑选看一下，一样的就略过了。

鱼群的共享数据

/// <summary>
/// 大群的共享数据
/// </summary>
[Serializable]
[WriteGroup(typeof(LocalToWorld))]
public struct Boid : ISharedComponentData
{
    /// <summary>
    /// 单元半径
    /// </summary>
    public float CellRadius;
    /// <summary>
    /// 间隔宽度
    /// </summary>
    public float SeparationWeight;
    /// <summary>
    /// 对齐宽度
    /// </summary>
    public float AlignmentWeight;
    /// <summary>
    /// 目标宽度
    /// </summary>
    public float TargetWeight;
    /// <summary>
    /// 排斥距离
    /// </summary>
    public float ObstacleAversionDistance;
    /// <summary>
    /// 移动速度
    /// </summary>
    public float MoveSpeed;
}

/// <summary>
/// 麦克在GDC上面的讲话‘面向数据的方式来使用组件系统’对于开发大群的案例代码来说有非常大的参考价值
/// https://youtu.be/p65Yt20pw0g?t=1446 （这是油管链接，需要翻墙观看，有兴趣的朋友可以在参考）
/// 它解释了这个案例之前版本的实现，但是几乎所有的信息仍然具有参考价值。
/// 目标（2条红鱼）和对手（1条鲨鱼）基于Unity UI里的ActorAnimation（角色动画）栏移动
/// 这样它们才能基于关键帧动画来移动
/// </summary>
namespace Samples.Boids
{
    /// <summary>
    /// S:大群系统，在模拟系统组中更新，在Transform系统组之前更新
    /// </summary>
    [UpdateInGroup(typeof(SimulationSystemGroup))]
    [UpdateBefore(typeof(TransformSystemGroup))]
    public class BoidSystem : JobComponentSystem
    {
        private EntityQuery  m_BoidQuery;//大群实体查询缓存
        private EntityQuery  m_TargetQuery;//目标实体查询缓存
        private EntityQuery  m_ObstacleQuery;//对手实体查询缓存

        /// <summary>
        /// 在这个案例中总共有3个独特的大群变体，各有各的共享组件值
        /// （提示：这包含了在索引0上默认未初始化的值，该值并未被实际用在这个案例中，）
        /// </summary>
        private List<Boid>                               m_UniqueTypes = new List<Boid>(3);
        private List<NativeMultiHashMap<int, int>> m_PrevFrameHashmaps = new List<NativeMultiHashMap<int, int>>();

        /// <summary>
        /// `CopyPositions`和`CopyHeadings`都是为了提取相对位置、导向组件到NativeArrays（原生数组）
        /// 这样它们才能被`MergeCells`（合并单元）和`Steer`（导航）任务随机访问到 （下面是这两个结构体）
        /// </summary>
        [BurstCompile]
        struct CopyPositions : IJobForEachWithEntity<LocalToWorld>
        {
            /// <summary>
            /// 位置，原生数组
            /// </summary>
            public NativeArray<float3> positions;
            /// <summary>
            /// 把本地位置放到原生数组里
            /// </summary>
            /// <param name="entity">实体</param>
            /// <param name="index">索引</param>
            /// <param name="localToWorld">只读本地位置</param>
            public void Execute(Entity entity, int index, [ReadOnly]ref LocalToWorld localToWorld)
            {
                positions[index] = localToWorld.Position;
            }
        }
        //同上
        [BurstCompile]
        struct CopyHeadings : IJobForEachWithEntity<LocalToWorld>
        {
            public NativeArray<float3> headings;

            public void Execute(Entity entity, int index, [ReadOnly]ref LocalToWorld localToWorld)
            {
                headings[index] = localToWorld.Forward;
            }
        }
        /// <summary>
        /// 生成一个哈希表，每一栏里包含了所有大群的索引，其位置量化成同一个值，即提供的单元半径
        /// 这样它们才能被`MergeCells`（合并单元）和`Steer`（导航）任务随机访问到 
        /// </summary>
        [BurstCompile]
        [RequireComponentTag(typeof(Boid))]
        struct HashPositions : IJobForEachWithEntity<LocalToWorld>
        {
            public NativeMultiHashMap<int, int>.ParallelWriter hashMap;
            public float                                       cellRadius;

            public void Execute(Entity entity, int index, [ReadOnly]ref LocalToWorld localToWorld)
            {
                var hash = (int)math.hash(new int3(math.floor(localToWorld.Position / cellRadius)));
                hashMap.Add(hash, index);
            }
        }

        /// <summary>
        /// 合并所有单元
        /// 这里收集了所有单元大群的位置和导向，为了做以下三件事情：
        /// 1.计算每个单元的数量
        /// 2.找到最近的对手并将互相标记为目标
        /// 3.找到包含已收集每个大群单元值的数组索引
        /// </summary>
        [BurstCompile]
        struct MergeCells : IJobNativeMultiHashMapMergedSharedKeyIndices
        {
            public NativeArray<int>                 cellIndices;//单元索引原生数组
            public NativeArray<float3>              cellAlignment;//单元对齐原生数组
            public NativeArray<float3>              cellSeparation;//单元间隔
            public NativeArray<int>                 cellObstaclePositionIndex;//单元对手位置索引
            public NativeArray<float>               cellObstacleDistance;//单元对手距离
            public NativeArray<int>                 cellTargetPositionIndex;//单元目标位置索引
            public NativeArray<int>                 cellCount;//单元数量
            [ReadOnly] public NativeArray<float3>   targetPositions;//目标位置
            [ReadOnly] public NativeArray<float3>   obstaclePositions;//对手位置
            /// <summary>
            /// 循环数组找到最近的位置
            /// </summary>
            /// <param name="targets">目标</param>
            /// <param name="position">位置</param>
            /// <param name="nearestPositionIndex">最近位置索引</param>
            /// <param name="nearestDistance">最近距离</param>
            void NearestPosition(NativeArray<float3> targets, float3 position, out int nearestPositionIndex, out float nearestDistance )
            {
                nearestPositionIndex = 0;
                nearestDistance      = math.lengthsq(position-targets[0]);
                for (int i = 1; i < targets.Length; i++)
                {
                    var targetPosition = targets[i];
                    var distance       = math.lengthsq(position-targetPosition);
                    var nearest        = distance < nearestDistance;

                    nearestDistance      = math.select(nearestDistance, distance, nearest);
                    nearestPositionIndex = math.select(nearestPositionIndex, i, nearest);
                }
                nearestDistance = math.sqrt(nearestDistance);
            }
            /// <summary>
            /// 首先执行：找到最近的对手和目标，并储存单元索引
            /// </summary>
            /// <param name="index"></param>
            public void ExecuteFirst(int index)
            {
                var position = cellSeparation[index] / cellCount[index];

                int obstaclePositionIndex;
                float obstacleDistance;
                NearestPosition(obstaclePositions, position, out obstaclePositionIndex, out obstacleDistance);
                cellObstaclePositionIndex[index] = obstaclePositionIndex;
                cellObstacleDistance[index]      = obstacleDistance;

                int targetPositionIndex;
                float targetDistance;
                NearestPosition(targetPositions, position, out targetPositionIndex, out targetDistance);
                cellTargetPositionIndex[index] = targetPositionIndex;

                cellIndices[index] = index;
            }

            /// <summary>
            /// 其次执行：合计被考虑到的实际索引的对齐和间隔，并保存我们正在保存单元的第一个值的索引
            /// </summary>
            /// <param name="cellIndex">单元索引</param>
            /// <param name="index">索引</param>
            public void ExecuteNext(int cellIndex, int index)
            {
                cellCount[cellIndex]      += 1;
                cellAlignment[cellIndex]  = cellAlignment[cellIndex] + cellAlignment[index];
                cellSeparation[cellIndex] = cellSeparation[cellIndex] + cellSeparation[index];
                cellIndices[index]        = cellIndex;
            }
        }

        /// <summary>
        /// 导航：这里读取之前计算的大群信息，再基于使用标准集群蜂拥算法新计算出来的导向，
        /// 用来更新每一个大群的本地位置
        /// </summary>
        [BurstCompile]
        [RequireComponentTag(typeof(Boid))]
        struct Steer : IJobForEachWithEntity<LocalToWorld>
        {
            public float                                                       dt; 
            [ReadOnly] public Boid                                             settings;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<int>     cellIndices;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<float3>  targetPositions;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<float3>  obstaclePositions;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<float3>  cellAlignment;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<float3>  cellSeparation;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<int>     cellObstaclePositionIndex;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<float>   cellObstacleDistance;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<int>     cellTargetPositionIndex;
            [DeallocateOnJobCompletion] [ReadOnly] public NativeArray<int>     cellCount;

            public void Execute(Entity entity, int index, ref LocalToWorld localToWorld)
            {
                // temporarily storing the values for code readability
                //为了代码的可读性缓存这些值
                var forward                           = localToWorld.Forward;
                var currentPosition                   = localToWorld.Position;
                var cellIndex                         = cellIndices[index];
                var neighborCount                     = cellCount[cellIndex];
                var alignment                         = cellAlignment[cellIndex];
                var separation                        = cellSeparation[cellIndex];
                var nearestObstacleDistance           = cellObstacleDistance[cellIndex];
                var nearestObstaclePositionIndex      = cellObstaclePositionIndex[cellIndex];
                var nearestTargetPositionIndex        = cellTargetPositionIndex[cellIndex];
                var nearestObstaclePosition           = obstaclePositions[nearestObstaclePositionIndex];
                var nearestTargetPosition             = targetPositions[nearestTargetPositionIndex];

                //基于集群模拟算法的导航计算
                var obstacleSteering                  = currentPosition - nearestObstaclePosition;
                var avoidObstacleHeading              = (nearestObstaclePosition + math.normalizesafe(obstacleSteering)
                                                        * settings.ObstacleAversionDistance)- currentPosition;
                var targetHeading                     = settings.TargetWeight
                                                        * math.normalizesafe(nearestTargetPosition - currentPosition);
                var nearestObstacleDistanceFromRadius = nearestObstacleDistance - settings.ObstacleAversionDistance;
                var alignmentResult                   = settings.AlignmentWeight
                                                        * math.normalizesafe((alignment/neighborCount)-forward);
                var separationResult                  = settings.SeparationWeight
                                                        * math.normalizesafe((currentPosition * neighborCount) - separation);
                var normalHeading                     = math.normalizesafe(alignmentResult + separationResult + targetHeading);
                var targetForward                     = math.select(normalHeading, avoidObstacleHeading, nearestObstacleDistanceFromRadius < 0);
                var nextHeading                       = math.normalizesafe(forward + dt*(targetForward-forward));

                //基于新的导向更新本地位置
                localToWorld = new LocalToWorld
                {
                    Value = float4x4.TRS(
                        new float3(localToWorld.Position + (nextHeading * settings.MoveSpeed * dt)),
                        quaternion.LookRotationSafe(nextHeading, math.up()),
                        new float3(1.0f, 1.0f, 1.0f))
                };
            }
        }
        /// <summary>
        /// 停止运行的时候释放上一帧的哈希表
        /// </summary>
        protected override void OnStopRunning()
        {
            for (var i = 0; i < m_PrevFrameHashmaps.Count; ++i)
            {
                m_PrevFrameHashmaps[i].Dispose();
            }
            m_PrevFrameHashmaps.Clear();
        }

        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            EntityManager.GetAllUniqueSharedComponentData(m_UniqueTypes);

            var obstacleCount = m_ObstacleQuery.CalculateEntityCount();
            var targetCount = m_TargetQuery.CalculateEntityCount();

            ///暂时还不能在哈希表上调用释放内存定语（[DeallocateOnJobCompletion]），
            ///所以在这里手动释放上一次迭代循环产生的哈希
            for (int i = 0; i < m_PrevFrameHashmaps.Count; ++i)
            {
                m_PrevFrameHashmaps[i].Dispose();
            }
            m_PrevFrameHashmaps.Clear();

            ///每一个大群的变体代表一个不同的SharedComponentData值，并且是独立的
            ///意味着同一种变体的群只与别的变体群互动。因此这个循环单独处理每一个变体类型
            for (int boidVariantIndex = 0; boidVariantIndex < m_UniqueTypes.Count; boidVariantIndex++)
            {
                var settings = m_UniqueTypes[boidVariantIndex];
                m_BoidQuery.SetFilter(settings);
                var boidCount = m_BoidQuery.CalculateEntityCount();

                if (boidCount == 0)
                {
                    ///如果变体不包含任何大群，则提前跳过当前循环。
                    /// 举个栗子，变体0总是会跳过，因为它代表默认的，未初始化的
                    /// 大群结构体并没有在这个案例里出现
                    continue;
                }

                ///下面计算相邻大群单元之间的空间
                /// 注意：使用的是一个稀疏的网格而不是密集带边界的网格，
                /// 所以这里没有预定义的空间边界
                var hashMap                   = new NativeMultiHashMap<int,int>(boidCount,Allocator.TempJob);

                var cellIndices               = new NativeArray<int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
                var cellObstaclePositionIndex = new NativeArray<int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
                var cellTargetPositionIndex   = new NativeArray<int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);

                var cellCount                 = new NativeArray<int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);

                var cellObstacleDistance      = new NativeArray<float>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
                var cellAlignment             = new NativeArray<float3>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
                var cellSeparation            = new NativeArray<float3>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);

                var copyTargetPositions       = new NativeArray<float3>(targetCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
                var copyObstaclePositions     = new NativeArray<float3>(obstacleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);

                ///接下来的任务全部并行，因为在安排任务的时候同一个JobHandle被传递给它们的输入依赖，
                ///因此它们可以任意顺序运行（或并发运行），并发是它们任务安排的属性，而不是任务结构体本身
                var initialCellAlignmentJob = new CopyHeadings
                {
                    headings = cellAlignment
                };
                var initialCellAlignmentJobHandle = initialCellAlignmentJob.Schedule(m_BoidQuery, inputDeps);

                var initialCellSeparationJob = new CopyPositions
                {
                    positions = cellSeparation
                };
                var initialCellSeparationJobHandle = initialCellSeparationJob.Schedule(m_BoidQuery, inputDeps);

                var copyTargetPositionsJob = new CopyPositions
                {
                    positions = copyTargetPositions
                };
                var copyTargetPositionsJobHandle = copyTargetPositionsJob.Schedule(m_TargetQuery, inputDeps);

                var copyObstaclePositionsJob = new CopyPositions
                {
                    positions = copyObstaclePositions
                };
                var copyObstaclePositionsJobHandle = copyObstaclePositionsJob.Schedule(m_ObstacleQuery, inputDeps);

                ///暂时还不能在哈希表上调用释放内存定语（[DeallocateOnJobCompletion]），
                /// 所以把已解决的哈希添加到列表，这样它们就能在接下来的单元任务中使用了，并且也能直接清除
                m_PrevFrameHashmaps.Add(hashMap);

                // setting up the jobs for position and cell count
                ///为位置和单元数量设置任务
                var hashPositionsJob = new HashPositions
                {
                    hashMap        = hashMap.AsParallelWriter(),
                    cellRadius     = settings.CellRadius
                };
                var hashPositionsJobHandle = hashPositionsJob.Schedule(m_BoidQuery, inputDeps);

                var initialCellCountJob = new MemsetNativeArray<int>
                {
                    Source = cellCount,
                    Value  = 1
                };
                var initialCellCountJobHandle = initialCellCountJob.Schedule(boidCount, 64, inputDeps);

                var initialCellBarrierJobHandle = JobHandle.CombineDependencies(initialCellAlignmentJobHandle, initialCellSeparationJobHandle, initialCellCountJobHandle);
                var copyTargetObstacleBarrierJobHandle = JobHandle.CombineDependencies(copyTargetPositionsJobHandle, copyObstaclePositionsJobHandle);
                var mergeCellsBarrierJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, initialCellBarrierJobHandle, copyTargetObstacleBarrierJobHandle);
                //合并所有单元
                var mergeCellsJob = new MergeCells
                {
                    cellIndices               = cellIndices,
                    cellAlignment             = cellAlignment,
                    cellSeparation            = cellSeparation,
                    cellObstacleDistance      = cellObstacleDistance,
                    cellObstaclePositionIndex = cellObstaclePositionIndex,
                    cellTargetPositionIndex   = cellTargetPositionIndex,
                    cellCount                 = cellCount,
                    targetPositions           = copyTargetPositions,
                    obstaclePositions         = copyObstaclePositions
                };
                var mergeCellsJobHandle = mergeCellsJob.Schedule(hashMap,64,mergeCellsBarrierJobHandle);
                //导航
                var steerJob = new Steer
                {
                    cellIndices               = cellIndices,
                    settings                  = settings,
                    cellAlignment             = cellAlignment,
                    cellSeparation            = cellSeparation,
                    cellObstacleDistance      = cellObstacleDistance,
                    cellObstaclePositionIndex = cellObstaclePositionIndex,
                    cellTargetPositionIndex   = cellTargetPositionIndex,
                    cellCount                 = cellCount,
                    targetPositions           = copyTargetPositions,
                    obstaclePositions         = copyObstaclePositions,
                    dt                        = Time.deltaTime,
                };
                var steerJobHandle = steerJob.Schedule(m_BoidQuery, mergeCellsJobHandle);

                inputDeps = steerJobHandle;
                m_BoidQuery.AddDependency(inputDeps);
            }
            m_UniqueTypes.Clear();

            return inputDeps;
        }

        protected override void OnCreate()
        {
            ///查询大群
            m_BoidQuery = GetEntityQuery(new EntityQueryDesc
            {
                All = new [] { ComponentType.ReadOnly<Boid>(), ComponentType.ReadWrite<LocalToWorld>() },
            });
            //目标大群
            m_TargetQuery = GetEntityQuery(new EntityQueryDesc
            {
                All = new [] { ComponentType.ReadOnly<BoidTarget>(), ComponentType.ReadOnly<LocalToWorld>() },
            });
            //对手大群
            m_ObstacleQuery = GetEntityQuery(new EntityQueryDesc
            {
                All = new [] { ComponentType.ReadOnly<BoidObstacle>(), ComponentType.ReadOnly<LocalToWorld>() },
            });
        }
    }
}

流程图

2019.3版本ECS代码改进

新版本针对一些繁琐的模板代码做了一些改进，可以对比看出简洁了不少，不过Lambda表达式的方式会产生额外的GC，所以还需要进一步改进。

丁小未