public void SetArchetype(ArchetypeManager typeMan, Entity entity, Archetype *archetype,
int *sharedComponentDataIndices)
{
var chunk = typeMan.GetChunkWithEmptySlots(archetype, sharedComponentDataIndices);
var chunkIndex = typeMan.AllocateIntoChunk(chunk);
var oldArchetype = m_Entities[entity.Index].Archetype;
var oldChunk = m_Entities[entity.Index].Chunk;
var oldChunkIndex = m_Entities[entity.Index].IndexInChunk;
ChunkDataUtility.Convert(oldChunk, oldChunkIndex, chunk, chunkIndex);
if (chunk->ManagedArrayIndex >= 0 && oldChunk->ManagedArrayIndex >= 0)
{
ChunkDataUtility.CopyManagedObjects(typeMan, oldChunk, oldChunkIndex, chunk, chunkIndex, 1);
}
m_Entities[entity.Index].Archetype = archetype;
m_Entities[entity.Index].Chunk = chunk;
m_Entities[entity.Index].IndexInChunk = chunkIndex;
var lastIndex = oldChunk->Count - 1;
// No need to replace with ourselves
if (lastIndex != oldChunkIndex)
{
var lastEntity = (Entity *)ChunkDataUtility.GetComponentData(oldChunk, lastIndex, 0);
m_Entities[lastEntity->Index].IndexInChunk = oldChunkIndex;
ChunkDataUtility.Copy(oldChunk, lastIndex, oldChunk, oldChunkIndex, 1);
if (oldChunk->ManagedArrayIndex >= 0)
{
ChunkDataUtility.CopyManagedObjects(typeMan, oldChunk, lastIndex, oldChunk, oldChunkIndex, 1);
}
}
if (oldChunk->ManagedArrayIndex >= 0)
{
ChunkDataUtility.ClearManagedObjects(typeMan, oldChunk, lastIndex, 1);
}
--oldArchetype->EntityCount;
typeMan.SetChunkCount(oldChunk, lastIndex);
}
public void MoveEntityToChunk(ArchetypeManager typeMan, Entity entity, Chunk *newChunk, int newChunkIndex)
{
var oldChunk = m_Entities[entity.Index].Chunk;
Assert.IsTrue(oldChunk->Archetype == newChunk->Archetype);
var oldChunkIndex = m_Entities[entity.Index].IndexInChunk;
ChunkDataUtility.Copy(oldChunk, oldChunkIndex, newChunk, newChunkIndex, 1);
if (oldChunk->ManagedArrayIndex >= 0)
{
ChunkDataUtility.CopyManagedObjects(typeMan, oldChunk, oldChunkIndex, newChunk, newChunkIndex, 1);
}
m_Entities[entity.Index].Chunk = newChunk;
m_Entities[entity.Index].IndexInChunk = newChunkIndex;
var lastIndex = oldChunk->Count - 1;
// No need to replace with ourselves
if (lastIndex != oldChunkIndex)
{
var lastEntity = (Entity *)ChunkDataUtility.GetComponentData(oldChunk, lastIndex, 0);
m_Entities[lastEntity->Index].IndexInChunk = oldChunkIndex;
ChunkDataUtility.Copy(oldChunk, lastIndex, oldChunk, oldChunkIndex, 1);
if (oldChunk->ManagedArrayIndex >= 0)
{
ChunkDataUtility.CopyManagedObjects(typeMan, oldChunk, lastIndex, oldChunk, oldChunkIndex, 1);
}
}
if (oldChunk->ManagedArrayIndex >= 0)
{
ChunkDataUtility.ClearManagedObjects(typeMan, oldChunk, lastIndex, 1);
}
newChunk->Archetype->EntityCount--;
typeMan.SetChunkCount(oldChunk, oldChunk->Count - 1);
}
public void DeallocateEnties(ArchetypeManager typeMan, SharedComponentDataManager sharedComponentDataManager, Entity *entities, int count)
{
while (count != 0)
{
int indexInChunk;
int batchCount;
Chunk *chunk;
//Profiler.BeginSample("DeallocateDataEntitiesInChunk");
fixed(EntityDataManager *manager = &this)
{
#if USE_BURST_DESTROY
chunk = ms_DeallocateDataEntitiesInChunkDelegate(manager, entities, count, out indexInChunk, out batchCount);
#else
chunk = DeallocateDataEntitiesInChunk(manager, entities, count, out indexInChunk, out batchCount);
#endif
}
//Profiler.EndSample();
IncrementComponentOrderVersion(chunk->Archetype, chunk, sharedComponentDataManager);
if (chunk->ManagedArrayIndex >= 0)
{
// We can just chop-off the end, no need to copy anything
if (chunk->Count != indexInChunk + batchCount)
{
ChunkDataUtility.CopyManagedObjects(typeMan, chunk, chunk->Count - batchCount, chunk,
indexInChunk, batchCount);
}
ChunkDataUtility.ClearManagedObjects(typeMan, chunk, chunk->Count - batchCount, batchCount);
}
chunk->Archetype->EntityCount -= batchCount;
typeMan.SetChunkCount(chunk, chunk->Count - batchCount);
entities += batchCount;
count -= batchCount;
}
}
public void TryRemoveEntityId(Entity *entities, int count, ArchetypeManager archetypeManager,
SharedComponentDataManager sharedComponentDataManager,
EntityGroupManager groupManager, ComponentTypeInArchetype *componentTypeInArchetypeArray)
{
var entityIndex = 0;
while (entityIndex != count)
{
int indexInChunk;
int batchCount;
fixed(EntityDataManager *manager = &this)
{
var chunk = EntityChunkBatch(manager, entities + entityIndex, count - entityIndex, out indexInChunk,
out batchCount);
var archetype = GetArchetype(entities[entityIndex]);
if (!archetype->SystemStateCleanupNeeded)
{
DeallocateDataEntitiesInChunk(manager, entities + entityIndex, chunk, indexInChunk, batchCount);
IncrementComponentOrderVersion(chunk->Archetype, chunk, sharedComponentDataManager);
if (chunk->ManagedArrayIndex >= 0)
{
// We can just chop-off the end, no need to copy anything
if (chunk->Count != indexInChunk + batchCount)
{
ChunkDataUtility.CopyManagedObjects(archetypeManager, chunk, chunk->Count - batchCount,
chunk,
indexInChunk, batchCount);
}
ChunkDataUtility.ClearManagedObjects(archetypeManager, chunk, chunk->Count - batchCount,
batchCount);
}
chunk->Archetype->EntityCount -= batchCount;
archetypeManager.SetChunkCount(chunk, chunk->Count - batchCount);
}
else
{
for (var batchEntityIndex = 0; batchEntityIndex < batchCount; batchEntityIndex++)
{
var entity = entities[entityIndex + batchEntityIndex];
var removedTypes = 0;
var removedComponentIsShared = false;
for (var t = 1; t < archetype->TypesCount; ++t)
{
var type = archetype->Types[t];
if (!(type.IsSystemStateComponent || type.IsSystemStateSharedComponent))
{
++removedTypes;
removedComponentIsShared |= type.IsSharedComponent;
}
else
{
componentTypeInArchetypeArray[t - removedTypes] = archetype->Types[t];
}
}
componentTypeInArchetypeArray[archetype->TypesCount - removedTypes] =
new ComponentTypeInArchetype(ComponentType.Create <CleanupEntity>());
var newType = archetypeManager.GetOrCreateArchetype(componentTypeInArchetypeArray,
archetype->TypesCount - removedTypes + 1, groupManager);
int *sharedComponentDataIndices = null;
if (newType->NumSharedComponents > 0)
{
var oldSharedComponentDataIndices =
GetComponentChunk(entity)->SharedComponentValueArray;
if (removedComponentIsShared)
{
int *tempAlloc = stackalloc int[newType->NumSharedComponents];
sharedComponentDataIndices = tempAlloc;
var srcIndex = 0;
var dstIndex = 0;
for (var t = 0; t < archetype->TypesCount; ++t)
{
if (archetype->SharedComponentOffset[t] != -1)
{
var typeIndex = archetype->Types[t].TypeIndex;
var systemStateType = typeof(ISystemStateComponentData).IsAssignableFrom(TypeManager.GetType(typeIndex));
var systemStateSharedType = typeof(ISystemStateSharedComponentData).IsAssignableFrom(TypeManager.GetType(typeIndex));
if (!(systemStateType || systemStateSharedType))
{
srcIndex++;
}
else
{
sharedComponentDataIndices[dstIndex] =
oldSharedComponentDataIndices[srcIndex];
srcIndex++;
dstIndex++;
}
}
}
}
else
{
// reuse old sharedComponentDataIndices
sharedComponentDataIndices = oldSharedComponentDataIndices;
}
}
IncrementComponentOrderVersion(archetype, GetComponentChunk(entity),
sharedComponentDataManager);
SetArchetype(archetypeManager, entity, newType, sharedComponentDataIndices);
}
}
}
entityIndex += batchCount;
}
}
public void TryRemoveEntityId(Entity *entities, int count, ArchetypeManager archetypeManager,
SharedComponentDataManager sharedComponentDataManager,
EntityGroupManager groupManager, ComponentTypeInArchetype *componentTypeInArchetypeArray)
{
var entityIndex = 0;
while (entityIndex != count)
{
int indexInChunk;
int batchCount;
fixed(EntityDataManager *manager = &this)
{
var chunk = EntityChunkBatch(manager, entities + entityIndex, count - entityIndex, out indexInChunk,
out batchCount);
var archetype = GetArchetype(entities[entityIndex]);
if (!archetype->SystemStateCleanupNeeded)
{
DeallocateDataEntitiesInChunk(manager, entities + entityIndex, chunk, indexInChunk, batchCount);
IncrementComponentOrderVersion(chunk->Archetype, chunk, sharedComponentDataManager);
if (chunk->ManagedArrayIndex >= 0)
{
// We can just chop-off the end, no need to copy anything
if (chunk->Count != indexInChunk + batchCount)
{
ChunkDataUtility.CopyManagedObjects(archetypeManager, chunk, chunk->Count - batchCount,
chunk,
indexInChunk, batchCount);
}
ChunkDataUtility.ClearManagedObjects(archetypeManager, chunk, chunk->Count - batchCount,
batchCount);
}
chunk->Archetype->EntityCount -= batchCount;
archetypeManager.SetChunkCount(chunk, chunk->Count - batchCount);
}
else
{
var newType = archetype->SystemStateResidueArchetype;
int *sharedComponentDataIndices = chunk->SharedComponentValueArray;
if ((newType->NumSharedComponents > 0) && (newType->NumSharedComponents != archetype->NumSharedComponents))
{
var oldSharedComponentDataIndices = sharedComponentDataIndices;
int *tempAlloc = stackalloc int[newType->NumSharedComponents];
sharedComponentDataIndices = tempAlloc;
int oldIndex = 0;
for (int newIndex = 0; newIndex < newType->TypesCount; ++newIndex, ++oldIndex)
{
if (newType->SharedComponentOffset[newIndex] != -1)
{
var t = newType->Types[newIndex];
while (t != archetype->Types[oldIndex])
{
++oldIndex;
}
var newOffset = newType->SharedComponentOffset[newIndex];
var oldOffset = archetype->SharedComponentOffset[oldIndex];
sharedComponentDataIndices[newOffset] = oldSharedComponentDataIndices[oldOffset];
}
}
}
for (var batchEntityIndex = 0; batchEntityIndex < batchCount; batchEntityIndex++)
{
var entity = entities[entityIndex + batchEntityIndex];
IncrementComponentOrderVersion(archetype, GetComponentChunk(entity),
sharedComponentDataManager);
SetArchetype(archetypeManager, entity, newType, sharedComponentDataIndices);
}
}
}
entityIndex += batchCount;
}
}