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); } }