Namespace Unity.Entities

Classes

AlwaysSynchronizeSystemAttribute

AlwaysSynchronizeSystem can be applied to a SystemBase to force it to synchronize on all of its dependencies before every update. This attribute should only be applied when a synchronization point is necessary every frame.

AlwaysUpdateSystemAttribute

Obsolete. Systems now update by default.

BakeDerivedTypesAttribute

Attribute that informs the baking system that bakers of types derived from the current authoring component must be executed.

Baker<TAuthoringType>

Inherit this class to bake an authoring component.

BakingSystem

Provides methods to control the baking process, and provides access to the BlobAssetStore used during baking.

BakingSystemGroup

The group of systems where baking systems run by default.

BakingTypeAttribute

Attribute that indicates that a component should persist in the baking world, but shouldn't be exported with the runtime data.

BakingVersionAttribute

By default if no baking version are declared in an assembly, the scene will be re-imported if the assembly has changed. If you only want to re-trigger scene import if a baker, a baking system or an optimization system has changed and not something else in the assembly, use this attribute and bump its version or username everytime you want to re-trigger the scene import.

BindingRegistry

Builds a static registry of bindings between a runtime field with an authoring field. Multiple different runtime fields can be associated with a same authoring field. Only primitive types of int, bool, and float, in addition to Unity.Mathematics variants of these primitives (e.g. int2, float4) will be added to the BindingRegistry. Other types will be silently ignored.

BindingRegistryUtility

Utility class for BindingRegistry.

BlobAssetSerializeExtensions

Extensions for supporting serialization and deserialization of blob assets.

BlobStringExtensions

Extensions that allow the creation of BlobString instances by a BlobBuilder.

BurstMonoInteropMethodAttribute

Attribute that indicates that a method should have Burst to mono interop code generated.

ChangeVersionUtility

Utilities to manipulate version numbers

ChunkIndexInQuery

Specifies that this int parameter is used as the chunk index inside the current query. Usage: An int parameter found inside the execute method of an IJobEntity.

ChunkSerializableAttribute

States that a component type is serializable.

ComponentSystemBase

A system provides behavior in an ECS architecture.

ComponentSystemBaseManagedComponentExtensions

Variants of ComponentSystemBase methods which support managed components.

ComponentSystemGroup

A special-case system that encapsulates an ordered list of other systems. When the group is updated, the group's member systems are updated in order.

ComponentSystemGroupExtensions

Obsolete. This class only contains deprecated extension methods.

CreateAfterAttribute

Apply to a system to specify a creation ordering constraint with another system in the same ComponentSystemGroup.

CreateBeforeAttribute

Apply to a system to specify a creation ordering constraint with another system in the same ComponentSystemGroup.

DefaultWorldInitialization

Utilities to help initialize the default ECS World.

DisableAutoCreationAttribute

Prevents a system from being automatically created and run.

DisableAutoTypeRegistrationAttribute

Prevents a Component Type from being registered in the TypeManager during TypeManager.Initialize(). Types that are not registered will not be recognized by EntityManager.

DisableGenerationAttribute

Disable the source generator for an Aspect type, i.e. a struct that implements IAspect It is up to the user to write the required code to complete all the functionalities needed by an Aspect. Disabling the source generator should not be used outside of development purposes.

DisallowRefReturnCrossingThisAttribute

What is this : Attribute signaling that ref returned values, of a type that has this attribute, cannot intersect with calls to methods that also have this attribute. Motivation(s): ref returns of values that are backed by native memory (unsafe), like IComponentData in ecs chunks, can have the referenced memory invalidated by certain methods. A way is needed to detect these situations a compilation time to prevent accessing invalidated references. Notes:

This attribute is used/feeds a Static Analyzer at compilation time.
Attribute transfers with aggragations: struct A has this attribute, struct B has a field of type A; both A and B are concidered to have the attribute.

ECBExtensionMethods

Extension methods for EntityCommandBufferSystem.

EndFixedStepSimulationEntityCommandBufferSystem

