internal void AddComponent(MatchingArchetypeList archetypeList, EntityQueryFilter filter, ComponentType componentType) { var jobHandle = new JobHandle(); using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter)) { jobHandle.Complete(); if (chunks.Length == 0) { return; } BeforeStructuralChange(); EntityComponentStore->AssertCanAddComponent(chunks, componentType); using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(chunks)) { EntityManagerChangeArchetypeUtility.AddComponent(entityBatchList, componentType, 0, EntityComponentStore, ManagedComponentStore, EntityGroupManager); } } }
public void AddComponent(Entity entity, ComponentType componentType) { CheckAccess(); m_EntityComponentStore->AssertCanAddComponent(entity, componentType); EntityManagerChangeArchetypeUtility.AddComponent(entity, componentType, EntityComponentStore, ManagedComponentStore, EntityGroupManager); }
/// <summary> /// Adds a component to each of the chunks identified by a EntityQuery and set the component values. /// </summary> /// <remarks> /// This function finds all chunks whose archetype satisfies the EntityQuery and adds the specified /// component to them. /// /// A chunk component is common to all entities in a chunk. You can access a chunk <see cref="IComponentData"/> /// instance through either the chunk itself or through an entity stored in that chunk. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before adding the component and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entityQuery">The EntityQuery identifying the chunks to modify.</param> /// <param name="componentData">The data to set.</param> /// <typeparam name="T">The type of component, which must implement IComponentData.</typeparam> public void AddChunkComponentData <T>(EntityQuery entityQuery, T componentData) where T : struct, IComponentData { using (var chunks = entityQuery.CreateArchetypeChunkArray(Allocator.TempJob)) { if (chunks.Length == 0) { return; } BeforeStructuralChange(); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); EntityComponentStore->AssertCanAddChunkComponent(chunks, ComponentType.ChunkComponent <T>()); var type = ComponentType.ReadWrite <T>(); var chunkType = ComponentType.FromTypeIndex(TypeManager.MakeChunkComponentTypeIndex(type.TypeIndex)); using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(chunks)) { EntityManagerChangeArchetypeUtility.AddComponentFromMainThread(entityBatchList, chunkType, 0, EntityComponentStore, ManagedComponentStore); m_EntityComponentStore->SetChunkComponent <T>(entityBatchList, componentData); } var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityGroupManager.AddAdditionalArchetypes(changedArchetypes); } }
public void RemoveComponent(Entity entity, ComponentType type) { CheckAccess(); EntityManagerChangeArchetypeUtility.RemoveComponent(entity, type, EntityComponentStore, ManagedComponentStore, EntityGroupManager); }
internal void RemoveComponent(MatchingArchetypeList archetypeList, EntityQueryFilter filter, ComponentType componentType) { var jobHandle = new JobHandle(); using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter)) { jobHandle.Complete(); if (chunks.Length == 0) { return; } BeforeStructuralChange(); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); EntityComponentStore->AssertCanRemoveComponent(chunks, componentType); EntityManagerChangeArchetypeUtility.RemoveComponent(chunks, componentType, EntityComponentStore, ManagedComponentStore); var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityGroupManager.AddAdditionalArchetypes(changedArchetypes); } }
public static void DestroyMetaChunkEntity(Entity entity, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { EntityManagerChangeArchetypeUtility.RemoveComponent(entity, ComponentType.ReadWrite <ChunkHeader>(), entityComponentStore, managedComponentStore); DestroyEntities(&entity, 1, entityComponentStore, managedComponentStore); }
/// <summary> /// Adds a component to a set of entities. /// </summary> /// <remarks> /// Adding a component changes an entity's archetype and results in the entity being moved to a different /// chunk. /// /// The added components have the default values for the type. /// /// If an <see cref="Entity"/> object in the `entities` array refers to an entity that has been destroyed, this function /// throws an ArgumentError exception. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before creating these chunks and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entities">An array of Entity objects.</param> /// <param name="componentType">The type of component to add.</param> public void AddComponent(NativeArray <Entity> entities, ComponentType componentType) { BeforeStructuralChange(); using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(entities)) { EntityManagerChangeArchetypeUtility.AddComponent(entityBatchList, componentType, 0, EntityComponentStore, ManagedComponentStore, EntityGroupManager); } }
/// <summary> /// Removes a component from an entity. /// </summary> /// <remarks> /// Removing a component changes an entity's archetype and results in the entity being moved to a different /// chunk. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before removing the component and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entity">The entity to modify.</param> /// <param name="type">The type of component to remove.</param> public void RemoveComponent(Entity entity, ComponentType type) { BeforeStructuralChange(); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); EntityManagerChangeArchetypeUtility.RemoveComponent(entity, type, EntityComponentStore, ManagedComponentStore); var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityGroupManager.AddAdditionalArchetypes(changedArchetypes); }
// ---------------------------------------------------------------------------------------------------------- // INTERNAL // ---------------------------------------------------------------------------------------------------------- internal void AddComponent(Entity entity, ComponentType componentType, bool ignoreDuplicateAdd) { if (ignoreDuplicateAdd && HasComponent(entity, componentType)) { return; } BeforeStructuralChange(); EntityComponentStore->AssertCanAddComponent(entity, componentType); EntityManagerChangeArchetypeUtility.AddComponent(entity, componentType, EntityComponentStore, ManagedComponentStore, EntityGroupManager); }
public void AddComponent(Entity entity, ComponentType componentType) { CheckAccess(); m_EntityComponentStore->AssertCanAddComponent(entity, componentType); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); EntityManagerChangeArchetypeUtility.AddComponent(entity, componentType, EntityComponentStore, ManagedComponentStore); var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityGroupManager.AddAdditionalArchetypes(changedArchetypes); }
/// <summary> /// Removes a component from the chunks identified by a EntityQuery. /// </summary> /// <remarks> /// A chunk component is common to all entities in a chunk. You can access a chunk <see cref="IComponentData"/> /// instance through either the chunk itself or through an entity stored in that chunk. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before removing the component and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entityQuery">The EntityQuery identifying the chunks to modify.</param> /// <typeparam name="T">The type of component to remove.</typeparam> public void RemoveChunkComponentData <T>(EntityQuery entityQuery) { using (var chunks = entityQuery.CreateArchetypeChunkArray(Allocator.TempJob)) { if (chunks.Length == 0) { return; } BeforeStructuralChange(); EntityManagerChangeArchetypeUtility.RemoveComponent(chunks, ComponentType.ChunkComponent <T>(), EntityComponentStore, ManagedComponentStore, EntityGroupManager); } }
/// <summary> /// Sets the shared component of an entity. /// </summary> /// <remarks> /// Changing a shared component value of an entity results in the entity being moved to a /// different chunk. The entity moves to a chunk with other entities that have the same shared component values. /// A new chunk is created if no chunk with the same archetype and shared component values currently exists. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before setting the component and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entity">The entity</param> /// <param name="componentData">A shared component object containing the values to set.</param> /// <typeparam name="T">The shared component type.</typeparam> public void SetSharedComponentData <T>(Entity entity, T componentData) where T : struct, ISharedComponentData { BeforeStructuralChange(); var typeIndex = TypeManager.GetTypeIndex <T>(); EntityComponentStore->AssertEntityHasComponent(entity, typeIndex); var newSharedComponentDataIndex = m_ManagedComponentStore.InsertSharedComponent(componentData); EntityManagerChangeArchetypeUtility.SetSharedComponentDataIndex(entity, typeIndex, newSharedComponentDataIndex, EntityComponentStore, ManagedComponentStore); m_ManagedComponentStore.RemoveReference(newSharedComponentDataIndex); }
public void SetSharedComponentData <T>(Entity entity, T componentData) where T : struct, ISharedComponentData { CheckAccess(); var typeIndex = TypeManager.GetTypeIndex <T>(); m_EntityComponentStore->AssertEntityHasComponent(entity, typeIndex); var newSharedComponentDataIndex = ManagedComponentStore.InsertSharedComponent(componentData); EntityManagerChangeArchetypeUtility.SetSharedComponentDataIndex(entity, typeIndex, newSharedComponentDataIndex, EntityComponentStore, ManagedComponentStore, EntityGroupManager); ManagedComponentStore.RemoveReference(newSharedComponentDataIndex); }
// ---------------------------------------------------------------------------------------------------------- // INTERNAL // ---------------------------------------------------------------------------------------------------------- internal void AddComponent(Entity entity, ComponentType componentType, bool ignoreDuplicateAdd) { if (ignoreDuplicateAdd && HasComponent(entity, componentType)) { return; } BeforeStructuralChange(); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); EntityComponentStore->AssertCanAddComponent(entity, componentType); EntityManagerChangeArchetypeUtility.AddComponent(entity, componentType, EntityComponentStore, ManagedComponentStore); var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityGroupManager.AddAdditionalArchetypes(changedArchetypes); }
/// <summary> /// Removes a component from the chunks identified by a EntityQuery. /// </summary> /// <remarks> /// A chunk component is common to all entities in a chunk. You can access a chunk <see cref="IComponentData"/> /// instance through either the chunk itself or through an entity stored in that chunk. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before removing the component and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entityQuery">The EntityQuery identifying the chunks to modify.</param> /// <typeparam name="T">The type of component to remove.</typeparam> public void RemoveChunkComponentData <T>(EntityQuery entityQuery) { using (var chunks = entityQuery.CreateArchetypeChunkArray(Allocator.TempJob)) { if (chunks.Length == 0) { return; } BeforeStructuralChange(); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); EntityManagerChangeArchetypeUtility.RemoveComponent(chunks, ComponentType.ChunkComponent <T>(), EntityComponentStore, ManagedComponentStore); var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityGroupManager.AddAdditionalArchetypes(changedArchetypes); } }
internal void AddSharedComponent <T>(NativeArray <ArchetypeChunk> chunks, T componentData) where T : struct, ISharedComponentData { CheckAccess(); var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking(); var componentType = ComponentType.ReadWrite <T>(); var newSharedComponentDataIndex = ManagedComponentStore.InsertSharedComponent(componentData); EntityComponentStore->AssertCanAddComponent(chunks, componentType); EntityManagerChangeArchetypeUtility.AddSharedComponent(chunks, componentType, newSharedComponentDataIndex, EntityComponentStore, ManagedComponentStore); ManagedComponentStore.RemoveReference(newSharedComponentDataIndex); var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityGroupManager.AddAdditionalArchetypes(changedArchetypes); }
/// <summary> /// Adds a shared component to a set of entities defined by a EntityQuery. /// </summary> /// <remarks> /// The fields of the `componentData` parameter are assigned to all of the added shared components. /// /// Adding a component to an entity changes its archetype and results in the entity being moved to a /// different chunk. The entity moves to a chunk with other entities that have the same shared component values. /// A new chunk is created if no chunk with the same archetype and shared component values currently exists. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before adding the component and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entityQuery">The EntityQuery defining a set of entities to modify.</param> /// <param name="componentData">The data to set.</param> /// <typeparam name="T">The data type of the shared component.</typeparam> public void AddSharedComponentData <T>(EntityQuery entityQuery, T componentData) where T : struct, ISharedComponentData { var componentType = ComponentType.ReadWrite <T>(); using (var chunks = entityQuery.CreateArchetypeChunkArray(Allocator.TempJob)) { if (chunks.Length == 0) { return; } BeforeStructuralChange(); var newSharedComponentDataIndex = m_ManagedComponentStore.InsertSharedComponent(componentData); EntityComponentStore->AssertCanAddComponent(chunks, componentType); EntityManagerChangeArchetypeUtility.AddSharedComponent(chunks, componentType, newSharedComponentDataIndex, EntityComponentStore, ManagedComponentStore, EntityGroupManager); m_ManagedComponentStore.RemoveReference(newSharedComponentDataIndex); } }
internal void SetSharedComponentDataBoxed(Entity entity, int typeIndex, int hashCode, object componentData) { BeforeStructuralChange(); EntityComponentStore->AssertEntityHasComponent(entity, typeIndex); var newSharedComponentDataIndex = 0; if (componentData != null) // null means default { newSharedComponentDataIndex = m_ManagedComponentStore.InsertSharedComponentAssumeNonDefault(typeIndex, hashCode, componentData); } EntityManagerChangeArchetypeUtility.SetSharedComponentDataIndex(entity, typeIndex, newSharedComponentDataIndex, EntityComponentStore, ManagedComponentStore); m_ManagedComponentStore.RemoveReference(newSharedComponentDataIndex); }
/// <summary> /// Adds a set of component to an entity. /// </summary> /// <remarks> /// Adding components changes the entity's archetype and results in the entity being moved to a different /// chunk. /// /// The added components have the default values for the type. /// /// If the <see cref="Entity"/> object refers to an entity that has been destroyed, this function throws an ArgumentError /// exception. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before adding these components and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entity">The entity to modify.</param> /// <param name="types">The types of components to add.</param> public void AddComponents(Entity entity, ComponentTypes types) { BeforeStructuralChange(); EntityComponentStore->AssertCanAddComponents(entity, types); EntityManagerChangeArchetypeUtility.AddComponents(entity, types, EntityComponentStore, ManagedComponentStore, EntityGroupManager); }
static void DestroyBatch(Entity *entities, Chunk *chunk, int indexInChunk, int batchCount, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { var archetype = chunk->Archetype; if (!archetype->SystemStateCleanupNeeded) { entityComponentStore->DeallocateDataEntitiesInChunk(entities, chunk, indexInChunk, batchCount); managedComponentStore.IncrementComponentOrderVersion(archetype, chunk->SharedComponentValues); entityComponentStore->IncrementComponentTypeOrderVersion(archetype); if (chunk->ManagedArrayIndex >= 0) { // We can just chop-off the end, no need to copy anything if (chunk->Count != indexInChunk + batchCount) { managedComponentStore.CopyManagedObjects(chunk, chunk->Count - batchCount, chunk, indexInChunk, batchCount); } managedComponentStore.ClearManagedObjects(chunk, chunk->Count - batchCount, batchCount); } chunk->Archetype->EntityCount -= batchCount; SetChunkCount(chunk, chunk->Count - batchCount, entityComponentStore, managedComponentStore); } else { var newType = archetype->SystemStateResidueArchetype; var sharedComponentValues = chunk->SharedComponentValues; if (RequiresBuildingResidueSharedComponentIndices(archetype, newType)) { var tempAlloc = stackalloc int[newType->NumSharedComponents]; BuildResidueSharedComponentIndices(archetype, newType, sharedComponentValues, tempAlloc); sharedComponentValues = tempAlloc; } // See: https://github.com/Unity-Technologies/dots/issues/1387 // For Locked Order Chunks specfically, need to make sure that structural changes are always done per-chunk. // If trying to muutate structure in a way that is not per chunk, will hit an exception in the else clause anyway. // This ultimately needs to be replaced by entity batch interface. if (batchCount == chunk->Count) { managedComponentStore.IncrementComponentOrderVersion(archetype, chunk->SharedComponentValues); entityComponentStore->IncrementComponentTypeOrderVersion(archetype); EntityManagerChangeArchetypeUtility.SetArchetype(chunk, newType, sharedComponentValues, entityComponentStore, managedComponentStore); } else { for (var i = 0; i < batchCount; i++) { var entity = entities[i]; managedComponentStore.IncrementComponentOrderVersion(archetype, entityComponentStore->GetChunk(entity)->SharedComponentValues); entityComponentStore->IncrementComponentTypeOrderVersion(archetype); EntityManagerChangeArchetypeUtility.SetArchetype(entity, newType, sharedComponentValues, entityComponentStore, managedComponentStore); } } } }
/// <summary> /// Removes a component from an entity. /// </summary> /// <remarks> /// Removing a component changes an entity's archetype and results in the entity being moved to a different /// chunk. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before removing the component and no additional Jobs can start before /// the function is finished. A sync point can cause a drop in performance because the ECS framework may not /// be able to make use of the processing power of all available cores. /// </remarks> /// <param name="entity">The entity to modify.</param> /// <param name="type">The type of component to remove.</param> public void RemoveComponent(Entity entity, ComponentType type) { BeforeStructuralChange(); EntityManagerChangeArchetypeUtility.RemoveComponent(entity, type, EntityComponentStore, ManagedComponentStore, EntityGroupManager); }
public static unsafe void DeserializeWorld(ExclusiveEntityTransaction manager, BinaryReader reader, int numSharedComponents) { if (manager.EntityComponentStore->CountEntities() != 0) { throw new ArgumentException( $"DeserializeWorld can only be used on completely empty EntityManager. Please create a new empty World and use EntityManager.MoveEntitiesFrom to move the loaded entities into the destination world instead."); } int storedVersion = reader.ReadInt(); if (storedVersion != CurrentFileFormatVersion) { throw new ArgumentException( $"Attempting to read a entity scene stored in an old file format version (stored version : {storedVersion}, current version : {CurrentFileFormatVersion})"); } var types = ReadTypeArray(reader); int totalEntityCount; var archetypes = ReadArchetypes(reader, types, manager, out totalEntityCount); int sharedComponentArraysLength = reader.ReadInt(); var sharedComponentArrays = new NativeArray <int>(sharedComponentArraysLength, Allocator.Temp); reader.ReadArray(sharedComponentArrays, sharedComponentArraysLength); manager.AllocateConsecutiveEntitiesForLoading(totalEntityCount); int totalChunkCount = reader.ReadInt(); var chunksWithMetaChunkEntities = new NativeList <ArchetypeChunk>(totalChunkCount, Allocator.Temp); int totalBlobAssetSize = reader.ReadInt(); byte *allBlobAssetData = null; NativeList <ArchetypeChunk> blobAssetRefChunks = new NativeList <ArchetypeChunk>(); int blobAssetOwnerIndex = -1; if (totalBlobAssetSize != 0) { allBlobAssetData = (byte *)UnsafeUtility.Malloc(totalBlobAssetSize, 16, Allocator.Persistent); reader.ReadBytes(allBlobAssetData, totalBlobAssetSize); blobAssetOwnerIndex = manager.ManagedComponentStore.InsertSharedComponent(new BlobAssetOwner(allBlobAssetData, totalBlobAssetSize)); blobAssetRefChunks = new NativeList <ArchetypeChunk>(32, Allocator.Temp); var end = allBlobAssetData + totalBlobAssetSize; var header = (BlobAssetHeader *)allBlobAssetData; while (header < end) { header->ValidationPtr = header + 1; header = (BlobAssetHeader *)OffsetFromPointer(header + 1, header->Length); } } int sharedComponentArraysIndex = 0; for (int i = 0; i < totalChunkCount; ++i) { var chunk = (Chunk *)UnsafeUtility.Malloc(Chunk.kChunkSize, 64, Allocator.Persistent); reader.ReadBytes(chunk, Chunk.kChunkSize); var archetype = chunk->Archetype = archetypes[(int)chunk->Archetype].Archetype; var numSharedComponentsInArchetype = chunk->Archetype->NumSharedComponents; int *sharedComponentValueArray = (int *)sharedComponentArrays.GetUnsafePtr() + sharedComponentArraysIndex; for (int j = 0; j < numSharedComponentsInArchetype; ++j) { // The shared component 0 is not part of the array, so an index equal to the array size is valid. if (sharedComponentValueArray[j] > numSharedComponents) { throw new ArgumentException( $"Archetype uses shared component at index {sharedComponentValueArray[j]} but only {numSharedComponents} are available, check if the shared scene has been properly loaded."); } } var remapedSharedComponentValues = stackalloc int[archetype->NumSharedComponents]; RemapSharedComponentIndices(remapedSharedComponentValues, archetype, sharedComponentValueArray); sharedComponentArraysIndex += numSharedComponentsInArchetype; // Allocate additional heap memory for buffers that have overflown into the heap, and read their data. int bufferAllocationCount = reader.ReadInt(); if (bufferAllocationCount > 0) { var bufferPatches = new NativeArray <BufferPatchRecord>(bufferAllocationCount, Allocator.Temp); reader.ReadArray(bufferPatches, bufferPatches.Length); // TODO: PERF: Batch malloc interface. for (int pi = 0; pi < bufferAllocationCount; ++pi) { var target = (BufferHeader *)OffsetFromPointer(chunk->Buffer, bufferPatches[pi].ChunkOffset); // TODO: Alignment target->Pointer = (byte *)UnsafeUtility.Malloc(bufferPatches[pi].AllocSizeBytes, 8, Allocator.Persistent); reader.ReadBytes(target->Pointer, bufferPatches[pi].AllocSizeBytes); } bufferPatches.Dispose(); } if (totalBlobAssetSize != 0 && archetype->ContainsBlobAssetRefs) { blobAssetRefChunks.Add(new ArchetypeChunk(chunk, manager.EntityComponentStore)); PatchBlobAssetsInChunkAfterLoad(chunk, allBlobAssetData); } EntityManagerMoveEntitiesUtility.AddExistingChunk(chunk, remapedSharedComponentValues, manager.EntityComponentStore, manager.ManagedComponentStore); if (chunk->metaChunkEntity != Entity.Null) { chunksWithMetaChunkEntities.Add(new ArchetypeChunk(chunk, manager.EntityComponentStore)); } } if (totalBlobAssetSize != 0) { EntityManagerChangeArchetypeUtility.AddSharedComponent(blobAssetRefChunks, ComponentType.ReadWrite <BlobAssetOwner>(), blobAssetOwnerIndex, manager.EntityComponentStore, manager.ManagedComponentStore, manager.EntityGroupManager); manager.ManagedComponentStore.RemoveReference(blobAssetOwnerIndex); blobAssetRefChunks.Dispose(); } for (int i = 0; i < chunksWithMetaChunkEntities.Length; ++i) { var chunk = chunksWithMetaChunkEntities[i].m_Chunk; manager.SetComponentData(chunk->metaChunkEntity, new ChunkHeader { ArchetypeChunk = chunksWithMetaChunkEntities[i] }); } chunksWithMetaChunkEntities.Dispose(); sharedComponentArrays.Dispose(); archetypes.Dispose(); types.Dispose(); }