protected override JobHandle OnUpdate(JobHandle inputDeps) { var entityType = GetArchetypeChunkEntityType(); JobHandle playerHandle; var playerEntity = playerGroup.ToEntityArray(Allocator.TempJob, out playerHandle); var updateJob = new UpdateJob { snapshotFromEntity = GetBufferFromEntity <ShipSnapshotData>(), targetTick = NetworkTimeSystem.interpolateTargetTick }; inputDeps = updateJob.Schedule(this, inputDeps); var destroyJob = new DestroyJob { commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(), entityType = entityType, playerEntity = playerEntity, playerStateFromEntity = GetComponentDataFromEntity <PlayerStateComponentData>() }; inputDeps = destroyJob.Schedule(destroyGroup, JobHandle.CombineDependencies(inputDeps, playerHandle)); m_Barrier.AddJobHandleForProducer(inputDeps); return(inputDeps); }
NativeArray <SceneTag> ExternalRefToSceneTag(NativeArray <ExternalEntityRefInfo> externalEntityRefInfos, Allocator allocator) { var sceneTags = new NativeArray <SceneTag>(externalEntityRefInfos.Length, allocator); using (var sectionDataEntities = m_SectionData.ToEntityArray(Allocator.TempJob)) { using (var sectionData = m_SectionData.ToComponentDataArray <SceneData>(Allocator.TempJob)) { for (int i = 0; i < sectionData.Length; ++i) { for (int j = 0; j < externalEntityRefInfos.Length; ++j) { if ( externalEntityRefInfos[j].SceneGUID == sectionData[i].SceneGUID && externalEntityRefInfos[j].SubSectionIndex == sectionData[i].SubSectionIndex ) { sceneTags[j] = new SceneTag { SceneEntity = sectionDataEntities[i] }; break; } } } } } return(sceneTags); }
protected override void OnUpdate() { using (NativeArray <Entity> playerSpawns = playerSpawnGroup.ToEntityArray(Allocator.TempJob)) { int playerCount = 0; foreach (Entity playerSpawn in playerSpawns) { GameObject playerPrefab = EntityManager.GetSharedComponentData <PlayerSpawn>(playerSpawn).prefab; Entity playerEntity = EntityManager.Instantiate(playerPrefab); Player player = EntityManager.GetComponentData <Player>(playerEntity); Position playerPosition = EntityManager.GetComponentData <Position>(playerSpawn); Rotation playerRotation = EntityManager.GetComponentData <Rotation>(playerSpawn); player.Id = playerCount; EntityManager.SetComponentData(playerEntity, player); EntityManager.SetComponentData(playerEntity, playerPosition); EntityManager.SetComponentData(playerEntity, playerRotation); EntityManager.DestroyEntity(playerSpawn); playerCount++; } } }
protected override void OnUpdate() { using (var rows = _rows.ToEntityArray(Allocator.TempJob)) { foreach (var row in rows) { var rowData = EntityManager.GetSharedComponentData <CompositionRow>(row); var positions = rowData.Positions; positions.Sort(CompareByDistance); var queue = new NativeQueue <float2>(Allocator.Persistent); foreach (var pos in positions) { queue.Enqueue(pos); } var maxPos = positions[positions.Count - 1]; var maxLength = 10 + math.max(math.abs(maxPos.x), math.abs(maxPos.y)); var runtimeRow = new RuntimeRow { Prefab = rowData.Prefab, Delay = rowData.Delay, Interval = rowData.Interval, Positions = queue, Distance = maxLength }; EntityManager.AddSharedComponentData(row, runtimeRow); EntityManager.RemoveComponent <CompositionRow>(row); } } }
protected override void OnUpdate() { //Get all selected units using (var selectedUnits = m_selectedUnits.ToEntityArray(Allocator.TempJob)) using (var highlights = m_highlights.ToEntityArray(Allocator.TempJob)) { foreach (var selectedUnit in selectedUnits) { //Bit of a hack, but we know there is only one highlight spawner var highlight = highlights[0]; var prefab = EntityManager.GetSharedComponentData <HighlightSpawner>(highlight).prefab; var entity = EntityManager.Instantiate(prefab); //Trying out the Attach component with the TransformSystem var attach = EntityManager.CreateEntity(typeof(Attach)); EntityManager.SetComponentData(entity, new Position { Value = new float3(0, -0.5f, 0) }); EntityManager.SetComponentData(entity, new Scale { Value = new float3(2, 0.1f, 2) }); EntityManager.SetComponentData(attach, new Attach { Parent = selectedUnit, Child = entity }); // Remove the "tagging" component so we only create & attach // the highlight once EntityManager.RemoveComponent(selectedUnit, typeof(Selecting)); } } }
private void DestroyExceedingCharacters(int count, int maxCount, int entityCount) { if (entityCount > 0) { return; } if (maxCount == 0 && count > 0) { World.GetExistingManager <BeginSimulationEntityCommandBufferSystem>().CreateCommandBuffer().CreateEntity(m_DestroyAllCharactersArchetype); } else if (entityCount < 0) { entityCount = math.abs(entityCount); var entityArray = m_Group.ToEntityArray(Allocator.TempJob); var maxDestroyCount = math.select(entityCount, m_MaxDestroyCount, entityCount > m_MaxDestroyCount); for (var entityIndex = 0; entityIndex < maxDestroyCount; entityIndex++) { PostUpdateCommands.AddComponent(entityArray[entityIndex], new Destroy()); PostUpdateCommands.AddComponent(entityArray[entityIndex], new Disabled()); } entityArray.Dispose(); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var transforms = m_InitialTransformGroup.GetTransformAccessArray(); var entities = m_InitialTransformGroup.ToEntityArray(Allocator.TempJob); var transformStashes = new NativeArray <TransformStash>(transforms.length, Allocator.TempJob); var stashTransformsJob = new StashTransforms { transformStashes = transformStashes }; var stashTransformsJobHandle = stashTransformsJob.Schedule(transforms, inputDeps); var copyTransformsJob = new CopyTransforms { transformStashes = transformStashes, }; var copyTransformsJobHandle = copyTransformsJob.ScheduleGroup(m_InitialTransformGroup, stashTransformsJobHandle); var removeComponentsJob = new RemoveCopyInitialTransformFromGameObjectComponent { entities = entities, entityCommandBuffer = m_EntityCommandBufferSystem.CreateCommandBuffer() }; var removeComponentsJobHandle = removeComponentsJob.Schedule(copyTransformsJobHandle); m_EntityCommandBufferSystem.AddJobHandleForProducer(removeComponentsJobHandle); return(removeComponentsJobHandle); }
protected override void OnUpdate() { int cameraGroupLength = cameraGroup.CalculateLength(); int mapGroupLength = mapGroup.CalculateLength(); if ((cameraGroupLength == 0) || (cameraGroupLength != mapGroupLength)) { return; } var cameraEntities = cameraGroup.ToEntityArray(Allocator.TempJob); var mapEntities = mapGroup.ToEntityArray(Allocator.TempJob); Position position; for (int i = 0; i < cameraEntities.Length; i++) { Map map = EntityManager.GetSharedComponentData <Map>(mapEntities[i]); position.Value = new float3(map.cols / 2, map.rows / 2, -10f); EntityManager.SetComponentData <Position>(cameraEntities[i], position); EntityManager.RemoveComponent <Initializer>(cameraEntities[i]); } cameraEntities.Dispose(); mapEntities.Dispose(); }
public void DetachFromAllVehicles() { using (var trafficEntities = m_AliveVehiclesGroup.ToEntityArray(Allocator.TempJob)) { for (int i = 0; i < trafficEntities.Length; ++i) { EntityManager.RemoveComponent <VehicleEmitter>(trafficEntities[i]); EntityManager.RemoveComponent <PositionalFlyByData>(trafficEntities[i]); } } using (var flyBys = m_FlyByGroup.ToEntityArray(Allocator.TempJob)) { for (int i = 0; i < flyBys.Length; ++i) { EntityManager.DestroyEntity(flyBys[i]); } } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { inputDeps = new ProcessJob { DamagedEntityArray = m_Group.ToEntityArray(Allocator.TempJob), DamagedFromEntity = GetComponentDataFromEntity <Damaged>(true), HealthFromEntity = GetComponentDataFromEntity <Health>() }.Schedule(m_Group.CalculateLength(), 64, inputDeps); return(inputDeps); }
void DestroyAllButOneEntityInGroup(int version, ComponentGroup group) { var entities = group.ToEntityArray(Allocator.TempJob); for (int i = 0; i < 49; i++) { var e = entities[i]; m_Manager.DestroyEntity(e); } entities.Dispose(); }
protected override void OnUpdate() { int spawnerLength = spawnerGroup.CalculateLength(); int mapLength = mapGroup.CalculateLength(); if (spawnerLength <= 0 || mapLength <= 0 || spawnerLength != mapLength) { return; } var spawnerEntities = spawnerGroup.ToEntityArray(Allocator.TempJob); var mapEntities = mapGroup.ToEntityArray(Allocator.TempJob); PhysicsObject physicsObject; for (int k = 0; k < spawnerEntities.Length; k++) { Map map = EntityManager.GetSharedComponentData <Map>(mapEntities[k]); Spawner spawner = EntityManager.GetSharedComponentData <Spawner>(spawnerEntities[k]); for (int i = 1; i < map.rows - 1; i++) { for (int j = 1; j < map.cols - 1; j++) { if ((i == map.rows / 2) && (j == map.cols / 2)) { var entity = EntityManager.Instantiate(spawner.playerPrefab); physicsObject = spawner.playerPrefab.GetComponent <PhysicsObjectProxy>().Value; physicsObject.cx = j; physicsObject.cy = i; EntityManager.SetComponentData(entity, physicsObject); } else if (map.mapArray[i * map.cols + j] == 0) { if (rnd.NextFloat(0f, 1f) > 0.3f) { var entity = EntityManager.Instantiate(spawner.obstaclePrefab); physicsObject = spawner.playerPrefab.GetComponent <PhysicsObjectProxy>().Value; physicsObject.cx = j; physicsObject.cy = i; EntityManager.SetComponentData(entity, physicsObject); } } } } EntityManager.RemoveComponent <Initializer>(spawnerEntities[k]); } spawnerEntities.Dispose(); mapEntities.Dispose(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var transforms = m_TransformGroup.GetTransformAccessArray(); var entities = m_TransformGroup.ToEntityArray(Allocator.TempJob); var copyTransformsJob = new CopyTransforms { LocalToWorlds = GetComponentDataFromEntity <LocalToWorld>(true), entities = entities }; return(copyTransformsJob.Schedule(transforms, inputDeps)); }
protected override void OnUpdate() { using (var rows = _rows.ToEntityArray(Allocator.TempJob)) { foreach (var row in rows) { var rowData = EntityManager.GetSharedComponentData <RuntimeRow>(row); if (rowData.Delay > 0) { rowData.Delay -= Time.deltaTime; EntityManager.SetSharedComponentData(row, rowData); continue; } if (rowData.Positions.Count == 0) { rowData.Positions.Dispose(); EntityManager.DestroyEntity(row); continue; } if (rowData.Timer < rowData.Interval) { rowData.Timer += Time.deltaTime; } else { rowData.Timer = 0; var pos2D = rowData.Positions.Dequeue(); var pos = EntityManager.GetComponentData <Position>(row).Value; pos.x += pos2D.x; pos.z += pos2D.y; var instance = EntityManager.Instantiate(rowData.Prefab); var startPos = GetStartPos(pos, rowData.Distance); var speedPerUnit = EntityManager.GetComponentData <MovementSpeed>(instance).Value; var actualSpeed = speedPerUnit / math.distance(startPos, pos); EntityManager.SetComponentData(instance, new Position() { Value = startPos }); EntityManager.SetComponentData(instance, new MovementSpeed { Value = actualSpeed }); EntityManager.AddComponentData(instance, new MovementTarget() { Start = startPos, End = pos }); } EntityManager.SetSharedComponentData(row, rowData); } } }
protected override void OnUpdate() { var groupEntities = m_MainGroup.ToEntityArray(Allocator.TempJob); foreach (var entity in groupEntities) { var creator = EntityManager.GetComponentData <CreatePyramids>(entity); float3 boxSize = creator.BoxSize; int boxCount = creator.Count * (creator.Height * (creator.Height + 1) / 2); var positions = new NativeArray <float3>(boxCount, Allocator.Temp); int boxIdx = 0; for (int p = 0; p < creator.Count; p++) { for (int i = 0; i < creator.Height; i++) { int rowSize = creator.Height - i; float3 start = new float3(-rowSize * boxSize.x * 0.5f + boxSize.x * 0.5f, i * boxSize.y, 0); for (int j = 0; j < rowSize; j++) { float3 shift = new float3(j * boxSize.x, 0f, p * boxSize.z * creator.Space); positions[boxIdx] = creator.StartPosition; positions[boxIdx] += start + shift; boxIdx++; } } } var entities = new NativeArray <Entity>(boxCount, Allocator.Temp); EntityManager.Instantiate(creator.BoxEntity, entities); var pyramidComponent = new PhysicsPyramid(); for (boxIdx = 0; boxIdx < entities.Length; boxIdx++) { EntityManager.AddComponentData <PhysicsPyramid>(entities[boxIdx], pyramidComponent); EntityManager.SetComponentData <Translation>(entities[boxIdx], new Translation() { Value = positions[boxIdx] }); } entities.Dispose(); positions.Dispose(); PostUpdateCommands.DestroyEntity(entity); } groupEntities.Dispose(); }
protected override void OnUpdate() { using (var attachedHighlights = m_highlights.ToEntityArray(Allocator.TempJob)) { foreach (var highlight in attachedHighlights) { var parent = EntityManager.GetComponentData <Parent>(highlight).Value; if (EntityManager.HasComponent <Deselecting>(parent)) { EntityManager.RemoveComponent <Deselecting>(parent); EntityManager.DestroyEntity(highlight); } } } }
protected override void OnUpdate() { using (var mapGeneratorEntities = mapGeneratorGroup.ToEntityArray(Allocator.TempJob)) { foreach (var generator in mapGeneratorEntities) { var map = EntityManager.GetSharedComponentData <Map>(generator); //map = WhiteRndInitMap(map); map = WorleyInitMap(map); //LogMap(map); EntityManager.SetSharedComponentData <Map>(generator, map); EntityManager.RemoveComponent <Initializer>(generator); SpawnMap(map); } } }
void ChangeGroupOrder(int version, ComponentGroup group) { var entities = group.ToEntityArray(Allocator.TempJob); for (int i = 0; i < 50; i++) { var e = entities[i]; if ((i & 0x01) == 0) { var testData2 = new EcsTestData2(i); m_Manager.AddComponentData(e, testData2); } } entities.Dispose(); }
protected override void OnUpdate() { if (controlGroup.CalculateLength() != 1) { throw new System.Exception("Number of Control Entity is not 1!"); } using (var controlEntities = controlGroup.ToEntityArray(Allocator.TempJob)) { var control = EntityManager.GetComponentData <Control>(controlEntities[0]); control.move = new float2(Input.GetAxis(Constants.Contorl.Horizontal), Input.GetAxis(Constants.Contorl.Vertial)); EntityManager.SetComponentData <Control>(controlEntities[0], control); } }
protected override void OnUpdate() { if (playerGroup.CalculateLength() != 1) { throw new System.Exception("Number of Player is not 1!"); } if (controlGroup.CalculateLength() != 1) { throw new System.Exception("Number of Control is not 1!"); } float dT = Time.deltaTime; var playerEntities = playerGroup.ToEntityArray(Allocator.TempJob); var controlEntities = controlGroup.ToEntityArray(Allocator.TempJob); var physicsObject = EntityManager.GetComponentData <PhysicsObject>(playerEntities[0]); var control = EntityManager.GetComponentData <Control>(controlEntities[0]); physicsObject.dx += physicsObject.moveSpeed * dT * control.move.x; physicsObject.dy += physicsObject.moveSpeed * dT * control.move.y; if (physicsObject.dx > physicsObject.maxSpeed) { physicsObject.dx = physicsObject.maxSpeed; } if (physicsObject.dx < -physicsObject.maxSpeed) { physicsObject.dx = -physicsObject.maxSpeed; } if (physicsObject.dy > physicsObject.maxSpeed) { physicsObject.dy = physicsObject.maxSpeed; } if (physicsObject.dy < -physicsObject.maxSpeed) { physicsObject.dy = -physicsObject.maxSpeed; } EntityManager.SetComponentData <PhysicsObject>(playerEntities[0], physicsObject); playerEntities.Dispose(); controlEntities.Dispose(); }
void UpdateRemoveParents() { var childEntities = m_RemovedParentsGroup.ToEntityArray(Allocator.TempJob); var previousParents = m_RemovedParentsGroup.ToComponentDataArray <PreviousParent>(Allocator.TempJob); for (int i = 0; i < childEntities.Length; i++) { var childEntity = childEntities[i]; var previousParentEntity = previousParents[i].Value; RemoveChildFromParent(childEntity, previousParentEntity); } EntityManager.RemoveComponent(m_RemovedParentsGroup, typeof(PreviousParent)); childEntities.Dispose(); previousParents.Dispose(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { // var reader = new OctreeReader(octree.octree); // var handle = new AssignVolumesAndHashJob // { // octree = reader, // ebc = barrier.CreateCommandBuffer().ToConcurrent(), // simulationBufferElement = GetBufferFromEntity<ChunkVolumes>(false) // }.Schedule(this, inputDeps); // // handle.Complete(); // reader.Dispose(); var handle = new VolumeBufferToHashJob { ebc = barrier.CreateCommandBuffer().ToConcurrent(), simulationBufferElement = GetBufferFromEntity <ChunkVolumes>(false), volumeBounds = GetComponentDataFromEntity <VolumeBounds>(true) }.Schedule(this, inputDeps); handle.Complete(); var disableChunksEntities = enabledChunks.ToEntityArray(Allocator.TempJob); var enableChunksEntities = disabledChunks.ToEntityArray(Allocator.TempJob); var disableHandle = new DisableEmptyChunksJob { chunks = disableChunksEntities, ecb = barrier.CreateCommandBuffer().ToConcurrent(), hashes = GetComponentDataFromEntity <ChunkVolumesHash>() }.Schedule(disableChunksEntities.Length, 64, handle); var enableHandle = new EnableFilledChunksJob { chunks = enableChunksEntities, ecb = barrier.CreateCommandBuffer().ToConcurrent(), hashes = GetComponentDataFromEntity <ChunkVolumesHash>() }.Schedule(enableChunksEntities.Length, 64, handle); var stateHandle = JobHandle.CombineDependencies(disableHandle, enableHandle); barrier.AddJobHandleForProducer(stateHandle); return(stateHandle); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var commandBuffer = m_Barrier.CreateCommandBuffer(); if (playerGroup.IsEmptyIgnoreFilter) { m_DelayedDespawnQueue.Clear(); var clearMapJob = new ClearMapJob { ghostMap = m_ghostEntityMap }; var clearHandle = clearMapJob.Schedule(inputDeps); var clearJob = new ClearGhostsJob { commandBuffer = commandBuffer.ToConcurrent() }; inputDeps = clearJob.Schedule(this, inputDeps); m_Barrier.AddJobHandleForProducer(inputDeps); return(JobHandle.CombineDependencies(inputDeps, clearHandle)); } serializers.BeginDeserialize(this); JobHandle playerHandle; var readJob = new ReadStreamJob { commandBuffer = commandBuffer, players = playerGroup.ToEntityArray(Allocator.TempJob, out playerHandle), snapshotFromEntity = GetBufferFromEntity <IncomingSnapshotDataStreamBufferComponent>(), snapshotAckFromEntity = GetComponentDataFromEntity <NetworkSnapshotAck>(), ghostEntityMap = m_ghostEntityMap, compressionModel = m_CompressionModel, serializers = serializers, #if ENABLE_UNITY_COLLECTIONS_CHECKS netStats = m_NetStats, #endif replicatedEntityType = ComponentType.ReadWrite <ReplicatedEntity>(), delayedDespawnQueue = m_DelayedDespawnQueue, targetTick = NetworkTimeSystem.interpolateTargetTick }; inputDeps = readJob.Schedule(JobHandle.CombineDependencies(inputDeps, playerHandle)); m_Barrier.AddJobHandleForProducer(inputDeps); return(inputDeps); }
protected override void OnUpdate() { var hasCameraTarget = HasSingleton <CameraTarget>(); if (hasCameraTarget && !EntityManager.Exists(GetSingleton <CameraTarget>().Value)) { EntityManager.RemoveComponent(m_RemoveGroup, ComponentType.ReadWrite <CameraTarget>()); } if (Input.GetKeyDown(KeyCode.Space) || Input.GetMouseButtonDown(1) || !hasCameraTarget) { Entities.With(m_AddGroup).ForEach((Entity entity, ref SpectatorCamera spectatorCamera, ref Translation translation, ref Rotation rotation) => { if (m_TargetGroup.CalculateLength() == 0) { return; } var targetArray = m_TargetGroup.ToEntityArray(Unity.Collections.Allocator.TempJob); var target = targetArray[m_Random.NextInt(0, targetArray.Length)]; if (!hasCameraTarget) { PostUpdateCommands.AddComponent(entity, new CameraTarget { Value = target }); } else { PostUpdateCommands.SetComponent(entity, new CameraTarget { Value = target }); } targetArray.Dispose(); }); } if (hasCameraTarget) { Entities.With(m_Group).ForEach((ref SpectatorCamera spectatorCamera, ref Translation translation, ref Rotation rotation, ref CameraTarget cameraTarget) => { translation.Value = math.lerp(translation.Value, EntityManager.GetComponentData <Translation>(cameraTarget.Value).Value, Time.deltaTime); rotation.Value = math.mul(math.normalize(rotation.Value), quaternion.AxisAngle(math.up(), spectatorCamera.RotationSpeed * Time.deltaTime)); }); } }
void UpdateNewParents() { var childEntities = m_NewParentsGroup.ToEntityArray(Allocator.TempJob); var parents = m_NewParentsGroup.ToComponentDataArray <Parent>(Allocator.TempJob); EntityManager.AddComponent(m_NewParentsGroup, typeof(PreviousParent)); for (int i = 0; i < childEntities.Length; i++) { var childEntity = childEntities[i]; var parentEntity = parents[i].Value; AddChildToParent(childEntity, parentEntity); } childEntities.Dispose(); parents.Dispose(); }
public void ExecuteEach(EntityManager entityManager, ComponentGroup phaseEnablerGroup) { NativeArray <Entity> entities = phaseEnablerGroup.ToEntityArray(Allocator.TempJob); for (int entityIndex = 0, numEntities = entities.Length; entityIndex < numEntities; ++entityIndex) { Entity entity = entities[entityIndex]; PhaseEnabler phaseEnabler = entityManager.GetComponentData <PhaseEnabler>(entity); ActivatableObject activatableObject = entityManager.GetSharedComponentData <ActivatableObject>(entity); if (!TryActivateObjectByPhase(ref phaseEnabler, ref activatableObject)) { continue; } entityManager.SetSharedComponentData <ActivatableObject>(entity, activatableObject); } entities.Dispose(); }
protected override JobHandle OnUpdate(JobHandle inputDeps) { var mapEntityArray = mapGroup.ToEntityArray(Allocator.TempJob); Map map = EntityManager.GetSharedComponentData <Map>(mapEntityArray[0]); var mapArray = new NativeArray <int>(map.mapArray, Allocator.TempJob); var objArray = objGroup.ToComponentDataArray <PhysicsObject>(Allocator.TempJob); var job = new CollisionJob { rows = map.rows, cols = map.cols, mapArray = mapArray, objArray = objArray }; mapEntityArray.Dispose(); return(job.Schedule(this, inputDeps)); }
protected override void OnUpdate() { // Get all the spawners in the scene. using (var spawners = m_Spawners.ToEntityArray(Allocator.TempJob)) { foreach (var spawner in spawners) { var spawnerData = EntityManager.GetSharedComponentData <ObjectSpawner>(spawner); var lastSpawnTime = spawnerData.lastSpawnTime; if (lastSpawnTime > 1.0f) { var count = spawnerData.spawnNumber; if (count > 0) { // Create an entity from the prefab set on the spawner component. var prefab = spawnerData.prefab; var entity = EntityManager.Instantiate(prefab); // Copy the position of the spawner to the new entity. var position = EntityManager.GetComponentData <Position>(spawner); var index = spawnerData.curIndex; position.Value += new float3(1.1f * index, 0, 0); EntityManager.SetComponentData(entity, position); spawnerData.curIndex = ++index; } count--; if (count <= 0) { // Destroy the spawner EntityManager.DestroyEntity(spawner); return; } // Write back spawnerData.spawnNumber = count; lastSpawnTime = 0f; } lastSpawnTime += UnityEngine.Time.deltaTime; spawnerData.lastSpawnTime = lastSpawnTime; EntityManager.SetSharedComponentData(spawner, spawnerData); } } }
void UpdateDeletedParents() { var previousParents = m_DeletedParentsGroup.ToEntityArray(Allocator.TempJob); for (int i = 0; i < previousParents.Length; i++) { var parentEntity = previousParents[i]; var childEntitiesSource = EntityManager.GetBuffer <Child>(parentEntity).AsNativeArray(); var childEntities = new NativeArray <Entity>(childEntitiesSource.Length, Allocator.Temp); for (int j = 0; j < childEntitiesSource.Length; j++) { childEntities[j] = childEntitiesSource[j].Value; } for (int j = 0; j < childEntities.Length; j++) { var childEntity = childEntities[j]; if (!EntityManager.Exists(childEntity)) { continue; } if (EntityManager.HasComponent(childEntity, typeof(Parent))) { EntityManager.RemoveComponent(childEntity, typeof(Parent)); } if (EntityManager.HasComponent(childEntity, typeof(PreviousParent))) { EntityManager.RemoveComponent(childEntity, typeof(PreviousParent)); } if (EntityManager.HasComponent(childEntity, typeof(LocalToParent))) { EntityManager.RemoveComponent(childEntity, typeof(LocalToParent)); } } childEntities.Dispose(); } EntityManager.RemoveComponent(m_DeletedParentsGroup, typeof(Child)); previousParents.Dispose(); }
protected override void OnUpdate() { // Get all the spawners in the scene. using (var spawners = m_Spawners.ToEntityArray(Allocator.TempJob)) { foreach (var spawner in spawners) { // Create an entity from the prefab set on the spawner component. var prefab = EntityManager.GetSharedComponentData <HelloSpawner>(spawner).prefab; var entity = EntityManager.Instantiate(prefab); // Copy the position of the spawner to the new entity. var position = EntityManager.GetComponentData <Position>(spawner); EntityManager.SetComponentData(entity, position); // Destroy the spawner so this system only runs once. EntityManager.DestroyEntity(spawner); } } }