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

BeginFixedStepSimulationEntityCommandBufferSystem

BeginInitializationEntityCommandBufferSystem

BeginPresentationEntityCommandBufferSystem

BeginSimulationEntityCommandBufferSystem

BeginVariableRateSimulationEntityCommandBufferSystem

BlobAssetSerializeExtensions

Extensions for supporting serialization and deserialization of blob assets.

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

BlobStringExtensions

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

BurstMonoInteropMethodAttribute

ChangeVersionUtility

ChunkSerializableAttribute

States that a component type is serializable.

CompanionGameObjectUpdateTransformSystem

ComponentSystem

An abstract class to implement in order to create a system.

ComponentSystemBase

A system provides behavior in an ECS architecture.

ComponentSystemBaseManagedComponentExtensions

ComponentSystemGroup

ComponentSystemGroupExtensions

ComponentSystemSorter

ComponentSystemSorter.CircularSystemDependencyException

ConverterVersionAttribute

By declaring a version number a ComponentSystem can ensure that any cached data by the asset pipeline was prepared using the active code. If the version number of any conversion system or optimization system changes or a new conversion system is added, then the scene will be re-converted.

ConvertToEntity

ConvertToEntitySystem

DefaultWorldInitialization

DisableAutoCreationAttribute

Prevents a system from being automatically created and run.

DisableAutoTypeRegistrationAttribute

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

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.

DOTSCompilerPatchedMethodAttribute

DOTSCompilerPatchedPropertyAttribute

EndFixedStepSimulationEntityCommandBufferSystem

EndInitializationEntityCommandBufferSystem

EndSimulationEntityCommandBufferSystem

EndVariableRateSimulationEntityCommandBufferSystem

EntityCommandBufferManagedComponentExtensions

EntityCommandBufferSystem

A system that provides EntityCommandBuffer objects for other systems.

EntityInQueryIndex

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

EntityManagerManagedComponentExtensions

EntityPatcher

EntityQueryDesc

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

EntityQueryDescValidationException

EntityQueryExtensionsForComponentArray

EntityQueryExtensionsForTransformAccessArray

EntityQueryManagedComponentExtensions

EntityRemapUtility

FixedStepSimulationSystemGroup

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

ForEachLambdaJobDescription_SetSharedComponent

GameObjectConversionSettings

GameObjectConversionUtility

GameObjectEntity

GenerateAuthoringComponentAttribute

GenerateBurstMonoInteropAttribute

IJobEntityExtensions

InitializationSystemGroup

InternalBufferCapacityAttribute

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

InternalCompilerInterface

JobChunkExtensions

Extensions for scheduling and running IJobChunk Jobs.

JobEntityBatchExtensions

Extensions for scheduling and running IJobEntityBatch jobs.

JobEntityBatchIndexExtensions

Extensions for scheduling and running IJobEntityBatchWithIndex jobs.

LambdaJobChunkDescription_SetSharedComponent

LambdaJobChunkDescriptionConstructionMethods

LambdaJobDescriptionConstructionMethods

LambdaJobDescriptionExecutionMethods

LambdaJobQueryConstructionMethods

LambdaSingleJobDescriptionConstructionMethods

LambdaSingleJobDescriptionExecutionMethods

LateSimulationSystemGroup

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.

PostLoadCommandBuffer

PresentationSystemGroup

RateUtils

RateUtils.FixedRateCatchUpManager

RateUtils.FixedRateSimpleManager

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

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 non-compatible types will be silently ignored if this attribute is applied to it.

RegisterGenericComponentTypeAttribute

RestrictAuthoringInputToAttribute

SceneViewWorldPositionAttribute

ScriptBehaviourUpdateOrder

SimulationSystemGroup

StaticOptimizeEntity

SystemBase

Implement SystemBase to create a systems in ECS.

SystemBaseDelegates

SystemBaseRegistry

TypeHash

TypeManager

TypeManager.ForcedMemoryOrderingAttribute

TypeManager.TypeVersionAttribute

UpdateAfterAttribute

UpdateBeforeAttribute

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

VariableRateSimulationSystemGroup

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

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 play if either of the ComponentTypes found as attributes of the IJobEntity has changed,

WithEntityQueryOptionsAttribute

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

WithNoneAttribute

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

World

WorldExtensions

WorldSystemFilterAttribute

For internal use only.

