public void Execute(int index)
{
var srcChunk = SrcChunks[index].m_Chunk;
var dstChunk = DstChunks[index].m_Chunk;
var srcArchetype = srcChunk->Archetype;
var dstArchetype = dstChunk->Archetype;
ChunkDataUtility.CloneChangeVersions(srcArchetype, srcChunk->ListIndex, dstArchetype, dstChunk->ListIndex);
DstEntityComponentStore->AddExistingEntitiesInChunk(dstChunk);
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int entityOffset)
{
var archetype = chunk.Archetype.Archetype;
var indexInTypeArray = ChunkDataUtility.GetIndexInTypeArray(archetype, TypeIndex);
var typeOffset = archetype->Offsets[indexInTypeArray];
var typeSize = archetype->SizeOfs[indexInTypeArray];
var dst = chunk.m_Chunk->Buffer + typeOffset;
var src = ComponentData + (entityOffset * typeSize);
var copySize = typeSize * chunk.Count;
UnsafeUtility.MemCpy(dst, src, copySize);
}
public unsafe void Execute(int index)
{
var chunk = Chunks[index].m_Chunk;
var archetype = chunk->Archetype;
var entities = (Entity *)(ChunkUtility.GetBuffer(chunk) + archetype->Offsets[0]);
var componentTypeIndexInArchetype = ChunkDataUtility.GetIndexInTypeArray(archetype, ComponentTypeIndex);
var componentBuffer = (TComponentData *)(ChunkUtility.GetBuffer(chunk) + archetype->Offsets[componentTypeIndexInArchetype]);
for (var i = 0; i < chunk->Count; ++i)
{
ComponentDataToEntity.Add(componentBuffer[i], entities[i]);
}
}
public Chunk *GetCleanChunk(Archetype *archetype, SharedComponentValues sharedComponentValues)
{
var newChunk = AllocateChunk();
ChunkDataUtility.AddEmptyChunk(archetype, newChunk, sharedComponentValues);
if (archetype->MetaChunkArchetype != null)
{
CreateMetaEntityForChunk(newChunk);
}
return(newChunk);
}
ArchetypeChunkFilter GetArchetypeChunkFilterWithChangedSharedComponent(Chunk *srcChunk, ComponentType componentType, int dstSharedComponentIndex)
{
var typeIndex = componentType.TypeIndex;
var srcArchetype = srcChunk->Archetype;
var indexInTypeArray = ChunkDataUtility.GetIndexInTypeArray(srcArchetype, typeIndex);
var srcSharedComponentValueArray = srcChunk->SharedComponentValues;
var sharedComponentOffset = indexInTypeArray - srcArchetype->FirstSharedComponent;
var srcSharedComponentIndex = srcSharedComponentValueArray[sharedComponentOffset];
if (dstSharedComponentIndex == srcSharedComponentIndex)
{
return(default);
public bool HasChunkComponent <T>(ArchetypeChunkComponentType <T> chunkComponentType)
where T : struct, IComponentData
{
var metaChunkArchetype = m_Chunk->Archetype->MetaChunkArchetype;
if (metaChunkArchetype == null)
{
return(false);
}
var typeIndexInArchetype = ChunkDataUtility.GetIndexInTypeArray(m_Chunk->Archetype->MetaChunkArchetype, chunkComponentType.m_TypeIndex);
return(typeIndexInArchetype != -1);
}
public void Execute(ArchetypeChunk batchInChunk, int batchIndex, int indexOfFirstEntityInQuery)
{
var archetype = batchInChunk.Archetype.Archetype;
var indexInTypeArray = ChunkDataUtility.GetIndexInTypeArray(archetype, TypeIndex);
var typeOffset = archetype->Offsets[indexInTypeArray];
var typeSize = archetype->SizeOfs[indexInTypeArray];
var dst = batchInChunk.m_Chunk->Buffer + typeOffset;
var src = ComponentData + (indexOfFirstEntityInQuery * typeSize);
var copySize = typeSize * batchInChunk.Count;
UnsafeUtility.MemCpy(dst, src, copySize);
}
/// <summary>
/// Returns a version number that increases whenever read-write access to the given
/// component is requested from this chunk, or 0 if the component doesn't exist in the chunk.
/// </summary>
/// <param name="chunkComponentType"></param>
/// <typeparam name="ArchetypeChunkComponentTypeDynamic"></typeparam>
/// <returns>Current version number of the given component</returns>
public uint GetChangeVersion(ArchetypeChunkComponentTypeDynamic chunkComponentType)
{
int cache = chunkComponentType.m_TypeLookupCache;
ChunkDataUtility.GetIndexInTypeArray(m_Chunk->Archetype, chunkComponentType.m_TypeIndex, ref cache);
chunkComponentType.m_TypeLookupCache = (short)cache;
int typeIndexInArchetype = cache;
if (typeIndexInArchetype == -1)
{
return(0);
}
return(m_Chunk->GetChangeVersion(typeIndexInArchetype));
}
public void AssertCanAddChunkComponent(NativeArray <ArchetypeChunk> chunkArray, ComponentType componentType)
{
var chunks = (ArchetypeChunk *)chunkArray.GetUnsafeReadOnlyPtr();
for (int i = 0; i < chunkArray.Length; ++i)
{
var chunk = chunks[i].m_Chunk;
if (ChunkDataUtility.GetIndexInTypeArray(chunk->Archetype, componentType.TypeIndex) != -1)
{
throw new ArgumentException(
$"A chunk component with type:{componentType} has already been added to the chunk.");
}
}
}
static void DestroyChunkForDiffing(EntityManager entityManager, Chunk *chunk)
{
var count = chunk->Count;
ChunkDataUtility.DeallocateBuffers(chunk);
entityManager.EntityComponentStore->DeallocateManagedComponents(chunk, 0, count);
chunk->Archetype->EntityCount -= chunk->Count;
entityManager.EntityComponentStore->FreeEntities(chunk);
entityManager.EntityComponentStore->SetChunkCountKeepMetaChunk(chunk, 0);
entityManager.ManagedComponentStore.Playback(ref entityManager.EntityComponentStore->ManagedChangesTracker);
}
/// <summary>
/// Reports whether any of IBufferElementData components of the type T, in the chunk containing the
/// specified <see cref="Entity"/>, could have changed.
/// </summary>
/// <remarks>
/// Note that for efficiency, the change version applies to whole chunks not individual entities. The change
/// version is incremented even when another job or system that has declared write access to a component does
/// not actually change the component value.</remarks>
/// <param name="entity">The entity.</param>
/// <param name="version">The version to compare. In a system, this parameter should be set to the
/// current <see cref="Unity.Entities.ComponentSystemBase.LastSystemVersion"/> at the time the job is run or
/// scheduled.</param>
/// <returns>True, if the version number stored in the chunk for this component is more recent than the version
/// passed to the <paramref name="version"/> parameter.</returns>
public bool DidChange(Entity entity, uint version)
{
var chunk = m_EntityComponentStore->GetChunk(entity);
var typeIndexInArchetype = ChunkDataUtility.GetIndexInTypeArray(chunk->Archetype, m_TypeIndex);
if (typeIndexInArchetype == -1)
{
return(false);
}
var chunkVersion = chunk->GetChangeVersion(typeIndexInArchetype);
return(ChangeVersionUtility.DidChange(chunkVersion, version));
}
public void CheckCanAddChunkComponent(NativeArray <ArchetypeChunk> chunkArray, ComponentType componentType, ref bool result)
{
var chunks = (ArchetypeChunk *)chunkArray.GetUnsafeReadOnlyPtr();
for (int i = 0; i < chunkArray.Length; ++i)
{
var chunk = chunks[i].m_Chunk;
if (ChunkDataUtility.GetIndexInTypeArray(chunk->Archetype, componentType.TypeIndex) != -1)
{
result = false;
return;
}
}
}
public unsafe uint GetComponentVersion <T>(ArchetypeChunkComponentType <T> chunkComponentType) where T : struct, IComponentData
{
uint num2;
int indexInTypeArray = ChunkDataUtility.GetIndexInTypeArray(this.m_Chunk.Archetype, chunkComponentType.m_TypeIndex);
if (indexInTypeArray == -1)
{
num2 = 0;
}
else
{
num2 = this.m_Chunk.ChangeVersion[indexInTypeArray];
}
return(num2);
}
public void CreateEntities(ArchetypeManager archetypeManager, Archetype *archetype, Entity *entities, int count)
{
while (count != 0)
{
var chunk = archetypeManager.GetChunkWithEmptySlots(archetype, null);
int allocatedIndex;
var allocatedCount = archetypeManager.AllocateIntoChunk(chunk, count, out allocatedIndex);
AllocateEntities(archetype, chunk, allocatedIndex, allocatedCount, entities);
ChunkDataUtility.ClearComponents(chunk, allocatedIndex, allocatedCount);
entities += allocatedCount;
count -= allocatedCount;
}
IncrementComponentTypeOrderVersion(archetype);
}
public int GetSharedComponentIndex <T>(ArchetypeChunkSharedComponentType <T> chunkSharedComponentData)
where T : struct, ISharedComponentData
{
var archetype = m_Chunk->Archetype;
var typeIndexInArchetype = ChunkDataUtility.GetIndexInTypeArray(archetype, chunkSharedComponentData.m_TypeIndex);
if (typeIndexInArchetype == -1)
{
return(-1);
}
var chunkSharedComponentIndex = typeIndexInArchetype - archetype->FirstSharedComponent;
var sharedComponentIndex = m_Chunk->GetSharedComponentValue(chunkSharedComponentIndex);
return(sharedComponentIndex);
}
public object GetComponentBoxed(Entity entity, Type type)
{
m_Manager.EntityComponentStore->AssertEntitiesExist(&entity, 1);
var archetype = m_Manager.m_EntityComponentStore->GetArchetype(entity);
var typeIndex = ChunkDataUtility.GetTypeIndexFromType(archetype, type);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (typeIndex == -1)
{
throw new ArgumentException($"A component with type:{type} has not been added to the entity.");
}
#endif
return(GetComponentBoxed(entity, ComponentType.FromTypeIndex(typeIndex)));
}
public ArchetypeChunkComponentObjects <T> GetComponentObjects <T>(ArchetypeChunkComponentType <T> componentType, EntityManager manager)
where T : class
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(componentType.m_Safety);
#endif
var archetype = m_Chunk->Archetype;
var typeIndexInArchetype = ChunkDataUtility.GetIndexInTypeArray(archetype, componentType.m_TypeIndex);
int offset, length;
var array = manager.ArchetypeManager.GetManagedObjectRange(m_Chunk, typeIndexInArchetype, out offset, out length);
var componentArray = new ArchetypeChunkComponentObjects <T>(offset, length, array);
return(componentArray);
}
public void GetCacheForType(int componentType, out ComponentChunkCache cache, out int typeIndexInArchetype)
{
var archetype = m_CurrentMatchingArchetype->Archetype;
typeIndexInArchetype = ChunkDataUtility.GetIndexInTypeArray(archetype, componentType);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (typeIndexInArchetype == -1)
{
throw new System.ArgumentException("componentType does not exist in the iterated archetype");
}
#endif
cache.CachedBeginIndex = m_CurrentChunkIndex + m_CurrentArchetypeIndex;
cache.CachedEndIndex = cache.CachedBeginIndex + m_CurrentChunk->Count;
cache.CachedSizeOf = archetype->SizeOfs[typeIndexInArchetype];
cache.CachedPtr = m_CurrentChunk->Buffer + archetype->Offsets[typeIndexInArchetype] - cache.CachedBeginIndex * cache.CachedSizeOf;
}
public void AssertCanRemoveComponent(NativeArray <ArchetypeChunk> chunkArray, ComponentType componentType)
{
var chunks = (ArchetypeChunk *)chunkArray.GetUnsafeReadOnlyPtr();
for (int i = 0; i < chunkArray.Length; ++i)
{
var chunk = chunks[i].m_Chunk;
if (ChunkDataUtility.GetIndexInTypeArray(chunk->Archetype, componentType.TypeIndex) != -1)
{
if (chunk->Locked)
{
throw new InvalidOperationException(
"Cannot remove components from locked Chunks. Unlock Chunk first.");
}
}
}
}
// ----------------------------------------------------------------------------------------------------------
// PUBLIC
// ----------------------------------------------------------------------------------------------------------
public void CreateEntities(Archetype *archetype, Entity *entities, int count)
{
var archetypeChunkFilter = new ArchetypeChunkFilter();
archetypeChunkFilter.Archetype = archetype;
while (count != 0)
{
var chunk = GetChunkWithEmptySlots(ref archetypeChunkFilter);
var allocateCount = math.min(count, chunk->UnusedCount);
ChunkDataUtility.Allocate(chunk, entities, allocateCount);
entities += allocateCount;
count -= allocateCount;
}
}
public unsafe int GetSharedComponentIndex <T>(ArchetypeChunkSharedComponentType <T> chunkSharedComponentData) where T : struct, ISharedComponentData
{
int num4;
Unity.Entities.Archetype *archetype = this.m_Chunk.Archetype;
int indexInTypeArray = ChunkDataUtility.GetIndexInTypeArray(archetype, chunkSharedComponentData.m_TypeIndex);
if (indexInTypeArray == -1)
{
num4 = -1;
}
else
{
int index = archetype->SharedComponentOffset[indexInTypeArray];
num4 = this.m_Chunk.SharedComponentValueArray[index];
}
return(num4);
}
static void DestroyChunkForDiffing(EntityManager entityManager, Chunk *chunk)
{
var access = entityManager.GetCheckedEntityDataAccess();
var ecs = access->EntityComponentStore;
var mcs = access->ManagedComponentStore;
var count = chunk->Count;
ChunkDataUtility.DeallocateBuffers(chunk);
ecs->DeallocateManagedComponents(chunk, 0, count);
chunk->Archetype->EntityCount -= chunk->Count;
ecs->FreeEntities(chunk);
ChunkDataUtility.SetChunkCountKeepMetaChunk(chunk, 0);
mcs.Playback(ref ecs->ManagedChangesTracker);
}
public void Execute()
{
var access = EntityManager.GetCheckedEntityDataAccess();
var ecs = access->EntityComponentStore;
for (var i = 0; i < Chunks.Length; i++)
{
var chunk = Chunks[i].m_Chunk;
var count = chunk->Count;
ChunkDataUtility.DeallocateBuffers(chunk);
ecs->DeallocateManagedComponents(chunk, 0, count);
chunk->Archetype->EntityCount -= chunk->Count;
ecs->FreeEntities(chunk);
ChunkDataUtility.SetChunkCountKeepMetaChunk(chunk, 0);
}
}
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);
}
internal void DeallocateDataEntitiesInChunk(Chunk *chunk, int indexInChunk, int batchCount)
{
DeallocateBuffers(chunk, indexInChunk, batchCount);
DeallocateManagedComponents(chunk, indexInChunk, batchCount);
var freeIndex = m_NextFreeEntityIndex;
var entities = (Entity *)chunk->Buffer + indexInChunk;
for (var i = batchCount - 1; i >= 0; --i)
{
var entityIndex = entities[i].Index;
m_EntityInChunkByEntity[entityIndex].Chunk = null;
m_VersionByEntity[entityIndex]++;
m_EntityInChunkByEntity[entityIndex].IndexInChunk = freeIndex;
#if UNITY_EDITOR
m_NameByEntity[entityIndex] = new NumberedWords();
#endif
freeIndex = entityIndex;
}
m_NextFreeEntityIndex = freeIndex;
m_EntityCreateDestroyVersion++;
// Compute the number of things that need to moved and patched.
int patchCount = Math.Min(batchCount, chunk->Count - indexInChunk - batchCount);
if (0 == patchCount)
{
return;
}
// updates indexInChunk to point to where the components will be moved to
//Assert.IsTrue(chunk->archetype->sizeOfs[0] == sizeof(Entity) && chunk->archetype->offsets[0] == 0);
var movedEntities = (Entity *)chunk->Buffer + (chunk->Count - patchCount);
for (var i = 0; i != patchCount; i++)
{
m_EntityInChunkByEntity[movedEntities[i].Index].IndexInChunk = indexInChunk + i;
}
// Move component data from the end to where we deleted components
ChunkDataUtility.Copy(chunk, chunk->Count - patchCount, chunk, indexInChunk, patchCount);
}
public void CreateEntities(ArchetypeManager archetypeManager, Archetype *archetype, Entity *entities, int count)
{
int *sharedComponentDataIndices = stackalloc int[archetype->NumSharedComponents];
UnsafeUtility.MemClear(sharedComponentDataIndices, archetype->NumSharedComponents * sizeof(int));
while (count != 0)
{
var chunk = archetypeManager.GetChunkWithEmptySlots(archetype, sharedComponentDataIndices);
int allocatedIndex;
var allocatedCount = archetypeManager.AllocateIntoChunk(chunk, count, out allocatedIndex);
AllocateEntities(archetype, chunk, allocatedIndex, allocatedCount, entities);
ChunkDataUtility.InitializeComponents(chunk, allocatedIndex, allocatedCount);
entities += allocatedCount;
count -= allocatedCount;
}
IncrementComponentTypeOrderVersion(archetype);
}
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 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);
}
private static void DeallocateDataEntitiesInChunk(EntityDataManager *entityDataManager, Entity *entities,
Chunk *chunk, int indexInChunk, int batchCount)
{
DeallocateBuffers(entityDataManager, entities, chunk, batchCount);
var freeIndex = entityDataManager->m_EntitiesFreeIndex;
var entityDatas = entityDataManager->m_Entities;
for (var i = batchCount - 1; i >= 0; --i)
{
var entityIndex = entities[i].Index;
var data = entityDatas + entityIndex;
data->Chunk = null;
data->Version++;
data->IndexInChunk = freeIndex;
freeIndex = entityIndex;
}
entityDataManager->m_EntitiesFreeIndex = freeIndex;
// Compute the number of things that need to moved and patched.
int patchCount = Math.Min(batchCount, chunk->Count - indexInChunk - batchCount);
if (0 == patchCount)
{
return;
}
// updates EntitityData->indexInChunk to point to where the components will be moved to
//Assert.IsTrue(chunk->archetype->sizeOfs[0] == sizeof(Entity) && chunk->archetype->offsets[0] == 0);
var movedEntities = (Entity *)chunk->Buffer + (chunk->Count - patchCount);
for (var i = 0; i != patchCount; i++)
{
entityDataManager->m_Entities[movedEntities[i].Index].IndexInChunk = indexInChunk + i;
}
// Move component data from the end to where we deleted components
ChunkDataUtility.Copy(chunk, chunk->Count - patchCount, chunk, indexInChunk, patchCount);
}
// ----------------------------------------------------------------------------------------------------------
// PUBLIC
// ----------------------------------------------------------------------------------------------------------
public void CreateEntities(Archetype *archetype, Entity *entities, int count)
{
var archetypeChunkFilter = new ArchetypeChunkFilter();
archetypeChunkFilter.Archetype = archetype;
while (count != 0)
{
var chunk = GetChunkWithEmptySlots(ref archetypeChunkFilter);
int allocatedIndex;
var allocatedCount = AllocateIntoChunk(chunk, count, out allocatedIndex);
AllocateEntities(archetype, chunk, allocatedIndex, allocatedCount, entities);
ChunkDataUtility.InitializeComponents(chunk, allocatedIndex, allocatedCount);
chunk->SetAllChangeVersions(GlobalSystemVersion);
entities += allocatedCount;
count -= allocatedCount;
}
IncrementComponentTypeOrderVersion(archetype);
}