public static void InitializeComponents(Chunk *dstChunk, int dstIndex, int count)
{
var arch = dstChunk->Archetype;
var offsets = arch->Offsets;
var sizeOfs = arch->SizeOfs;
var dstBuffer = dstChunk->Buffer;
var typesCount = arch->TypesCount;
var types = arch->Types;
for (var t = 1; t != typesCount; t++)
{
var offset = offsets[t];
var sizeOf = sizeOfs[t];
var dst = dstBuffer + (offset + sizeOf * dstIndex);
if (types[t].IsBuffer)
{
for (var i = 0; i < count; ++i)
{
BufferHeader.Initialize((BufferHeader *)dst, types[t].BufferCapacity);
dst += sizeOf;
}
}
else
{
UnsafeUtility.MemClear(dst, sizeOf * count);
}
}
}
public static unsafe void InitializeComponents(Chunk *dstChunk, int dstIndex, int count)
{
Archetype *archetype = dstChunk.Archetype;
int * offsets = archetype->Offsets;
int * sizeOfs = archetype->SizeOfs;
byte * numPtr3 = &dstChunk.Buffer.FixedElementField;
int typesCount = archetype->TypesCount;
ComponentTypeInArchetype *types = archetype->Types;
for (int i = 1; i != typesCount; i++)
{
int num3 = offsets[i];
int num4 = sizeOfs[i];
byte *numPtr4 = numPtr3 + (num3 + (num4 * dstIndex));
if (!(types + i).IsBuffer)
{
UnsafeUtility.MemClear((void *)numPtr4, (long)(num4 * count));
}
else
{
int num5 = 0;
while (true)
{
if (num5 >= count)
{
break;
}
BufferHeader.Initialize((BufferHeader *)numPtr4, types[i].BufferCapacity);
numPtr4 += num4;
num5++;
}
}
}
}
public static void InitializeBuffersInChunk(byte *p, int count, int stride, int bufferCapacity)
{
for (int i = 0; i < count; i++)
{
BufferHeader.Initialize((BufferHeader *)p, bufferCapacity);
p += stride;
}
}
public static void ReplicateComponents(Chunk *srcChunk, int srcIndex, Chunk *dstChunk, int dstBaseIndex, int count)
{
var srcArchetype = srcChunk->Archetype;
var srcBuffer = srcChunk->Buffer;
var dstBuffer = dstChunk->Buffer;
var dstArchetype = dstChunk->Archetype;
var srcOffsets = srcArchetype->Offsets;
var srcSizeOfs = srcArchetype->SizeOfs;
var srcBufferCapacities = srcArchetype->BufferCapacities;
var srcTypesCount = srcArchetype->TypesCount;
var srcTypes = srcArchetype->Types;
var dstTypes = dstArchetype->Types;
var dstOffsets = dstArchetype->Offsets;
var dstTypeIndex = 1;
// type[0] is always Entity, and will be patched up later, so just skip
for (var srcTypeIndex = 1; srcTypeIndex != srcTypesCount; srcTypeIndex++)
{
var srcType = srcTypes[srcTypeIndex];
var dstType = dstTypes[dstTypeIndex];
// Type does not exist in destination. Skip it.
if (srcType.TypeIndex != dstType.TypeIndex)
{
continue;
}
var srcOffset = srcOffsets[srcTypeIndex];
var srcSizeOf = srcSizeOfs[srcTypeIndex];
var dstOffset = dstOffsets[dstTypeIndex];
var src = srcBuffer + (srcOffset + srcSizeOf * srcIndex);
var dst = dstBuffer + (dstOffset + srcSizeOf * dstBaseIndex);
if (!srcType.IsBuffer)
{
UnsafeUtility.MemCpyReplicate(dst, src, srcSizeOf, count);
}
else
{
var srcBufferCapacity = srcBufferCapacities[srcTypeIndex];
var alignment = 8; // TODO: Need a way to compute proper alignment for arbitrary non-generic types in TypeManager
var elementSize = TypeManager.GetTypeInfo(srcType.TypeIndex).ElementSize;
for (int i = 0; i < count; ++i)
{
BufferHeader *srcHdr = (BufferHeader *)src;
BufferHeader *dstHdr = (BufferHeader *)dst;
BufferHeader.Initialize(dstHdr, srcBufferCapacity);
BufferHeader.Assign(dstHdr, BufferHeader.GetElementPointer(srcHdr), srcHdr->Length, elementSize, alignment);
dst += srcSizeOf;
}
}
dstTypeIndex++;
}
}
public static unsafe void ReplicateComponents(Chunk *srcChunk, int srcIndex, Chunk *dstChunk, int dstBaseIndex, int count)
{
Archetype *archetypePtr = srcChunk.Archetype;
byte * numPtr = &srcChunk.Buffer.FixedElementField;
byte * numPtr2 = &dstChunk.Buffer.FixedElementField;
Archetype *archetypePtr2 = dstChunk.Archetype;
int * offsets = archetypePtr->Offsets;
int * sizeOfs = archetypePtr->SizeOfs;
int typesCount = archetypePtr->TypesCount;
ComponentTypeInArchetype *types = archetypePtr->Types;
ComponentTypeInArchetype *archetypePtr4 = archetypePtr2->Types;
int *numPtr5 = archetypePtr2->Offsets;
int index = 1;
for (int i = 1; i != typesCount; i++)
{
ComponentTypeInArchetype archetype = types[i];
ComponentTypeInArchetype archetype2 = archetypePtr4[index];
if (archetype.TypeIndex == archetype2.TypeIndex)
{
int size = sizeOfs[i];
byte *numPtr6 = numPtr + (offsets[i] + (size * srcIndex));
byte *numPtr7 = numPtr2 + (numPtr5[index] + (size * dstBaseIndex));
if (!archetype.IsBuffer)
{
UnsafeUtility.MemCpyReplicate((void *)numPtr7, (void *)numPtr6, size, count);
}
else
{
int alignment = 8;
int elementSize = TypeManager.GetTypeInfo(archetype.TypeIndex).ElementSize;
int num9 = 0;
while (true)
{
if (num9 >= count)
{
break;
}
BufferHeader *header = (BufferHeader *)numPtr6;
BufferHeader *headerPtr2 = (BufferHeader *)numPtr7;
BufferHeader.Initialize(headerPtr2, archetype.BufferCapacity);
BufferHeader.Assign(headerPtr2, BufferHeader.GetElementPointer(header), header->Length, elementSize, alignment);
numPtr7 += size;
num9++;
}
}
index++;
}
}
}
internal unsafe BufferHeader *AddEntityBufferCommand <T>(EntityCommandBufferChain *chain, int jobIndex, ECBCommand op, Entity e) where T : struct, IBufferElementData
{
TypeManager.TypeInfo typeInfo = TypeManager.GetTypeInfo <T>();
int size = Align(sizeof(EntityBufferCommand) + typeInfo.SizeInChunk, 8);
EntityBufferCommand *commandPtr = (EntityBufferCommand *)ref this.Reserve(chain, jobIndex, size);
commandPtr->Header.Header.CommandType = (int)op;
commandPtr->Header.Header.TotalSize = size;
commandPtr->Header.Header.SortIndex = chain.m_LastSortIndex;
commandPtr->Header.Entity = e;
commandPtr->ComponentTypeIndex = TypeManager.GetTypeIndex <T>();
commandPtr->ComponentSize = typeInfo.SizeInChunk;
BufferHeader.Initialize(&commandPtr->TempBuffer, typeInfo.BufferCapacity);
return(&commandPtr->TempBuffer);
}
internal BufferHeader *AddEntityBufferCommand <T>(EntityCommandBufferChain *chain, ECBCommand op, Entity e) where T : struct, IBufferElementData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
var type = TypeManager.GetTypeInfo <T>();
var sizeNeeded = Align(sizeof(EntityBufferCommand) + type.SizeInChunk, 8);
var data = (EntityBufferCommand *)Reserve(chain, sizeNeeded);
data->Header.Header.CommandType = (int)op;
data->Header.Header.TotalSize = sizeNeeded;
data->Header.Entity = e;
data->ComponentTypeIndex = typeIndex;
data->ComponentSize = type.SizeInChunk;
BufferHeader.Initialize(&data->TempBuffer, type.BufferCapacity);
return(&data->TempBuffer);
}
public static void ReplicateComponents(Chunk *srcChunk, int srcIndex, Chunk *dstChunk, int dstBaseIndex,
int count)
{
Assert.IsTrue(srcChunk->Archetype == dstChunk->Archetype);
var arch = srcChunk->Archetype;
var srcBuffer = srcChunk->Buffer;
var dstBuffer = dstChunk->Buffer;
var offsets = arch->Offsets;
var sizeOfs = arch->SizeOfs;
var typesCount = arch->TypesCount;
var types = arch->Types;
// type[0] is always Entity, and will be patched up later, so just skip
for (var t = 1; t != typesCount; t++)
{
var type = types[t];
var offset = offsets[t];
var sizeOf = sizeOfs[t];
var src = srcBuffer + (offset + sizeOf * srcIndex);
var dst = dstBuffer + (offset + sizeOf * dstBaseIndex);
if (!type.IsBuffer)
{
UnsafeUtility.MemCpyReplicate(dst, src, sizeOf, count);
}
else
{
var alignment = 8; // TODO: Need a way to compute proper alignment for arbitrary non-generic types in TypeManager
for (int i = 0; i < count; ++i)
{
BufferHeader *srcHdr = (BufferHeader *)src;
BufferHeader *dstHdr = (BufferHeader *)dst;
BufferHeader.Initialize(dstHdr, type.BufferCapacity);
BufferHeader.Assign(dstHdr, BufferHeader.GetElementPointer(srcHdr), srcHdr->Length, sizeOf, alignment);
src += sizeOf;
dst += sizeOf;
}
}
}
}
public static unsafe void Convert(Chunk *srcChunk, int srcIndex, Chunk *dstChunk, int dstIndex)
{
Archetype *archetype = srcChunk.Archetype;
Archetype *archetypePtr2 = dstChunk.Archetype;
int index = 0;
int num2 = 0;
while (true)
{
if ((index >= archetype->TypesCount) || (num2 >= archetypePtr2->TypesCount))
{
while (true)
{
if (index >= archetype->TypesCount)
{
while (num2 < archetypePtr2->TypesCount)
{
byte *numPtr4 = (&dstChunk.Buffer.FixedElementField + archetypePtr2->Offsets[num2]) + (dstIndex * archetypePtr2->SizeOfs[num2]);
if ((archetypePtr2->Types + num2).IsBuffer)
{
BufferHeader.Initialize((BufferHeader *)numPtr4, archetypePtr2->Types[num2].BufferCapacity);
}
else
{
UnsafeUtility.MemClear((void *)numPtr4, (long)archetypePtr2->SizeOfs[num2]);
}
num2++;
}
return;
}
byte *numPtr3 = (&srcChunk.Buffer.FixedElementField + archetype->Offsets[index]) + (srcIndex * archetype->SizeOfs[index]);
if ((archetype->Types + index).IsBuffer)
{
BufferHeader.Destroy((BufferHeader *)numPtr3);
}
index++;
}
}
byte *numPtr = (&srcChunk.Buffer.FixedElementField + archetype->Offsets[index]) + (srcIndex * archetype->SizeOfs[index]);
byte *numPtr2 = (&dstChunk.Buffer.FixedElementField + archetypePtr2->Offsets[num2]) + (dstIndex * archetypePtr2->SizeOfs[num2]);
if (archetype->Types[index] < archetypePtr2->Types[num2])
{
if ((archetype->Types + index).IsBuffer)
{
BufferHeader.Destroy((BufferHeader *)numPtr);
}
index++;
continue;
}
if (archetype->Types[index] <= archetypePtr2->Types[num2])
{
UnsafeUtility.MemCpy((void *)numPtr2, (void *)numPtr, (long)archetype->SizeOfs[index]);
if ((archetype->Types + index).IsBuffer)
{
BufferHeader.Initialize((BufferHeader *)numPtr, archetype->Types[index].BufferCapacity);
}
index++;
num2++;
continue;
}
if ((archetypePtr2->Types + num2).IsBuffer)
{
BufferHeader.Initialize((BufferHeader *)numPtr2, archetypePtr2->Types[num2].BufferCapacity);
}
else
{
UnsafeUtility.MemClear((void *)numPtr2, (long)archetypePtr2->SizeOfs[num2]);
}
num2++;
}
}
public static void Convert(Chunk *srcChunk, int srcIndex, Chunk *dstChunk, int dstIndex)
{
var srcArch = srcChunk->Archetype;
var dstArch = dstChunk->Archetype;
//Debug.Log($"Convert {EntityManager.EntityManagerDebug.GetArchetypeDebugString(srcArch)} to {EntityManager.EntityManagerDebug.GetArchetypeDebugString(dstArch)}");
var srcI = 0;
var dstI = 0;
while (srcI < srcArch->TypesCount && dstI < dstArch->TypesCount)
{
var src = srcChunk->Buffer + srcArch->Offsets[srcI] + srcIndex * srcArch->SizeOfs[srcI];
var dst = dstChunk->Buffer + dstArch->Offsets[dstI] + dstIndex * dstArch->SizeOfs[dstI];
if (srcArch->Types[srcI] < dstArch->Types[dstI])
{
// Clear any buffers we're not going to keep.
if (srcArch->Types[srcI].IsBuffer)
{
BufferHeader.Destroy((BufferHeader *)src);
}
++srcI;
}
else if (srcArch->Types[srcI] > dstArch->Types[dstI])
{
// Clear components in the destination that aren't copied
if (dstArch->Types[dstI].IsBuffer)
{
BufferHeader.Initialize((BufferHeader *)dst, dstArch->Types[dstI].BufferCapacity);
}
else
{
UnsafeUtility.MemClear(dst, dstArch->SizeOfs[dstI]);
}
++dstI;
}
else
{
UnsafeUtility.MemCpy(dst, src, srcArch->SizeOfs[srcI]);
// Poison source buffer to make sure there is no aliasing.
if (srcArch->Types[srcI].IsBuffer)
{
BufferHeader.Initialize((BufferHeader *)src, srcArch->Types[srcI].BufferCapacity);
}
++srcI;
++dstI;
}
}
// Handle remaining components in the source that aren't copied
for (; srcI < srcArch->TypesCount; ++srcI)
{
var src = srcChunk->Buffer + srcArch->Offsets[srcI] + srcIndex * srcArch->SizeOfs[srcI];
if (srcArch->Types[srcI].IsBuffer)
{
BufferHeader.Destroy((BufferHeader *)src);
}
}
// Clear remaining components in the destination that aren't copied
for (; dstI < dstArch->TypesCount; ++dstI)
{
var dst = dstChunk->Buffer + dstArch->Offsets[dstI] + dstIndex * dstArch->SizeOfs[dstI];
if (dstArch->Types[dstI].IsBuffer)
{
BufferHeader.Initialize((BufferHeader *)dst, dstArch->Types[dstI].BufferCapacity);
}
else
{
UnsafeUtility.MemClear(dst, dstArch->SizeOfs[dstI]);
}
}
}
public static void ReplicateComponents(Chunk *srcChunk, int srcIndex, Chunk *dstChunk, int dstBaseIndex, int count, ref EntityComponentStore entityComponentStore)
{
var srcArchetype = srcChunk->Archetype;
var srcBuffer = srcChunk->Buffer;
var dstBuffer = dstChunk->Buffer;
var dstArchetype = dstChunk->Archetype;
var srcOffsets = srcArchetype->Offsets;
var srcSizeOfs = srcArchetype->SizeOfs;
var srcBufferCapacities = srcArchetype->BufferCapacities;
var srcTypes = srcArchetype->Types;
var dstTypes = dstArchetype->Types;
var dstOffsets = dstArchetype->Offsets;
var dstTypeIndex = 1;
var nativeComponentsEnd = srcArchetype->NativeComponentsEnd;
for (var srcTypeIndex = 1; srcTypeIndex != nativeComponentsEnd; srcTypeIndex++)
{
var srcType = srcTypes[srcTypeIndex];
var dstType = dstTypes[dstTypeIndex];
// Type does not exist in destination. Skip it.
if (srcType.TypeIndex != dstType.TypeIndex)
{
continue;
}
var srcSizeOf = srcSizeOfs[srcTypeIndex];
var src = srcBuffer + (srcOffsets[srcTypeIndex] + srcSizeOf * srcIndex);
var dst = dstBuffer + (dstOffsets[dstTypeIndex] + srcSizeOf * dstBaseIndex);
UnsafeUtility.MemCpyReplicate(dst, src, srcSizeOf, count);
dstTypeIndex++;
}
dstTypeIndex = dstArchetype->FirstBufferComponent;
var bufferComponentsEnd = srcArchetype->BufferComponentsEnd;
for (var srcTypeIndex = srcArchetype->FirstBufferComponent; srcTypeIndex != bufferComponentsEnd; srcTypeIndex++)
{
var srcType = srcTypes[srcTypeIndex];
var dstType = dstTypes[dstTypeIndex];
// Type does not exist in destination. Skip it.
if (srcType.TypeIndex != dstType.TypeIndex)
{
continue;
}
var srcSizeOf = srcSizeOfs[srcTypeIndex];
var src = srcBuffer + (srcOffsets[srcTypeIndex] + srcSizeOf * srcIndex);
var dst = dstBuffer + (dstOffsets[dstTypeIndex] + srcSizeOf * dstBaseIndex);
var srcBufferCapacity = srcBufferCapacities[srcTypeIndex];
var alignment = 8; // TODO: Need a way to compute proper alignment for arbitrary non-generic types in TypeManager
var elementSize = TypeManager.GetTypeInfo(srcType.TypeIndex).ElementSize;
for (int i = 0; i < count; ++i)
{
BufferHeader *srcHdr = (BufferHeader *)src;
BufferHeader *dstHdr = (BufferHeader *)dst;
BufferHeader.Initialize(dstHdr, srcBufferCapacity);
BufferHeader.Assign(dstHdr, BufferHeader.GetElementPointer(srcHdr), srcHdr->Length, elementSize, alignment, false, 0);
dst += srcSizeOf;
}
dstTypeIndex++;
}
if (dstArchetype->NumManagedComponents > 0)
{
ReplicateManagedComponents(srcChunk, srcIndex, dstChunk, dstBaseIndex, count, ref entityComponentStore);
}
}
