Struct EntityManager

The EntityManager manages entities and components in a World.

Namespace: Unity.Entities
Syntax
[Preserve]
[NativeContainer]
public struct EntityManager : IEquatable<EntityManager>
Remarks

The EntityManager provides an API to create, read, update, and destroy entities.

A World has one EntityManager, which manages all the entities for that World.

Many EntityManager operations result in structural changes that change the layout of entities in memory. Before it can perform such operations, the EntityManager must wait for all running Jobs to complete, an event called a sync point. A sync point both blocks the main thread and prevents the application from taking advantage of all available cores as the running Jobs wind down.

Although you cannot prevent sync points entirely, you should avoid them as much as possible. To this end, the ECS framework provides the EntityCommandBuffer, which allows you to queue structural changes so that they all occur at one time in the frame.

Properties

Debug

An object providing debugging information and operations.

Declaration
public EntityManager.EntityManagerDebug Debug { get; }
Property Value
Type Description
EntityManager.EntityManagerDebug

EntityCapacity

The capacity of the internal entities array.

Declaration
public int EntityCapacity { get; }
Property Value
Type Description
Int32

The number of entities the array can hold before it must be resized.
Remarks

The entities array automatically resizes itself when the entity count approaches the capacity. You should rarely need to set this value directly.

Important: when you set this value (or when the array automatically resizes), the EntityManager first ensures that all Jobs finish. This can prevent the Job scheduler from utilizing available CPU cores and threads, resulting in a temporary performance drop.

ExclusiveEntityTransactionDependency

Declaration
public JobHandle ExclusiveEntityTransactionDependency { get; set; }
Property Value
Type Description
JobHandle

GlobalSystemVersion

A counter that increments after every system update.

Declaration
public uint GlobalSystemVersion { get; }
Property Value
Type Description
UInt32
Remarks

The ECS framework uses the GlobalSystemVersion to track changes in a conservative, efficient fashion. Changes are recorded per component per chunk.

See Also

TotalChunkAddressSpaceInBytes

The total reserved address space for all Chunks in all Worlds.

Declaration
public static ulong TotalChunkAddressSpaceInBytes { get; set; }
Property Value
Type Description
UInt64

UniversalQuery

A EntityQuery instance that matches all components.

Declaration
public EntityQuery UniversalQuery { get; }
Property Value
Type Description
EntityQuery

Version

The latest entity generational version.

Declaration
public int Version { get; }
Property Value
Type Description
Int32

This is the version number that is assigned to a new entity. See Version.

World

The World of this EntityManager.

Declaration
public World World { get; }
Property Value
Type Description
World

A World has one EntityManager and an EntityManager manages the entities of one World.

Methods

AddBuffer<T>(Entity)

Adds a dynamic buffer component to an entity.

Declaration
public DynamicBuffer<T> AddBuffer<T>(Entity entity)
    where T : struct, IBufferElementData
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
DynamicBuffer<T>

The buffer.
Type Parameters
Name Description
T

The type of buffer element. Must implement IBufferElementData.
Remarks

A buffer component stores the number of elements inside the chunk defined by the [InternalBufferCapacity] attribute applied to the buffer element type declaration. Any additional elements are stored in a separate memory block that is managed by the EntityManager.

Adding 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 adding the buffer 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.

See Also

AddChunkComponentData<T>(Entity)

