private static unsafe void ApplySetComponents( EntityManager entityManager, NativeArray <PackedComponentDataChange> changes, NativeArray <byte> payload, NativeArray <EntityGuid> packedEntityGuids, NativeMultiHashMap <int, Entity> packedEntities, NativeArray <ComponentType> packedTypes, NativeMultiHashMap <EntityGuid, Entity> entityGuidToEntity, NativeHashMap <Entity, EntityGuid> entityToEntityGuid) { var entityGuidTypeIndex = TypeManager.GetTypeIndex <EntityGuid>(); var offset = 0L; for (var i = 0; i < changes.Length; i++) { var packedComponentDataChange = changes[i]; var packedComponent = packedComponentDataChange.Component; var component = packedTypes[packedComponent.PackedTypeIndex]; var size = packedComponentDataChange.Size; var data = (byte *)payload.GetUnsafeReadOnlyPtr() + offset; var componentTypeInArchetype = new ComponentTypeInArchetype(component); if (packedEntities.TryGetFirstValue(packedComponent.PackedEntityIndex, out var entity, out var iterator)) { do { if (!entityManager.Exists(entity)) { Debug.LogWarning($"SetComponent<{component}>({packedEntityGuids[packedComponent.PackedEntityIndex]}) but entity does not exist."); } else if (!entityManager.HasComponent(entity, component)) { Debug.LogWarning($"SetComponent<{component}>({packedEntityGuids[packedComponent.PackedEntityIndex]}) but component does not exist."); } else { if (componentTypeInArchetype.IsZeroSized) { // Nothing to set. } else if (componentTypeInArchetype.IsBuffer) { var typeInfo = TypeManager.GetTypeInfo(componentTypeInArchetype.TypeIndex); var elementSize = typeInfo.ElementSize; var lengthInElements = size / elementSize; var header = (BufferHeader *)entityManager.GetComponentDataRawRW(entity, component.TypeIndex); BufferHeader.Assign(header, data, lengthInElements, elementSize, 16); } else { var target = (byte *)entityManager.GetComponentDataRawRW(entity, component.TypeIndex); // Perform incremental updates on the entityGuidToEntity map to avoid a full rebuild. if (componentTypeInArchetype.TypeIndex == entityGuidTypeIndex) { EntityGuid entityGuid; UnsafeUtility.MemCpy(&entityGuid, target, sizeof(EntityGuid)); if (!entityGuid.Equals(default))
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++; } } }
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 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); } }