The EntityCommandBufferSystem at the end of the FixedStepSimulationSystemGroup.

EndInitializationEntityCommandBufferSystem

The EntityCommandBufferSystem at the end of the InitializationSystemGroup.

EndSimulationEntityCommandBufferSystem

The EntityCommandBufferSystem at the end of the SimulationSystemGroup.

EndVariableRateSimulationEntityCommandBufferSystem

The EntityCommandBufferSystem at the end of the VariableRateSimulationSystemGroup.

EntitiesJournaling

Entities journaling provides detailed information about past ECS events.

EntitiesJournaling.Preferences

Class that stores journaling preferences used during initialization.

EntitiesJournaling.RecordViewArrayUtility

Utiliy methods for EntitiesJournaling.RecordViewArray.

EntitiesJournaling.Records

Non-blocking utility methods to retrieve records.

EntityCommandBufferManagedComponentExtensions

Provides additional methods for using managed components with an EntityCommandBuffer.

EntityCommandBufferSystem

A system that provides EntityCommandBuffer objects for other systems.

EntityInQueryIndex

Obsolete. Use EntityIndexInQuery instead.

EntityIndexInChunk

Specifies that this int parameter is used as the entity index inside the current chunk. Usage: An int parameter found inside the execute method of an IJobEntity.

EntityIndexInQuery

Specifies that this int parameter is used as a way to get the packed entity index inside the current query. Usage: An int parameter found inside the execute method of an IJobEntity.

EntityManagerManagedComponentExtensions

Variants of EntityManager methods that support managed components.

EntityPatcher

Utility class to apply a EntityChangeSet to an EntityManager

EntityQueryDesc

Describes a query to find archetypes in terms of required, optional, and excluded components.

EntityQueryDescValidationException

Exception type thrown if EntityQueryDesc validation fails.

EntityQueryExtensionsForComponentArray

Variants of EntityQuery methods that support managed components

EntityQueryExtensionsForTransformAccessArray

Allows access to GameObject transform data through an EntityQuery.

EntityQueryManagedComponentExtensions

Variants of EntityQuery methods that support managed component types

EntityRemapUtility

Utility class to remap Entity IDs.

FixedStepSimulationSystemGroup

This system group is configured by default to use a fixed timestep for the duration of its updates.

GenerateBurstMonoInteropAttribute

Attribute used to signal this type should be scanned for BurstMonoInteropMethodAttribute decorated methods.

IBaker

This class contains all the methods to bake a authoring component to an Entity.

IJobEntityExtensions

Extension methods for IJobEntity job type

InitializationSystemGroup

The earliest of the default system groups to run in each frame. Contains systems related to setting up each new frame.

InternalBufferCapacityAttribute

Specifies the maximum number of elements to store inside a chunk.

JobChunkExtensions

Extensions for scheduling and running IJobChunk jobs.

LambdaForEachDescriptionConstructionMethods

Provides methods for Constructing Entities.ForEach invocations.

LambdaJobDescriptionConstructionMethods

Static class holding methods to construct lambda jobs (Entities.ForEach and Job.WithCode)

LambdaJobDescriptionExecutionMethods

Static class holding methods to construct lambda jobs (Entities.ForEach and Job.WithCode)

LambdaJobQueryConstructionMethods

Extension methods implementing the fluent API for Entities.ForEach.

LambdaSingleJobDescriptionConstructionMethods

Static class holding methods to construct Job.WithCode jobs.

LambdaSingleJobDescriptionExecutionMethods

Static class holding methods to construct lambda jobs (Entities.ForEach and Job.WithCode)

LateSimulationSystemGroup

Default group that runs at the end of the SimulationSystemGroup. Contains systems that perform simulation logic, but which should run after the main simulation logic is complete.

LayerFieldAttribute

Attribute used to make an int field display as a layer selector drop-down.

MaximumChunkCapacityAttribute

Specifies the maximum number of components of a type that can be stored in the same chunk.

MayOnlyLiveInBlobStorageAttribute