WriteGroupAttribute

[WriteGroup] 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

ArchetypeChunk

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

ArchetypeChunkArray

ArchetypeChunkIterator

Can be passed into IJobChunk.RunWithoutJobs to iterate over an entity query without running any jobs.

Asset

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

BlobArray<T>

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

BlobAssetChange

Header for a changed blob asset.

BlobAssetComputationContext<TS, TB>

The BlobAssetComputationContext must be used during Authoring to ECS conversion process to detect which BlobAsset should be computed and to declare their association with a UnityObject

BlobAssetReference<T>

A reference to a blob asset stored in unmanaged memory.

BlobAssetReferenceChange

Represents a blob asset reference that was changed within a EntityChangeSet

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>

BufferFromEntity<T>

BufferTypeHandle<T>

ChunkEntitiesDescription

ChunkHeader

ComponentDataFromEntity<T>

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

ComponentSystemSorter.TypeHeapElement

ComponentType

ComponentTypeHandle<T>

ComponentTypeHash

ComponentTypes

ComponentTypes.Masks

Disabled

Disables the entity.

DynamicBuffer<T>

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

DynamicComponentTypeHandle

DynamicSharedComponentTypeHandle

EditorRenderData

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.

EntityChanges

EntityChangeSet

An atomic package of changes to entity and component data.

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.

EntityContainer

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

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.

EntityQuery.GatherEntitiesResult

EntityQueryBuilder

EntityQueryDescBuilder

Struct for storing entity query data for multiple queries. Currently used to convert EntityQueryDesc[] into unmanaged data that EntityQueryManager can use when creating queries.

EntityQueryMask

Provides an efficient test of whether a specific entity would be selected 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

EntityRemapUtility.EntityPatchInfo

EntityRemapUtility.EntityRemapInfo

EntityStorageInfo

EntityTypeHandle

ExcludeComponent<T>

ExclusiveEntityTransaction

FastEquality

FastEquality.TypeInfo

Hash128

LayoutUtility

Low-level utility functions for AOS->SOA (scatter) and SOA->AOS (gather) conversions.

LayoutUtilityManaged

LinkedEntityGroup

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

LinkedEntityGroupChange

ManagedComponentAccessor<T>

MemsetNativeArray<T>

Assign Value to each element of NativeArray

NativeArraySharedInt

Merge sort index list referencing NativeArray values. Provide list of shared values, indices to shared values, and lists of source i value indices with identical shared value. As an example: Given Source NativeArray: [A,A,A,B,B,C,C,A,B] Provides: Shared value indices: [0,0,0,1,1,2,2,0,1] Shared value counts: [4,3,2] (number of occurrences of a shared value) Shared values: [A,B,C] (not stored in this structure) Sorted indices: [0,1,2,7,3,4,8,5,6] (using these indices to look up values in the source array would give you [A,A,A,A,B,B,B,C,C]) Shared value start offsets (into sorted indices): [0,4,7]

PackedComponent

Represents a packed component within an EntityChangeSet

PackedComponentDataChange

Represents a packed component data change within a EntityChangeSet

PackedManagedComponentDataChange

PackedSharedComponentDataChange

Prefab

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

PrefabRoot

RequestSceneLoaded

SceneReference

SceneSection

SceneSectionData

SceneTag

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

Scratchpad

ScratchpadAllocator

SectionMetadataSetup

SharedComponentTypeHandle<T>

SharedComponentView

SOAFieldInfo

StorageInfoFromEntity

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

SystemHandle<T>

An identifier representing an unmanaged system struct instance in a particular world.

SystemHandleUntyped

An identifier representing an unmanaged system struct instance in a particular world.

SystemRef<T>

Allows access by reference to the struct instance backing a system

SystemState

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

TypeManager.EntityOffsetInfo

TypeManager.TypeInfo

World.NoAllocReadOnlyCollection<T>

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

WorldAllocator

WorldUnmanaged

WorldUpdateAllocatorResetSystem

Interfaces

IBufferElementData

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

IComponentData

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

IConvertGameObjectToEntity

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.

IDeclareReferencedPrefabs

IJobChunk

IJobChunk is a type of Job that iterates over a set of ArchetypeChunk instances.

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 IJobEntityBatch type. The generated IJobEntityBatch type in turn invokes the Execute() method on the IJobEntity type with the appropriate arguments.