protected override JobHandle OnUpdate(JobHandle inputDeps) { if (m_Query.CalculateEntityCount() <= 0) { return(inputDeps); } var generator = m_GeneratorQuery.GetSingleton <LbBoardGenerator>(); var board = m_BoardQuery.GetSingleton <LbBoard>(); var boardEntity = m_BoardQuery.GetSingletonEntity(); var bufferLookup = GetBufferFromEntity <LbDirectionMap>(); var buffer = bufferLookup[boardEntity]; var bufferArray = buffer.AsNativeArray(); var spawnerHandle = new BoardSpawnerJob() { Generator = generator, Seed = m_Random.NextUInt(), DirectionBuffer = bufferLookup[boardEntity].AsNativeArray(), CommandBuffer = m_Barrier.CreateCommandBuffer() }.Schedule(inputDeps); var cleanUpHandle = new BoardSpawnerCleanJob() { CommandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(), }.Schedule(this, spawnerHandle); m_Barrier.AddJobHandleForProducer(cleanUpHandle); return(cleanUpHandle); }
protected override JobHandle OnUpdate(JobHandle inputDependencies) { m_yellowGroup.SetFilter(new C_Shared_Team() { Team = Proxy_Bee.Team.YellowTeam }); var yellowJob = new Sys_Bee_GoHomeJob() { CarryForce = BeeManager.S.CarryForce, Field = Field.size, Team = (int)Proxy_Bee.Team.YellowTeam, dt = UnityEngine.Time.deltaTime, ecb = m_entityCommandBufferSystem.CreateCommandBuffer().ToConcurrent() }.Schedule(m_yellowGroup, inputDependencies); m_purpleGroup.SetFilter(new C_Shared_Team() { Team = Proxy_Bee.Team.PurpleTeam }); var purpleJob = new Sys_Bee_GoHomeJob() { CarryForce = BeeManager.S.CarryForce, Field = Field.size, Team = (int)Proxy_Bee.Team.PurpleTeam, dt = UnityEngine.Time.deltaTime, ecb = m_entityCommandBufferSystem.CreateCommandBuffer().ToConcurrent() }.Schedule(m_purpleGroup, yellowJob); m_entityCommandBufferSystem.AddJobHandleForProducer(yellowJob); m_entityCommandBufferSystem.AddJobHandleForProducer(purpleJob); return(purpleJob); }
#pragma warning restore 618 protected override JobHandle OnUpdate(JobHandle inputDependencies) { var newEntityJob = new NewEntityJob() { ConcurrentECB = m_ECBSource.CreateCommandBuffer().ToConcurrent() }; var newJobHandle = newEntityJob.ScheduleSingle(m_newEntities, inputDependencies); m_ECBSource.AddJobHandleForProducer(newJobHandle); var processEntityJob = new ProcessEntityJob() { ConcurrentECB = m_ECBSource.CreateCommandBuffer().ToConcurrent() }; var processJobHandle = processEntityJob.Schedule(m_activeEntities, newJobHandle); m_ECBSource.AddJobHandleForProducer(processJobHandle); var cleanupEntityJob = new CleanupEntityJob() { ConcurrentECB = m_ECBSource.CreateCommandBuffer().ToConcurrent() }; var cleanupJobHandle = cleanupEntityJob.ScheduleSingle(m_destroyedEntities, processJobHandle); m_ECBSource.AddJobHandleForProducer(cleanupJobHandle); return(cleanupJobHandle); }
private void AddCommandTween <T>(int tagId, T command, EntityQuery tweens) where T : struct, IComponentData { var totalTweens = tweens.CalculateLength(); if (totalTweens == 0) { return; } var entities = tweens.ToEntityArray(Allocator.TempJob); var tags = tweens.ToComponentDataArray <TweenTag>(Allocator.TempJob); var commandBuffer = m_EndFrameSystem.CreateCommandBuffer(); for (int i = 0; i < totalTweens; i++) { var entity = entities[i]; var tag = tags[i]; if (tagId == -1 || tag.Value == tagId) { commandBuffer.AddComponent <T>(entity, command); } } entities.Dispose(); tags.Dispose(); }
void InitByRandomSeed() { var ecb = _ECB.CreateCommandBuffer().AsParallelWriter(); var randomSeed = new Random((uint)System.Environment.TickCount); Entities.WithNone <ExistTag, BehaviorTreeRandomSeed>() .ForEach((Entity entity, int nativeThreadIndex, ref BehaviorTreeRandom random) => { random.Value.InitState(randomSeed.NextUInt()); ecb.AddComponent <ExistTag>(nativeThreadIndex, entity); }).ScheduleParallel(); }
protected override void OnUpdate() { var cb = _barrier.CreateCommandBuffer(); Entities .WithNone <GameOfLifeTexture>() .WithAll <IsConwaysSimulation>() .ForEach((Entity e, ref WorldSize world) => { if (world.Size.x <= 0) { world.Size.x = Screen.width; } if (world.Size.y <= 0) { world.Size.y = Screen.height; } var sizeInDemandedAreas = (int2)math.ceil(world.Size / new float2(16, 3)); world.Size = sizeInDemandedAreas * new int2(16, 3); var texture = new Texture2D(4 * sizeInDemandedAreas.x, sizeInDemandedAreas.y, TextureFormat.RGBA32, false); texture.wrapMode = TextureWrapMode.Clamp; var array = texture.GetRawTextureData <int4>(); for (int i = 0; i < array.Length; i++) { array[i] = 0; } texture.Apply(); cb.AddComponent(e, new GameOfLifeTexture { Value = texture, IsCreated = true }); }).WithoutBurst().Run(); }
protected override unsafe void OnUpdate() { var deltaTime = UnityEngine.Time.deltaTime; EntityCommandBuffer commandBuffer = m_EntityCommandBufferSystem.CreateCommandBuffer(); Entities .WithName("ChangeColliderType") .WithAll <PhysicsCollider, RenderMesh>() .WithoutBurst() .ForEach((Entity entity, ref ChangeColliderType modifier) => { modifier.LocalTime -= deltaTime; if (modifier.LocalTime > 0.0f) { return; } modifier.LocalTime = modifier.TimeToSwap; var collider = EntityManager.GetComponentData <PhysicsCollider>(entity); if (collider.ColliderPtr->Type == modifier.ColliderA.ColliderPtr->Type) { commandBuffer.SetComponent(entity, modifier.ColliderB); commandBuffer.SetSharedComponent(entity, EntityManager.GetSharedComponentData <RenderMesh>(modifier.EntityB)); } else { commandBuffer.SetComponent(entity, modifier.ColliderA); commandBuffer.SetSharedComponent(entity, EntityManager.GetSharedComponentData <RenderMesh>(modifier.EntityA)); } }).Run(); m_EntityCommandBufferSystem.AddJobHandleForProducer(Dependency); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { //test if we have any requests if (pokemonMoveDataQuery.CalculateEntityCount() == 0 && pokemonMoveFinishEntities.CalculateEntityCount() == 0) { return(inputDeps); } NativeArray <EntityParent> entityParents = pokemonMoveDataQuery.ToComponentDataArray <EntityParent>(Allocator.TempJob); NativeArray <GroupIndexInfo> parentInfos = new NativeArray <GroupIndexInfo>(entityParents.Length, Allocator.TempJob); for (int i = 0; i < entityParents.Length; i++) { parentInfos[i] = EntityManager.GetComponentData <GroupIndexInfo>(entityParents[i].entity); } //preform the job JobHandle jh = new RemovePokemonData { pokemonMoveDataEntities = pokemonMoveDataQuery.ToEntityArray(Allocator.TempJob), ecb = ecbs.CreateCommandBuffer(), pokemonMoveDatas = pokemonMoveDataQuery.ToComponentDataArray <PokemonMoveDataEntity>(Allocator.TempJob), parents = entityParents, parentInfos = parentInfos, pokemonMoveEntityEntities = pokemonMoveFinishEntities.ToEntityArray(Allocator.TempJob), hasParticleRemoveRequest = GetComponentDataFromEntity <ParticleSystemRemoveRequest>(), pokemonMoveRemoveDatas = pokemonMoveFinishEntities.ToComponentDataArray <PokemonMoveDataEntity>(Allocator.TempJob) }.Schedule(inputDeps); jh.Complete(); return(jh); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var glyphMap = new NativeHashMap <int, Entity>(glyphQuery.CalculateEntityCount(), Allocator.TempJob); var glyphMapDeps = new BuildGlyphMapJob { GlyphMap = glyphMap.AsParallelWriter() }.Schedule(glyphQuery, inputDeps); var textMeshDeps = new BuildTextMeshJob { GlyphMap = glyphMap, GlyphData = GetBufferFromEntity <GlyphElement>(true), FontFaces = GetComponentDataFromEntity <FontFaceInfo>(true), EntityType = GetArchetypeChunkEntityType(), CharBufferType = GetArchetypeChunkBufferType <CharElement>(true), TextOptionType = GetArchetypeChunkComponentType <TextOptions>(true), TxtFontIDType = GetArchetypeChunkComponentType <TextFontID>(true), ColorType = GetArchetypeChunkComponentType <AppliedColor>(true), LTWType = GetArchetypeChunkComponentType <LocalToWorld>(true), DimensionType = GetArchetypeChunkComponentType <Dimensions>(true), MeshVertexDataType = GetArchetypeChunkBufferType <MeshVertexData>(), TriangleIndexType = GetArchetypeChunkBufferType <TriangleIndexElement>(), CmdBuffer = cmdBufferSystem.CreateCommandBuffer().ToConcurrent() }.Schedule(textQuery, glyphMapDeps); var finalDeps = glyphMap.Dispose(textMeshDeps); cmdBufferSystem.AddJobHandleForProducer(finalDeps); return(finalDeps); }
protected override void OnUpdate() { //hacky var inPreround = false; Entities.WithAll <PreRoundPhase>().ForEach((Entity e) => inPreround = true); var buffer = CommandBuffer.CreateCommandBuffer(); Entities.WithAll <Carrier>().ForEach( (Entity e, ref Focussing focussing, ref Carrier carrier) => { if (inPreround) { return; } if (focussing.Entity == Entity.Null) { return; } if (!carrier.WantsToPickUp || focussing.Intention != FocusType.Carryable) { return; } var pickup = buffer.CreateEntity(); buffer.AddComponent(pickup, new PickingUp { Carrier = e, Carryable = focussing.Entity } ); buffer.AddComponent(pickup, new Message()); } ); }
protected override void OnUpdate() { var ecb = _ecbSystem.CreateCommandBuffer().AsParallelWriter(); var dt = Time.DeltaTime; Entities.ForEach((Entity entity, int entityInQueryIndex, DynamicBuffer <PathPosition> pathPositionBuffer, ref Translation translation, ref PathIndex pathIndex) => { if (pathIndex.Value >= 0) { int2 pathPosition = pathPositionBuffer[pathIndex.Value].Value; float3 targetPosition = new float3(pathPosition.x, translation.Value.y, pathPosition.y); float3 moveDirection = math.normalizesafe(targetPosition - translation.Value); float moveSpeed = 3f; translation.Value += moveDirection * moveSpeed * dt; if (math.distance(translation.Value, targetPosition) < .1f) { //next waypoint pathIndex.Value--; } } else { ecb.AddComponent(entityInQueryIndex, entity, new AwaitingOrder()); } }).ScheduleParallel(); }
protected override void OnUpdate() { var commandBuffer = enityCommandBufferSystem.CreateCommandBuffer().AsParallelWriter(); Entities.ForEach((Entity entity, int entityInQueryIndex, ref SpawnerComponent spawner, ref LocalToWorld location) => { for (var x = 0; x < spawner.countX; x++) { for (var y = 0; y < spawner.countY; y++) { for (int z = 0; z < spawner.countZ; z++) { var instance = commandBuffer.Instantiate(entityInQueryIndex, spawner.entity); // Place the instantiated in a grid with some noise var position = math.transform(location.Value, new float3(x * spawner.spaceX, y * spawner.spaceY, z * spawner.spaceZ)); commandBuffer.SetComponent(entityInQueryIndex, instance, new Translation { Value = position }); } } } commandBuffer.DestroyEntity(entityInQueryIndex, entity); }) .WithName("SpawnerSystem") .ScheduleParallel(); enityCommandBufferSystem.AddJobHandleForProducer(Dependency); }
protected override void OnUpdate() { EntityCommandBuffer.Concurrent ECB = ECBSystem.CreateCommandBuffer().ToConcurrent(); float deltaTime = Time.DeltaTime; Entities .ForEach((int entityInQueryIndex, ref FireCooldown fireCooldown, in TurretInput input, in FireInterval fireInterval, in FireSpeed fireSpeed, in LocalToWorld localToWorld, in ProjectilePrefab projectilePrefab, in ProjectileSpawnPoint spawnPointData) => { //decrease the cooldown if (fireCooldown.Value > 0f) { fireCooldown.Value -= deltaTime; } if (input.Fire && fireCooldown.Value <= 0f) { //fire! Entity newProjectile = ECB.Instantiate(entityInQueryIndex, projectilePrefab.Reference); //override a few components to position, rotate and push the newly created bullet ECB.SetComponent <Translation>(entityInQueryIndex, newProjectile, new Translation { Value = math.transform(localToWorld.Value, spawnPointData.LocalTranslation) }); quaternion worldRotation = math.mul(localToWorld.Rotation, spawnPointData.LocalRotation); ECB.SetComponent <Rotation>(entityInQueryIndex, newProjectile, new Rotation { Value = worldRotation }); ECB.SetComponent <PhysicsVelocity>(entityInQueryIndex, newProjectile, new PhysicsVelocity { Linear = fireSpeed.Value * math.forward(worldRotation) }); fireCooldown.Value = fireInterval.Value; } }).ScheduleParallel();
protected override void OnUpdate() { var translationType = GetArchetypeChunkComponentType <Translation>(true); var factionComponentType = GetArchetypeChunkComponentType <FactionComponent>(true); var batteryComponentType = GetArchetypeChunkComponentType <BatteryComponent>(); var random = new Unity.Mathematics.Random((uint)UnityEngine.Random.Range(1, 100000)); var job = new FireJob { deltaTime = Time.DeltaTime, commandBuffer = barrier.CreateCommandBuffer().ToConcurrent(), prefab = prefab, random = random, entities = group.ToEntityArray(Allocator.TempJob), factions = GetComponentDataFromEntity <FactionComponent>(true), translations = GetComponentDataFromEntity <Translation>(true), batteryComponentType = batteryComponentType, factionComponentType = factionComponentType, translationType = translationType, }; Dependency = job.Schedule(group, Dependency); barrier.AddJobHandleForProducer(Dependency); }
protected override void OnUpdate() { var commandBuffer = _entityCommandBufferSystem.CreateCommandBuffer(); Entities.ForEach((Entity unitEntity, ref HasTarget hasTarget, ref Translation translation) => { var targetExist = EntityManager.Exists(hasTarget.targetEntity); if (targetExist) { // Debug.Log($"has target"); var targetTranslation = EntityManager.GetComponentData <Translation>(hasTarget.targetEntity); var targetDirection = math.normalize(targetTranslation.Value - translation.Value); // var moveSpeed = 10.0f; var moveSpeed = Random.Range(2.0f, 10.0f); translation.Value += targetDirection * moveSpeed * Time.DeltaTime; if (math.distance(translation.Value, targetTranslation.Value) < 0.2f) { Debug.Log($"move close to {hasTarget.targetEntity}"); commandBuffer.DestroyEntity(hasTarget.targetEntity); commandBuffer.RemoveComponent <HasTarget>(unitEntity); } } else { commandBuffer.RemoveComponent <HasTarget>(unitEntity); } }) .WithoutBurst() .Run(); }
protected override void OnUpdate() { var commandBuffer = commandBufferSystem.CreateCommandBuffer(); Entities .WithoutBurst() .WithSharedComponentFilter(new EffectTriggerApplyEffectType { EffectType = EffectType.Damage }) .ForEach((int entityInQueryIndex, Entity entity, in EffectTriggerApplyData effectTriggerApplyData) => { commandBuffer.DestroyEntity(entity); if (!entityManager.Exists(effectTriggerApplyData.Target)) { return; } var buffer = entityManager.GetBuffer <DamageToApplyBufferElement>(effectTriggerApplyData.Target); buffer.Add((int)effectTriggerApplyData.Value); }) .Run(); commandBufferSystem.AddJobHandleForProducer(Dependency); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var boardCount = m_BoardQuery.CalculateEntityCount(); if (boardCount <= 0) { return(inputDeps); } var board = m_BoardQuery.GetSingleton <LbBoard>(); float deltaTime = Mathf.Clamp(Time.deltaTime, 0.0f, 0.3f); var handle = new PlayerCursorJob() { BoardSize = new int2(board.SizeX, board.SizeY), Seed = m_Random.NextInt(), CommandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(), MovementType = GetArchetypeChunkComponentType <LbMovementTarget>(), DistanceType = GetArchetypeChunkComponentType <LbDistanceToTarget>(), ArrowPrefabType = GetArchetypeChunkComponentType <LbArrowPrefab>(), PlayerType = GetArchetypeChunkComponentType <LbPlayer>(), }.Schedule(m_Query, inputDeps); return(handle); }
protected override JobHandle OnUpdate(JobHandle inputDependencies) { JobHandle job = new JobHandle(); var commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(); ShotPositions = m_Group.ToComponentDataArray <Translation>(Allocator.Persistent); Tags = m_Group.ToComponentDataArray <ShotTag>(Allocator.Persistent); Shots = m_Group.ToEntityArray(Allocator.Persistent); for (int i = 0; i < ShotPositions.Length; i++) { job.Complete(); job = new MPShotCollidingJob { shotTag = Tags[i].Character, ShotIndex = Shots[i].Index, ShotPos = ShotPositions[i].Value, CommandBuffer = commandBuffer, }.Schedule(this, inputDependencies); m_Barrier.AddJobHandleForProducer(job); } Shots.Dispose(); ShotPositions.Dispose(); Tags.Dispose(); return(job); }
protected override void OnUpdate() { var buffer = BufferSystem.CreateCommandBuffer(); float dt = Time.DeltaTime; Entities.WithNone <SpawnWaveComponent>().ForEach( ( ref WaveSpawner spawner, in DynamicBuffer <SpawnWave> waves, in Translation translation, in Team team ) => { spawner.CurrentTime -= dt; if (spawner.CurrentTime > 0f) { return; } //Spawn a random wave spawner.CurrentTime = spawner.TimeBetweenWaves; var waveToSpawn = waves[Random.Range(0, waves.Length)].Wave; var spawnedWave = buffer.Instantiate(waveToSpawn); buffer.SetComponent(spawnedWave, translation); buffer.AddComponent(spawnedWave, team); buffer.AddComponent(spawnedWave, spawner); }
protected override void OnUpdate() { var cb = _barrier.CreateCommandBuffer(); Entities .WithNone <GameOfLifeTexture>() .WithAll <IsSteppersSimulation>() .ForEach((Entity e, ref WorldSize world) => { if (world.Size.x <= 0) { world.Size.x = Screen.width; } if (world.Size.y <= 0) { world.Size.y = Screen.height; } var texture = new Texture2D(world.Size.x, world.Size.y, TextureFormat.R8, false); texture.wrapMode = TextureWrapMode.Clamp; var array = texture.GetRawTextureData <int4>(); for (int i = 0; i < array.Length; i++) { array[i] = 0; } texture.Apply(); cb.AddComponent(e, new GameOfLifeTexture { Value = texture, IsCreated = true }); }).WithoutBurst().Run(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityCommandBuffer.Concurrent buffer = bufferSystem.CreateCommandBuffer().ToConcurrent(); //If DamageEvent => set Health component var jobApplyDamage = Entities .ForEach((Entity e, int entityInQueryIndex, ref DynamicBuffer <DamageEvent> damageBuffer, ref Health health) => { for (int i = damageBuffer.Length - 1; i >= 0; i--) { health.currentHealth -= damageBuffer[i].damage; if (health.currentHealth < 0f) { // DIE! buffer.DestroyEntity(entityInQueryIndex, e); return; } damageBuffer.RemoveAt(i); } }).Schedule(inputDeps); //If health component was just removed => destroy the entity, spawn death FX return(jobApplyDamage); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var configEntity = GetSingletonEntity <StreamingLogicConfig>(); var config = EntityManager.GetComponentData <StreamingLogicConfig>(configEntity); var cameraPosition = EntityManager.GetComponentData <LocalToWorld>(configEntity).Position; m_AddRequestList.Clear(); var streamInHandle = new StreamSubScenesIn { AddRequestList = m_AddRequestList, CameraPosition = cameraPosition, MaxDistanceSquared = config.DistanceForStreamingIn * config.DistanceForStreamingIn }.ScheduleSingle(this, inputDeps); m_RemoveRequestList.Clear(); var streamOutHandle = new StreamSubScenesOut { RemoveRequestList = m_RemoveRequestList, CameraPosition = cameraPosition, MaxDistanceSquared = config.DistanceForStreamingOut * config.DistanceForStreamingOut }.ScheduleSingle(this, inputDeps); var combinedHandle = JobHandle.CombineDependencies(streamInHandle, streamOutHandle); var commandHandle = new BuildCommandBufferJob { CommandBuffer = m_EntityCommandBufferSystem.CreateCommandBuffer(), AddRequestArray = m_AddRequestList.AsDeferredJobArray(), RemoveRequestArray = m_RemoveRequestList.AsDeferredJobArray() }.Schedule(combinedHandle); m_EntityCommandBufferSystem.AddJobHandleForProducer(commandHandle); return(commandHandle); }
protected override void OnUpdate() { var commandBuffer = commandBufferSystem.CreateCommandBuffer().ToConcurrent(); // Foreach entity with damage to apply -> sum damage, clear buffer and apply. Entities .WithChangeFilter <DamageToApplyBufferElement>() .ForEach((Entity entity, int entityInQueryIndex, ref HealthPoints healthPoints, ref DynamicBuffer <DamageToApplyBufferElement> damageBuffer) => { int damage = 0; for (int i = 0; i < damageBuffer.Length; i++) { damage += damageBuffer[i].Value; } damageBuffer.Clear(); healthPoints.Value = math.max(healthPoints.Value - damage, 0); if (healthPoints.Value == 0) { commandBuffer.AddComponent <HealthDepleted>(entityInQueryIndex, entity); } }) .ScheduleParallel(); commandBufferSystem.AddJobHandleForProducer(Dependency); }
protected override void OnUpdate() { var buffer = _removeECBufferSystem.CreateCommandBuffer() .SetBuffer <State>(CurrentStatesEntity); buffer.Clear(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var concurrent = bufferSystem.CreateCommandBuffer().ToConcurrent(); //添加View所需组件 var addJob1 = new AddCommponentJob(); addJob1.concurrent = concurrent; inputDeps = addJob1.Schedule(nonMassQuery, inputDeps); var addJob2 = new AddCommponentJob(); addJob2.concurrent = concurrent; inputDeps = addJob2.Schedule(nonScaleQuery, inputDeps); var addMoverJob = new AddMoverJob(); addMoverJob.concurrent = concurrent; inputDeps = addMoverJob.Schedule(nonMoverQuery, inputDeps); //添加View //var addViewJob = new AddViewJob(); //addViewJob.concurrent = concurrent; //inputDeps = addViewJob .Schedule(nonViewQuery, inputDeps); return(inputDeps); }
protected unsafe override void OnUpdate() { var current = new int2(Screen.width, Screen.height); if (res->Equals(current)) { return; } * res = current; int2 *local = res; var cmdBuffer = cmdBufferSystem.CreateCommandBuffer(); Dependency = Entities.ForEach((ref LocalToWorld c2, in ReferenceResolution c0, in WidthHeightRatio c1) => { var logWidth = math.log2(local->x / c0.Value.x); var logHeight = math.log2(local->y / c0.Value.y); var avg = math.lerp(logWidth, logHeight, c1.Value); var scale = math.pow(2, avg); var center = new float3(local->xy / 2, 0); c2 = new LocalToWorld { Value = float4x4.TRS(center, c2.Rotation, new float3(scale)) }; }).WithNativeDisableUnsafePtrRestriction(local).Schedule(Dependency);
protected override JobHandle OnUpdate(JobHandle inputDependencies) { Entity avatarEntity = Entity.Null; var entities = EntityManager.GetAllEntities(); foreach (var entity in entities) { if (EntityManager.HasComponent <AvatarComponent>(entity)) { avatarEntity = entity; break; } } entities.Dispose(); if (Entity.Null == avatarEntity || EntityManager.HasComponent <EyesightComponent>(avatarEntity)) { return(inputDependencies); } var job = new SearchSystemJob() { xPos = EntityManager.GetComponentData <Translation>(avatarEntity).Value.x, xDir = EntityManager.GetComponentData <VelocityComponent>(avatarEntity).xValue, propComp = EntityManager.GetComponentData <AvatarComponent>(avatarEntity), avatarEntity = avatarEntity, cmdBuf = _cmdSystem.CreateCommandBuffer().ToConcurrent() }; var handle = job.Schedule(this, inputDependencies); _cmdSystem.AddJobHandleForProducer(handle); return(handle); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var commandBuffer = m_EntityCommandBufferSystem.CreateCommandBuffer().ToConcurrent(); var jobHandle = Entities .WithBurst(FloatMode.Default, FloatPrecision.Standard, true) .ForEach((Entity entity, int entityInQueryIndex, ref SpawnerComponent spawner) => { for (var x = 0; x < spawner.spawnerValue; x++) { var instance = commandBuffer.Instantiate(entityInQueryIndex, spawner.prefabToSpawn); // Place the instantiated in a grid with some noise var position = new float3(0, 12, 0); commandBuffer.SetComponent(entityInQueryIndex, instance, new Translation { Value = position }); } commandBuffer.DestroyEntity(entityInQueryIndex, entity); }).Schedule(inputDeps); m_EntityCommandBufferSystem.AddJobHandleForProducer(jobHandle); return(jobHandle); }
//[RequireComponentTag(typeof(MovingCube))] //struct MoveRandomJob : IJobForEachWithEntity<Translation, MoveRandom> //{ // public float DeltaTime; // [WriteOnly] // public EntityCommandBuffer.Concurrent CommandBuffer; // // The [ReadOnly] attribute tells the job scheduler that this job will not write to rotSpeedSpawnAndRemove // public void Execute(Entity entity, int index, ref Translation translation, ref MoveRandom moving) // { // // Rotate something about its up vector at the speed given by RotationSpeed_SpawnAndRemove. // translation.Value = new float3(translation.Value.x + moving.Direction.x * DeltaTime, translation.Value.y + DeltaTime * moving.Direction.y, translation.Value.z + moving.Direction.z * DeltaTime); // moving.LifeSpan -= DeltaTime; // if (translation.Value.y > 7.0f || moving.LifeSpan <= 0f || translation.Value.x > 20f) // { // CommandBuffer.RemoveComponent<MoveRandom>(index, entity); // CommandBuffer.AddComponent<ResetCube>(index, entity); // } // } //} protected override JobHandle OnUpdate(JobHandle inputDeps) { var commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(); ///create the job that needs to be scheduled var job = new MoveJob { DeltaTime = Time.deltaTime, CommandBuffer = commandBuffer }.Schedule(this, inputDeps); m_Barrier.AddJobHandleForProducer(job); ///I have no idea if this is right but it does what I want it to /*job.Complete(); * * job = new MoveRandomJob * { * DeltaTime = Time.deltaTime, * CommandBuffer = commandBuffer * }.Schedule(this, inputDeps); * * m_Barrier.AddJobHandleForProducer(job); */ return(job); }
protected override JobHandle OnUpdate(JobHandle inputDependencies) { var cmdBuf = _bufSystem.CreateCommandBuffer().ToConcurrent(); var deltaTime = Time.DeltaTime; return(Entities .WithName("ThinkingSystem") .WithoutBurst() .ForEach((Entity entity, int entityInQueryIndex, ref EyesightComponent eyesight, in PropertyComponent property) => { eyesight.thinkingTime -= property.intelligence * deltaTime; if (0.0f < eyesight.thinkingTime) { return; } cmdBuf.AddComponent(entityInQueryIndex, entity, new ReactiveComponent() { target = eyesight.target }); if (SomethingProxy.Type.Wall == (SomethingProxy.Type)eyesight.type) { cmdBuf.AddComponent(entityInQueryIndex, entity, new WallComponent()); } cmdBuf.RemoveComponent <EyesightComponent>(entityInQueryIndex, entity); }) .Schedule(inputDependencies)); }