Use this attribute if you have structs that use offset pointers that are only valid when they live inside the blob storage. It will turn ensure a compiler error is generated for every time a reference to the struct is copied, or a field is read from a reference to the struct this attribute is applied on.

OptionalAttribute

When used on an aspect's ComponentDataRef field, marks that component type as optional. The DOTS source generator handles the generation of the query using this attribute. A ComponentDataRef may also be marked read-only by using the attribute [Unity.Collections.ReadOnly]

PostBakingSystemGroup

The group of systems that runs after BakingSystemGroup.

PostLoadCommandBuffer

Component that contains an EntityCommandBuffer, which is used to execute commands after a scene is loaded.

PreBakingSystemGroup

The group of systems that runs before the bakers execute.

PresentationSystemGroup

The system group containing systems related to rendering the simulated world.

RateUtils

Contains some default IRateManager implementations to address the most common use cases.

RateUtils.FixedRateCatchUpManager

Implements system update semantics similar to UnityEngine.MonoBehaviour.FixedUpdate.

RateUtils.FixedRateSimpleManager

Implements a rate manager that updates the group exactly once per presentation frame, but uses a constant timestep instead of the actual elapsed time since the previous frame.

RateUtils.VariableRateManager

A IRateManager implementation providing a variable update rate in milliseconds.

RegisterBindingAttribute

Creates a table association between the Type specified and the runtime field of an IComponentData, accessible via the BindingRegistry

RegisterGenericComponentTypeAttribute

When added as an assembly-level attribute, allows creating component type reflection data for instances of generic components for the TypeManager to reason about.

RegisterGenericSystemTypeAttribute

When added as an assembly-level attribute, allows creating generic ISystems, which will not work without being registered this way.

RequireMatchingQueriesForUpdateAttribute

Use RequireMatchingQueriesForUpdate to force a System to skip calling OnUpdate if every EntityQuery in the system is empty.

SceneSectionComponent

Component to indicate that a GameObject and its children belong to the specified scene section.

ScriptBehaviourUpdateOrder

Contains helpers to add and remove systems to the UnityEngine player loop.

SimulationSystemGroup

Default system group that contains systems that update the simulated world for a new frame.

StaticOptimizeEntity

Authoring component that indicates that the hierarchy from this point should be considered static and can be optimized.

SystemAPI

Giving quick and consistent access to buffers, components, time, enumeration, singletons and more. This includes any IAspect, IJobEntity, SystemBase, and ISystem. Suggested usage is:

  using static Unity.Entities.SystemAPI;
  [...]
  partial struct SomeJob : IJobEntity { void Execute(ref EcsTestData e1) => e1.value += Time.deltaTime; }

SystemAPI.ManagedAPI

The managed half of SystemAPI. It's exactly what you'd expect. Managed versions of API found in SystemAPI, that only runs on main thread. You can use this in ISystem and SystemBase.

SystemBase

Implement SystemBase to create a system in ECS.

SystemBaseDelegates

Delegates only used by compiler

TemporaryBakingTypeAttribute

Attribute that indicates that the component should be removed at the end of each baking iteration.

TransformBakingSystemGroup

The group of systems that runs just after the bakers but before BakingSystemGroup.

TypeHash

Produces a stable type hash for a Type based on its layout in memory and how that memory should be interpreted.

TypeManager

The TypeManager registers all Components and Systems available at runtime. Information about components and systems can be retrieved at runtime via static methods on TypeManager. The Initialize() method must be invoked before the TypeManager can be used.

TypeManager.ForcedMemoryOrderingAttribute

Attribute to force the MemoryOrdering for a component to a specific value.

TypeManager.TypeOverridesAttribute

[TypeOverrides] can be applied to a component that is known to never contain Entity and/or Blob references, in order to reduce time taken during serialization operations.

TypeManager.TypeVersionAttribute

TypeVersion allows you to override the StableTypeHash for a component type to a specific value rather than using the default generated hash.

UpdateAfterAttribute

Apply to a system to specify an update ordering constraint with another system in the same ComponentSystemGroup.

UpdateBeforeAttribute

Apply to a system to specify an update ordering constraint with another system in the same ComponentSystemGroup.

