public static void CreateChunks(Archetype *archetype, ArchetypeChunk *chunks, int entityCount,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
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, entityGroupManager);
int allocatedIndex;
var allocatedCount = AllocateIntoChunk(chunk, entityCount, out allocatedIndex,
entityComponentStore, managedComponentStore, entityGroupManager);
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);
}
// ----------------------------------------------------------------------------------------------------------
// PUBLIC
// ----------------------------------------------------------------------------------------------------------
/// <summary>
/// Moves all entities managed by the specified EntityManager to the <see cref="World"/> of this EntityManager and fills
/// an array with their <see cref="Entity"/> objects.
/// </summary>
/// <remarks>
/// After the move, the entities are managed by this EntityManager. Use the `output` array to make post-move
/// changes to the transferred entities.
///
/// Each world has one EntityManager, which manages all the entities in that world. This function
/// allows you to transfer entities from one World to another.
///
/// **Important:** This function creates a sync point, which means that the EntityManager waits for all
/// currently running Jobs to complete before moving the entities 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="output">An array to receive the Entity objects of the transferred entities.</param>
/// <param name="srcEntities">The EntityManager whose entities are appropriated.</param>
/// <param name="entityRemapping">A set of entity transformations to make during the transfer.</param>
/// <exception cref="ArgumentException"></exception>
public void MoveEntitiesFrom(out NativeArray <Entity> output, EntityManager srcEntities,
NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapping)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (srcEntities == this)
{
throw new ArgumentException("srcEntities must not be the same as this EntityManager.");
}
if (!srcEntities.m_ManagedComponentStore.AllSharedComponentReferencesAreFromChunks(srcEntities
.EntityComponentStore))
{
throw new ArgumentException(
"EntityManager.MoveEntitiesFrom failed - All ISharedComponentData references must be from EntityManager. (For example EntityQuery.SetFilter with a shared component type is not allowed during EntityManager.MoveEntitiesFrom)");
}
#endif
BeforeStructuralChange();
srcEntities.BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityManagerMoveEntitiesUtility.MoveChunks(entityRemapping,
srcEntities.EntityComponentStore, srcEntities.ManagedComponentStore,
EntityComponentStore, ManagedComponentStore);
EntityRemapUtility.GetTargets(out output, entityRemapping);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityGroupManager.AddAdditionalArchetypes(changedArchetypes);
//@TODO: Need to increment the component versions based the moved chunks...
}
public bool CompareComponents(ComponentType[] componentTypes)
{
fixed(ComponentType *componentTypesPtr = componentTypes)
{
return(EntityGroupManager.CompareComponents(componentTypesPtr, componentTypes.Length, m_GroupData));
}
}
// ----------------------------------------------------------------------------------------------------------
// INTERNAL
// ----------------------------------------------------------------------------------------------------------
void MoveEntitiesFrom(out NativeArray <Entity> output, EntityManager srcEntities,
NativeArray <ArchetypeChunk> chunks, NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapping)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (srcEntities == this)
{
throw new ArgumentException("srcEntities must not be the same as this EntityManager.");
}
for (int i = 0; i < chunks.Length; ++i)
{
if (chunks[i].m_Chunk->Archetype->HasChunkHeader)
{
throw new ArgumentException(
"MoveEntitiesFrom can not move chunks that contain ChunkHeader components.");
}
}
#endif
BeforeStructuralChange();
srcEntities.BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityManagerMoveEntitiesUtility.MoveChunks(chunks, entityRemapping,
srcEntities.EntityComponentStore, srcEntities.ManagedComponentStore,
EntityComponentStore, ManagedComponentStore);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityGroupManager.AddAdditionalArchetypes(changedArchetypes);
EntityRemapUtility.GetTargets(out output, entityRemapping);
}
public static void SetChunkCount(Chunk *chunk, int newCount,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
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, entityGroupManager);
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);
}
/// <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);
}
}
internal void DestroyInstance()
{
EndExclusiveEntityTransaction();
m_ComponentJobSafetyManager->PreDisposeCheck();
m_UniversalQuery.Dispose();
m_UniversalQuery = null;
m_ComponentJobSafetyManager->Dispose();
UnsafeUtility.Free(m_ComponentJobSafetyManager, Allocator.Persistent);
m_ComponentJobSafetyManager = null;
Entities.EntityComponentStore.Destroy(m_EntityComponentStore);
m_EntityComponentStore = null;
m_EntityGroupManager.Dispose();
m_EntityGroupManager = null;
m_ExclusiveEntityTransaction.OnDestroy();
m_ManagedComponentStore.Dispose();
m_World = null;
m_Debug = null;
TypeManager.Shutdown();
}
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 CreateEntities(Archetype *archetype, Entity *entities, int count,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
var sharedComponentValues = stackalloc int[archetype->NumSharedComponents];
UnsafeUtility.MemClear(sharedComponentValues, archetype->NumSharedComponents * sizeof(int));
while (count != 0)
{
var chunk = GetChunkWithEmptySlots(archetype, sharedComponentValues,
entityComponentStore, managedComponentStore, entityGroupManager);
int allocatedIndex;
var allocatedCount = AllocateIntoChunk(chunk, count, out allocatedIndex,
entityComponentStore, managedComponentStore, entityGroupManager);
entityComponentStore->AllocateEntities(archetype, chunk, allocatedIndex, allocatedCount, entities);
ChunkDataUtility.InitializeComponents(chunk, allocatedIndex, allocatedCount);
chunk->SetAllChangeVersions(entityComponentStore->GlobalSystemVersion);
entities += allocatedCount;
count -= allocatedCount;
}
entityComponentStore->IncrementComponentTypeOrderVersion(archetype);
}
protected override void OnDestroyManager()
{
EndExclusiveEntityTransaction();
ComponentJobSafetyManager.PreDisposeCheck();
// Clean up all entities. This is needed to free all internal buffer allocations so memory is not leaked.
using (var allEntities = GetAllEntities())
{
DestroyEntity(allEntities);
}
ComponentJobSafetyManager.Dispose();
ComponentJobSafetyManager = null;
Entities->OnDestroy();
UnsafeUtility.Free(Entities, Allocator.Persistent);
Entities = null;
ArchetypeManager.Dispose();
ArchetypeManager = null;
m_GroupManager.Dispose();
m_GroupManager = null;
m_ExclusiveEntityTransaction.OnDestroyManager();
m_SharedComponentManager.Dispose();
UnsafeUtility.Free(m_CachedComponentTypeArray, Allocator.Persistent);
m_CachedComponentTypeArray = null;
UnsafeUtility.Free(m_CachedComponentTypeInArchetypeArray, Allocator.Persistent);
m_CachedComponentTypeInArchetypeArray = null;
}
public Archetype *GetOrCreateArchetype(ComponentTypeInArchetype *types, int count,
EntityGroupManager groupManager)
{
var srcArchetype = GetOrCreateArchetypeInternal(types, count, groupManager);
var removedTypes = 0;
var prefabTypeIndex = TypeManager.GetTypeIndex <Prefab>();
for (var t = 0; t < srcArchetype->TypesCount; ++t)
{
var type = srcArchetype->Types[t];
var skip = type.IsSystemStateComponent || type.IsSystemStateSharedComponent || (type.TypeIndex == prefabTypeIndex);
if (skip)
{
++removedTypes;
}
else
{
types[t - removedTypes] = srcArchetype->Types[t];
}
}
srcArchetype->InstantiableArchetype = srcArchetype;
if (removedTypes > 0)
{
var instantiableArchetype = GetOrCreateArchetypeInternal(types, count - removedTypes, groupManager);
srcArchetype->InstantiableArchetype = instantiableArchetype;
instantiableArchetype->InstantiableArchetype = instantiableArchetype;
}
return(srcArchetype);
}
private Archetype *GetOrCreateArchetypeInternal(ComponentTypeInArchetype *types, int count,
EntityGroupManager groupManager)
{
var type = GetExistingArchetype(types, count);
return(type != null ? type : CreateArchetypeInternal(types, count, groupManager));
}
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 unsafe void RemoveComponent(Entity entity, ComponentType type)
{
this.CheckAccess();
EntityGroupManager target = (EntityGroupManager)this.m_EntityGroupManager.Target;
this.m_Entities.AssertEntityHasComponent(entity, type);
this.m_Entities.RemoveComponent(entity, type, this.ArchetypeManager, this.SharedComponentDataManager, target, this.m_CachedComponentTypeInArchetypeArray);
}
private unsafe void DestroyEntityInternal(Entity *entities, int count)
{
this.CheckAccess();
this.m_Entities.AssertEntitiesExist(entities, count);
EntityGroupManager target = (EntityGroupManager)this.m_EntityGroupManager.Target;
this.m_Entities.TryRemoveEntityId(entities, count, this.ArchetypeManager, this.SharedComponentDataManager, target, this.m_CachedComponentTypeInArchetypeArray);
}
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);
}
}
public static void DestroyMetaChunkEntity(Entity entity,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
EntityManagerChangeArchetypeUtility.RemoveComponent(entity, ComponentType.ReadWrite <ChunkHeader>(),
entityComponentStore, managedComponentStore, entityGroupManager);
DestroyEntities(&entity, 1, entityComponentStore, managedComponentStore, entityGroupManager);
}
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);
}
}
private Archetype *GetEntityOnlyArchetype(ComponentTypeInArchetype *types, EntityGroupManager groupManager)
{
if (m_entityOnlyArchetype == null)
{
m_entityOnlyArchetype = GetOrCreateArchetypeInternal(types, 1, groupManager);
m_entityOnlyArchetype->InstantiableArchetype = m_entityOnlyArchetype;
m_entityOnlyArchetype->SystemStateResidueArchetype = null;
}
return(m_entityOnlyArchetype);
}
internal unsafe EntityArchetype CreateArchetype(ComponentType *types, int count)
{
EntityArchetype archetype;
this.CheckAccess();
EntityGroupManager target = (EntityGroupManager)this.m_EntityGroupManager.Target;
archetype.Archetype = this.ArchetypeManager.GetOrCreateArchetype(this.m_CachedComponentTypeInArchetypeArray, this.PopulatedCachedTypeInArchetypeArray(types, count), target);
return(archetype);
}
internal ExclusiveEntityTransaction(EntityGroupManager entityGroupManager,
ManagedComponentStore managedComponentStore, EntityComponentStore *componentStore)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_Safety = new AtomicSafetyHandle();
#endif
m_EntityComponentStore = componentStore;
m_EntityGroupManager = GCHandle.Alloc(entityGroupManager, GCHandleType.Weak);
m_ManagedComponentStore = GCHandle.Alloc(managedComponentStore, GCHandleType.Weak);
}
public static void DestroyChunkForDiffing(Chunk *chunk,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
chunk->Archetype->EntityCount -= chunk->Count;
entityComponentStore->FreeEntities(chunk);
EntityManagerCreateDestroyEntitiesUtility.SetChunkCount(chunk, 0,
entityComponentStore, managedComponentStore, entityGroupManager);
}
internal ExclusiveEntityTransaction(ArchetypeManager archetypes, EntityGroupManager entityGroupManager,
SharedComponentDataManager sharedComponentDataManager, EntityDataManager *data)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_Safety = new AtomicSafetyHandle();
#endif
m_Entities = data;
m_ArchetypeManager = GCHandle.Alloc(archetypes, GCHandleType.Weak);
m_EntityGroupManager = GCHandle.Alloc(entityGroupManager, GCHandleType.Weak);
m_SharedComponentDataManager = GCHandle.Alloc(sharedComponentDataManager, GCHandleType.Weak);
}
/// <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);
}
private unsafe void InstantiateInternal(Entity srcEntity, Entity *outputEntities, int count)
{
this.CheckAccess();
if (!this.m_Entities.Exists(srcEntity))
{
throw new ArgumentException("srcEntity is not a valid entity");
}
EntityGroupManager target = (EntityGroupManager)this.m_EntityGroupManager.Target;
this.m_Entities.InstantiateEntities(this.ArchetypeManager, this.SharedComponentDataManager, target, srcEntity, outputEntities, count, this.m_CachedComponentTypeInArchetypeArray);
}
public static Chunk *GetCleanChunk(Archetype *archetype, SharedComponentValues sharedComponentValues,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
Chunk *newChunk = entityComponentStore->AllocateChunk();
ConstructChunk(archetype, newChunk, sharedComponentValues,
entityComponentStore, managedComponentStore, entityGroupManager);
return(newChunk);
}
public static int AllocateIntoChunk(Chunk *chunk,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
int outIndex;
var res = AllocateIntoChunk(chunk, 1, out outIndex,
entityComponentStore, managedComponentStore, entityGroupManager);
Assert.AreEqual(1, res);
return(outIndex);
}
protected override unsafe void OnCreateManager()
{
TypeManager.Initialize();
this.Entities = (EntityDataManager *)UnsafeUtility.Malloc((long)sizeof(EntityDataManager), 0x40, Allocator.Persistent);
this.Entities.OnCreate();
this.m_SharedComponentManager = new SharedComponentDataManager();
this.ArchetypeManager = new Unity.Entities.ArchetypeManager(this.m_SharedComponentManager);
this.ComponentJobSafetyManager = new Unity.Entities.ComponentJobSafetyManager();
this.m_GroupManager = new EntityGroupManager(this.ComponentJobSafetyManager);
this.m_ExclusiveEntityTransaction = new ExclusiveEntityTransaction(this.ArchetypeManager, this.m_GroupManager, this.m_SharedComponentManager, this.Entities);
this.m_CachedComponentTypeInArchetypeArray = (ComponentTypeInArchetype *)UnsafeUtility.Malloc((long)(sizeof(ComponentTypeInArchetype) * 0x400), 0x10, Allocator.Persistent);
}
internal ExclusiveEntityTransaction(ArchetypeManager archetypes, EntityGroupManager entityGroupManager, SharedComponentDataManager sharedComponentDataManager, EntityDataManager *data)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_Safety = new AtomicSafetyHandle();
#endif
m_Entities = data;
m_ArchetypeManager = GCHandle.Alloc(archetypes, GCHandleType.Weak);
m_EntityGroupManager = GCHandle.Alloc(entityGroupManager, GCHandleType.Weak);
m_SharedComponentDataManager = GCHandle.Alloc(sharedComponentDataManager, GCHandleType.Weak);
m_CachedComponentTypeInArchetypeArray = (ComponentTypeInArchetype *)UnsafeUtility.Malloc(sizeof(ComponentTypeInArchetype) * 32 * 1024, 16, Allocator.Persistent);
}
public static int AllocateIntoChunk(Chunk *chunk, int count, out int outIndex,
EntityComponentStore *entityComponentStore,
ManagedComponentStore managedComponentStore,
EntityGroupManager entityGroupManager)
{
var allocatedCount = Math.Min(chunk->Capacity - chunk->Count, count);
outIndex = chunk->Count;
SetChunkCount(chunk, chunk->Count + allocatedCount,
entityComponentStore, managedComponentStore, entityGroupManager);
chunk->Archetype->EntityCount += allocatedCount;
return(allocatedCount);
}