public void Execute(int index)
{
var srcChunk = Chunks[index].m_Chunk;
var dstChunk = ClonedChunks[index].m_Chunk;
var copySize = Chunk.GetChunkBufferSize();
UnsafeUtility.MemCpy((byte *)dstChunk + Chunk.kBufferOffset, (byte *)srcChunk + Chunk.kBufferOffset, copySize);
BufferHeader.PatchAfterCloningChunk(dstChunk);
}
static Chunk *CloneChunkWithoutAllocatingEntities(EntityManager dstEntityManager, Chunk *srcChunk, ManagedComponentStore srcManagedComponentStore)
{
var dstEntityComponentStore = dstEntityManager.EntityComponentStore;
var dstManagedComponentStore = dstEntityManager.ManagedComponentStore;
// Copy shared component data
var dstSharedIndices = stackalloc int[srcChunk->Archetype->NumSharedComponents];
srcChunk->SharedComponentValues.CopyTo(dstSharedIndices, 0, srcChunk->Archetype->NumSharedComponents);
dstManagedComponentStore.CopySharedComponents(srcManagedComponentStore, dstSharedIndices, srcChunk->Archetype->NumSharedComponents);
// @TODO: Why don't we memcpy the whole chunk. So we include all extra fields???
// Allocate a new chunk
var srcArchetype = srcChunk->Archetype;
var dstArchetype = dstEntityComponentStore->GetOrCreateArchetype(srcArchetype->Types, srcArchetype->TypesCount);
var dstChunk = dstEntityComponentStore->GetCleanChunkNoMetaChunk(dstArchetype, dstSharedIndices);
dstManagedComponentStore.Playback(ref dstEntityComponentStore->ManagedChangesTracker);
dstChunk->metaChunkEntity = srcChunk->metaChunkEntity;
// Release any references obtained by GetCleanChunk & CopySharedComponents
for (var i = 0; i < srcChunk->Archetype->NumSharedComponents; i++)
{
dstManagedComponentStore.RemoveReference(dstSharedIndices[i]);
}
dstEntityComponentStore->SetChunkCountKeepMetaChunk(dstChunk, srcChunk->Count);
dstManagedComponentStore.Playback(ref dstEntityComponentStore->ManagedChangesTracker);
dstChunk->Archetype->EntityCount += srcChunk->Count;
var copySize = Chunk.GetChunkBufferSize();
UnsafeUtility.MemCpy((byte *)dstChunk + Chunk.kBufferOffset, (byte *)srcChunk + Chunk.kBufferOffset, copySize);
var numManagedComponents = dstChunk->Archetype->NumManagedComponents;
for (int t = 0; t < numManagedComponents; ++t)
{
int type = t + dstChunk->Archetype->FirstManagedComponent;
var offset = dstChunk->Archetype->Offsets[type];
var a = (int *)(dstChunk->Buffer + offset);
dstManagedComponentStore.CloneManagedComponentsFromDifferentWorld(a, dstChunk->Count, srcManagedComponentStore, ref *dstEntityManager.EntityComponentStore);
}
BufferHeader.PatchAfterCloningChunk(dstChunk);
dstChunk->SequenceNumber = srcChunk->SequenceNumber;
return(dstChunk);
}
static Chunk *CloneChunkWithoutAllocatingEntities(EntityManager dstEntityManager, Chunk *srcChunk, ManagedComponentStore srcManagedComponentStore)
{
var dstEntityComponentStore = dstEntityManager.EntityComponentStore;
var dstManagedComponentStore = dstEntityManager.ManagedComponentStore;
// Copy shared component data
var dstSharedIndices = stackalloc int[srcChunk->Archetype->NumSharedComponents];
srcChunk->SharedComponentValues.CopyTo(dstSharedIndices, 0, srcChunk->Archetype->NumSharedComponents);
dstManagedComponentStore.CopySharedComponents(srcManagedComponentStore, dstSharedIndices, srcChunk->Archetype->NumSharedComponents);
// @TODO: Why don't we memcpy the whole chunk. So we include all extra fields???
// Allocate a new chunk
var srcArchetype = srcChunk->Archetype;
var dstArchetype = dstEntityComponentStore->GetOrCreateArchetype(srcArchetype->Types, srcArchetype->TypesCount);
var dstChunk = dstEntityComponentStore->GetCleanChunkNoMetaChunk(dstArchetype, dstSharedIndices);
dstManagedComponentStore.Playback(ref dstEntityComponentStore->ManagedChangesTracker);
dstChunk->metaChunkEntity = srcChunk->metaChunkEntity;
// Release any references obtained by GetCleanChunk & CopySharedComponents
for (var i = 0; i < srcChunk->Archetype->NumSharedComponents; i++)
{
dstManagedComponentStore.RemoveReference(dstSharedIndices[i]);
}
dstEntityComponentStore->SetChunkCountKeepMetaChunk(dstChunk, srcChunk->Count);
dstManagedComponentStore.Playback(ref dstEntityComponentStore->ManagedChangesTracker);
dstChunk->Archetype->EntityCount += srcChunk->Count;
var copySize = Chunk.GetChunkBufferSize();
UnsafeUtility.MemCpy((byte *)dstChunk + Chunk.kBufferOffset, (byte *)srcChunk + Chunk.kBufferOffset, copySize);
// @TODO: Class components should be duplicated instead of copied by ref?
if (dstChunk->ManagedArrayIndex != -1)
{
ManagedComponentStore.CopyManagedObjects(srcManagedComponentStore, srcChunk->Archetype, srcChunk->ManagedArrayIndex, srcChunk->Capacity, 0, dstManagedComponentStore, dstChunk->Archetype, dstChunk->ManagedArrayIndex, dstChunk->Capacity, 0, srcChunk->Count);
}
BufferHeader.PatchAfterCloningChunk(dstChunk);
dstChunk->SequenceNumber = srcChunk->SequenceNumber;
return(dstChunk);
}
public static Chunk *CloneChunkForDiffing(Chunk *chunk,
ManagedComponentStore srcManagedManager,
EntityComponentStore *dstEntityComponentStore,
ManagedComponentStore dstManagedComponentStore,
EntityGroupManager dstEntityGroupManager)
{
int *sharedIndices = stackalloc int[chunk->Archetype->NumSharedComponents];
chunk->SharedComponentValues.CopyTo(sharedIndices, 0, chunk->Archetype->NumSharedComponents);
dstManagedComponentStore.CopySharedComponents(srcManagedManager, sharedIndices,
chunk->Archetype->NumSharedComponents);
// Allocate a new chunk
Archetype *arch = EntityManagerCreateArchetypeUtility.GetOrCreateArchetype(chunk->Archetype->Types,
chunk->Archetype->TypesCount, dstEntityComponentStore, dstEntityGroupManager);
Chunk *targetChunk = EntityManagerCreateDestroyEntitiesUtility.GetCleanChunk(arch, sharedIndices,
dstEntityComponentStore, dstManagedComponentStore, dstEntityGroupManager);
// GetCleanChunk & CopySharedComponents both acquire a ref, once chunk owns, release CopySharedComponents ref
for (int i = 0; i < chunk->Archetype->NumSharedComponents; ++i)
{
dstManagedComponentStore.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);
EntityManagerCreateDestroyEntitiesUtility.SetChunkCount(targetChunk, chunk->Count,
dstEntityComponentStore, dstManagedComponentStore, dstEntityGroupManager);
targetChunk->Archetype->EntityCount += chunk->Count;
BufferHeader.PatchAfterCloningChunk(targetChunk);
var tempEntities = new NativeArray <Entity>(targetChunk->Count, Allocator.Temp);
dstEntityComponentStore->AllocateEntities(targetChunk->Archetype, targetChunk, 0, targetChunk->Count,
(Entity *)tempEntities.GetUnsafePtr());
tempEntities.Dispose();
return(targetChunk);
}
static Chunk *CloneChunkWithoutAllocatingEntities(EntityManager dstEntityManager, Chunk *srcChunk, ManagedComponentStore srcManagedComponentStore)
{
var dstAccess = dstEntityManager.GetCheckedEntityDataAccess();
var dstEntityComponentStore = dstAccess->EntityComponentStore;
var dstManagedComponentStore = dstAccess->ManagedComponentStore;
// Copy shared component data
var dstSharedIndices = stackalloc int[srcChunk->Archetype->NumSharedComponents];
srcChunk->SharedComponentValues.CopyTo(dstSharedIndices, 0, srcChunk->Archetype->NumSharedComponents);
dstManagedComponentStore.CopySharedComponents(srcManagedComponentStore, dstSharedIndices, srcChunk->Archetype->NumSharedComponents);
// @TODO: Why don't we memcpy the whole chunk. So we include all extra fields???
// Allocate a new chunk
var srcArchetype = srcChunk->Archetype;
var dstArchetype = dstEntityComponentStore->GetOrCreateArchetype(srcArchetype->Types, srcArchetype->TypesCount);
var dstChunk = dstEntityComponentStore->GetCleanChunkNoMetaChunk(dstArchetype, dstSharedIndices);
dstManagedComponentStore.Playback(ref dstEntityComponentStore->ManagedChangesTracker);
dstChunk->metaChunkEntity = srcChunk->metaChunkEntity;
// Release any references obtained by GetCleanChunk & CopySharedComponents
for (var i = 0; i < srcChunk->Archetype->NumSharedComponents; i++)
{
dstManagedComponentStore.RemoveReference(dstSharedIndices[i]);
}
ChunkDataUtility.SetChunkCountKeepMetaChunk(dstChunk, srcChunk->Count);
dstManagedComponentStore.Playback(ref dstEntityComponentStore->ManagedChangesTracker);
dstChunk->Archetype->EntityCount += srcChunk->Count;
var copySize = Chunk.GetChunkBufferSize();
UnsafeUtility.MemCpy((byte *)dstChunk + Chunk.kBufferOffset, (byte *)srcChunk + Chunk.kBufferOffset, copySize);
var numManagedComponents = dstChunk->Archetype->NumManagedComponents;
var hasHybridComponents = dstArchetype->HasHybridComponents;
for (int t = 0; t < numManagedComponents; ++t)
{
int indexInArchetype = t + dstChunk->Archetype->FirstManagedComponent;
if (hasHybridComponents)
{
// We consider hybrid components as always different, there's no reason to clone those at this point
var typeCategory = TypeManager.GetTypeInfo(dstChunk->Archetype->Types[indexInArchetype].TypeIndex).Category;
if (typeCategory == TypeManager.TypeCategory.Class)
{
continue;
}
}
var offset = dstChunk->Archetype->Offsets[indexInArchetype];
var a = (int *)(dstChunk->Buffer + offset);
dstManagedComponentStore.CloneManagedComponentsFromDifferentWorld(a, dstChunk->Count, srcManagedComponentStore, ref *dstAccess->EntityComponentStore);
}
BufferHeader.PatchAfterCloningChunk(dstChunk);
dstChunk->SequenceNumber = srcChunk->SequenceNumber;
return(dstChunk);
}