UpdateInGroupAttribute

The specified Type must be a ComponentSystemGroup. Updating in a group means this system will be automatically updated by the specified ComponentSystemGroup when the group is updated. The system may order itself relative to other systems in the group with UpdateBefore and UpdateAfter. This ordering takes effect when the system group is sorted.

If the optional OrderFirst parameter is set to true, this system will act as if it has an implicit [UpdateBefore] targeting all other systems in the group that do not have OrderFirst=true, but it may still order itself relative to other systems with OrderFirst=true.

If the optional OrderLast parameter is set to true, this system will act as if it has an implicit [UpdateAfter] targeting all other systems in the group that do not have OrderLast=true, but it may still order itself relative to other systems with OrderLast=true.

An UpdateInGroup attribute with both OrderFirst=true and OrderLast=true is invalid, and will throw an exception.

UpdateWorldTimeSystem

A system that updates the WorldTime value, based on the elapsed time since the previous frame.

VariableRateSimulationSystemGroup

This system group is configured by default to use a variable update rate of ~15fps (66ms).

WithAbsentAttribute

Specify that an IJobEntity should not include any of the component types specified as part of the attribute.

WithAllAttribute

Specifies that this IJobEntity should include all ComponentTypes found as attributes of the IJobEntity

WithAnyAttribute

Specifies that this IJobEntity should include any ComponentTypes found as attributes of the IJobEntity

WithChangeFilterAttribute

Specifies that this IJobEntity should only process a chunk if any of the ComponentTypes found as attributes of the IJobEntity have changed.

WithDisabledAttribute

Specify that an IJobEntity should include all of the component types specified as part of the attribute, but they must all be disabled.

WithEntityQueryOptionsAttribute

Obsolete. Use WithOptionsAttribute instead.

WithNoneAttribute

Specifies that this IJobEntity should include no ComponentTypes found as attributes of the IJobEntity

WithOptionsAttribute

Specifies that this IJobEntity should include a given EntityQueryOption found as attributes of the IJobEntity

WithPresentAttribute

Specify that an IJobEntity should include all of the component types specified as part of the attribute, whether or not the components are enabled on individual entities.

World

Encapsulates a set of entities, component data, and systems.

WorldExtensions

Variants of World methods that support unmanaged systems (ISystems)

WorldSystemFilterAttribute

For internal use only.

WriteGroupAttribute

Can exclude components which are unknown at the time of creating the query that have been declared to write to the same component.

This allows for extending systems of components safely without editing the previously existing systems.

The goal is to have a way for systems that expect to transform data from one set of components (inputs) to another (output[s]) be able to declare that explicit transform, and they exclusively know about one set of inputs. If there are other inputs that want to write to the same output, the query shouldn't match because it's a nonsensical/unhandled setup. It's both a way to guard against nonsensical components (having two systems write to the same output value), and a way to "turn off" existing systems/queries by putting a component with the same write lock on an entity, letting another system handle it.

Structs

AdditionalEntityParent

Contains information to identify the parent of an additional entity.

ArchetypeChunk

A block of unmanaged memory containing the components for entities sharing the same Archetype.

AspectType

Native friendly container for managed Type derived from IAspect.

Asset

Marks the entity as an asset, which is used for the Export phase of GameObject conversion.

BakedEntity

This type is used to identify identities that had any baking done on them before the BakingSystems ran

BakingOnlyEntity

The entity will be stripped out before it appears in the live game world.

BeginFixedStepSimulationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

BeginInitializationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

BeginPresentationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

BeginSimulationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

BeginVariableRateSimulationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

BindingRegistry.ReverseBinding

Binds a runtime field property to an authoring field name

BindingRegistry.RuntimeFieldProperties

Properties of a runtime field.

BlobArray<T>

An immutable array of value types stored in a blob asset.

BlobAssetChange

Header for a changed blob asset.

BlobAssetReferenceChange

Represents a blob asset reference that was changed within a EntityChangeSet

BlobAssetReference<T>

