internal EntityManager(World world) { TypeManager.Initialize(); m_World = world; m_ComponentJobSafetyManager = (ComponentJobSafetyManager *)UnsafeUtility.Malloc(sizeof(ComponentJobSafetyManager), 64, Allocator.Persistent); m_ComponentJobSafetyManager->OnCreate(); m_EntityComponentStore = Entities.EntityComponentStore.Create(world.SequenceNumber << 32); m_ManagedComponentStore = new ManagedComponentStore(); m_EntityGroupManager = new EntityGroupManager(m_ComponentJobSafetyManager); m_ExclusiveEntityTransaction = new ExclusiveEntityTransaction(EntityGroupManager, m_ManagedComponentStore, EntityComponentStore); m_UniversalQuery = CreateEntityQuery( new EntityQueryDesc { Options = EntityQueryOptions.IncludePrefab | EntityQueryOptions.IncludeDisabled } ); }
public static void SetChunkCount(Chunk *chunk, int newCount, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { Assert.AreNotEqual(newCount, chunk->Count); Assert.IsFalse(chunk->Locked); Assert.IsTrue(!chunk->LockedEntityOrder || newCount == 0); // Chunk released to empty chunk pool if (newCount == 0) { ReleaseChunk(chunk, entityComponentStore, managedComponentStore); return; } var capacity = chunk->Capacity; // Chunk is now full if (newCount == capacity) { // this chunk no longer has empty slots, so it shouldn't be in the empty slot list. chunk->Archetype->EmptySlotTrackingRemoveChunk(chunk); } // Chunk is no longer full else if (chunk->Count == capacity) { Assert.IsTrue(newCount < chunk->Count); chunk->Archetype->EmptySlotTrackingAddChunk(chunk); } chunk->Count = newCount; chunk->Archetype->Chunks.SetChunkEntityCount(chunk->ListIndex, newCount); }
public unsafe NativeArray <int> MoveAllSharedComponents(ManagedComponentStore srcManagedComponents, Allocator allocator) { var remap = new NativeArray <int>(srcManagedComponents.GetSharedComponentCount(), allocator); remap[0] = 0; for (int srcIndex = 1; srcIndex < remap.Length; ++srcIndex) { var srcData = srcManagedComponents.m_SharedComponentData[srcIndex]; if (srcData == null) { continue; } var typeIndex = srcManagedComponents.m_SharedComponentType[srcIndex]; var hashCode = TypeManager.GetHashCode(srcData, typeIndex); var dstIndex = InsertSharedComponentAssumeNonDefaultMove(typeIndex, hashCode, srcData); m_SharedComponentRefCount[dstIndex] += srcManagedComponents.m_SharedComponentRefCount[srcIndex] - 1; remap[srcIndex] = dstIndex; } srcManagedComponents.m_HashLookup.Clear(); srcManagedComponents.m_SharedComponentVersion.ResizeUninitialized(1); srcManagedComponents.m_SharedComponentRefCount.ResizeUninitialized(1); srcManagedComponents.m_SharedComponentType.ResizeUninitialized(1); srcManagedComponents.m_SharedComponentData.Clear(); srcManagedComponents.m_SharedComponentData.Add(null); srcManagedComponents.m_FreeListIndex = -1; return(remap); }
public NativeArray <int> MoveAllSharedComponents(ManagedComponentStore srcManagedComponents, Allocator allocator) { var remap = new NativeArray <int>(srcManagedComponents.GetSharedComponentCount(), allocator); remap[0] = 0; var srcInfos = srcManagedComponents.SharedComponentInfoPtr; for (int srcIndex = 1; srcIndex < remap.Length; ++srcIndex) { var srcData = srcManagedComponents.m_SharedComponentData[srcIndex]; if (srcData == null) { continue; } var typeIndex = srcInfos[srcIndex].ComponentType; var hashCode = srcInfos[srcIndex].HashCode; var dstIndex = InsertSharedComponentAssumeNonDefaultMove(typeIndex, hashCode, srcData); SharedComponentInfoPtr[dstIndex].RefCount += srcInfos[srcIndex].RefCount - 1; remap[srcIndex] = dstIndex; } srcManagedComponents.ResetSharedComponentData(); return(remap); }
/// <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 = EntityComponentStore->CreateEntityBatchList(chunks)) { EntityComponentStore->AddComponentFromMainThread(entityBatchList, chunkType, 0); EntityComponentStore->SetChunkComponent <T>(entityBatchList, componentData); } var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityQueryManager.AddAdditionalArchetypes(changedArchetypes); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); } }
internal void AddComponent(UnsafeMatchingArchetypePtrList archetypeList, EntityQueryFilter filter, ComponentType componentType) { var jobHandle = new JobHandle(); //@TODO: Missing EntityQuery.SyncFilter 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->AssertCanAddComponent(chunks, componentType); using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(chunks)) { EntityComponentStore->AddComponentFromMainThread(entityBatchList, componentType, 0); } var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges); EntityQueryManager.AddAdditionalArchetypes(changedArchetypes); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); } }
public static void CreateChunks(Archetype *archetype, ArchetypeChunk *chunks, int entityCount, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { int *sharedComponentValues = stackalloc int[archetype->NumSharedComponents]; UnsafeUtility.MemClear(sharedComponentValues, archetype->NumSharedComponents * sizeof(int)); Chunk *lastChunk = null; int chunkIndex = 0; while (entityCount != 0) { var chunk = GetCleanChunk(archetype, sharedComponentValues, entityComponentStore, managedComponentStore); int allocatedIndex; var allocatedCount = AllocateIntoChunk(chunk, entityCount, out allocatedIndex, entityComponentStore, managedComponentStore); entityComponentStore->AllocateEntities(archetype, chunk, allocatedIndex, allocatedCount, null); ChunkDataUtility.InitializeComponents(chunk, allocatedIndex, allocatedCount); chunk->SetAllChangeVersions(entityComponentStore->GlobalSystemVersion); chunks[chunkIndex] = new ArchetypeChunk(chunk, entityComponentStore); lastChunk = chunk; entityCount -= allocatedCount; chunkIndex++; } entityComponentStore->IncrementComponentTypeOrderVersion(archetype); }
/// <summary> /// Creates a set of entities of the specified archetype. /// </summary> /// <remarks>Fills the [NativeArray](https://docs.unity3d.com/ScriptReference/Unity.Collections.NativeArray_1.html) /// object assigned to the `entities` parameter with the Entity objects of the created entities. Each entity /// has the components specified by the <see cref="EntityArchetype"/> object assigned /// to the `archetype` parameter. The EntityManager adds these entities to the <see cref="World"/> entity list. Use the /// Entity objects in the array for further processing, such as setting the component values.</remarks> /// <param name="archetype">The archetype defining the structure for the new entities.</param> /// <param name="entities">An array to hold the Entity objects needed to access the new entities. /// The length of the array determines how many entities are created.</param> public void CreateEntity(EntityArchetype archetype, NativeArray <Entity> entities) { BeforeStructuralChange(); EntityComponentStore->CreateEntities(archetype.Archetype, (Entity *)entities.GetUnsafePtr(), entities.Length); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); }
internal void InstantiateInternal(Entity srcEntity, Entity *outputEntities, int count) { BeforeStructuralChange(); EntityComponentStore->AssertEntitiesExist(&srcEntity, 1); EntityComponentStore->InstantiateEntities(srcEntity, outputEntities, count); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); }
// ---------------------------------------------------------------------------------------------------------- // INTERNAL // ---------------------------------------------------------------------------------------------------------- internal void DestroyEntityInternal(Entity *entities, int count) { BeforeStructuralChange(); EntityComponentStore->AssertCanDestroy(entities, count); EntityComponentStore->DestroyEntities(entities, count); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); }
public static void CreateEntities(Archetype *archetype, Entity *entities, int count, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { var sharedComponentValues = stackalloc int[archetype->NumSharedComponents]; UnsafeUtility.MemClear(sharedComponentValues, archetype->NumSharedComponents * sizeof(int)); while (count != 0) { var chunk = GetChunkWithEmptySlots(archetype, sharedComponentValues, entityComponentStore, managedComponentStore); int allocatedIndex; var allocatedCount = AllocateIntoChunk(chunk, count, out allocatedIndex, entityComponentStore, managedComponentStore); entityComponentStore->AllocateEntities(archetype, chunk, allocatedIndex, allocatedCount, entities); ChunkDataUtility.InitializeComponents(chunk, allocatedIndex, allocatedCount); chunk->SetAllChangeVersions(entityComponentStore->GlobalSystemVersion); entities += allocatedCount; count -= allocatedCount; } entityComponentStore->IncrementComponentTypeOrderVersion(archetype); }
internal object GetManagedObject(ManagedComponentStore managedComponentStore, int typeIndexInQuery, int entityInChunkIndex) { var indexInArchetype = CurrentMatchingArchetype->IndexInArchetype[typeIndexInQuery]; var managedComponentArray = (int *)ChunkDataUtility.GetComponentDataRW(CurrentChunk, 0, indexInArchetype, CurrentArchetype->EntityComponentStore->GlobalSystemVersion); return(managedComponentStore.GetManagedComponent(managedComponentArray[entityInChunkIndex])); }
public static void CopyManagedObjects( ManagedComponentStore srcStore, Archetype *srcArch, int srcManagedArrayIndex, int srcChunkCapacity, int srcStartIndex, ManagedComponentStore dstStore, Archetype *dstArch, int dstManagedArrayIndex, int dstChunkCapacity, int dstStartIndex, int count) { var srcI = 0; var dstI = 0; while (srcI < srcArch->TypesCount && dstI < dstArch->TypesCount) { if (srcArch->Types[srcI] < dstArch->Types[dstI]) { ++srcI; } else if (srcArch->Types[srcI] > dstArch->Types[dstI]) { ++dstI; } else { if (srcArch->ManagedArrayOffset[srcI] >= 0) { for (var i = 0; i < count; ++i) { var obj = srcStore.GetManagedObject(srcArch, srcManagedArrayIndex, srcChunkCapacity, srcI, srcStartIndex + i); dstStore.SetManagedObject(dstArch, dstManagedArrayIndex, dstChunkCapacity, dstI, dstStartIndex + i, obj); } } ++srcI; ++dstI; } } }
internal object GetSharedComponentData(Entity entity, int typeIndex) { EntityComponentStore->AssertEntityHasComponent(entity, typeIndex); var sharedComponentIndex = EntityComponentStore->GetSharedComponentDataIndex(entity, typeIndex); return(ManagedComponentStore.GetSharedComponentDataBoxed(sharedComponentIndex, typeIndex)); }
public T GetComponentObject <T>(Entity entity, ComponentType componentType) { EntityComponentStore->AssertEntityHasComponent(entity, componentType.TypeIndex); var entityInChunk = EntityComponentStore->GetEntityInChunk(entity); return((T)ManagedComponentStore.GetManagedObject(entityInChunk.Chunk, componentType, entityInChunk.IndexInChunk)); }
public void CreateChunk(EntityArchetype archetype, NativeArray <ArchetypeChunk> chunks, int entityCount) { Unity.Entities.EntityComponentStore.AssertValidArchetype(EntityComponentStore, archetype); BeforeStructuralChange(); EntityComponentStore->CreateChunks(archetype.Archetype, (ArchetypeChunk *)chunks.GetUnsafePtr(), chunks.Length, entityCount); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); }
public void CreateChunk(EntityArchetype archetype, NativeArray <ArchetypeChunk> chunks, int entityCount) { BeforeStructuralChange(); EntityComponentStore->CreateChunks(archetype.Archetype, (ArchetypeChunk *)chunks.GetUnsafePtr(), entityCount); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); }
public static void DestroyMetaChunkEntity(Entity entity, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { EntityManagerChangeArchetypeUtility.RemoveComponent(entity, ComponentType.ReadWrite <ChunkHeader>(), entityComponentStore, managedComponentStore); DestroyEntities(&entity, 1, entityComponentStore, managedComponentStore); }
internal object GetManagedComponentDataAsObject(Entity entity, ComponentType componentType) { EntityComponentStore->AssertEntityHasComponent(entity, componentType.TypeIndex); var entityInChunk = EntityComponentStore->GetEntityInChunk(entity); return(ManagedComponentStore.GetManagedObject(entityInChunk.Chunk, componentType, entityInChunk.IndexInChunk)); }
internal EntityQuery(EntityQueryData *queryData, ComponentJobSafetyManager *safetyManager, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { m_QueryData = queryData; m_Filter = default(EntityQueryFilter); m_SafetyManager = safetyManager; m_EntityComponentStore = entityComponentStore; m_ManagedComponentStore = managedComponentStore; }
// ---------------------------------------------------------------------------------------------------------- // PUBLIC // ---------------------------------------------------------------------------------------------------------- /// <summary> /// Creates an entity having the specified archetype. /// </summary> /// <remarks> /// The EntityManager creates the entity in the first available chunk with the matching archetype that has /// enough space. /// /// **Important:** This function creates a sync point, which means that the EntityManager waits for all /// currently running Jobs to complete before creating the entity 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="archetype">The archetype for the new entity.</param> /// <returns>The Entity object that you can use to access the entity.</returns> public Entity CreateEntity(EntityArchetype archetype) { Entity entity; BeforeStructuralChange(); EntityComponentStore->CreateEntities(archetype.Archetype, &entity, 1); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); return(entity); }
public Entity CreateEntity() { BeforeStructuralChange(); Entity entity; EntityComponentStore->CreateEntities(m_EntityDataAccess.GetEntityOnlyArchetype().Archetype, &entity, 1); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); return(entity); }
internal void DestroyChunkForDiffing(Chunk *chunk) { chunk->Archetype->EntityCount -= chunk->Count; EntityComponentStore->FreeEntities(chunk); EntityComponentStore->SetChunkCountKeepMetaChunk(chunk, 0); ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker); }
static void ConstructChunk(Archetype *archetype, Chunk *chunk, SharedComponentValues sharedComponentValues, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore, EntityGroupManager entityGroupManager) { chunk->Archetype = archetype; chunk->Count = 0; chunk->Capacity = archetype->ChunkCapacity; chunk->SequenceNumber = entityComponentStore->AssignSequenceNumber(chunk); chunk->metaChunkEntity = Entity.Null; var numSharedComponents = archetype->NumSharedComponents; if (numSharedComponents > 0) { for (var i = 0; i < archetype->NumSharedComponents; ++i) { var sharedComponentIndex = sharedComponentValues[i]; managedComponentStore.AddReference(sharedComponentIndex); } } archetype->AddToChunkList(chunk, sharedComponentValues, entityComponentStore->GlobalSystemVersion); Assert.IsTrue(archetype->Chunks.Count != 0); // Chunk can't be locked at at construction time archetype->EmptySlotTrackingAddChunk(chunk); if (numSharedComponents == 0) { Assert.IsTrue(archetype->ChunksWithEmptySlots.Count != 0); } else { Assert.IsTrue(archetype->FreeChunksBySharedComponents.TryGet(chunk->SharedComponentValues, archetype->NumSharedComponents) != null); } if (archetype->NumManagedArrays > 0) { chunk->ManagedArrayIndex = managedComponentStore.AllocateManagedArrayStorage(archetype->NumManagedArrays * chunk->Capacity); } else { chunk->ManagedArrayIndex = -1; } chunk->Flags = 0; if (archetype->MetaChunkArchetype != null) { CreateMetaEntityForChunk(chunk, entityComponentStore, managedComponentStore, entityGroupManager); } }
private static PackedSharedComponentDataChange[] GetChangedSharedComponents( PackedCollection <EntityGuid> packedEntityCollection, PackedCollection <ComponentTypeHash> packedStableTypeHashCollection, NativeList <DeferredPackedSharedComponentDataChange> changes, ManagedComponentStore beforeManagedComponentStore, ManagedComponentStore afterManagedComponentStore) { if (changes.Length == 0) { return(s_EmptySetSharedComponentDiff); } var result = new List <PackedSharedComponentDataChange>(); for (var i = 0; i < changes.Length; i++) { var change = changes[i]; object afterValue = null; if (change.AfterSharedComponentIndex != 0) { afterValue = afterManagedComponentStore.GetSharedComponentDataBoxed(change.AfterSharedComponentIndex, change.TypeIndex); } if (change.BeforeSharedComponentIndex > -1 && change.AfterSharedComponentIndex != 0) { var beforeValue = beforeManagedComponentStore.GetSharedComponentDataBoxed(change.BeforeSharedComponentIndex, change.TypeIndex); if (TypeManager.Equals(beforeValue, afterValue, change.TypeIndex)) { continue; } } var packedEntityIndex = packedEntityCollection.GetOrAdd(change.EntityGuid); var packedTypeIndex = packedStableTypeHashCollection.GetOrAdd(new ComponentTypeHash { StableTypeHash = TypeManager.GetTypeInfo(change.TypeIndex).StableTypeHash }); var packedComponent = new PackedComponent { PackedEntityIndex = packedEntityIndex, PackedTypeIndex = packedTypeIndex }; result.Add(new PackedSharedComponentDataChange { Component = packedComponent, BoxedSharedValue = afterValue }); } return(result.ToArray()); }
/// <summary> /// This method will handle the cloning of Hybrid Components (if any) during the batched instantiation of an Entity /// </summary> /// <param name="obj">The Hybrid Component. We don't know for sure it's a component to clone or to reference, this method is also about detecting this use case and the return value will give us the info</param> /// <param name="srcStore">Source Managed Store of the entity to instantiate</param> /// <param name="dstArch">Destination archetype of the entity to instantiate</param> /// <param name="dstStore">Destination Managed Store that will own the instances we create</param> /// <param name="dstManagedArrayIndex">Index of the Hybrid Component associated with <paramref name="obj"/></param> /// <param name="dstChunkCapacity">Chunk capacity</param> /// <param name="srcEntity">Entity to instantiate</param> /// <param name="dstEntities">Array containing all the entities instantiated</param> /// <param name="dstTypeIndex">Destination type index</param> /// <param name="dstBaseIndex">Destination base index</param> /// <param name="gameObjectInstances">An array that will contain all the cloned Game Object companion. This method will fill this array at the first call for a Hybrid Component to clone and will be used for subsequent ones</param> /// <returns><c>true</c> if the <paramref name="obj"/> was meant to be cloned, <c>false</c> if it is meant to be referenced</returns> static bool InstantiateHybridComponentDelegate(object obj, ManagedComponentStore srcStore, Archetype *dstArch, ManagedComponentStore dstStore, int dstManagedArrayIndex, int dstChunkCapacity, Entity srcEntity, NativeArray <Entity> dstEntities, int dstTypeIndex, int dstBaseIndex, ref object[] gameObjectInstances) { // For now, it only makes sense to support a conversion that happens in the same world // If whenever that changes, this assert will warn us it's not supported Assert.AreEqual(srcStore, dstStore, "Companion GameObject instancing assumes the src and dst EntityManager are the same, are you instancing across worlds?"); // This method is only about cloning Hybrid Components: if it's not a component we have nothing to do var unityComponent = obj as UnityEngine.Component; if (unityComponent == null) { return(false); } // This method is only about cloning Hybrid Components: if there's no Companion Link it means there's nothing to clone // This can still be a valid use case, the entity might be storing references to external Hybrid Components (e.g. first stage of conversion) var companionLink = unityComponent.gameObject.GetComponent <CompanionLink>(); if (companionLink == null) { return(false); } // The instantiation works in two phases: // 1) The first call on this method will clone the GameObject that owns the Hybrid Components for each instance we have to create and make it a Companion Game Object by attaching a CompanionLink component to it // 2) The first and all other calls will add the Hybrid Managed Component we cloned to the entity // 1) We know it's the first call if the array is null, it means we have to clone the GameObject for dstEntities.Length times and make it a Companion Game Object by adding a CompanionLink to it // Cloning the Game Object will also clone its components, which is exactly what we're looking for. // Note that we are relaxed with the content of the Game Object we clone: it may contains more than we need regarding the association with the Entity, but that's what we want, // if the user adds Components to the Game Object that are not used by the entity: so be it, the user will still have these components in the instantiated Game Objects if (gameObjectInstances == null) { gameObjectInstances = new object[dstEntities.Length]; for (int i = 0; i < dstEntities.Length; ++i) { var instance = GameObject.Instantiate(unityComponent.gameObject); instance.name = CompanionLink.GenerateCompanionName(dstEntities[i]); gameObjectInstances[i] = instance; instance.hideFlags |= HideFlags.HideInHierarchy; } } // For each instance we create, we add the cloned Hybrid Component to the entity for (int i = 0; i < dstEntities.Length; i++) { var componentInInstance = ((GameObject)gameObjectInstances[i]).GetComponent(obj.GetType()); dstStore.SetManagedObject(dstArch, dstManagedArrayIndex, dstChunkCapacity, dstTypeIndex, dstBaseIndex + i, componentInInstance); } return(true); }
public static void InstantiateEntities(Entity srcEntity, Entity *outputEntities, int instanceCount, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore, EntityGroupManager entityGroupManager) { var linkedType = TypeManager.GetTypeIndex <LinkedEntityGroup>(); if (entityComponentStore->HasComponent(srcEntity, linkedType)) { var header = (BufferHeader *)entityComponentStore->GetComponentDataWithTypeRO(srcEntity, linkedType); var entityPtr = (Entity *)BufferHeader.GetElementPointer(header); var entityCount = header->Length; #if ENABLE_UNITY_COLLECTIONS_CHECKS if (entityCount == 0 || entityPtr[0] != srcEntity) { throw new ArgumentException("LinkedEntityGroup[0] must always be the Entity itself."); } for (int i = 0; i < entityCount; i++) { if (!entityComponentStore->Exists(entityPtr[i])) { throw new ArgumentException( "The srcEntity's LinkedEntityGroup references an entity that is invalid. (Entity at index {i} on the LinkedEntityGroup.)"); } var archetype = entityComponentStore->GetArchetype(entityPtr[i]); if (archetype->InstantiableArchetype == null) { throw new ArgumentException( "The srcEntity's LinkedEntityGroup references an entity that has already been destroyed. (Entity at index {i} on the LinkedEntityGroup. Only system state components are left on the entity)"); } } #endif InstantiateEntitiesGroup(entityPtr, entityCount, outputEntities, instanceCount, entityComponentStore, managedComponentStore, entityGroupManager); } else { #if ENABLE_UNITY_COLLECTIONS_CHECKS if (!entityComponentStore->Exists(srcEntity)) { throw new ArgumentException("srcEntity is not a valid entity"); } var srcArchetype = entityComponentStore->GetArchetype(srcEntity); if (srcArchetype->InstantiableArchetype == null) { throw new ArgumentException( "srcEntity is not instantiable because it has already been destroyed. (Only system state components are left on it)"); } #endif InstantiateEntitiesOne(srcEntity, outputEntities, instanceCount, null, 0, entityComponentStore, managedComponentStore, entityGroupManager); } }
public T GetComponentObject <T>(Entity entity, ComponentType componentType) { EntityComponentStore->AssertEntityHasComponent(entity, componentType.TypeIndex); Chunk *chunk; int chunkIndex; EntityComponentStore->GetChunk(entity, out chunk, out chunkIndex); return((T)ManagedComponentStore.GetManagedObject(chunk, componentType, chunkIndex)); }
internal void SetComponentObject(Entity entity, ComponentType componentType, object componentObject) { EntityComponentStore->AssertEntityHasComponent(entity, componentType.TypeIndex); Chunk *chunk; int chunkIndex; EntityComponentStore->GetChunk(entity, out chunk, out chunkIndex); ManagedComponentStore.SetManagedObject(chunk, componentType, chunkIndex, componentObject); }
public static void DestroyChunkForDiffing(Chunk *chunk, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore) { chunk->Archetype->EntityCount -= chunk->Count; entityComponentStore->FreeEntities(chunk); EntityManagerCreateDestroyEntitiesUtility.SetChunkCount(chunk, 0, entityComponentStore, managedComponentStore); }