internal Chunk *GetExistingChunkWithEmptySlots(SharedComponentValues sharedComponentValues)
{
if (NumSharedComponents == 0)
{
if (ChunksWithEmptySlots.Length != 0)
{
var chunk = ChunksWithEmptySlots.Ptr[0];
Assert.AreNotEqual(chunk->Count, chunk->Capacity);
return(chunk);
}
}
else
{
var chunk = FreeChunksBySharedComponents.TryGet(sharedComponentValues, NumSharedComponents);
if (chunk != null)
{
return(chunk);
}
}
return(null);
}
public void AddToChunkList(Chunk *chunk, SharedComponentValues sharedComponentIndices, uint changeVersion)
{
chunk->ListIndex = Chunks.Count;
if (Chunks.Count == Chunks.Capacity)
{
int newCapacity = Chunks.Capacity == 0 ? 1 : Chunks.Capacity * 2;
if (Chunks.data <= sharedComponentIndices.firstIndex &&
sharedComponentIndices.firstIndex < Chunks.data + Chunks.Count)
{
int sourceChunk = (int)(sharedComponentIndices.firstIndex - Chunks.data);
// The shared component indices we are inserting belong to the same archetype so they need to be adjusted after reallocation
Chunks.Grow(newCapacity);
sharedComponentIndices = Chunks.GetSharedComponentValues(sourceChunk);
}
else
{
Chunks.Grow(newCapacity);
}
}
Chunks.Add(chunk, sharedComponentIndices, changeVersion);
}
public void AddToChunkList(Chunk *chunk, SharedComponentValues sharedComponentIndices, uint changeVersion)
{
chunk->ListIndex = Chunks.Count;
if (Chunks.Count == Chunks.Capacity)
{
var newCapacity = (Chunks.Capacity == 0) ? 1 : (Chunks.Capacity * 2);
// The shared component indices we are inserting belong to the same archetype so they need to be adjusted after reallocation
if (Chunks.InsideAllocation((ulong)sharedComponentIndices.firstIndex))
{
int chunkIndex = (int)(sharedComponentIndices.firstIndex - Chunks.GetSharedComponentValueArrayForType(0));
Chunks.Grow(newCapacity);
sharedComponentIndices = Chunks.GetSharedComponentValues(chunkIndex);
}
else
{
Chunks.Grow(newCapacity);
}
}
Chunks.Add(chunk, sharedComponentIndices, changeVersion);
}
void ConstructChunk(Archetype *archetype, Chunk *chunk, SharedComponentValues sharedComponentValues)
{
chunk->Archetype = archetype;
chunk->Count = 0;
chunk->Capacity = archetype->ChunkCapacity;
chunk->SequenceNumber = AssignSequenceNumber(chunk);
chunk->metaChunkEntity = Entity.Null;
var numSharedComponents = archetype->NumSharedComponents;
if (numSharedComponents > 0)
{
for (var i = 0; i < archetype->NumSharedComponents; ++i)
{
var sharedComponentIndex = sharedComponentValues[i];
ManagedChangesTracker.AddReference(sharedComponentIndex);
}
}
archetype->AddToChunkList(chunk, sharedComponentValues, GlobalSystemVersion);
Assert.IsTrue(archetype->Chunks.Count != 0);
// Chunk can't be locked at at construction time
archetype->EmptySlotTrackingAddChunk(chunk);
if (numSharedComponents == 0)
{
Assert.IsTrue(archetype->ChunksWithEmptySlots.Length != 0);
}
else
{
Assert.IsTrue(archetype->FreeChunksBySharedComponents.TryGet(chunk->SharedComponentValues,
archetype->NumSharedComponents) != null);
}
chunk->Flags = 0;
}
public void Add(Chunk *chunk, SharedComponentValues sharedComponentIndices)
{
var chunkIndex = Count++;
p[chunkIndex] = chunk;
int *dst = data + chunkIndex;
int i = 0;
for (; i < SharedComponentCount; ++i)
{
*dst = sharedComponentIndices[i];
dst += Capacity;
}
for (; i < EntityCountIndex; ++i)
{
*dst = 0;
dst += Capacity;
}
*dst = chunk->Count;
}
static uint GetHashCode(SharedComponentValues sharedComponentValues, int numSharedComponents)
{
UInt32 result;
if (sharedComponentValues.stride == sizeof(int))
{
result = math.hash(sharedComponentValues.firstIndex, numSharedComponents * sizeof(int));
}
else
{
int *indexArray = stackalloc int[numSharedComponents];
for (int i = 0; i < numSharedComponents; ++i)
{
indexArray[i] = sharedComponentValues[i];
}
result = math.hash(indexArray, numSharedComponents * sizeof(int));
}
if (result == 0 || result == kSkipCode)
{
result = kAValidHashCode;
}
return(result);
}
public void Move(Entity entity, Archetype *archetype, SharedComponentValues sharedComponentValues)
{
var archetypeChunkFilter = new ArchetypeChunkFilter(archetype, sharedComponentValues);
Move(entity, ref archetypeChunkFilter);
}
static int InstantiateEntitiesOne(Entity srcEntity, Entity *outputEntities,
int instanceCount, InstantiateRemapChunk *remapChunks, int remapChunksCount,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore)
{
var src = entityComponentStore->GetEntityInChunk(srcEntity);
var srcArchetype = src.Chunk->Archetype;
var dstArchetype = srcArchetype->InstantiableArchetype;
var temp = stackalloc int[dstArchetype->NumSharedComponents];
if (RequiresBuildingResidueSharedComponentIndices(srcArchetype, dstArchetype))
{
BuildResidueSharedComponentIndices(srcArchetype, dstArchetype,
src.Chunk->SharedComponentValues, temp);
}
else
{
// Always copy shared component indices since GetChunkWithEmptySlots might reallocate the storage of SharedComponentValues
src.Chunk->SharedComponentValues.CopyTo(temp, 0, dstArchetype->NumSharedComponents);
}
SharedComponentValues sharedComponentValues = temp;
Chunk *chunk = null;
int instanceBeginIndex = 0;
while (instanceBeginIndex != instanceCount)
{
chunk = GetChunkWithEmptySlots(dstArchetype, sharedComponentValues,
entityComponentStore, managedComponentStore);
int indexInChunk;
var allocatedCount = AllocateIntoChunk(chunk, instanceCount - instanceBeginIndex, out indexInChunk,
entityComponentStore, managedComponentStore);
ChunkDataUtility.ReplicateComponents(src.Chunk, src.IndexInChunk, chunk, indexInChunk, allocatedCount);
entityComponentStore->AllocateEntities(dstArchetype, chunk, indexInChunk, allocatedCount,
outputEntities + instanceBeginIndex);
chunk->SetAllChangeVersions(entityComponentStore->GlobalSystemVersion);
#if UNITY_EDITOR
for (var i = 0; i < allocatedCount; ++i)
{
entityComponentStore->SetName(outputEntities[i + instanceBeginIndex], entityComponentStore->GetName(srcEntity));
}
#endif
if (remapChunks != null)
{
remapChunks[remapChunksCount].Chunk = chunk;
remapChunks[remapChunksCount].IndexInChunk = indexInChunk;
remapChunks[remapChunksCount].AllocatedCount = allocatedCount;
remapChunks[remapChunksCount].InstanceBeginIndex = instanceBeginIndex;
remapChunksCount++;
}
instanceBeginIndex += allocatedCount;
}
if (chunk != null)
{
managedComponentStore.IncrementComponentOrderVersion(dstArchetype, chunk->SharedComponentValues);
entityComponentStore->IncrementComponentTypeOrderVersion(dstArchetype);
}
return(remapChunksCount);
}