A reference to a blob asset stored in unmanaged memory.

BlobAssetStore

Purpose of this class is to provide a consistent cache of BlobAsset object in order to avoid rebuilding them when it is not necessary

BlobBuilder

Creates blob assets.

BlobBuilderArray<T>

Used by the BlobBuilder methods to reference the arrays within a blob asset.

BlobPtr<T>

A pointer referencing a struct, array, or field inside a blob asset.

BlobString

An immutable, variable-length string stored in a blob asset.

BufferAccessor<T>

Interface to a chunk's array of component values for a buffer component type

BufferFromEntity<T>

Obsolete. Use BufferLookup<T> instead.

BufferLookup<T>

A [NativeContainer] that provides access to all instances of DynamicBuffer components with elements of type T, indexed by Entity.

BufferTypeHandle<T>

A handle to a specific buffer component type, used to access an ArchetypeChunk's component data in a job.

ChunkEntityEnumerator

Helper utility to quickly identify the next available entity or component within a chunk (e.g. the index of the NativeArray`1 retrieved via GetComponentDataPtrRW<T>(ref ComponentTypeHandle<T>) or GetEntityDataPtrRO(EntityTypeHandle))

ChunkHeader

Wrapper around the header data for a specific chunk

CompanionGameObjectUpdateTransformSystem

ComponentDataFromEntity<T>

Obsolete. Use ComponentLookup<T> instead.

ComponentLookup<T>

A [NativeContainer] that provides access to all instances of components of type T, indexed by Entity.

ComponentType

A struct to define a component including how it's accessed and what type of component it is

ComponentTypeHandle<T>

A handle to a specific component type, used to access an ArchetypeChunk's component data in a job.

ComponentTypeHash

Represents a hash of a component type.

ComponentTypeSet

An immutable set of ComponentType values.

ComponentTypes

Obsolete. Use ComponentTypeSet instead.

Disabled

Disables the entity.

DynamicBuffer<T>

An array-like data structure that can be used as a component.

DynamicComponentTypeHandle

A handle to a specific component type, used to access an ArchetypeChunk's component data in a job.

DynamicSharedComponentTypeHandle

A handle to a specific shared component type, used to access an ArchetypeChunk's component data in a job.

EnabledMask

Safe pointer to a bit buffer first bit, and a pointer to the chunk's component disabled count, which is updated when the bits are written to.

EnabledRefRO<T>

Stores a safe reference to a read-only component enable bit.

EnabledRefRW<T>

Stores a safe reference to a read-writable component enable bit. Also keeps a pointer to the chunk disabled count, which is updated when the enabled bit is written to.

EndFixedStepSimulationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

EndInitializationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

EndSimulationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

EndVariableRateSimulationEntityCommandBufferSystem.Singleton

Call GetSingleton<T>() to get this component for this system, and then call CreateCommandBuffer(WorldUnmanaged) on this singleton to create an ECB to be played back by this system.

EntitiesJournaling.ComponentTypeView

Entity view into journal buffer.

EntitiesJournaling.ComponentTypeViewArray

Array of EntitiesJournaling.ComponentTypeView.

EntitiesJournaling.ComponentTypeViewArray.Enumerator

Enumerator that can iterate through the EntitiesJournaling.ComponentTypeViewArray.

EntitiesJournaling.EntityView

Entity view into journal buffer.

EntitiesJournaling.EntityViewArray

Array of EntitiesJournaling.EntityView.

EntitiesJournaling.EntityViewArray.Enumerator

Enumerator that can iterate through the EntitiesJournaling.EntityViewArray.

EntitiesJournaling.RecordView

Record view into journal buffer.

EntitiesJournaling.RecordViewArray

Array of EntitiesJournaling.RecordView.

EntitiesJournaling.RecordViewArray.Enumerator

Enumerator that can iterate through the EntitiesJournaling.RecordViewArray.

EntitiesJournaling.SystemView

System view into journal buffer.

EntitiesJournaling.WorldView

World view into journal buffer.

Entity

Identifies an entity.

EntityArchetype

An EntityArchetype is a unique combination of component types. The EntityManager uses the archetype to group all entities that have the same sets of components.

EntityChangeSet

An atomic package of changes to entity and component data.

EntityChanges

Contains all the changes needed to convert and revert a world from one state to another.

EntityCommandBuffer

A thread-safe command buffer that can buffer commands that affect entities and components for later playback.

EntityCommandBuffer.ParallelWriter

Allows concurrent (deterministic) command buffer recording.

EntityGuid

This component is attached to converted Entities and is guaranteed to be unique within a World. It can be used to map back to the authoring GameObject from which it was converted. Note that an EntityGuid does not have enough information to be persistent across sessions.

EntityInChunk

Represents a single entity within a chunk. Mainly used internally to sort lists of entities into chunk order.

EntityManager

The EntityManager manages entities and components in a World.

EntityManager.EntityManagerDebug

Provides information and utility functions for debugging.

EntityManagerDiffer

The EntityManagerDiffer is used to efficiently track changes to a given world over time.

EntityQuery

Use an EntityQuery object to select entities with components that meet specific requirements.

EntityQueryBuilder

Describes a query to find archetypes in terms of required, optional, and excluded components.

EntityQueryDescBuilder

Obsolete. Use EntityQueryBuilder instead.

EntityQueryMask

Provides an efficient test of whether a specific archetype is included in the set of archetypes matched by an EntityQuery.

EntityReferenceChange

Represents an entity reference that was changed within a EntityChangeSet

This structure references the entity by it's unique EntityGuid.

EntityRemapUtility.BufferEntityPatchInfo

Contains the information for applying a patch on a DynamicBuffer in a chunk.

EntityRemapUtility.EntityBlobRefResult

Reports whether an Entity blob has any Entity or BlobAssetReferenceData references.

EntityRemapUtility.EntityPatchInfo

Contains the information for applying a patch on a chunk.

EntityRemapUtility.EntityRemapInfo

Structure mapping a target entity to an entity in the current world.

EntityStorageInfo

Contains information about where an Entity is stored. To retrieve this information, use EntityStorageInfoLookup.

EntityStorageInfoLookup

A [NativeContainer] that provides access to information about how Entities are stored. Entity.

EntityTypeHandle

A handle to the Entity component type, used to access an ArchetypeChunk's entities in a job.

ExclusiveEntityTransaction

Provides an interface to safely perform EntityManager operations from a single worker thread, by temporarily giving that thread exclusive access to a World's EntityManager.

GlobalScratchpad

A global scratchpad.

Hash128

A 128 bit hash, for cases where 32 or 64 bits are insufficient. Built on top of Unity.Mathematics types that will Burst-compile to SIMD instructions, for efficiency comparable to a 32-bit hash.

LinkedEntityGroup

The LinkedEntityGroup buffer makes the entity be the root of a set of connected entities.

LinkedEntityGroupChange

Represents a linked entity group change

ManagedComponentAccessor<T>

Interface to a chunk's array of component values for managed component type T

MemsetNativeArray<T>

Assign Value to each element of NativeArray

NativeArraySharedInt

Merge sort index list referencing NativeArray values.

OmitLinkedEntityGroupFromPrefabInstance

The presence of this component instructs EntityManager.Instantiate to not to create the LinkedEntityGroup buffer component for every prefab instance, and the prefab child entities are still created. This component is not kept on the instantiated entities afterwards. This component is completely ignored and treated as a regular tag component when LinkedEntityGroup is not present on the source prefab entity.

PackedComponent

Represents a packed component within an EntityChangeSet

PackedComponentDataChange

Represents a packed component data change within a EntityChangeSet

PackedManagedComponentDataChange

Represents a managed component data change in a packed format

PackedSharedComponentDataChange

Represents a shared component data change in a packed format

Prefab

Marks the entity as a prefab, which implicitly disables the entity.

PrefabRoot

This component contains the root entity of a prefab

QueryEnumerableWithEntity<T1>

An enumeration interface for the entities that match an EntityQuery. This variant includes access the the entity and its component values.

QueryEnumerableWithEntity<T1, T2>

An enumeration interface for the entities that match an EntityQuery. This variant includes access the the entity and its component values.

QueryEnumerableWithEntity<T1, T2, T3>

An enumeration interface for the entities that match an EntityQuery. This variant includes access the the entity and its component values.

QueryEnumerableWithEntity<T1, T2, T3, T4>

An enumeration interface for the entities that match an EntityQuery. This variant includes access the the entity and its component values.

QueryEnumerableWithEntity<T1, T2, T3, T4, T5>

An enumeration interface for the entities that match an EntityQuery. This variant includes access the the entity and its component values.

QueryEnumerableWithEntity<T1, T2, T3, T4, T5, T6>

An enumeration interface for the entities that match an EntityQuery. This variant includes access the the entity and its component values.

QueryEnumerableWithEntity<T1, T2, T3, T4, T5, T6, T7>

An enumeration interface for the entities that match an EntityQuery. This variant includes access the the entity and its component values.

QueryEnumerable<T1>

An enumeration interface for the entities that match an EntityQuery.

QueryEnumerable<T1, T2>

An enumeration interface for the entities that match an EntityQuery.

QueryEnumerable<T1, T2, T3>

An enumeration interface for the entities that match an EntityQuery.

QueryEnumerable<T1, T2, T3, T4>

An enumeration interface for the entities that match an EntityQuery.

QueryEnumerable<T1, T2, T3, T4, T5>

An enumeration interface for the entities that match an EntityQuery.

QueryEnumerable<T1, T2, T3, T4, T5, T6>

An enumeration interface for the entities that match an EntityQuery.

QueryEnumerable<T1, T2, T3, T4, T5, T6, T7>

An enumeration interface for the entities that match an EntityQuery.

RefRO<T>

ReadOnlyRef stores a safe read-only reference to a component data.

RefRW<T>

RefRW stores a reference (with write access) to native memory

RequestSceneLoaded

A component that requests the load of a sub scene.

SafeBitRef

Pointer to a single bit, and a safety handle.

SceneReference

Component that references a scene.

SceneSection

Identifies the SceneSection where the entity belongs to.

SceneSectionData

This component contains data relative to a SceneSection.

SceneTag

A Unity-defined shared component assigned to all entities in the same subscene.

Scratchpad

A scratch pad that contains multiple scratch pad allocators. User can can get a scratch pad allocator from the pad corresponding to its thread index. It automatically invalidates all allocations made from it, when "rewound" by the user.

ScratchpadAllocator

A fast allocator which allocates memory from its scratchpad.

SectionMetadataSetup

This component identifies the entity which holds the meta data components that belong to the section with the specified SceneSectionIndex.

SharedComponentTypeHandle<T>

A handle to a specific shared component type, used to access an ArchetypeChunk's component data in a job.

Simulate

Enable simulation of an entity.

StorageInfoFromEntity

Obsolete. Use BufferLookup<T> instead.

SystemAPI.ManagedAPI.UnityEngineComponent<T>

Can be used inside Query<T1>() iteration to retrieve UnityEngine components like ScriptableObjects, MonoBehaviour and UnityEngine.Transform

SystemAPIQueryBuilder

Supports construction of queries matching one or multiple archetypes inside ISystem and SystemBase types. All queried components must be known at compile-time.

SystemHandle

An identifier representing a system instance in a particular world.

SystemHandleUntyped

Obsolete. Use SystemHandle instead.

SystemState

Contains raw entity system state. Used by unmanaged systems (ISystem) as well as managed systems behind the scenes.

SystemTypeIndex

Provides a unique id for system types as well as quick lookup information about the system type itself. This value is fully deterministic at runtime but should not be considered deterministic across builds and thus should not be serialized.

TransformAuthoring

TransformAuthoring is automatically created for every single entity created during baking. It gives access to the complete data the authoring Transform carries, the components exist only during baking. The TransformAuthoring component is stripped out automatically at runtime.

This can be used by systems that want to access the original authoring transform data in baking systems, without relying on the runtime transforms existing. In many cases we want to bake our authoring state into more optimal runtime representations. For example Unity.Physics bakes all colliders that may be children in the game object hierarchy into the entity containing the rigidbody. Hence the game objects with those colliders might not be required to be entities at runtime at all, but in baking systems we need to be able to access the TransformAuthoring data to correctly bake the colliders based on their positions relative to the parent rigidbody.

TypeIndex

Provides a unique id for component types as well as quick lookup information about the component type itself. This value is fully deterministic at runtime but should not be considered deterministic across builds and thus should not be serialized. For serialization, please prefer StableTypeHash instead.

TypeManager.EntityOffsetInfo

Stores the byte offset into a component where an Entity member is stored.

TypeManager.ManagedSharedComponentFnPtrs

Used by codegen. Function pointer wrapper for managed ISharedComponentData method overloads

TypeManager.SharedComponentFnPtrs

Used by codegen. Function pointer wrapper for unmanaged ISharedComponentData method overloads

TypeManager.TypeInfo

Provides information about component types such as their runtime size, how much space they use in Chunk storage, their TypeIndex, how many entity references they contain, and more.

UnityObjectRef<T>

A utility structure that stores a reference of an Object for the BakingSystem to process in an unmanaged component.

World.NoAllocReadOnlyCollection<T>

Read only collection that doesn't generate garbage when used in a foreach.

WorldUnmanaged

A pointer-to-implementation for the unmanaged representation of a World.

WorldUpdateAllocatorResetSystem

A system that resets the world update allocator by rewinding its memories.

Interfaces

IAspect

Base interface for Aspects, a higher level combination for components.

IBufferElementData

An interface for creating structs that can be stored in a DynamicBuffer<T>.

ICleanupBufferElementData

An interface for a buffer component that must be removed individually after its entity is destroyed.

ICleanupComponentData

An interface for a component that must be removed individually after its entity is destroyed.

ICleanupSharedComponentData

An interface for a shared component that must be removed individually after its entity is destroyed.

IComponentData

This interface marks structs as 'unmanaged components' and classes as 'managed components'.

ICustomBootstrap

When entering playmode or the game starts in the Player a default world is created. Sometimes you need multiple worlds to be setup when the game starts or perform some custom world initialization. This lets you override the bootstrap of game code world creation.

IECBSingleton

Interface for use with EntityCommandBufferSystems to store the list of pending buffers, which can be accessed from a bursted ISystem. You should implement a singleton with this interface every time you inherit from EntityCommandBufferSystem.

IEnableableComponent

An interface for a component type which allows the component to be enabled and disabled at runtime without a structural change.

IFixedRateManager

Obsolete. Use IRateManager instead.

IJobChunk

IJobChunk is a type of IJob that iterates over a set of chunks. For each chunk the job runs on, the job code receives an ArchetypeChunk instance representing the full chunk, plus a bitmask indicating which entities in the chunk should be processed.

IJobEntity

Any type which implements this interface and also contains an Execute() method (with any number of parameters) will trigger source generation of a corresponding IJobChunk or IJobEntity type. The generated job in turn invokes the Execute() method on the IJobEntity type with the appropriate arguments.

IJobEntityChunkBeginEnd

When added to an implemented IJobEntity the two functions will be called at the beginning and end of each chunk iteration.

IQueryTypeParameter

Interface used to indicate that a type can be used as type to construct a QueryEnumerable. This should only be used by types internal to the Entities package.

IRateManager

Interface to define custom behaviors for controlling when a ComponentSystemGroup should update, and what timestep should be visible to the systems in that group. This allows the implementation of Unity's traditional MonoBehaviour "FixedUpdate()" semantics within DOTS, as well as more advanced/flexible update schemes.

IRefCounted

An interface for managed and unmanaged shared component types to inherit from. Whenever a IRefCounted shared component is added to a world, its Retain() method will be invoked. Similarly, when removed from a world, its Release() method will be invoked. This interface can be used to safely manage the lifetime of a shared component whose instance data is shared between multiple worlds.