Adds a chunk component to the specified entity. Returns true if the chunk component was added, false if the entity already had the chunk component. (The chunk component's data is set either way.)

Declaration
public bool AddChunkComponentData<T>(Entity entity)
    where T : struct, IComponentData
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
Boolean
Type Parameters
Name Description
T

The type of component, which must implement IComponentData.
Remarks

Adding a chunk component to an entity changes that entity's archetype and results in the entity being moved to a different chunk, either one that already has an archetype containing the chunk component or a new chunk.

A chunk component is common to all entities in a chunk. You can access a chunk IComponentData instance through either the chunk itself or through an entity stored in that chunk. In either case, getting or setting the component reads or writes the same data.

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.

AddChunkComponentData<T>(EntityQuery, T)

Adds a component to each of the chunks identified by a EntityQuery and set the component values.

Declaration
public void AddChunkComponentData<T>(EntityQuery entityQuery, T componentData)
    where T : struct, IComponentData
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery identifying the chunks to modify.
T componentData

The data to set.
Type Parameters
Name Description
T

The type of component, which must implement IComponentData.
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 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.

AddComponent(NativeArray<Entity>, ComponentType)

Adds a component to a set of entities.

Declaration
public void AddComponent(NativeArray<Entity> entities, ComponentType componentType)
Parameters
Type Name Description
NativeArray<Entity> entities

An array of Entity objects.
ComponentType componentType

The type of component to add.
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 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.

AddComponent(Entity, ComponentType)

Adds a component to an entity.

Declaration
public bool AddComponent(Entity entity, ComponentType componentType)
Parameters
Type Name Description
Entity entity

The Entity object.
ComponentType componentType

The type of component to add.
Returns
Type Description
Boolean
Remarks

Adding a component changes the entity's archetype and results in the entity being moved to a different chunk.

The added component has the default values for the type.

If the Entity object refers to an entity that has been destroyed, this function throws an ArgumentError exception.

If the Entity object refers to an entity that already has the specified ComponentType, the function returns false without performing any modifications.

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.

AddComponent(EntityQuery, ComponentType)

Adds a component to a set of entities defined by a EntityQuery.

Declaration
public void AddComponent(EntityQuery entityQuery, ComponentType componentType)
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery defining the entities to modify.
ComponentType componentType

The type of component to add.
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.

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.

AddComponent(EntityQuery, ComponentTypes)

Adds components to a set of entities defined by a EntityQuery.

Declaration
public void AddComponent(EntityQuery entityQuery, ComponentTypes componentTypes)
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery defining the entities to modify.
ComponentTypes componentTypes

The type of components to add.
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.

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.

AddComponent<T>(NativeArray<Entity>)

Adds a component to a set of entities.

Declaration
public void AddComponent<T>(NativeArray<Entity> entities)
Parameters
Type Name Description
NativeArray<Entity> entities

An array of Entity objects.
Type Parameters
Name Description
T

The type of component to add.
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 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.

AddComponent<T>(Entity)

Adds a component to an entity.

Declaration
public bool AddComponent<T>(Entity entity)
Parameters
Type Name Description
Entity entity

The Entity object.
Returns
Type Description
Boolean
Type Parameters
Name Description
T

The type of component to add.
Remarks

Adding a component changes the entity's archetype and results in the entity being moved to a different chunk.

The added component has the default values for the type.

If the Entity object refers to an entity that has been destroyed, this function throws an ArgumentError exception.

If the Entity object refers to an entity that already has the specified ComponentType of type T, the function returns false without performing any modifications.

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.

AddComponent<T>(EntityQuery)

Adds a component to a set of entities defined by a EntityQuery.

Declaration
public void AddComponent<T>(EntityQuery entityQuery)
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery defining the entities to modify.
Type Parameters
Name Description
T

The type of component to add.
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.

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.

AddComponentData<T>(Entity, T)

Adds a component to an entity and set the value of that component. Returns true if the component was added, false if the entity already had the component. (The component's data is set either way.)

Declaration
public bool AddComponentData<T>(Entity entity, T componentData)
    where T : struct, IComponentData
Parameters
Type Name Description
Entity entity

The entity.
T componentData

The data to set.
Returns
Type Description
Boolean
Type Parameters
Name Description
T

The type of component.
Remarks

Adding 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 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.

AddComponentData<T>(EntityQuery, NativeArray<T>)

Adds a component to a set of entities defines by the EntityQuery and sets the component of each entity in the query to the value in the component array. componentArray.Length must match entityQuery.ToEntityArray().Length.

Declaration
public void AddComponentData<T>(EntityQuery entityQuery, NativeArray<T> componentArray)
    where T : struct, IComponentData
Parameters
Type Name Description
EntityQuery entityQuery

THe EntityQuery defining the entities to add component to
NativeArray<T> componentArray
Type Parameters
Name Description
T

AddComponentObject(Entity, Object)

Adds a managed UnityEngine.Component object to an entity.

Declaration
public void AddComponentObject(Entity entity, object componentData)
Parameters
Type Name Description
Entity entity

The entity to modify.
Object componentData

An object inheriting UnityEngine.Component.
Remarks

Accessing data in a managed object forfeits many opportunities for increased performance. Adding managed objects to an entity should be avoided or used sparingly.

Adding 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 adding the object 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.

Exceptions
Type Condition
ArgumentNullException

If the componentData object is not an instance of UnityEngine.Component.

AddComponents(Entity, ComponentTypes)

Adds a set of component to an entity.

Declaration
public void AddComponents(Entity entity, ComponentTypes types)
Parameters
Type Name Description
Entity entity

The entity to modify.
ComponentTypes types

The types of components to add.
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 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.

AddSharedComponentData<T>(Entity, T)

Adds a shared component to an entity. Returns true if the shared component was added, false if the entity already had the shared component. (The shared component's data is set either way.)

Declaration
public bool AddSharedComponentData<T>(Entity entity, T componentData)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
Entity entity

The entity.
T componentData

An instance of the shared component having the values to set.
Returns
Type Description
Boolean
Type Parameters
Name Description
T

The shared component type.
Remarks

The fields of the componentData parameter are assigned to the added shared component.

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.

AddSharedComponentData<T>(EntityQuery, T)

Adds a shared component to a set of entities defined by a EntityQuery.

Declaration
public void AddSharedComponentData<T>(EntityQuery entityQuery, T componentData)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery defining a set of entities to modify.
T componentData

The data to set.
Type Parameters
Name Description
T

The data type of the shared component.
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.

BeginExclusiveEntityTransaction()

Begins an exclusive entity transaction, which allows you to make structural changes inside a Job.

Declaration
public ExclusiveEntityTransaction BeginExclusiveEntityTransaction()
Returns
Type Description
ExclusiveEntityTransaction

A transaction object that provides an functions for making structural changes.
Remarks

ExclusiveEntityTransaction allows you to create and destroy entities from a job. The purpose is to enable procedural generation scenarios where instantiation on big scale must happen on jobs. As the name implies it is exclusive to any other access to the EntityManager.

An exclusive entity transaction should be used on a manually created World that acts as a staging area to construct and setup entities.

After the job has completed you can end the transaction and use MoveEntitiesFrom(EntityManager) to move the entities to an active World.

CompleteAllJobs()

Waits for all Jobs to complete.

Declaration
public void CompleteAllJobs()
Remarks

Calling CompleteAllJobs() blocks the main thread until all currently running Jobs finish.

CopyAndReplaceEntitiesFrom(EntityManager)

Copies all entities from srcEntityManager and replaces all entities in this EntityManager

Declaration
public void CopyAndReplaceEntitiesFrom(EntityManager srcEntityManager)
Parameters
Type Name Description
EntityManager srcEntityManager
Remarks

Guarantees that the chunk layout and order of the entities will match exactly, thus this method can be used for deterministic rollback. This feature is not complete and only supports a subset of the EntityManager features at the moment:

  • Currently it copies all SystemStateComponents (They should not be copied)
  • Currently does not support class based components

CopyEntities(NativeArray<Entity>, NativeArray<Entity>)

Clones a set of entities, different from Instantiate because it does not remove the prefab tag component.

Declaration
public void CopyEntities(NativeArray<Entity> srcEntities, NativeArray<Entity> outputEntities)
Parameters
Type Name Description
NativeArray<Entity> srcEntities

The set of entities to clone
NativeArray<Entity> outputEntities

the set of entities that were cloned. outputEntities.Length must match srcEntities.Length
Remarks

The new entity has the same archetype and component values as the original, however system state components are removed from the clone.

Entity references on components that are being cloned to entities inside the set are remapped to the instantiated entities. This method overload ignores the LinkedEntityGroup component, since the group of entities that will be cloned is passed explicitly.

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.

CopyEntitiesFrom(EntityManager, NativeArray<Entity>, NativeArray<Entity>)

Instantiates / Copies all entities from srcEntityManager and copies them into this EntityManager. Entity references on components that are being cloned to entities inside the srcEntities set are remapped to the instantiated entities.

Declaration
public void CopyEntitiesFrom(EntityManager srcEntityManager, NativeArray<Entity> srcEntities, NativeArray<Entity> outputEntities = default(NativeArray<Entity>))
Parameters
Type Name Description
EntityManager srcEntityManager
NativeArray<Entity> srcEntities
NativeArray<Entity> outputEntities

CreateArchetype(ComponentType[])

Creates an archetype from a set of component types.

Declaration
public EntityArchetype CreateArchetype(params ComponentType[] types)
Parameters
Type Name Description
ComponentType[] types

The component types to include as part of the archetype.
Returns
Type Description
EntityArchetype

The EntityArchetype object for the archetype.
Remarks

Creates a new archetype in the ECS framework's internal type registry, unless the archetype already exists.

CreateEntity()

Creates an entity with no components.

Declaration
public Entity CreateEntity()
Returns
Type Description
Entity

The Entity object that you can use to access the entity.
Remarks

The EntityManager creates the entity in the first available chunk with the archetype having no components.

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.

CreateEntity(ComponentType[])

Creates an entity having components of the specified types.

Declaration
public Entity CreateEntity(params ComponentType[] types)
Parameters
Type Name Description
ComponentType[] types

The types of components to add to the new entity.
Returns
Type Description
Entity

The Entity object that you can use to access the entity.
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.

CreateEntity(EntityArchetype)

Creates an entity having the specified archetype.

Declaration
public Entity CreateEntity(EntityArchetype archetype)
Parameters
Type Name Description
EntityArchetype archetype

The archetype for the new entity.
Returns
Type Description
Entity

The Entity object that you can use to access the entity.
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.

CreateEntity(EntityArchetype, Int32, Allocator)

Creates a set of entities of the specified archetype.

Declaration
public NativeArray<Entity> CreateEntity(EntityArchetype archetype, int entityCount, Allocator allocator)
Parameters
Type Name Description
EntityArchetype archetype

The archetype defining the structure for the new entities.
Int32 entityCount

The number of entities to create with the specified archetype.
Allocator allocator

How the created native array should be allocated.
Returns
Type Description
NativeArray<Entity>

A NativeArray of entities with the given archetype.
Remarks

Creates a NativeArray of entities, each of which has the components specified by the EntityArchetype object assigned to the archetype parameter. The EntityManager adds these entities to the World entity list.

CreateEntity(EntityArchetype, NativeArray<Entity>)

Creates a set of entities of the specified archetype.

Declaration
public void CreateEntity(EntityArchetype archetype, NativeArray<Entity> entities)
Parameters
Type Name Description
EntityArchetype archetype

The archetype defining the structure for the new entities.
NativeArray<Entity> 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.
Remarks

Fills the NativeArray object assigned to the entities parameter with the Entity objects of the created entities. Each entity has the components specified by the EntityArchetype object assigned to the archetype parameter. The EntityManager adds these entities to the World entity list. Use the Entity objects in the array for further processing, such as setting the component values.

CreateEntityQuery(ComponentType[])

Creates a EntityQuery from an array of component types.

Declaration
public EntityQuery CreateEntityQuery(params ComponentType[] requiredComponents)
Parameters
Type Name Description
ComponentType[] requiredComponents

An array containing the component types.
Returns
Type Description
EntityQuery

The EntityQuery derived from the specified array of component types.
See Also

CreateEntityQuery(EntityQueryDesc[])

Creates a EntityQuery from an EntityQueryDesc.

Declaration
public EntityQuery CreateEntityQuery(params EntityQueryDesc[] queriesDesc)
Parameters
Type Name Description
EntityQueryDesc[] queriesDesc

A queryDesc identifying a set of component types.
Returns
Type Description
EntityQuery

The EntityQuery corresponding to the queryDesc.

CreateEntityRemapArray(Allocator)

Creates a remapping array with one element for each entity in the World.

Declaration
public NativeArray<EntityRemapUtility.EntityRemapInfo> CreateEntityRemapArray(Allocator allocator)
Parameters
Type Name Description
Allocator allocator

The type of memory allocation to use when creating the array.
Returns
Type Description
NativeArray<EntityRemapUtility.EntityRemapInfo>

An array containing a no-op identity transformation for each entity.

DestroyEntity(NativeArray<Entity>)

Destroys all entities in an array.

Declaration
public void DestroyEntity(NativeArray<Entity> entities)
Parameters
Type Name Description
NativeArray<Entity> entities

An array containing the Entity objects of the entities to destroy.
Remarks

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before destroying 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.

DestroyEntity(NativeSlice<Entity>)

Destroys all entities in a slice of an array.

Declaration
public void DestroyEntity(NativeSlice<Entity> entities)
Parameters
Type Name Description
NativeSlice<Entity> entities

The slice of an array containing the Entity objects of the entities to destroy.
Remarks

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before destroying 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.

DestroyEntity(Entity)

Destroys an entity.

Declaration
public void DestroyEntity(Entity entity)
Parameters
Type Name Description
Entity entity

The Entity object of the entity to destroy.
Remarks

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before destroying 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.

DestroyEntity(EntityQuery)

Destroy all entities having a common set of component types.

Declaration
public void DestroyEntity(EntityQuery entityQuery)
Parameters
Type Name Description
EntityQuery entityQuery
Remarks

Since entities in the same chunk share the same component structure, this function effectively destroys the chunks holding any entities identified by the entityQueryFilter parameter.

EndExclusiveEntityTransaction()

Ends an exclusive entity transaction.

Declaration
public void EndExclusiveEntityTransaction()
See Also

Equals(Object)

Declaration
public override bool Equals(object obj)
Parameters
Type Name Description
Object obj
Returns
Type Description
Boolean
Overrides

Equals(EntityManager)

Declaration
public bool Equals(EntityManager other)
Parameters
Type Name Description
EntityManager other
Returns
Type Description
Boolean

Exists(Entity)

Reports whether an Entity object is still valid.

Declaration
public bool Exists(Entity entity)
Parameters
Type Name Description
Entity entity

The Entity object to check.
Returns
Type Description
Boolean

True, if Version matches the version of the current entity at Index in the entities array.
Remarks

An Entity object does not contain a reference to its entity. Instead, the Entity struct contains an index and a generational version number. When an entity is destroyed, the EntityManager increments the version of the entity within the internal array of entities. The index of a destroyed entity is recycled when a new entity is created.

After an entity is destroyed, any existing Entity objects will still contain the older version number. This function compares the version numbers of the specified Entity object and the current version of the entity recorded in the entities array. If the versions are different, the Entity object no longer refers to an existing entity and cannot be used.

GetAllArchetypes(NativeList<EntityArchetype>)

Gets all the archetypes.

Declaration
public void GetAllArchetypes(NativeList<EntityArchetype> allArchetypes)
Parameters
Type Name Description
NativeList<EntityArchetype> allArchetypes

A native list to receive the EntityArchetype objects.
Remarks

The function adds the archetype objects to the existing contents of the list. The list is not cleared.

GetAllChunks(Allocator)

Gets all the chunks managed by this EntityManager.

Declaration
public NativeArray<ArchetypeChunk> GetAllChunks(Allocator allocator = Allocator.TempJob)
Parameters
Type Name Description
Allocator allocator

The type of allocation for creating the NativeArray to hold the ArchetypeChunk objects.
Returns
Type Description
NativeArray<ArchetypeChunk>

An array of ArchetypeChunk objects referring to all the chunks in the World.
Remarks

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before getting 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.

GetAllEntities(Allocator)

Gets all the entities managed by this EntityManager.

Declaration
public NativeArray<Entity> GetAllEntities(Allocator allocator = Allocator.Temp)
Parameters
Type Name Description
Allocator allocator

The type of allocation for creating the NativeArray to hold the Entity objects.
Returns
Type Description
NativeArray<Entity>

An array of Entity objects referring to all the entities in the World.
Remarks

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before getting 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.

GetAllUniqueSharedComponentData<T>(List<T>)

Gets a list of all the unique instances of a shared component type.

Declaration
public void GetAllUniqueSharedComponentData<T>(List<T> sharedComponentValues)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
List<T> sharedComponentValues

A List^lt;T> object to receive the unique instances of the shared component of type T.
Type Parameters
Name Description
T

The type of shared component.
Remarks

All entities with the same archetype and the same values for a shared component are stored in the same set of chunks. This function finds the unique shared components existing across chunks and archetype and fills a list with copies of those components.

GetAllUniqueSharedComponentData<T>(List<T>, List<Int32>)

Gets a list of all unique shared components of the same type and a corresponding list of indices into the internal shared component list.

Declaration
public void GetAllUniqueSharedComponentData<T>(List<T> sharedComponentValues, List<int> sharedComponentIndices)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
List<T> sharedComponentValues
List<Int32> sharedComponentIndices
Type Parameters
Name Description
T
Remarks

All entities with the same archetype and the same values for a shared component are stored in the same set of chunks. This function finds the unique shared components existing across chunks and archetype and fills a list with copies of those components and fills in a separate list with the indices of those components in the internal shared component list. You can use the indices to ask the same shared components directly by calling GetSharedComponentData<T>(Int32), passing in the index. An index remains valid until the shared component order version changes. Check this version using GetSharedComponentOrderVersion<T>(T).

GetAssignableComponentTypes(Type)

Gets a list of the types of components that can be assigned to the specified component.

Declaration
public List<Type> GetAssignableComponentTypes(Type interfaceType)
Parameters
Type Name Description
Type interfaceType

The type to check.
Returns
Type Description
List<Type>

A new List object containing the System.Types that can be assigned to interfaceType.
Remarks

Assignable components include those with the same compile-time type and those that inherit from the same compile-time type.

GetAssignableComponentTypes(Type, List<Type>)

Gets a list of the types of components that can be assigned to the specified component.

Declaration
public List<Type> GetAssignableComponentTypes(Type interfaceType, List<Type> listOut)
Parameters
Type Name Description
Type interfaceType

The type to check.
List<Type> listOut

The list to receive the output.
Returns
Type Description
List<Type>

The list that was passed in, containing the System.Types that can be assigned to interfaceType.
Remarks

Assignable components include those with the same compile-time type and those that inherit from the same compile-time type.

GetBuffer<T>(Entity)

Gets the dynamic buffer of an entity.

Declaration
public DynamicBuffer<T> GetBuffer<T>(Entity entity)
    where T : struct, IBufferElementData
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
DynamicBuffer<T>

The DynamicBuffer object for accessing the buffer contents.
Type Parameters
Name Description
T

The type of the buffer's elements.
Exceptions
Type Condition
ArgumentException

Thrown if T is an unsupported type.

GetBufferTypeHandle<T>(Boolean)

Gets the dynamic type object required to access a chunk buffer containing elements of type T.

Declaration
public BufferTypeHandle<T> GetBufferTypeHandle<T>(bool isReadOnly)
    where T : struct, IBufferElementData
Parameters
Type Name Description
Boolean isReadOnly

Specify whether the access to the component through this object is read only or read and write.

Returns
Type Description
BufferTypeHandle<T>

The run-time type information of the buffer component.
Type Parameters
Name Description
T

The compile-time type of the buffer elements.
Remarks

To access a component stored in a chunk, you must have the type registry information for the component. This function provides that information for buffer components. Use the returned ComponentTypeHandle<T> object with the functions of an ArchetypeChunk object to get information about the components in that chunk and to access the component values.

GetChunk(Entity)

Gets the chunk in which the specified entity is stored.

Declaration
public ArchetypeChunk GetChunk(Entity entity)
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
ArchetypeChunk

The chunk containing the entity.

GetChunkComponentData<T>(ArchetypeChunk)

Gets the value of a chunk component.

Declaration
public T GetChunkComponentData<T>(ArchetypeChunk chunk)
    where T : struct, IComponentData
Parameters
Type Name Description
ArchetypeChunk chunk

The chunk.
Returns
Type Description
T

A struct of type T containing the component value.
Type Parameters
Name Description
T

The component type.
Remarks

A chunk component is common to all entities in a chunk. You can access a chunk IComponentData instance through either the chunk itself or through an entity stored in that chunk.

Exceptions
Type Condition
ArgumentException

Thrown if the ArchetypeChunk object is invalid.

GetChunkComponentData<T>(Entity)

Gets the value of chunk component for the chunk containing the specified entity.

Declaration
public T GetChunkComponentData<T>(Entity entity)
    where T : struct, IComponentData
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
T

A struct of type T containing the component value.
Type Parameters
Name Description
T

The component type.
Remarks

A chunk component is common to all entities in a chunk. You can access a chunk IComponentData instance through either the chunk itself or through an entity stored in that chunk.

GetComponentCount(Entity)

Gets the number of component types associated with an entity.

Declaration
public int GetComponentCount(Entity entity)
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
Int32

The number of components.

GetComponentData<T>(Entity)

Gets the value of a component for an entity.

Declaration
public T GetComponentData<T>(Entity entity)
    where T : struct, IComponentData
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
T

A struct of type T containing the component value.
Type Parameters
Name Description
T

The type of component to retrieve.
Exceptions
Type Condition
ArgumentException

Thrown if the component type has no fields.

GetComponentObject<T>(Entity)

Gets the managed UnityEngine.Component object from an entity.

Declaration
public T GetComponentObject<T>(Entity entity)
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
T

The managed object, cast to type T.
Type Parameters
Name Description
T

The type of the managed object.

GetComponentObject<T>(Entity, ComponentType)

Declaration
public T GetComponentObject<T>(Entity entity, ComponentType componentType)
Parameters
Type Name Description
Entity entity
ComponentType componentType
Returns
Type Description
T
Type Parameters
Name Description
T

GetComponentOrderVersion<T>()

Gets the version number of the specified component type.

Declaration
public int GetComponentOrderVersion<T>()
Returns
Type Description
Int32

The current version number.
Type Parameters
Name Description
T

The component type.
Remarks

This version number is incremented each time there is a structural change involving the specified type of component. Such changes include creating or destroying entities that have this component and adding or removing the component type from an entity. Shared components are not covered by this version; see GetSharedComponentOrderVersion<T>(T).

Version numbers can overflow. To compare if one version is more recent than another use a calculation such as:

bool VersionBisNewer = (VersionB - VersionA) > 0;

GetComponentTypeHandle<T>(Boolean)

Gets the dynamic type object required to access a chunk component of type T.

Declaration
public ComponentTypeHandle<T> GetComponentTypeHandle<T>(bool isReadOnly)
Parameters
Type Name Description
Boolean isReadOnly

Specify whether the access to the component through this object is read only or read and write. For managed components isReadonly will always be treated as false.
Returns
Type Description
ComponentTypeHandle<T>

The run-time type information of the component.
Type Parameters
Name Description
T

The compile-time type of the component.
Remarks

To access a component stored in a chunk, you must have the type registry information for the component. This function provides that information. Use the returned ComponentTypeHandle<T> object with the functions of an ArchetypeChunk object to get information about the components in that chunk and to access the component values.

GetComponentTypes(Entity, Allocator)

Gets an entity's component types.

Declaration
public NativeArray<ComponentType> GetComponentTypes(Entity entity, Allocator allocator = Allocator.Temp)
Parameters
Type Name Description
Entity entity

The entity.
Allocator allocator

The type of allocation for creating the NativeArray to hold the ComponentType objects.
Returns
Type Description
NativeArray<ComponentType>

An array of ComponentType containing all the types of components associated with the entity.

GetCreatedAndDestroyedEntities(NativeList<Int32>, NativeList<Entity>, NativeList<Entity>)

Detects the created and destroyed entities compared to last time the method was called with the given state.

Declaration
public void GetCreatedAndDestroyedEntities(NativeList<int> state, NativeList<Entity> createdEntities, NativeList<Entity> destroyedEntities)
Parameters
Type Name Description
NativeList<Int32> state

The same state list must be passed when you call this method, it remembers the entities that were already notified created and destroyed.
NativeList<Entity> createdEntities

The entities that were created.
NativeList<Entity> destroyedEntities

The entities that were destroyed.
Remarks

Entities must be fully destroyed, if system state components keep it alive it still counts as not yet destroyed. EntityCommandBuffer instances that have not been played back will have no effect on this until they are played back.

GetCreatedAndDestroyedEntitiesAsync(NativeList<Int32>, NativeList<Entity>, NativeList<Entity>)

Detects the created and destroyed entities compared to last time the method was called with the given state.

Declaration
public JobHandle GetCreatedAndDestroyedEntitiesAsync(NativeList<int> state, NativeList<Entity> createdEntities, NativeList<Entity> destroyedEntities)
Parameters
Type Name Description
NativeList<Int32> state

The same state list must be passed when you call this method, it remembers the entities that were already notified created and destroyed.
NativeList<Entity> createdEntities

The entities that were created.
NativeList<Entity> destroyedEntities

The entities that were destroyed.
Returns
Type Description
JobHandle
Remarks

Entities must be fully destroyed, if system state components keep it alive it still counts as not yet destroyed. EntityCommandBuffer instances that have not been played back will have no effect on this until they are played back.

GetDynamicComponentTypeHandle(ComponentType)

Gets the dynamic type object required to access a chunk component of dynamic type acquired from reflection.

Declaration
public DynamicComponentTypeHandle GetDynamicComponentTypeHandle(ComponentType componentType)
Parameters
Type Name Description
ComponentType componentType

Type of the component
Returns
Type Description
DynamicComponentTypeHandle

The run-time type information of the component.
Remarks

To access a component stored in a chunk, you must have the type registry information for the component. This function provides that information. Use the returned DynamicComponentTypeHandle object with the functions of an ArchetypeChunk object to get information about the components in that chunk and to access the component values.

GetEnabled(Entity)

Declaration
public bool GetEnabled(Entity entity)
Parameters
Type Name Description
Entity entity
Returns
Type Description
Boolean

GetEntityQueryMask(EntityQuery)

Gets an EntityQueryMask that can be used to quickly match if an entity belongs to an EntityQuery. There is a maximum limit of 1024 EntityQueryMasks that can be created. EntityQueryMasks cannot be created from EntityQueries with filters.

Declaration
public EntityQueryMask GetEntityQueryMask(EntityQuery query)
Parameters
Type Name Description
EntityQuery query

The EntityQuery that describes the EntityQueryMask.
Returns
Type Description
EntityQueryMask

The EntityQueryMask corresponding to the EntityQuery.
Remarks

Note that EntityQueryMask only filters by Archetype, it doesn't support EntityQuery shared component or change filtering.

GetEntityTypeHandle()

Gets the dynamic type object required to access the Entity component of a chunk.

Declaration
public EntityTypeHandle GetEntityTypeHandle()
Returns
Type Description
EntityTypeHandle

The run-time type information of the Entity component.
Remarks

All chunks have an implicit Entity component referring to the entities in that chunk.

To access any component stored in a chunk, you must have the type registry information for the component. This function provides that information for the implicit Entity component. Use the returned ComponentTypeHandle<T> object with the functions of an ArchetypeChunk object to access the component values.

GetHashCode()

Declaration
public override int GetHashCode()
Returns
Type Description
Int32
Overrides

GetSharedComponentCount()

Gets the number of shared components managed by this EntityManager.

Declaration
public int GetSharedComponentCount()
Returns
Type Description
Int32

The shared component count

GetSharedComponentData<T>(Int32)

Gets a shared component by index.

Declaration
public T GetSharedComponentData<T>(int sharedComponentIndex)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
Int32 sharedComponentIndex

The index of the shared component in the internal shared component list.
Returns
Type Description
T

A copy of the shared component.
Type Parameters
Name Description
T

The data type of the shared component.
Remarks

The ECS framework maintains an internal list of unique shared components. You can get the components in this list, along with their indices using GetAllUniqueSharedComponentData<T>(List<T>, List<Int32>). An index in the list is valid and points to the same shared component index as long as the shared component order version from GetSharedComponentOrderVersion<T>(T) remains the same.

GetSharedComponentData<T>(Entity)

Gets a shared component from an entity.

Declaration
public T GetSharedComponentData<T>(Entity entity)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
T

A copy of the shared component.
Type Parameters
Name Description
T

The type of shared component.

GetSharedComponentDataIndex<T>(Entity)

Declaration
public int GetSharedComponentDataIndex<T>(Entity entity)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
Entity entity
Returns
Type Description
Int32
Type Parameters
Name Description
T

GetSharedComponentOrderVersion<T>(T)

Gets the version number of the specified shared component.

Declaration
public int GetSharedComponentOrderVersion<T>(T sharedComponent)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
T sharedComponent

The shared component instance.
Returns
Type Description
Int32

The current version number.
Type Parameters
Name Description
T

The shared component type.
Remarks

This version number is incremented each time there is a structural change involving entities in the chunk of the specified shared component. Such changes include creating or destroying entities or anything that changes the archetype of an entity.

Version numbers can overflow. To compare if one version is more recent than another use a calculation such as:

bool VersionBisNewer = (VersionB - VersionA) > 0;

GetSharedComponentTypeHandle<T>()

Gets the dynamic type object required to access a shared component of type T.

Declaration
public SharedComponentTypeHandle<T> GetSharedComponentTypeHandle<T>()
    where T : struct, ISharedComponentData
Returns
Type Description
SharedComponentTypeHandle<T>

The run-time type information of the shared component.
Type Parameters
Name Description
T

The compile-time type of the shared component.
Remarks

To access a component stored in a chunk, you must have the type registry information for the component. This function provides that information for shared components. Use the returned ComponentTypeHandle<T> object with the functions of an ArchetypeChunk object to get information about the components in that chunk and to access the component values.

HasChunkComponent<T>(Entity)

Checks whether the chunk containing an entity has a specific type of component.

Declaration
public bool HasChunkComponent<T>(Entity entity)
Parameters
Type Name Description
Entity entity

The Entity object.
Returns
Type Description
Boolean

True, if the chunk containing the specified entity has the component.
Type Parameters
Name Description
T

The data type of the chunk component.
Remarks

Always returns false for an entity that has been destroyed.

HasComponent(Entity, ComponentType)

Checks whether an entity has a specific type of component.

Declaration
public bool HasComponent(Entity entity, ComponentType type)
Parameters
Type Name Description
Entity entity

The Entity object.
ComponentType type

The data type of the component.
Returns
Type Description
Boolean

True, if the specified entity has the component.
Remarks

Always returns false for an entity that has been destroyed.

HasComponent<T>(Entity)

Checks whether an entity has a specific type of component.

Declaration
public bool HasComponent<T>(Entity entity)
Parameters
Type Name Description
Entity entity

The Entity object.
Returns
Type Description
Boolean

True, if the specified entity has the component.
Type Parameters
Name Description
T

The data type of the component.
Remarks

Always returns false for an entity that has been destroyed.

Instantiate(NativeArray<Entity>, NativeArray<Entity>)

Clones a set of entities.

Declaration
public void Instantiate(NativeArray<Entity> srcEntities, NativeArray<Entity> outputEntities)
Parameters
Type Name Description
NativeArray<Entity> srcEntities

The set of entities to clone
NativeArray<Entity> outputEntities

the set of entities that were cloned. outputEntities.Length must match srcEntities.Length
Remarks

The new entity has the same archetype and component values as the original, however system state and prefab tag components are removed from the clone.

Entity references on components that are being cloned to entities inside the set are remapped to the instantiated entities. This method overload ignores the LinkedEntityGroup component, since the group of entities that will be cloned is passed explicitly.

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.

Instantiate(Entity)

Clones an entity.

Declaration
public Entity Instantiate(Entity srcEntity)
Parameters
Type Name Description
Entity srcEntity

The entity to clone.
Returns
Type Description
Entity

The Entity object for the new entity.
Remarks

The new entity has the same archetype and component values as the original; however, ISystemStateComponentData and Prefab components are removed from the clone.

If the source entity was converted from a prefab and thus has a LinkedEntityGroup component, the entire group is cloned as a new set of entities. Entity references on components that are being cloned to entities inside the set are remapped to the instantiated entities. 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.

Instantiate(Entity, Int32, Allocator)

Makes multiple clones of an entity.

Declaration
public NativeArray<Entity> Instantiate(Entity srcEntity, int instanceCount, Allocator allocator)
Parameters
Type Name Description
Entity srcEntity

The entity to clone.
Int32 instanceCount

The number of entities to instantiate with the same components as the source entity.
Allocator allocator

How the created native array should be allocated.
Returns
Type Description
NativeArray<Entity>

A NativeArray of entities.
Remarks

The new entity has the same archetype and component values as the original, however system state and prefab tag components are removed from the clone.

If the source entity has a LinkedEntityGroup component, the entire group is cloned as a new set of entities. Entity references on components that are being cloned to entities inside the set are remapped to the instantiated entities.

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before creating these 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.

Instantiate(Entity, NativeArray<Entity>)

Makes multiple clones of an entity.

Declaration
public void Instantiate(Entity srcEntity, NativeArray<Entity> outputEntities)
Parameters
Type Name Description
Entity srcEntity

The entity to clone.
NativeArray<Entity> outputEntities

An array to receive the Entity objects of the root entity in each clone. The length of this array determines the number of clones.
Remarks

The new entity has the same archetype and component values as the original, however system state and prefab tag components are removed from the clone.

If the source entity has a LinkedEntityGroup component, the entire group is cloned as a new set of entities. Entity references on components that are being cloned to entities inside the set are remapped to the instantiated entities.

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before creating these 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.

IsQueryValid(EntityQuery)

Check if an entity query is still valid

Declaration
public bool IsQueryValid(EntityQuery query)
Parameters
Type Name Description
EntityQuery query
Returns
Type Description
Boolean

Return true if the specified query handle is still valid (and can be disposed)

MoveEntitiesFrom(out NativeArray<Entity>, EntityManager)

Moves all entities managed by the specified EntityManager to the World of this EntityManager and fills an array with their Entity objects.

Declaration
public void MoveEntitiesFrom(out NativeArray<Entity> output, EntityManager srcEntities)
Parameters
Type Name Description
NativeArray<Entity> output

An array to receive the Entity objects of the transferred entities.
EntityManager srcEntities

The EntityManager whose entities are appropriated.
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.

MoveEntitiesFrom(out NativeArray<Entity>, EntityManager, NativeArray<EntityRemapUtility.EntityRemapInfo>)

Moves all entities managed by the specified EntityManager to the World of this EntityManager and fills an array with their Entity objects.

Declaration
public void MoveEntitiesFrom(out NativeArray<Entity> output, EntityManager srcEntities, NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping)
Parameters
Type Name Description
NativeArray<Entity> output

An array to receive the Entity objects of the transferred entities.
EntityManager srcEntities

The EntityManager whose entities are appropriated.
NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping

A set of entity transformations to make during the transfer.
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.

Exceptions
Type Condition
ArgumentException

MoveEntitiesFrom(out NativeArray<Entity>, EntityManager, EntityQuery)

Moves a selection of the entities managed by the specified EntityManager to the World of this EntityManager and fills an array with their Entity objects.

Declaration
public void MoveEntitiesFrom(out NativeArray<Entity> output, EntityManager srcEntities, EntityQuery filter)
Parameters
Type Name Description
NativeArray<Entity> output

An array to receive the Entity objects of the transferred entities.
EntityManager srcEntities

The EntityManager whose entities are appropriated.
EntityQuery filter

A EntityQuery that defines the entities to move. Must be part of the source World.
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.

Exceptions
Type Condition
ArgumentException

MoveEntitiesFrom(out NativeArray<Entity>, EntityManager, EntityQuery, NativeArray<EntityRemapUtility.EntityRemapInfo>)

Moves a selection of the entities managed by the specified EntityManager to the World of this EntityManager and fills an array with their Entity objects.

Declaration
public void MoveEntitiesFrom(out NativeArray<Entity> output, EntityManager srcEntities, EntityQuery filter, NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping)
Parameters
Type Name Description
NativeArray<Entity> output

An array to receive the Entity objects of the transferred entities.
EntityManager srcEntities

The EntityManager whose entities are appropriated.
EntityQuery filter

A EntityQuery that defines the entities to move. Must be part of the source World.
NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping

A set of entity transformations to make during the transfer.
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.

Exceptions
Type Condition
ArgumentException

MoveEntitiesFrom(EntityManager)

Moves all entities managed by the specified EntityManager to the world of this EntityManager.

Declaration
public void MoveEntitiesFrom(EntityManager srcEntities)
Parameters
Type Name Description
EntityManager srcEntities

The EntityManager whose entities are appropriated.
Remarks

The entities moved are owned by this EntityManager.

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.

MoveEntitiesFrom(EntityManager, NativeArray<EntityRemapUtility.EntityRemapInfo>)

Moves all entities managed by the specified EntityManager to the World of this EntityManager.

Declaration
public void MoveEntitiesFrom(EntityManager srcEntities, NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping)
Parameters
Type Name Description
EntityManager srcEntities

The EntityManager whose entities are appropriated.
NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping

A set of entity transformations to make during the transfer.
Remarks

After the move, the entities are managed by this EntityManager.

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.

Exceptions
Type Condition
ArgumentException

Thrown if you attempt to transfer entities to the EntityManager that already owns them.

MoveEntitiesFrom(EntityManager, EntityQuery)

Moves a selection of the entities managed by the specified EntityManager to the World of this EntityManager and fills an array with their Entity objects.

Declaration
public void MoveEntitiesFrom(EntityManager srcEntities, EntityQuery filter)
Parameters
Type Name Description
EntityManager srcEntities

The EntityManager whose entities are appropriated.
EntityQuery filter

A EntityQuery that defines the entities to move. Must be part of the source World.
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.

Exceptions
Type Condition
ArgumentException

MoveEntitiesFrom(EntityManager, EntityQuery, NativeArray<EntityRemapUtility.EntityRemapInfo>)

Moves a selection of the entities managed by the specified EntityManager to the World of this EntityManager.

Declaration
public void MoveEntitiesFrom(EntityManager srcEntities, EntityQuery filter, NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping)
Parameters
Type Name Description
EntityManager srcEntities

The EntityManager whose entities are appropriated.
EntityQuery filter

A EntityQuery that defines the entities to move. Must be part of the source World.
NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping

A set of entity transformations to make during the transfer.
Remarks

After the move, the entities are managed by this EntityManager.

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.

Exceptions
Type Condition
ArgumentException

Thrown if the EntityQuery object used as the filter comes from a different world than the srcEntities EntityManager.

MoveEntitiesFromInternalAll(EntityManager, NativeArray<EntityRemapUtility.EntityRemapInfo>)

Declaration
public void MoveEntitiesFromInternalAll(EntityManager srcEntities, NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping)
Parameters
Type Name Description
EntityManager srcEntities
NativeArray<EntityRemapUtility.EntityRemapInfo> entityRemapping

PrepareForDeserialize()

Prepares an empty World to load serialized entities.

Declaration
public void PrepareForDeserialize()

RemoveChunkComponent<T>(Entity)

Removes a chunk component from the specified entity. Returns false if the entity did not have the component.

Declaration
public bool RemoveChunkComponent<T>(Entity entity)
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
Boolean
Type Parameters
Name Description
T

The type of component to remove.
Remarks

A chunk component is common to all entities in a chunk. Removing the chunk component from an entity changes that entity's archetype and results in the entity being moved to a different chunk (that does not have the removed component).

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.

RemoveChunkComponentData<T>(EntityQuery)

Removes a component from the chunks identified by a EntityQuery.

Declaration
public void RemoveChunkComponentData<T>(EntityQuery entityQuery)
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery identifying the chunks to modify.
Type Parameters
Name Description
T

The type of component to remove.
Remarks

A chunk component is common to all entities in a chunk. You can access a chunk 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.

RemoveComponent(NativeArray<Entity>, ComponentType)

Remove a component from a set of entities.

Declaration
public void RemoveComponent(NativeArray<Entity> entities, ComponentType componentType)
Parameters
Type Name Description
NativeArray<Entity> entities

An array of Entity objects.
ComponentType componentType

The type of component to remove.
Remarks

Removing a component changes an entity's archetype and results in the entity being moved to a different chunk.

If an 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.

RemoveComponent(Entity, ComponentType)

Removes a component from an entity. Returns false if the entity did not have the component.

Declaration
public bool RemoveComponent(Entity entity, ComponentType componentType)
Parameters
Type Name Description
Entity entity

The entity to modify.
ComponentType componentType

The type of component to remove.
Returns
Type Description
Boolean
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.

RemoveComponent(Entity, ComponentTypes)

Removes multiple components from an entity.

Declaration
public void RemoveComponent(Entity entity, ComponentTypes componentTypes)
Parameters
Type Name Description
Entity entity

The entity to modify.
ComponentTypes componentTypes

The types of components to remove.
Remarks

If the entity has none of the specified components, the call will do nothing.

Removing components 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.

RemoveComponent(EntityQuery, ComponentType)

Removes a component from a set of entities defined by a EntityQuery.

Declaration
public void RemoveComponent(EntityQuery entityQuery, ComponentType componentType)
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery defining the entities to modify.
ComponentType componentType

The type of component to remove.
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.

RemoveComponent(EntityQuery, ComponentTypes)

Removes a set of components from a set of entities defined by a EntityQuery.

Declaration
public void RemoveComponent(EntityQuery entityQuery, ComponentTypes types)
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery defining the entities to modify.
ComponentTypes types

The types of components to add.
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.

RemoveComponent<T>(NativeArray<Entity>)

Removes a component from a set of entities.

Declaration
public void RemoveComponent<T>(NativeArray<Entity> entities)
Parameters
Type Name Description
NativeArray<Entity> entities

An array identifying the entities to modify.
Type Parameters
Name Description
T

The type of component to remove.
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.

RemoveComponent<T>(Entity)

Removes a component from an entity. Returns false if the entity did not have the component.

Declaration
public bool RemoveComponent<T>(Entity entity)
Parameters
Type Name Description
Entity entity

The entity.
Returns
Type Description
Boolean
Type Parameters
Name Description
T

The type of component to remove.
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.

RemoveComponent<T>(EntityQuery)

Removes a component from a set of entities defined by a EntityQuery.

Declaration
public void RemoveComponent<T>(EntityQuery entityQuery)
Parameters
Type Name Description
EntityQuery entityQuery

The EntityQuery defining the entities to modify.
Type Parameters
Name Description
T

The type of component to remove.
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.

SetArchetype(Entity, EntityArchetype)

Adds and removes components of an entity to match the specified EntityArchetype.

Declaration
public void SetArchetype(Entity entity, EntityArchetype archetype)
Parameters
Type Name Description
Entity entity

The entity whose archetype to change.
EntityArchetype archetype

The new archetype for the entity.
Remarks

Components of the archetype which the entity already has will preserve their values.

Components of the archetype which the entity does not have will get the default value for their types.

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.

SetChunkComponentData<T>(ArchetypeChunk, T)

Sets the value of a chunk component.

Declaration
public void SetChunkComponentData<T>(ArchetypeChunk chunk, T componentValue)
    where T : struct, IComponentData
Parameters
Type Name Description
ArchetypeChunk chunk

The chunk to modify.
T componentValue

The component data to set.
Type Parameters
Name Description
T

The component type.
Remarks

A chunk component is common to all entities in a chunk. You can access a chunk IComponentData instance through either the chunk itself or through an entity stored in that chunk.

Exceptions
Type Condition
ArgumentException

Thrown if the ArchetypeChunk object is invalid.

SetComponentData<T>(Entity, T)

Sets the value of a component of an entity.

Declaration
public void SetComponentData<T>(Entity entity, T componentData)
    where T : struct, IComponentData
Parameters
Type Name Description
Entity entity

The entity.
T componentData

The data to set.
Type Parameters
Name Description
T

The component type.
Exceptions
Type Condition
ArgumentException

Thrown if the component type has no fields.

SetEnabled(Entity, Boolean)

Enabled entities are processed by systems, disabled entities are not. Adds or removes the Disabled component. By default EntityQuery does not include entities containing the Disabled component.

If the entity was converted from a prefab and thus has a LinkedEntityGroup component, the entire group will enabled or disabled.

Declaration
public void SetEnabled(Entity entity, bool enabled)
Parameters
Type Name Description
Entity entity

The entity to enable or disable
Boolean enabled

True if the entity should be enabled

SetSharedComponentData<T>(Entity, T)

Sets the shared component of an entity.

Declaration
public void SetSharedComponentData<T>(Entity entity, T componentData)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
Entity entity

The entity
T componentData

A shared component object containing the values to set.
Type Parameters
Name Description
T

The shared component type.
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.

SetSharedComponentData<T>(EntityQuery, T)

Sets the shared component of all entities in the query.

Declaration
public void SetSharedComponentData<T>(EntityQuery query, T componentData)
    where T : struct, ISharedComponentData
Parameters
Type Name Description
EntityQuery query
T componentData

A shared component object containing the values to set.
Type Parameters
Name Description
T

The shared component type.
Remarks

The component data stays in the same chunk, the internal shared component data indices will be adjusted.

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.

SwapComponents(ArchetypeChunk, Int32, ArchetypeChunk, Int32)

Swaps the components of two entities.

Declaration
public void SwapComponents(ArchetypeChunk leftChunk, int leftIndex, ArchetypeChunk rightChunk, int rightIndex)
Parameters
Type Name Description
ArchetypeChunk leftChunk

A chunk containing one of the entities to swap.
Int32 leftIndex

The index within the leftChunk of the entity and components to swap.
ArchetypeChunk rightChunk

The chunk containing the other entity to swap. This chunk can be the same as the leftChunk. It also does not need to be in the same World as leftChunk.
Int32 rightIndex

The index within the rightChunk of the entity and components to swap.
Remarks

The entities must have the same components. However, this function can swap the components of entities in different worlds, so they do not need to have identical archetype instances.

Important: This function creates a sync point, which means that the EntityManager waits for all currently running Jobs to complete before swapping the 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.

Operators

Equality(EntityManager, EntityManager)

Declaration
public static bool operator ==(EntityManager lhs, EntityManager rhs)
Parameters
Type Name Description
EntityManager lhs
EntityManager rhs
Returns
Type Description
Boolean

Inequality(EntityManager, EntityManager)

Declaration
public static bool operator !=(EntityManager lhs, EntityManager rhs)
Parameters
Type Name Description
EntityManager lhs
EntityManager rhs
Returns
Type Description
Boolean

Extension Methods