// ----------------------------------------------------------------------------------------------------------
// INTERNAL
// ----------------------------------------------------------------------------------------------------------
internal void DestroyEntityInternal(Entity *entities, int count)
{
BeforeStructuralChange();
EntityComponentStore->AssertCanDestroy(entities, count);
EntityComponentStore->DestroyEntities(entities, count);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
/// <summary>
/// Creates a set of entities of the specified archetype.
/// </summary>
/// <remarks>Fills the [NativeArray](https://docs.unity3d.com/ScriptReference/Unity.Collections.NativeArray_1.html)
/// object assigned to the `entities` parameter with the Entity objects of the created entities. Each entity
/// has the components specified by the <see cref="EntityArchetype"/> object assigned
/// to the `archetype` parameter. The EntityManager adds these entities to the <see cref="World"/> entity list. Use the
/// Entity objects in the array for further processing, such as setting the component values.</remarks>
/// <param name="archetype">The archetype defining the structure for the new entities.</param>
/// <param name="entities">An array to hold the Entity objects needed to access the new entities.
/// The length of the array determines how many entities are created.</param>
public void CreateEntity(EntityArchetype archetype, NativeArray <Entity> entities)
{
BeforeStructuralChange();
EntityComponentStore->CreateEntities(archetype.Archetype, (Entity *)entities.GetUnsafePtr(),
entities.Length);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
internal void AddComponent(UnsafeMatchingArchetypePtrList archetypeList, EntityQueryFilter filter, ComponentType componentType)
{
var jobHandle = new JobHandle();
//@TODO: Missing EntityQuery.SyncFilter
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
if (chunks.Length == 0)
{
return;
}
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->AssertCanAddComponent(chunks, componentType);
using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(chunks))
{
EntityComponentStore->AddComponentFromMainThread(entityBatchList, componentType, 0);
}
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
}
/// <summary>
/// Adds a component to each of the chunks identified by a EntityQuery and set the component values.
/// </summary>
/// <remarks>
/// This function finds all chunks whose archetype satisfies the EntityQuery and adds the specified
/// component to them.
///
/// A chunk component is common to all entities in a chunk. You can access a chunk <see cref="IComponentData"/>
/// instance through either the chunk itself or through an entity stored in that chunk.
///
/// **Important:** This function creates a sync point, which means that the EntityManager waits for all
/// currently running Jobs to complete before adding the component and no additional Jobs can start before
/// the function is finished. A sync point can cause a drop in performance because the ECS framework may not
/// be able to make use of the processing power of all available cores.
/// </remarks>
/// <param name="entityQuery">The EntityQuery identifying the chunks to modify.</param>
/// <param name="componentData">The data to set.</param>
/// <typeparam name="T">The type of component, which must implement IComponentData.</typeparam>
public void AddChunkComponentData <T>(EntityQuery entityQuery, T componentData) where T : struct, IComponentData
{
using (var chunks = entityQuery.CreateArchetypeChunkArray(Allocator.TempJob))
{
if (chunks.Length == 0)
{
return;
}
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->AssertCanAddChunkComponent(chunks, ComponentType.ChunkComponent <T>());
var type = ComponentType.ReadWrite <T>();
var chunkType = ComponentType.FromTypeIndex(TypeManager.MakeChunkComponentTypeIndex(type.TypeIndex));
using (var entityBatchList = EntityComponentStore->CreateEntityBatchList(chunks))
{
EntityComponentStore->AddComponentFromMainThread(entityBatchList, chunkType, 0);
EntityComponentStore->SetChunkComponent <T>(entityBatchList, componentData);
}
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
}
internal void InstantiateInternal(Entity srcEntity, Entity *outputEntities, int count)
{
BeforeStructuralChange();
EntityComponentStore->AssertEntitiesExist(&srcEntity, 1);
EntityComponentStore->InstantiateEntities(srcEntity, outputEntities, count);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
public void CreateChunk(EntityArchetype archetype, NativeArray <ArchetypeChunk> chunks, int entityCount)
{
BeforeStructuralChange();
EntityComponentStore->CreateChunks(archetype.Archetype, (ArchetypeChunk *)chunks.GetUnsafePtr(),
entityCount);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
public void CreateChunk(EntityArchetype archetype, NativeArray <ArchetypeChunk> chunks, int entityCount)
{
Unity.Entities.EntityComponentStore.AssertValidArchetype(EntityComponentStore, archetype);
BeforeStructuralChange();
EntityComponentStore->CreateChunks(archetype.Archetype, (ArchetypeChunk *)chunks.GetUnsafePtr(), chunks.Length, entityCount);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
internal void DestroyChunkForDiffing(Chunk *chunk)
{
chunk->Archetype->EntityCount -= chunk->Count;
EntityComponentStore->FreeEntities(chunk);
EntityComponentStore->SetChunkCountKeepMetaChunk(chunk, 0);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
public Entity CreateEntity()
{
BeforeStructuralChange();
Entity entity;
EntityComponentStore->CreateEntities(m_EntityDataAccess.GetEntityOnlyArchetype().Archetype, &entity, 1);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
return(entity);
}
// ----------------------------------------------------------------------------------------------------------
// PUBLIC
// ----------------------------------------------------------------------------------------------------------
/// <summary>
/// Creates an entity having the specified archetype.
/// </summary>
/// <remarks>
/// The EntityManager creates the entity in the first available chunk with the matching archetype that has
/// enough space.
///
/// **Important:** This function creates a sync point, which means that the EntityManager waits for all
/// currently running Jobs to complete before creating the entity and no additional Jobs can start before
/// the function is finished. A sync point can cause a drop in performance because the ECS framework may not
/// be able to make use of the processing power of all available cores.
/// </remarks>
/// <param name="archetype">The archetype for the new entity.</param>
/// <returns>The Entity object that you can use to access the entity.</returns>
public Entity CreateEntity(EntityArchetype archetype)
{
Entity entity;
BeforeStructuralChange();
EntityComponentStore->CreateEntities(archetype.Archetype, &entity, 1);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
return(entity);
}
/// <summary>
/// Removes a component from an entity.
/// </summary>
/// <remarks>
/// Removing a component changes an entity's archetype and results in the entity being moved to a different
/// chunk.
///
/// **Important:** This function creates a sync point, which means that the EntityManager waits for all
/// currently running Jobs to complete before removing the component and no additional Jobs can start before
/// the function is finished. A sync point can cause a drop in performance because the ECS framework may not
/// be able to make use of the processing power of all available cores.
/// </remarks>
/// <param name="entity">The entity to modify.</param>
/// <param name="type">The type of component to remove.</param>
public void RemoveComponent(Entity entity, ComponentType type)
{
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->RemoveComponent(entity, type);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
/// <summary>
/// Sets the shared component of an entity.
/// </summary>
/// <remarks>
/// Changing a shared component value of an entity results in the entity being moved to a
/// different chunk. The entity moves to a chunk with other entities that have the same shared component values.
/// A new chunk is created if no chunk with the same archetype and shared component values currently exists.
///
/// **Important:** This function creates a sync point, which means that the EntityManager waits for all
/// currently running Jobs to complete before setting the component and no additional Jobs can start before
/// the function is finished. A sync point can cause a drop in performance because the ECS framework may not
/// be able to make use of the processing power of all available cores.
/// </remarks>
/// <param name="entity">The entity</param>
/// <param name="componentData">A shared component object containing the values to set.</param>
/// <typeparam name="T">The shared component type.</typeparam>
public void SetSharedComponentData <T>(Entity entity, T componentData) where T : struct, ISharedComponentData
{
BeforeStructuralChange();
var typeIndex = TypeManager.GetTypeIndex <T>();
EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
var newSharedComponentDataIndex = m_ManagedComponentStore.InsertSharedComponent(componentData);
EntityComponentStore->SetSharedComponentDataIndex(entity, typeIndex, newSharedComponentDataIndex);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
ManagedComponentStore.RemoveReference(newSharedComponentDataIndex);
}
internal Chunk *CloneChunkForDiffingFrom(Chunk *chunk,
ManagedComponentStore srcManagedManager)
{
int *sharedIndices = stackalloc int[chunk->Archetype->NumSharedComponents];
chunk->SharedComponentValues.CopyTo(sharedIndices, 0, chunk->Archetype->NumSharedComponents);
ManagedComponentStore.CopySharedComponents(srcManagedManager, sharedIndices,
chunk->Archetype->NumSharedComponents);
// Allocate a new chunk
Archetype *arch = EntityComponentStore->GetOrCreateArchetype(chunk->Archetype->Types,
chunk->Archetype->TypesCount);
Chunk *targetChunk = EntityComponentStore->GetCleanChunk(arch, sharedIndices);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
// GetCleanChunk & CopySharedComponents both acquire a ref, once chunk owns, release CopySharedComponents ref
for (int i = 0; i < chunk->Archetype->NumSharedComponents; ++i)
{
ManagedComponentStore.RemoveReference(sharedIndices[i]);
}
UnityEngine.Assertions.Assert.AreEqual(0, targetChunk->Count);
UnityEngine.Assertions.Assert.IsTrue(targetChunk->Capacity >= chunk->Count);
int copySize = Chunk.GetChunkBufferSize();
UnsafeUtility.MemCpy(targetChunk->Buffer, chunk->Buffer, copySize);
EntityComponentStore->SetChunkCountKeepMetaChunk(targetChunk, chunk->Count);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
targetChunk->Archetype->EntityCount += chunk->Count;
BufferHeader.PatchAfterCloningChunk(targetChunk);
var tempEntities = new NativeArray <Entity>(targetChunk->Count, Allocator.Temp);
EntityComponentStore->AllocateEntities(targetChunk->Archetype, targetChunk, 0, targetChunk->Count,
(Entity *)tempEntities.GetUnsafePtr());
tempEntities.Dispose();
return(targetChunk);
}
public void SetArchetype(Entity entity, EntityArchetype archetype)
{
BeforeStructuralChange();
EntityComponentStore->AssertEntitiesExist(&entity, 1);
var oldArchetype = EntityComponentStore->GetArchetype(entity);
var newArchetype = archetype.Archetype;
Unity.Entities.EntityComponentStore.AssertArchetypeDoesNotRemoveSystemStateComponents(oldArchetype, newArchetype);
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->SetArchetype(entity, archetype);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
internal void SetSharedComponentDataBoxedDefaultMustBeNull(Entity entity, int typeIndex, int hashCode, object componentData)
{
BeforeStructuralChange();
EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
var newSharedComponentDataIndex = 0;
if (componentData != null) // null means default
{
newSharedComponentDataIndex = m_ManagedComponentStore.InsertSharedComponentAssumeNonDefault(typeIndex,
hashCode, componentData);
}
EntityComponentStore->SetSharedComponentDataIndex(entity, typeIndex, newSharedComponentDataIndex);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
ManagedComponentStore.RemoveReference(newSharedComponentDataIndex);
}
// ----------------------------------------------------------------------------------------------------------
// INTERNAL
// ----------------------------------------------------------------------------------------------------------
internal void AddComponent(Entity entity, ComponentType componentType, bool ignoreDuplicateAdd)
{
if (ignoreDuplicateAdd && HasComponent(entity, componentType))
{
return;
}
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->AssertCanAddComponent(entity, componentType);
EntityComponentStore->AddComponent(entity, componentType);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
internal void AddSharedComponentData(NativeArray <ArchetypeChunk> chunks, int sharedComponentIndex, ComponentType componentType)
{
if (chunks.Length == 0)
{
return;
}
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->AssertCanAddComponent(chunks, componentType);
EntityComponentStore->AddSharedComponent(chunks, componentType, sharedComponentIndex);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
ManagedComponentStore.RemoveReference(sharedComponentIndex);
}
/// <summary>
/// Remove a component from a set of entities.
/// </summary>
/// <remarks>
/// Removing a component changes an entity's archetype and results in the entity being moved to a different
/// chunk.
///
/// If an <see cref="Entity"/> object in the `entities` array refers to an entity that has been destroyed, this function
/// throws an ArgumentError exception.
///
/// **Important:** This function creates a sync point, which means that the EntityManager waits for all
/// currently running Jobs to complete before creating these chunks and no additional Jobs can start before
/// the function is finished. A sync point can cause a drop in performance because the ECS framework may not
/// be able to make use of the processing power of all available cores.
/// </remarks>
/// <param name="entities">An array of Entity objects.</param>
/// <param name="componentType">The type of component to remove.</param>
public void RemoveComponent(NativeArray <Entity> entities, ComponentType componentType)
{
if (entities.Length == 0)
{
return;
}
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(entities))
{
EntityComponentStore->RemoveComponentFromMainThread(entityBatchList, componentType, 0);
}
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
internal void DestroyEntity(UnsafeMatchingArchetypePtrList archetypeList, EntityQueryFilter filter)
{
Profiler.BeginSample("DestroyEntity(EntityQuery entityQueryFilter)");
Profiler.BeginSample("GetAllMatchingChunks");
var jobHandle = new JobHandle();
// @TODO: Missing EntityQuery.SyncFilter
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
Profiler.EndSample();
if (chunks.Length != 0)
{
BeforeStructuralChange();
Profiler.BeginSample("EditorOnlyChecks");
EntityComponentStore->AssertCanDestroy(chunks);
EntityComponentStore->AssertWillDestroyAllInLinkedEntityGroup(chunks, GetArchetypeChunkBufferType <LinkedEntityGroup>(false));
Profiler.EndSample();
// #todo @macton DestroyEntities should support IJobChunk. But internal writes need to be handled.
Profiler.BeginSample("DeleteChunks");
new DestroyChunks {
EntityComponentStore = EntityComponentStore, Chunks = chunks
}.Run();
Profiler.EndSample();
Profiler.BeginSample("Managed Playback");
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
Profiler.EndSample();
}
}
Profiler.EndSample();
}
internal void MoveChunksFromAll(
NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapping,
EntityComponentStore *srcEntityComponentStore,
ManagedComponentStore srcManagedComponentStore)
{
var access = GetCheckedEntityDataAccess();
var ecs = access->EntityComponentStore;
var mcs = access->ManagedComponentStore;
var moveChunksJob = new MoveAllChunksJob
{
srcEntityComponentStore = srcEntityComponentStore,
dstEntityComponentStore = ecs,
entityRemapping = entityRemapping
}.Schedule();
int managedComponentCount = srcEntityComponentStore->ManagedComponentIndexUsedCount;
NativeArray <int> srcManagedIndices = default;
NativeArray <int> dstManagedIndices = default;
JobHandle gatherManagedComponentIndices = default;
if (managedComponentCount > 0)
{
srcManagedIndices = new NativeArray <int>(managedComponentCount, Allocator.TempJob);
dstManagedIndices = new NativeArray <int>(managedComponentCount, Allocator.TempJob);
ecs->ReserveManagedComponentIndices(managedComponentCount);
gatherManagedComponentIndices = new
GatherAllManagedComponentIndicesJob
{
SrcEntityComponentStore = srcEntityComponentStore,
DstEntityComponentStore = ecs,
SrcManagedIndices = srcManagedIndices,
DstManagedIndices = dstManagedIndices
}.Schedule();
}
JobHandle.ScheduleBatchedJobs();
int chunkCount = 0;
for (var i = 0; i < srcEntityComponentStore->m_Archetypes.Length; ++i)
{
var srcArchetype = srcEntityComponentStore->m_Archetypes.Ptr[i];
chunkCount += srcArchetype->Chunks.Count;
}
var remapChunks = new NativeArray <RemapChunk>(chunkCount, Allocator.TempJob);
var remapArchetypes = new NativeArray <RemapArchetype>(srcEntityComponentStore->m_Archetypes.Length, Allocator.TempJob);
int chunkIndex = 0;
int archetypeIndex = 0;
for (var i = 0; i < srcEntityComponentStore->m_Archetypes.Length; ++i)
{
var srcArchetype = srcEntityComponentStore->m_Archetypes.Ptr[i];
if (srcArchetype->Chunks.Count != 0)
{
var dstArchetype = ecs->GetOrCreateArchetype(srcArchetype->Types,
srcArchetype->TypesCount);
remapArchetypes[archetypeIndex] = new RemapArchetype
{
srcArchetype = srcArchetype, dstArchetype = dstArchetype
};
for (var j = 0; j < srcArchetype->Chunks.Count; ++j)
{
var srcChunk = srcArchetype->Chunks.p[j];
remapChunks[chunkIndex] = new RemapChunk {
chunk = srcChunk, dstArchetype = dstArchetype
};
chunkIndex++;
}
archetypeIndex++;
ecs->IncrementComponentTypeOrderVersion(dstArchetype);
}
}
moveChunksJob.Complete();
mcs.Playback(ref ecs->ManagedChangesTracker);
srcManagedComponentStore.Playback(ref srcEntityComponentStore->ManagedChangesTracker);
k_ProfileMoveSharedComponents.Begin();
var remapShared = mcs.MoveAllSharedComponents(srcManagedComponentStore, Allocator.TempJob);
k_ProfileMoveSharedComponents.End();
gatherManagedComponentIndices.Complete();
k_ProfileMoveManagedComponents.Begin();
mcs.MoveManagedComponentsFromDifferentWorld(srcManagedIndices, dstManagedIndices, srcManagedIndices.Length, srcManagedComponentStore);
srcEntityComponentStore->m_ManagedComponentFreeIndex.Length = 0;
srcEntityComponentStore->m_ManagedComponentIndex = 1;
k_ProfileMoveManagedComponents.End();
new ChunkPatchEntities
{
RemapChunks = remapChunks,
EntityRemapping = entityRemapping,
EntityComponentStore = ecs
}.Run();
var remapAllChunksJob = new RemapAllChunksJob
{
dstEntityComponentStore = ecs,
remapChunks = remapChunks,
entityRemapping = entityRemapping
}.Schedule(remapChunks.Length, 1);
var remapArchetypesJob = new RemapAllArchetypesJob
{
remapArchetypes = remapArchetypes,
remapShared = remapShared,
dstEntityComponentStore = ecs,
chunkHeaderType = TypeManager.GetTypeIndex <ChunkHeader>()
}.Schedule(archetypeIndex, 1, remapAllChunksJob);
mcs.Playback(ref ecs->ManagedChangesTracker);
if (managedComponentCount > 0)
{
srcManagedIndices.Dispose();
dstManagedIndices.Dispose();
}
remapArchetypesJob.Complete();
remapShared.Dispose();
remapChunks.Dispose();
}
internal void MoveChunksFromFiltered(
NativeArray <ArchetypeChunk> chunks,
NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapping,
EntityComponentStore *srcEntityComponentStore,
ManagedComponentStore srcManagedComponentStore)
{
var access = GetCheckedEntityDataAccess();
var ecs = access->EntityComponentStore;
var mcs = access->ManagedComponentStore;
new MoveChunksJob
{
srcEntityComponentStore = srcEntityComponentStore,
dstEntityComponentStore = ecs,
entityRemapping = entityRemapping,
chunks = chunks
}.Run();
int chunkCount = chunks.Length;
var remapChunks = new NativeArray <RemapChunk>(chunkCount, Allocator.TempJob);
Archetype *previousSrcArchetypee = null;
Archetype *dstArchetype = null;
int managedComponentCount = 0;
NativeList <IntPtr> managedChunks = new NativeList <IntPtr>(0, Allocator.TempJob);
for (int i = 0; i < chunkCount; ++i)
{
var chunk = chunks[i].m_Chunk;
var archetype = chunk->Archetype;
// Move Chunk World. ChangeVersion:Yes OrderVersion:Yes
if (previousSrcArchetypee != archetype)
{
dstArchetype = ecs->GetOrCreateArchetype(archetype->Types, archetype->TypesCount);
}
remapChunks[i] = new RemapChunk {
chunk = chunk, dstArchetype = dstArchetype
};
if (dstArchetype->NumManagedComponents > 0)
{
managedComponentCount += chunk->Count * dstArchetype->NumManagedComponents;
managedChunks.Add((IntPtr)chunk);
}
if (archetype->MetaChunkArchetype != null)
{
Entity srcEntity = chunk->metaChunkEntity;
Entity dstEntity;
ecs->CreateEntities(dstArchetype->MetaChunkArchetype, &dstEntity, 1);
var srcEntityInChunk = srcEntityComponentStore->GetEntityInChunk(srcEntity);
var dstEntityInChunk = ecs->GetEntityInChunk(dstEntity);
ChunkDataUtility.SwapComponents(srcEntityInChunk.Chunk, srcEntityInChunk.IndexInChunk, dstEntityInChunk.Chunk, dstEntityInChunk.IndexInChunk, 1,
srcEntityComponentStore->GlobalSystemVersion, ecs->GlobalSystemVersion);
EntityRemapUtility.AddEntityRemapping(ref entityRemapping, srcEntity, dstEntity);
srcEntityComponentStore->DestroyEntities(&srcEntity, 1);
}
}
NativeArray <int> srcManagedIndices = default;
NativeArray <int> dstManagedIndices = default;
int nonNullManagedComponentCount = 0;
if (managedComponentCount > 0)
{
srcManagedIndices = new NativeArray <int>(managedComponentCount, Allocator.TempJob);
dstManagedIndices = new NativeArray <int>(managedComponentCount, Allocator.TempJob);
new
GatherManagedComponentIndicesInChunkJob()
{
SrcEntityComponentStore = srcEntityComponentStore,
DstEntityComponentStore = ecs,
SrcManagedIndices = srcManagedIndices,
DstManagedIndices = dstManagedIndices,
Chunks = managedChunks,
NonNullCount = &nonNullManagedComponentCount
}.Run();
}
mcs.Playback(ref ecs->ManagedChangesTracker);
srcManagedComponentStore.Playback(ref srcEntityComponentStore->ManagedChangesTracker);
k_ProfileMoveSharedComponents.Begin();
var remapShared = mcs.MoveSharedComponents(srcManagedComponentStore, chunks, Allocator.TempJob);
k_ProfileMoveSharedComponents.End();
if (managedComponentCount > 0)
{
k_ProfileMoveManagedComponents.Begin();
mcs.MoveManagedComponentsFromDifferentWorld(srcManagedIndices, dstManagedIndices, nonNullManagedComponentCount, srcManagedComponentStore);
srcEntityComponentStore->m_ManagedComponentFreeIndex.Add(srcManagedIndices.GetUnsafeReadOnlyPtr(), sizeof(int) * srcManagedIndices.Length);
k_ProfileMoveManagedComponents.End();
}
new ChunkPatchEntities
{
RemapChunks = remapChunks,
EntityRemapping = entityRemapping,
EntityComponentStore = ecs
}.Run();
var remapChunksJob = new RemapChunksFilteredJob
{
dstEntityComponentStore = ecs,
remapChunks = remapChunks,
entityRemapping = entityRemapping,
chunkHeaderType = TypeManager.GetTypeIndex <ChunkHeader>()
}.Schedule(remapChunks.Length, 1);
var moveChunksBetweenArchetypeJob = new MoveFilteredChunksBetweenArchetypexJob
{
RemapChunks = remapChunks,
RemapShared = remapShared,
GlobalSystemVersion = ecs->GlobalSystemVersion
}.Schedule(remapChunksJob);
moveChunksBetweenArchetypeJob.Complete();
mcs.Playback(ref ecs->ManagedChangesTracker);
if (managedComponentCount > 0)
{
srcManagedIndices.Dispose();
dstManagedIndices.Dispose();
}
managedChunks.Dispose();
remapShared.Dispose();
remapChunks.Dispose();
}
internal void MoveChunksFrom(
NativeArray <ArchetypeChunk> chunks,
NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapping,
EntityComponentStore *srcEntityComponentStore,
ManagedComponentStore srcManagedComponentStore)
{
new MoveChunksJob
{
srcEntityComponentStore = srcEntityComponentStore,
dstEntityComponentStore = EntityComponentStore,
entityRemapping = entityRemapping,
chunks = chunks
}.Run();
var managedArrayChunks = new NativeList <IntPtr>(Allocator.Temp);
int chunkCount = chunks.Length;
var remapChunks = new NativeArray <RemapChunk>(chunkCount, Allocator.TempJob);
for (int i = 0; i < chunkCount; ++i)
{
var chunk = chunks[i].m_Chunk;
var archetype = chunk->Archetype;
//TODO: this should not be done more than once for each archetype
var dstArchetype = EntityComponentStore->GetOrCreateArchetype(archetype->Types, archetype->TypesCount);
remapChunks[i] = new RemapChunk {
chunk = chunk, dstArchetype = dstArchetype
};
if (archetype->NumManagedArrays > 0)
{
managedArrayChunks.Add((IntPtr)chunk);
}
if (archetype->MetaChunkArchetype != null)
{
Entity srcEntity = chunk->metaChunkEntity;
Entity dstEntity;
EntityComponentStore->CreateEntities(dstArchetype->MetaChunkArchetype, &dstEntity, 1);
var srcEntityInChunk = srcEntityComponentStore->GetEntityInChunk(srcEntity);
var dstEntityInChunk = EntityComponentStore->GetEntityInChunk(dstEntity);
ChunkDataUtility.SwapComponents(srcEntityInChunk.Chunk, srcEntityInChunk.IndexInChunk, dstEntityInChunk.Chunk, dstEntityInChunk.IndexInChunk, 1,
srcEntityComponentStore->GlobalSystemVersion, EntityComponentStore->GlobalSystemVersion);
EntityRemapUtility.AddEntityRemapping(ref entityRemapping, srcEntity, dstEntity);
srcEntityComponentStore->DestroyEntities(&srcEntity, 1);
}
}
var managedArrayDstIndices = new NativeArray <int>(managedArrayChunks.Length, Allocator.TempJob);
var managedArraySrcIndices = new NativeArray <int>(managedArrayChunks.Length, Allocator.TempJob);
EntityComponentStore->ReserveManagedObjectArrays(managedArrayDstIndices);
var remapManaged = new RemapManagedArraysJob
{
chunks = managedArrayChunks,
dstIndices = managedArrayDstIndices,
srcIndices = managedArraySrcIndices,
}.Schedule(managedArrayChunks.Length, 64);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
srcManagedComponentStore.Playback(ref srcEntityComponentStore->ManagedChangesTracker);
k_ProfileMoveObjectComponents.Begin();
remapManaged.Complete();
m_ManagedComponentStore.MoveManagedObjectArrays(managedArraySrcIndices, managedArrayDstIndices, srcManagedComponentStore);
k_ProfileMoveObjectComponents.End();
managedArrayDstIndices.Dispose();
managedArraySrcIndices.Dispose();
managedArrayChunks.Dispose();
k_ProfileMoveSharedComponents.Begin();
var remapShared =
ManagedComponentStore.MoveSharedComponents(srcManagedComponentStore, chunks, Allocator.TempJob);
k_ProfileMoveSharedComponents.End();
new ChunkPatchEntities
{
RemapChunks = remapChunks,
EntityRemapping = entityRemapping,
EntityComponentStore = EntityComponentStore
}.Run();
var remapChunksJob = new RemapChunksJob
{
dstEntityComponentStore = EntityComponentStore,
remapChunks = remapChunks,
entityRemapping = entityRemapping
}.Schedule(remapChunks.Length, 1);
var moveChunksBetweenArchetypeJob = new MoveChunksBetweenArchetypeJob
{
remapChunks = remapChunks,
remapShared = remapShared,
globalSystemVersion = EntityComponentStore->GlobalSystemVersion
}.Schedule(remapChunksJob);
moveChunksBetweenArchetypeJob.Complete();
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
remapShared.Dispose();
remapChunks.Dispose();
}
internal void MoveChunksFrom(
NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapping,
EntityComponentStore *srcEntityComponentStore,
ManagedComponentStore srcManagedComponentStore)
{
var moveChunksJob = new MoveAllChunksJob
{
srcEntityComponentStore = srcEntityComponentStore,
dstEntityComponentStore = EntityComponentStore,
entityRemapping = entityRemapping
}.Schedule();
JobHandle.ScheduleBatchedJobs();
int chunkCount = 0;
for (var i = 0; i < srcEntityComponentStore->m_Archetypes.Length; ++i)
{
var srcArchetype = srcEntityComponentStore->m_Archetypes.Ptr[i];
chunkCount += srcArchetype->Chunks.Count;
}
var remapChunks = new NativeArray <RemapChunk>(chunkCount, Allocator.TempJob);
var remapArchetypes = new NativeArray <RemapArchetype>(srcEntityComponentStore->m_Archetypes.Length, Allocator.TempJob);
var managedArrayChunks = new NativeList <IntPtr>(Allocator.Temp);
int chunkIndex = 0;
int archetypeIndex = 0;
for (var i = 0; i < srcEntityComponentStore->m_Archetypes.Length; ++i)
{
var srcArchetype = srcEntityComponentStore->m_Archetypes.Ptr[i];
if (srcArchetype->Chunks.Count != 0)
{
var dstArchetype = EntityComponentStore->GetOrCreateArchetype(srcArchetype->Types,
srcArchetype->TypesCount);
remapArchetypes[archetypeIndex] = new RemapArchetype
{
srcArchetype = srcArchetype, dstArchetype = dstArchetype
};
for (var j = 0; j < srcArchetype->Chunks.Count; ++j)
{
var srcChunk = srcArchetype->Chunks.p[j];
remapChunks[chunkIndex] = new RemapChunk {
chunk = srcChunk, dstArchetype = dstArchetype
};
chunkIndex++;
}
if (srcArchetype->NumManagedArrays > 0)
{
for (var j = 0; j < srcArchetype->Chunks.Count; ++j)
{
var chunk = srcArchetype->Chunks.p[j];
managedArrayChunks.Add((IntPtr)chunk);
}
}
archetypeIndex++;
EntityComponentStore->IncrementComponentTypeOrderVersion(dstArchetype);
}
}
moveChunksJob.Complete();
var managedArrayDstIndices = new NativeArray <int>(managedArrayChunks.Length, Allocator.TempJob);
var managedArraySrcIndices = new NativeArray <int>(managedArrayChunks.Length, Allocator.TempJob);
EntityComponentStore->ReserveManagedObjectArrays(managedArrayDstIndices);
var remapManaged = new RemapManagedArraysJob
{
chunks = managedArrayChunks,
dstIndices = managedArrayDstIndices,
srcIndices = managedArraySrcIndices,
}.Schedule(managedArrayChunks.Length, 64);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
srcManagedComponentStore.Playback(ref srcEntityComponentStore->ManagedChangesTracker);
k_ProfileMoveObjectComponents.Begin();
remapManaged.Complete();
m_ManagedComponentStore.MoveManagedObjectArrays(managedArraySrcIndices, managedArrayDstIndices, srcManagedComponentStore);
k_ProfileMoveObjectComponents.End();
managedArrayDstIndices.Dispose();
managedArraySrcIndices.Dispose();
managedArrayChunks.Dispose();
k_ProfileMoveSharedComponents.Begin();
var remapShared =
ManagedComponentStore.MoveAllSharedComponents(srcManagedComponentStore, Allocator.TempJob);
k_ProfileMoveSharedComponents.End();
new ChunkPatchEntities
{
RemapChunks = remapChunks,
EntityRemapping = entityRemapping,
EntityComponentStore = EntityComponentStore
}.Run();
var remapAllChunksJob = new RemapAllChunksJob
{
dstEntityComponentStore = EntityComponentStore,
remapChunks = remapChunks,
entityRemapping = entityRemapping
}.Schedule(remapChunks.Length, 1);
var remapArchetypesJob = new RemapArchetypesJob
{
remapArchetypes = remapArchetypes,
remapShared = remapShared,
dstEntityComponentStore = EntityComponentStore,
chunkHeaderType = TypeManager.GetTypeIndex <ChunkHeader>()
}.Schedule(archetypeIndex, 1, remapAllChunksJob);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
remapArchetypesJob.Complete();
remapShared.Dispose();
remapChunks.Dispose();
}
