ESC框架知识点
安装ECS
在PackageManager中搜索并安装Entities Graphics
烘焙Entity
public class FallingCubeSpawnerAuthoring : MonoBehaviour { public class Baker : Baker<FallingCubeSpawnerAuthoring> { public override void Bake(FallingCubeSpawnerAuthoring authoring) { Entity spawnerEntity = GetEntity(TransformUsageFlags.None); } } }烘焙显示在场景中的物体用TransformUsageFlags.Dynamic
构建Component
创建
所有Component必须继承IComponentData
标签
public struct CreatCubeTag : IComponentData { }数据
public struct FallingCubeSpawner : IComponentData { public Entity CubePrefab; public int MaxCount; }赋值
public class FallingCubeSpawnerAuthoring : MonoBehaviour { [SerializeField] private GameObject cubePrefab; [SerializeField] private int maxCount = 1000; public class Baker : Baker<FallingCubeSpawnerAuthoring> { public override void Bake(FallingCubeSpawnerAuthoring authoring) { Entity spawnerEntity = GetEntity(TransformUsageFlags.None); Entity cubePrefabEntity = GetEntity( authoring.cubePrefab, TransformUsageFlags.Dynamic ); AddComponent<CreatCubeTag>(spawnerEntity); AddComponent(spawnerEntity, new FallingCubeSpawner { CubePrefab = cubePrefabEntity, MaxCount = authoring.maxCount, }); } } }创建System
框架
public partial struct FallingCubeSystem : ISystem { public void OnCreate(ref SystemState state) { state.RequireForUpdate<FallingCubeSpawner>(); } public void OnUpdate(ref SystemState state) { float deltaTime = SystemAPI.Time.DeltaTime; EntityCommandBuffer ecb = new EntityCommandBuffer(state.WorldUpdateAllocator); //todo 这里写工作流 ecb.Playback(state.EntityManager); ecb.Dispose(); } }state.RequireForUpdate<FallingCubeSpawner>();泛型传入参数代表烘焙场景中存在指定组件才会执行Update
可以执行多次，添加多次
float deltaTime = SystemAPI.Time.DeltaTime;获取每一帧的时间间隔
EntityCommandBuffer ecb = new EntityCommandBuffer(state.WorldUpdateAllocator);创建ecb对象，工作流中需要使用，Entity的删除与创建，激活与隐藏，添加和删除组件，都需要走ecb，这里自己实例化了一个，在涉及到物理的System当中不能这么用
ecb.Playback(state.EntityManager); ecb.Dispose();调用ecb并释放ecb，通常一起使用，处理工作流中注册的对于Entity的操作，然后释放，自己实例化的ecb对象需要手动调用，不调用会出错
工作流
创建工作流
[BurstCompile] [WithAll(typeof(CreatCubeTag))] public partial struct CreatCubeJob : IJobEntity { public int countNow; public EntityCommandBuffer.ParallelWriter Ecb; void Execute([EntityIndexInQuery]int sortKey, ref FallingCubeSpawner cubeValue) { if (countNow < cubeValue.MaxCount) { Entity cube = Ecb.Instantiate(sortKey,cubeValue.CubePrefab); float randomX = new Random().NextFloat(-10f, 10f); Ecb.SetComponent(sortKey, cube, LocalTransform.FromPosition(new float3(randomX, 20f, 0f)) ); } } }工作流必须继承IJobEntity基类，然后实现Execute方法，方法参数任意
如果涉及到操作Entity物体，激活或隐藏，创建或释放，则需要在类中创建参数
public EntityCommandBuffer.ParallelWriter Ecb;ecb是操作Entity物体的关键，然后还需要在Execute方法，指定第一个参数为
void Execute([EntityIndexInQuery]int sortKey)其中[EntityIndexInQuery]标签为必添加的，这个标签添加以后，这个变量能够自动赋值，每次调用ecb的时候，都需要传入这个参数，用来指定在ecb中逻辑执行的顺序，如果不传或者传0会出现代码顺序错乱的问题
然后仔细讲一下Execute方法
这个方法在工作流中会自动执行，根据参数筛选需要被处理的Entity，同时除了带有，比如[EntityIndexInQuery]标签的顺序参数和Entity参数以外，所有的参数必须是Component，也就是必须继承IComponentData基类
void Execute([EntityIndexInQuery]int sortKey, ref FallingCubeSpawner cubeValue)这种写法，就代表无视第一个顺序参数，筛选出所有挂载FallingCubeSpawner这个Component的Entity，然后在方法中处理，如果有一千个满足条件的Entity，就会执行一千次，如果只有一个，那就只会执行一次，参数可以无限往后叠加，每增加一个参数就增加一个筛选条件
void Execute([EntityIndexInQuery]int sortKey,ref LocalTransform localTransform,in FallCubeUsingValue cubeValue)同时，这种写法还可以拥有一个参数，类型为Entity，工作流会自动将满足这些Component的Entity传入进来，如果只需要操作数据参数则不需要获取实体
void Execute([EntityIndexInQuery]int sortKey,Entity entity,ref LocalTransform localTransform,in FallCubeUsingValue cubeValue)同时，参数中的Component前面需要有关键字：
ref 代表读写，会读取并修改里面的值
in 代表只读，只会读取，不会修改
然后解释一下工作流上的标签
[BurstCompile]意思是用 Burst 编译器编译这段代码（机器码）
运行效率更快的，编译更高效的编译器，但是存在限制
通过Burst编译的代码只能处理值类型数据，以及将操作注册到ecb中
不能调用引用类型的值，比如string，class，不能调用Unity原生方法（Debug.Log），不能调用Unity原生对象(GameObject)
Vector3在值类型中使用float3代替
string在值类型中使用FixedString64Bytes代替
使用方式完全相同
还有FixedString32Bytes，FixedString128Bytes，FixedString512Bytes，容纳更多字符，按需使用
[WithAll(typeof(CreatCubeTag))]额外增加一条筛选规则，满足Execute参数筛选的同时，额外拥有CreatCubeTag这个参数的Component的Entity才行，这种通常只作为筛选条件，不会用到里面的数据，通常传入标签
调用工作流(System中)
顺序调用
public partial struct FallingCubeSystem : ISystem { public void OnCreate(ref SystemState state) { state.RequireForUpdate<FallingCubeSpawner>(); } public void OnUpdate(ref SystemState state) { float deltaTime = SystemAPI.Time.DeltaTime; EntityCommandBuffer ecb = new EntityCommandBuffer(state.WorldUpdateAllocator); //这里开始是调用工作流 MoveCubeJob moveJob = new MoveCubeJob(){deltaTime = deltaTime,Ecb = ecb.AsParallelWriter()}; ChangeAnimJob changeAnimJob = new ChangeAnimJob() { deltaTime = deltaTime }; state.Dependency = moveJob.ScheduleParallel(state.Dependency); state.Dependency = changeAnimJob.ScheduleParallel(state.Dependency); state.Dependency.Complete(); //在这里结束 ecb.Playback(state.EntityManager); ecb.Dispose(); } }先是创建工作流，直接通过new进行实例化，实例化的时候需要传入参数，计算帧数的需要传入当前帧时间，操作Entity的需要传入ecb对象
state.Dependency = IJobEntity.ScheduleParallel(state.Dependency);将实例化好的工作流添加到执行列表当中，可以重复添加多个，会按照添加的先后顺序执行
state.Dependency.Complete();开始按照添加顺序执行工作流，线程会开始等待直到工作流完成，再执行后面的逻辑，这样做性能非常好，等工作流执行完成了再处理ecb中注册的Entity操作
并行工作流
public partial struct FallingCubeSystem : ISystem { public void OnCreate(ref SystemState state) { state.RequireForUpdate<FallingCubeSpawner>(); } public void OnUpdate(ref SystemState state) { float deltaTime = SystemAPI.Time.DeltaTime; EntityCommandBuffer ecb = new EntityCommandBuffer(state.WorldUpdateAllocator); //这里开始是调用工作流 MoveCubeJob moveJob = new MoveCubeJob(){deltaTime = deltaTime,Ecb = ecb.AsParallelWriter()}; ChangeAnimJob changeAnimJob = new ChangeAnimJob() { deltaTime = deltaTime }; JobHandle moveHandle = moveJob.ScheduleParallel(state.Dependency); JobHandle animHandle = changeAnimJob.ScheduleParallel(state.Dependency); state.Dependency = JobHandle.CombineDependencies(moveHandle, animHandle); //在这里结束 ecb.Playback(state.EntityManager); ecb.Dispose(); } }并行工作流在实例化工作流对象之后，需要将工作流转化成JobHandle对象，然后再将所有的JobHandle一起赋值给state.Dependency
这种情况下多个工作流会一起执行，没有先后顺序，执行效率更高，但是更容易出现ecb执行混乱，出现先调用再注册的情况，开发和调试难度要高于按顺序调用
在工作流中改变能直接影响显示的属性
1.LocalTransfrom
[BurstCompile] [WithAll(typeof(FallingCubeTag))] public partial struct MoveCubeJob : IJobEntity { public float deltaTime; void Execute([EntityIndexInQuery]int sortKey,ref LocalTransform localTransform) { localTransform.Position.y -= cubeValue.Value * deltaTime; } }LocalTransform必须带有ref，修改LocalTransform中的值能够直接改变场景中Entity的位置
2.改变Shader中字段的值
首先，需要在Component中进行一下特殊处理，需要添加标签
[MaterialProperty("_FrameIndex")] public struct ChangeShaderValue : IComponentData { public float Value; }其中这个标签尤其重要
[MaterialProperty("_FrameIndex")]代表着这个Component被添加到Entity之后，会自动寻找Entity上挂载的Renderer，然后从Renderer上获取材质球，然后找到材质球的Shader，然后从Shader上寻找字符串中的字段，也就是_FrameIndex这个字段，意思是shader中必须存在_FrameIndex这个字段
_FrameIndex("Frame Index", Float) = 0同时，在Component中，必须有一个变量，变量名必须为Value，变量类型必须与Shader中的对应字段的类型一致
public partial struct ChangeAnimJob : IJobEntity { public float deltaTime; void Execute(ref ChangeAnimValue animValue,ref ChangeShaderValue shaderValue) { animValue.index++; if (animValue.index >= animValue.indexMax) { animValue.index = 0; } shaderValue.Value = animValue.index; } }然后直接在Job工具流中修改Value的值，就能直接应用到材质球当中
想要实时应用材质球，必须使用MeshRenderer，即使是2D，也不能使用SpriteRenderer，在2D中使用MeshRenderer来渲染2D图的时候，MeshFilter的网格选择Quad
待补充......
Ecb实体处理器
1.创建Entity
Entity entity = Ecb.Instantiate(sortKey,mainEntity);传入工作流顺序和需要创建的实体的原型，返回创建出来的实体
2.删除Entity
Ecb.DestroyEntity(sortKey,entity);传入工作流顺序和需要删除的实体，删除传入的实体
3.激活或隐藏Entity
Ecb.SetEnabled(sortKey, entity, true); Ecb.SetEnabled(sortKey, entity, false);传入工作流顺序和需要操作的实体，然后最后传入是否激活，true为激活，false为隐藏
4.为实体增加组件
Ecb.AddComponent<FallingCubeTag>(sortKey,entity); Ecb.AddComponent(sortKey,entity,new FallCubeUsingValue{ Value = 1.0f });用Ecb添加组件，添加标签使用泛型，添加数据需要实例化，传入工作流顺序，需要添加的实体，以及泛型类型或实例化对象
5.为实体的组件设置属性
Ecb.SetComponent(sortKey, entity,LocalTransform.FromPosition(new float3(0, 20f, 0f)));用Ecb给已经添加的Component中的字段设置值，这里是给刚创建的Entity设置初始位置
也可以用另一种方式
var t = LocalTransform.FromPosition(new float3(randomX, 20f, 0f)); t.Scale = 0.25f; Ecb.SetComponent(sortKey, cube, t);先根据位置创建出LocalTransfrom，再给它的Scale赋值，然后再传入SetComponent当中
Ecs物理
安装插件
先在PackageManager安装Unity Physics
然后再预制体中直接挂载Collider和RigBody就能直接在烘焙出来的Entity中使用物理了
要注意，必须使用3D物理，即使是2D游戏也要使用3D物理，使用2D物理没有效果，
处理物理碰撞的工作流
创建物理工作流
public partial struct TriggerJob : ITriggerEventsJob { public int sortKey; public ComponentLookup<BulletTag> bulletLook; public ComponentLookup<FallingCubeTag> cubeLook; public EntityCommandBuffer.ParallelWriter ecb; public void Execute(TriggerEvent triggerEvent) { Entity bulletEntity = Entity.Null; Entity cubeEntity = Entity.Null; bulletEntity = bulletLook.HasComponent(triggerEvent.EntityA) ? triggerEvent.EntityA : bulletEntity; bulletEntity = bulletLook.HasComponent(triggerEvent.EntityB) ? triggerEvent.EntityB : bulletEntity; cubeEntity = cubeLook.HasComponent(triggerEvent.EntityA) ? triggerEvent.EntityA : cubeEntity; cubeEntity = cubeLook.HasComponent(triggerEvent.EntityB) ? triggerEvent.EntityB : cubeEntity; if (bulletEntity != Entity.Null && cubeEntity != Entity.Null) { ecb.DestroyEntity(sortKey, cubeEntity); } } }处理物理碰撞分为Trigger和Collision，这里处理的是Trigger，如果想要处理Collision的话
工作流需要继承ICollisionEventsJob，同时Execute方法的参数为CollisionEvent，使用方式相同
ComponentLookup<> 这个是物理工作流中必须要有的，用来判断碰撞的两个物体是否拥有泛型中传入的这个标签
继承了ITriggerEventsJob和ICollisionEventsJob的物理工作流，里面的Execute方法，会在任意两个拥有碰撞体且附带Triger和Rigbody的物体后执行，并且出现持续碰撞的时候，每帧都会执行，无法在调用方法前筛选出要处理哪些碰撞
所以必须要在方法内判断，碰撞的两个物体是否是自己想要检测的物体，判断就必须要通过ComponentLookup<>来判断
triggerEvent.EntityA和triggerEvent.EntityB可以在方法中访问被碰撞的两个实体：Entity
然后调用ComponentLookup<>.HasComponent(Entity)方法，在参数中传入想要判断的Entity，可以判断这个实体中是否拥有创建时的泛型包含的组件
用这种方式，就可以判断出两个Entity是否为想要检测碰撞的两个物体，然后处理逻辑
调用工作流
[UpdateInGroup(typeof(FixedStepSimulationSystemGroup))] [UpdateAfter(typeof(PhysicsSimulationGroup))] public partial struct EcsPhysicsJobSystem : ISystem { public void OnCreate(ref SystemState state) { state.RequireForUpdate<SimulationSingleton>(); state.RequireForUpdate<EndFixedStepSimulationEntityCommandBufferSystem.Singleton>(); } public void OnUpdate(ref SystemState state) { var ecbSing = SystemAPI.GetSingleton<EndFixedStepSimulationEntityCommandBufferSystem.Singleton>(); var ecb = ecbSing.CreateCommandBuffer(state.WorldUnmanaged).AsParallelWriter(); TriggerJob triggerJob = new TriggerJob { sortKey = 0, bulletLook = SystemAPI.GetComponentLookup<BulletTag>(), cubeLook = SystemAPI.GetComponentLookup<FallingCubeTag>(), ecb = ecb }; state.Dependency = triggerJob.Schedule(SystemAPI.GetSingleton<SimulationSingleton>(), state.Dependency); } }先讲解两个标签
[UpdateInGroup(typeof(FixedStepSimulationSystemGroup))]添加这个标签之后，这个System会在FixedUpdate运算完成之后，再进行运算，如果没有添加这个标签，就会在Update每帧渲染之后进行运算
在Physics当中务必添加这个标签，非Physics的System中不要添加
[UpdateAfter(typeof(PhysicsSimulationGroup))]添加这个标签之后，这个System会在物理碰撞模拟完成之后，再运算System，不添加这个标签的话，可能会在物理运算完成之前执行System，物理效果可能会出现错误或者延迟
在Physics当中务必添加这个标签，非Physics的System中不要添加
var ecbSing = SystemAPI.GetSingleton<EndFixedStepSimulationEntityCommandBufferSystem.Singleton>(); var ecb = ecbSing.CreateCommandBuffer(state.WorldUnmanaged).AsParallelWriter();在调用物理工作流的System中，Ecb不能直接用New实例化，需要采用特定的方式进行创建
SystemAPI.GetSingleton<EndFixedStepSimulationEntityCommandBufferSystem.Singleton>();这个方法会返回一个固定的Ecs原型，通过这个方法返回的Ecs无法控制什么时候执行或者释放，而是固定在每次FxedUpdate结束时的最后执行，物理需要使用这种类型的Ecb，不然会出现问题
ecbSing.CreateCommandBuffer(state.WorldUnmanaged).AsParallelWriter()ecbSing.CreateCommandBuffer(state.WorldUnmanaged)这个方法会返回一个可用的Ecb，然后通过.AsParallelWriter()返回一个可以在Job工作流中使用的Ecb实体
SystemAPI.GetComponentLookup<IComponentData>()通过这个方法，可以返回一个查找器，这个查找器用来查找Entity中是否挂载着泛型中传入的Component
state.Dependency = triggerJob.Schedule(SystemAPI.GetSingleton<SimulationSingleton>(), state.Dependency)这句代码是真正的将Job添加到工作流，
.Schedule(SystemAPI.GetSingleton<SimulationSingleton>(), state.Dependency)
这一段是固定的，不需要修改任何参数，只是前面的是自己实例化出来的Job就可以