Unity Entities

https://docs.unity3d.com/Packages/com.unity.entities@6.5/manual/
Admin
Unity Entities is a data-oriented implementation of the Entity Component System (ECS) architecture,...
Tokens:112,523
Snippets:1,585
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Example of using EntityQuery

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/upgrade-guide.html

Demonstrates the recommended replacement pattern using SystemAPI.Query with explicit component references and a static helper method.

```csharp
public partial struct RotationSystem : ISystem
{
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        var elapsedTime = SystemAPI.Time.ElapsedTime;

        foreach (var (transform, speed) in SystemAPI.Query<RefRW<LocalTransform>, RefRO<RotationSpeed>>())
        {
            VerticalMovementHelper.Move(elapsedTime, transform, speed);
        }
    }
}

static class VerticalMovementHelper
{
    public static void Move(double elapsedTime, RefRW<LocalTransform> transform, RefRO<RotationSpeed> speed)
    {
        transform.ValueRW.Position.y = (float)math.sin(elapsedTime * speed.ValueRO.RadiansPerSecond);
    }
}
```

--------------------------------

### Simple Baker Example

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/baking-baker-overview.html

Demonstrates how to create a baker for a custom authoring component. This baker converts authoring data into ECS components and creates additional entities.

```csharp
public class RotationSpeedAuthoring : MonoBehaviour
{
    public float DegreesPerSecond;
}

public struct RotationSpeed : IComponentData
{
    public float RadiansPerSecond;
}

public struct Additional : IComponentData
{
    public float SomeValue;
}

public class SimpleBaker : Baker<RotationSpeedAuthoring>
{
    public override void Bake(RotationSpeedAuthoring authoring)
    {
        var entity = GetEntity(TransformUsageFlags.Dynamic);
        AddComponent(entity, new RotationSpeed
        {
            RadiansPerSecond = math.radians(authoring.DegreesPerSecond)
        });

        var additionalA = CreateAdditionalEntity(TransformUsageFlags.Dynamic, entityName: "Additional A");
        var additionalB = CreateAdditionalEntity(TransformUsageFlags.Dynamic, entityName: "Additional B");

        AddComponent(additionalA, new Additional { SomeValue = 123 });
        AddComponent(additionalB, new Additional { SomeValue = 234 });
    }
}
```

--------------------------------

### Full system example for entity movement

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-looking-up-data.html

A complete system implementation that uses ComponentLookup to move entities toward a target entity.

```csharp
[RequireMatchingQueriesForUpdate]
public partial class MoveTowardsEntitySystem : SystemBase
{
    private EntityQuery query;

    [BurstCompile]
    private partial struct MoveTowardsJob : IJobEntity
    {

        // Read-only data stored (potentially) in other chunks
        [ReadOnly]
        public ComponentLookup<LocalToWorld> EntityPositions;

        // Non-entity data
        public float deltaTime;

        public void Execute(ref LocalTransform transform, in Target target, in LocalToWorld entityPosition)
        {
            // Get the target Entity object
            Entity targetEntity = target.entity;

            // Check that the target still exists
            if (!EntityPositions.HasComponent(targetEntity))
                return;

            // Update translation to move the chasing entity toward the target
            float3 targetPosition = EntityPositions[targetEntity].Position;
            float3 chaserPosition = transform.Position;

            float3 displacement = targetPosition - chaserPosition;
            transform.Position = chaserPosition + displacement * deltaTime;
        }
    }

    protected override void OnCreate()
    {
        // Select all entities that have Translation and Target Component
        query = this.GetEntityQuery
            (
                typeof(LocalTransform),
                ComponentType.ReadOnly<Target>()
            );
    }

    protected override void OnUpdate()
    {
        // Create the job
        var job = new MoveTowardsJob();

        // Set the component data lookup field
        job.EntityPositions = GetComponentLookup<LocalToWorld>(true);

        // Set non-ECS data fields
        job.deltaTime = SystemAPI.Time.DeltaTime;

        // Schedule the job using Dependency property
        Dependency = job.ScheduleParallel(query, Dependency);
    }
}
```

--------------------------------

### Example of using Aspects

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/upgrade-guide.html

Demonstrates the deprecated pattern of using an IAspect to encapsulate component logic.

```csharp
public partial struct RotationSystem : ISystem
{
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        var deltaTime = SystemAPI.Time.DeltaTime;
        var elapsedTime = SystemAPI.Time.ElapsedTime;

        foreach (var movement in SystemAPI.Query<VerticalMovementAspect>())
        {
            movement.Move(elapsedTime);
        }
    }
}

readonly partial struct VerticalMovementAspect : IAspect
{
    readonly RefRW<LocalTransform> m_Transform;
    readonly RefRO<RotationSpeed> m_Speed;

    public void Move(double elapsedTime)
    {
        m_Transform.ValueRW.Position.y = (float)math.sin(elapsedTime * m_Speed.ValueRO.RadiansPerSecond);
    }
}
```

--------------------------------

### Implement system data using data-oriented approach

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-data.html

An example of storing system data in a separate IComponentData struct, associated with the system via its SystemHandle.

```csharp
public struct PlayerInputData : IComponentData
{
    public float AxisX;
    public float AxisY;
}

public partial struct PlayerInputSystem : ISystem
{
    public void OnCreate(ref SystemState state)
    {
        state.EntityManager.AddComponent<PlayerInputData>(state.SystemHandle);
    }

    public void OnUpdate(ref SystemState state)
    {
        SystemAPI.SetComponent(state.SystemHandle, new PlayerInputData {
            AxisX = [...read controller data],
            AxisY = [...read controller data]
        });
    }

    // Component data is automatically destroyed when the system is destroyed. 
    // If a Native Container existed in the component, however, OnDestroy could be used to
    // ensure memory is disposed.
    public void OnDestroy(ref SystemState state) { }  
}
```

--------------------------------

### Recording Commands with EntityCommandBufferSystem

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-entity-command-buffer-automatic-playback.html

Use this pattern within a system to get a singleton EntityCommandBufferSystem, create an EntityCommandBuffer, and schedule a job to record commands.

```csharp
// ... in a system.

// Assume an EntityCommandBufferSystem exists named FooECBSystem.
// This call to GetSingleton automatically registers the job so that
// it gets completed by the ECB system.
var singleton = SystemAPI.GetSingleton<FooECBSystem.Singleton>();

// Create a command buffer that will be played back
// and disposed by MyECBSystem.
EntityCommandBuffer ecb = singleton.CreateCommandBuffer(state.WorldUnmanaged);

// An IJobEntity with no argument to Schedule implicitly
// assigns its returned JobHandle to this.Dependency
new MyParallelRecordingJob() { ecbParallel = ecb.AsParallelWriter() }.Schedule();

```

--------------------------------

### Get Position and Rotation Main-thread Implementation

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/transforms-comparison.html

Retrieves world position and rotation by extracting them from the LocalToWorld matrix.

```csharp
void GetPositionAndRotation(ref SystemState state, Entity e,
    out float3 position, out quaternion rotation)
{
    float4x4 l2w =
        SystemAPI.GetComponent<LocalToWorld>(e).Value;
    position = l2w.Translation();
    rotation = l2w.Rotation();
}
```

--------------------------------

### Implement system data using object-oriented approach

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-data.html

An example of storing system data directly as fields within the system struct, which is discouraged in data-oriented design.

```csharp
/// Object-oriented code example
public partial struct PlayerInputSystem : ISystem
{
    public float AxisX;
    public float AxisY;

    public void OnCreate(ref SystemState state) { }

    public void OnUpdate(ref SystemState state)
    {
        AxisX = [... read controller input];
        AxisY = [... read controller input];
    }

    public void OnDestroy(ref SystemState state) { }
}
```

--------------------------------

### System Setup for Job Buffer Access

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/components-buffer-jobs.html

This system prepares and schedules a job that accesses dynamic buffers. It requires a BufferLookup member, which is initialized in OnCreate using SystemState.GetBufferLookup and updated in OnUpdate before scheduling the job.

```csharp
public partial struct AccessDynamicBufferFromJobSystem : ISystem
{
    private BufferLookup<ExampleBufferComponent> _bufferLookup;

    public void OnCreate(ref SystemState state)
    {
        _bufferLookup = state.GetBufferLookup<ExampleBufferComponent>(true);
    }

    public void OnUpdate(ref SystemState state)
    {
        _bufferLookup.Update(ref state);
        var exampleBufferAccessJob = new AccessDynamicBufferJob { BufferLookup = _bufferLookup };
        exampleBufferAccessJob.ScheduleParallel();
    }
}
```

--------------------------------

### Get Child Main-thread Implementation

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/transforms-comparison.html

Retrieves a child entity at a specific index using SystemAPI.HasBuffer and SystemAPI.GetBuffer.

```csharp
Entity GetChild(ref SystemState state, Entity e, int index)
{
    if (SystemAPI.HasBuffer<Child>(e))
        return SystemAPI.GetBuffer<Child>(e)[index].Value;
    return Entity.Null;
}
```

--------------------------------

### Example Console Output for .hexpat File Creation

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/entities-binary-debugging.html

This console message indicates the successful creation of a .hexpat file, which is a pattern file for describing data types and their locations within a binary file. This file is generated after a subscene baking operation is completed.

```text
Created an .hexpat file from the recent bake, located at: ./Library/GeneratedImHex/45a2c8428b97e4e48955d9b5114509fe.0.entities.hexpat (Size: 24154 bytes)

```

--------------------------------

### Get Local Position and Rotation Main-thread Implementation

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/transforms-comparison.html

Accesses the LocalTransform component to retrieve local position and rotation values.

```csharp
void GetLocalPositionAndRotation(ref SystemState state,
    Entity e, out float3 localPosition,
    out quaternion localRotation)
{
    LocalTransform transform =
            SystemAPI.GetComponent<LocalTransform>(e);
    localPosition = transform.Position;
    localRotation = transform.Rotation;
}
```

--------------------------------

### Get UntypedWeakReferenceId of Selected Objects

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/content-management-get-a-weak-reference.html

This code sample shows how to get the `UntypedWeakReferenceId` of the objects currently selected in the Project window. To make Unity include these objects in content archives, you must bake the weak reference IDs into an ECS component.

```csharp
using UnityEngine;
using UnityEditor;
using Unity.Entities.Serialization;

public static class ContentManagementEditorUtility
{
    [MenuItem("Content Management/Log UntypedWeakReferenceId of Selected")]
    private static void LogWeakReferenceIDs()
    {
        Object[] selectedObjects = Selection.GetFiltered(typeof(Object), SelectionMode.Assets);
        for (int i = 0; i < selectedObjects.Length; i++)
        {
            Debug.Log($"{selectedObjects[i].name}: {UntypedWeakReferenceId.CreateFromObjectInstance(selectedObjects[i])}");
        }
    }
}
```

--------------------------------

### HelloWorld.cs implementation

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/ecs-workflow-example-starter.html

Defines an unmanaged component using IComponentData and a system that creates an entity and logs component data.

```csharp
using Unity.Entities;
using Unity.Collections;
using UnityEngine;

// This is an example of an unmanaged ECS component.
public struct HelloComponent : IComponentData
{
    // FixedString32Bytes is used instead of string, because
    // struct IComponentData can only contain unmanaged types.
    public FixedString32Bytes Message;
}

public partial struct ExampleSystem : ISystem
{
    public void OnCreate(ref SystemState state)
    {
        var entity = state.EntityManager.CreateEntity();
        // Initialize and add a HelloComponent component to the entity.
        state.EntityManager.AddComponentData(entity, new HelloComponent 
            { Message = "Hello ECS World" });
        // Set the name of the entity to make it easier to identify it.
        // Note: the entity Name property only exists in the Editor.
        state.EntityManager.SetName(entity, "Hello World Entity");
    }

    public void OnUpdate(ref SystemState state)
    {
        // The query retrieves all entities with a HelloComponent component.
        foreach (var message in
                    SystemAPI.Query<RefRO<HelloComponent>>())
        {
            Debug.Log(message.ValueRO.Message);
        }
    }
}
```

--------------------------------

### Get and Set Chunk Component Data via Entity

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/components-chunk-use.html

Shows how to retrieve and modify a chunk component's data by first getting the chunk associated with an entity. This method is useful when you have an entity and need to interact with its chunk's component data.

```csharp
private void ChunkComponentExample(Entity e)
{
    var entityChunk = EntityManager.GetChunk(e);
    // Sets the ExampleChunkComponent value of the entity's chunk.
    EntityManager.SetChunkComponentData<ExampleChunkComponent>(entityChunk,
        new ExampleChunkComponent { Value = 6 });

    // Gets the ExampleChunkComponent value of the entity's chunk.
    ExampleChunkComponent exampleChunkComponent = EntityManager.GetChunkComponentData<ExampleChunkComponent>(e);
    Debug.Log(exampleChunkComponent.Value)    // 6
}
```

--------------------------------

### Add, Set, and Get Chunk Component Data

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/components-chunk-use.html

Demonstrates adding a chunk component to an entity's chunk, querying for chunks with specific components, and then setting and getting the chunk component's value. Use `ComponentType.ChunkComponent` when querying for chunk components.

```csharp
private void ChunkComponentExample(Entity e)
{
    // Adds ExampleChunkComponent to the passed in entity's chunk.
    EntityManager.AddChunkComponentData<ExampleChunkComponent>(e);

    // Finds all chunks with an ExampleComponent and an ExampleChunkComponent.
    // To distinguish chunk components from a regular IComponentData, You must
    // specify the chunk component with ComponentType.ChunkComponent.
    EntityQuery query = GetEntityQuery(typeof(ExampleComponent), ComponentType.ChunkComponent<ExampleChunkComponent>());
    NativeArray<ArchetypeChunk> chunks = query.ToArchetypeArray(Allocator.Temp);

    // Sets the ExampleChunkComponent value of the first chunk.
    EntityManager.SetChunkComponentData<ExampleChunkComponent>(chunks[0], new ExampleChunkComponent { Value = 6 });

    // Gets the ExampleChunkComponent value of the first chunk.
    ExampleChunkComponent exampleChunkComponent = EntityManager.GetChunkComponentData<ExampleChunkComponent>(chunks[0]);
    Debug.Log(exampleChunkComponent.Value)    // 6
}
```

--------------------------------

### Instantiate Prefab using SystemAPI

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/reference-unity-objects.html

Demonstrates accessing the UnityObjectRef from a system to instantiate a prefab and adding the resulting component to an entity.

```csharp
public partial struct SpawnAnimatedCubeSystem : ISystem
{
    public void OnCreate(ref SystemState state)
    {
        var entities = SystemAPI.QueryBuilder().WithAll<AnimatorRefComponent>().WithNone<Animator>().Build().ToEntityArray(state.WorldUpdateAllocator);

        foreach (var entity in entities)
        {
            var animRef = SystemAPI.GetComponent<AnimatorRefComponent>(entity);

            var rotatingCube = (GameObject)Object.Instantiate(animRef.AnimatorAsGO);

            state.EntityManager.AddComponentObject(entity, rotatingCube.GetComponent<Animator>());
        }
    }
}
```

--------------------------------

### Iterate with Entities.ForEach (Deprecated)

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/upgrade-guide.html

Example of the deprecated Entities.ForEach pattern used in SystemBase.

```csharp
public partial class RotationSpeedSystemForEachISystem : SystemBase
{
    protected override void OnUpdate()
    {
        float deltaTime = SystemAPI.Time.DeltaTime;
        Entities
            .ForEach((ref LocalTransform transform, in RotationSpeed rotationSpeed) =>
            {
                transform.Rotation = math.mul(
                    math.normalize(transform.Rotation),
                    quaternion.AxisAngle(math.up(), rotationSpeed.RadiansPerSecond * deltaTime));
            })
            .ScheduleParallel();
    }
}
```

--------------------------------

### ISystem Implementation with Foreach Loop

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-comparison.html

Demonstrates how to implement a spline-following system using ISystem and a foreach loop. It utilizes ComponentLookup and BufferLookup for efficient data access and updates the entity's LocalTransform.

```csharp
var lengthLookup = SystemAPI.GetComponentLookup<SplineLength>(true);
var pointsBufferLookup = SystemAPI.GetBufferLookup<SplinePointsBuffer>(true);

// Version with writeable buffer lookup
foreach (var (transform, follower) in
        SystemAPI.Query<RefRW<LocalTransform>, RefRO<SplineFollower>>()
        .WithAll<FollowingSplineTag>())
{
   var splineLength = lengthLookup[follower.ValueRO.Spline].Value;
   var pointsBuf = pointsBufferLookup[follower.ValueRO.Spline];
   transform.ValueRW = SplineHelper.FollowSpline(pointsBuf, splineLength, follower.ValueRO.Distance);
}
```

--------------------------------

### Get EndSimulationEntityCommandBufferSystem Singleton

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/ecs-workflow-example-ecb.html

Retrieves the singleton for the EndSimulationEntityCommandBufferSystem, which is necessary for creating a command buffer.

```csharp
var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
```

--------------------------------

### Instantiate a scene with PostLoadCommandBuffer

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/streaming-scene-instancing.html

Demonstrates loading a scene with NewInstance flags and attaching a PostLoadCommandBuffer to apply custom instance data.

```csharp
var loadParameters = new SceneSystem.LoadParameters()
    { Flags = SceneLoadFlags.NewInstance };
var sceneEntity = SceneSystem.LoadSceneAsync(state.WorldUnmanaged,
    sceneReference, loadParameters);

var ecb = new EntityCommandBuffer(Allocator.Persistent,
    PlaybackPolicy.MultiPlayback);
var postLoadEntity = ecb.CreateEntity();
var postLoadOffset = new PostLoadOffset
{
    Offset = sceneOffset
};
ecb.AddComponent(postLoadEntity, postLoadOffset);

var postLoadCommandBuffer = new PostLoadCommandBuffer()
{
    CommandBuffer = ecb
};
state.EntityManager.AddComponentData(sceneEntity, postLoadCommandBuffer);
```

--------------------------------

### Complete System for Manual ECB Management

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/ecs-workflow-example-ecb.html

This C# system demonstrates the complete workflow for manual Entity Command Buffer management. It includes creating a temporary ECB, iterating through entities to modify components or queue removal, executing all queued commands with Playback, and finally disposing of the ECB.

```csharp
using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Transforms;

public partial struct RotationSystemManualECB : ISystem
{
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        float deltaTime = SystemAPI.Time.DeltaTime;

        // Create a temporary command buffer.
        var ecb = new EntityCommandBuffer(Allocator.Temp);

        foreach (var (transform, speed, lifetime, entity) in
                    SystemAPI.Query<RefRW<LocalTransform>, RefRO<RotationSpeed>>().WithEntityAccess())
        {
            float rotationThisFrame = speed.ValueRO.RadiansPerSecond * deltaTime;
            transform.ValueRW = transform.ValueRO.RotateY(rotationThisFrame);
            lifetime.ValueRW.RadiansRemaining -= rotationThisFrame;

            if (lifetime.ValueRO.RadiansRemaining <= 0)
            {
                // Queue the command.
                ecb.RemoveComponent<RotationSpeed>(entity);
            }
        }

        // Execute all queued commands immediately after the loop.
        ecb.Playback(state.EntityManager);

        // Dispose of the buffer.
        ecb.Dispose();
    }
}
```

--------------------------------

### Load remote content catalogs with a system

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/content-management-delivery.html

This system demonstrates how to register for content update callbacks and trigger catalog loading until initialization succeeds or the maximum number of attempts is reached.

```csharp
using Unity.Collections;
using Unity.Entities;
using Unity.Entities.Content;
using UnityEngine;

// Loads remote content catalogs, caches them locally, and makes weakly-referenced
// assets available for use by resolving their references to the downloaded content.
public partial struct LoadingRemoteCatalogSystem : ISystem
{
    private bool initialized;
    private FixedString512Bytes remoteUrlRoot;
    private FixedString512Bytes cachePath;
    private FixedString64Bytes contentNameSet;
    private int maxLoadAttempts; // Max number of times to try loading the catalog
    private int loadAttempts;    // Current number of attempts
        
    public void OnCreate(ref SystemState state)
    {
        initialized = false;
        contentNameSet = "all";
        remoteUrlRoot = "https://127.0.0.1/content/";
        cachePath = Application.persistentDataPath + "/content-cache/";
        maxLoadAttempts = 3;
        loadAttempts = 0;
            
        // Register a callback that runs when content delivery completes
        ContentDeliveryGlobalState.RegisterForContentUpdateCompletion(UpdateStateCallback);
    }

    private void UpdateStateCallback(ContentDeliveryGlobalState.ContentUpdateState
        contentUpdateState)
    {
        // Use this condition to implement logic for cases when content update failed and
        // there is no data in the cache, or for an early exit.
        if (contentUpdateState == ContentDeliveryGlobalState.ContentUpdateState
                .NoContentAvailable)
        {
            // The system attempts again until it reaches the maximum number of attempts.
            return;
        }

        // Track the state of the content and define when it's ready to use
        if (contentUpdateState >= ContentDeliveryGlobalState.ContentUpdateState
                .ContentReady)
        {
            // Only mark initialized when catalog loading actually succeeded.
            initialized = true;
            LoadMainScene();
        }
    }

    public void OnUpdate(ref SystemState state)
    {
        // Attempt to load content a content catalog until it is initialized or the maximum
        // number of attempts is reached.
        if (!initialized && loadAttempts < maxLoadAttempts)
        {
            loadAttempts++;
            // Calling the LoadContentCatalog method initializes the content catalog.
            RuntimeContentSystem.LoadContentCatalog(remoteUrlRoot.ToString(),
                cachePath.ToString(), contentNameSet.ToString(), true);
        }
    }

    private void LoadMainScene()
    {
        // Content is ready - load your main scene or enable gameplay systems here
    }
}
```

--------------------------------

### Create a blob asset with BlobBuilder

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/blob-assets-create.html

Demonstrates the lifecycle of creating a blob asset, including builder initialization, root construction, data assignment, and final reference creation.

```csharp
struct MarketData
{
    public float PriceOranges;
    public float PriceApples;
}

BlobAssetReference<MarketData> CreateMarketData()
{
    // Create a new builder that will use temporary memory to construct the blob asset
    var builder = new BlobBuilder(Allocator.Temp);

    // Construct the root object for the blob asset. Notice the use of `ref`.
    ref MarketData marketData = ref builder.ConstructRoot<MarketData>();

    // Now fill the constructed root with the data:
    // Apples compare to Oranges in the universally accepted ratio of 2 : 1 .
    marketData.PriceApples = 2f;
    marketData.PriceOranges = 4f;

    // Now copy the data from the builder into its final place, which will
    // use the persistent allocator
    var result = builder.CreateBlobAssetReference<MarketData>(Allocator.Persistent);

    // Make sure to dispose the builder itself so all internal memory is disposed.
    builder.Dispose();
    return result;
}
```

--------------------------------

### Schedule IJobChunk Job in SystemBase

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/iterating-data-ijobchunk-implement.html

Demonstrates how to set up an EntityQuery, instantiate an IJobChunk job struct, set its component type handles and other data, and then schedule it for parallel execution within a SystemBase's OnUpdate method.

```csharp
[RequireMatchingQueriesForUpdate]
public partial class UpdateTranslationFromVelocitySystem : SystemBase
{
    EntityQuery query;

    protected override void OnCreate()
    {
        // Set up the query
        query = new EntityQueryBuilder(Allocator.Temp)
            .WithAllRW<ObjectPosition>()
            .WithAll<VelocityVector>()
            .Build(this);
    }

    protected override void OnUpdate()
    {
        // Instantiate the job struct
        var updateFromVelocityJob
            = new UpdateTranslationFromVelocityJob();

        // Set the job component type handles
        // "this" is your SystemBase subclass
        updateFromVelocityJob.PositionTypeHandle
            = this.GetComponentTypeHandle<ObjectPosition>(false);
        updateFromVelocityJob.VelocityTypeHandle
            = this.GetComponentTypeHandle<VelocityVector>(true);

        // Set other data need in job, such as time
        updateFromVelocityJob.DeltaTime = World.Time.DeltaTime;

        // Schedule the job
        this.Dependency
            = updateFromVelocityJob.ScheduleParallel(query, this.Dependency);
    }
}
```

--------------------------------

### Demonstrate cleanup component lifecycle

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/components-cleanup-introducing.html

Shows how an entity with a cleanup component persists after a destroy command until all cleanup components are explicitly removed.

```csharp
// Creates an entity that contains a cleanup component.
Entity e = EntityManager.CreateEntity(
    typeof(Translation), typeof(Rotation), typeof(ExampleCleanup));

// Attempts to destroy the entity but, because the entity has a cleanup component, Unity doesn't actually destroy the entity. Instead, Unity just removes the Translation and Rotation components. 
EntityManager.DestroyEntity(e);

// The entity still exists so this demonstrates that you can still use the entity normally.
EntityManager.AddComponent<Translation>(e);

// Removes all the remaining components from the entity.
// Removing the final cleanup component (ExampleCleanup) automatically destroys the entity.
EntityManager.RemoveComponent(e, new ComponentTypeSet(typeof(ExampleCleanup), typeof(Translation)));

// Demonstrates that the entity no longer exists. entityExists is false. 
bool entityExists = EntityManager.Exists(e);
```

--------------------------------

### Manual ComponentLookup Implementation

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-systemapi.html

Illustrates the manual equivalent of using SystemAPI.GetComponentLookup, requiring explicit OnCreate initialization and OnUpdate updates.

```csharp
ComponentLookup<HealthData> lookup_HealthData_RO;
public void OnCreate(ref SystemState state){
    lookup_HealthData_RO = state.GetComponentLookup<HealthData>(isReadOnly:true);
}

public void OnUpdate(ref SystemState state){
    lookup_HealthData_RO.Update(ref state);
    new MyJob{healthLookup=lookup_HealthData_RO};
}
```

--------------------------------

### Get a Dynamic Buffer Component

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/components-buffer-create.html

Retrieve a dynamic buffer component from an entity using EntityManager.GetBuffer<T>. This is used to interact with the buffer's elements.

```csharp
public void GetDynamicBufferComponentExample(Entity e)
{
	DynamicBuffer<ExampleBufferComponent> myDynamicBuffer = EntityManager.GetBuffer<ExampleBufferComponent>(e);
}
```

--------------------------------

### System to Add Cleanup Component

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/components-cleanup-create.html

This system queries for entities with ExampleTagComponent and adds the ExampleCleanupComponent to them. It runs once and then disables itself.

```csharp
public partial struct AddCleanupSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var ecb = new EntityCommandBuffer(state.WorldUpdateAllocator);

        foreach (var (tag, entity) in SystemAPI.Query<ExampleTagComponent>().WithEntityAccess())
        {
            // Add the cleanup component to all entities with the tag component.
            ecb.AddComponent<ExampleCleanupComponent>(entity);
        }
        ecb.Playback(state.EntityManager);
        ecb.Dispose();

        state.Enabled = false;
    }
}
```

--------------------------------

### Extended Write Group System with WithAny

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-write-groups.html

Demonstrates how to extend a system that uses write groups by explicitly querying for specific component combinations using `WithAny`. This ensures that only entities matching the defined criteria are processed.

```csharp
[DisableAutoCreation]
[BurstCompile]
public partial struct ExtendedWriteGroupSystem : ISystem
{
    private EntityQuery m_Query;

    public void OnCreate(ref SystemState state)
    {
        // When extending a system that uses write groups, you must explicitly
        // query for each combination of components that make sense.
        // Use WithAny to match entities with A OR B (in addition to C and W).
        m_Query = new EntityQueryBuilder(Allocator.Temp)
            .WithAllRW<W>()
            .WithAll<C>()
            .WithAny<A, B>()
            .WithOptions(EntityQueryOptions.FilterWriteGroup)
            .Build(ref state);

        state.RequireForUpdate(m_Query);
    }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        // Process entities that have C and W, and also have A or B.
        foreach (var (w, c) in
            SystemAPI.Query<RefRW<W>, RefRO<C>>()
                .WithAny<A, B>()
                .WithOptions(EntityQueryOptions.FilterWriteGroup))
        {
            w.ValueRW.Value += c.ValueRO.Value;
        }
    }
}
```

--------------------------------

### IJobEntity with Write Group Filtering

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/systems-write-groups.html

Example of an `IJobEntity` that processes entities based on write group filtering. This job modifies component `W` using data from component `B`.

```csharp
[BurstCompile]
public partial struct AddingJob : IJobEntity
{
    private void Execute(ref W w, in B b)
    {
        w.Value += b.Value;
    }
}
```

--------------------------------

### IJobChunk Job Struct Example

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/iterating-data-ijobchunk-implement.html

Defines a job struct that accesses and modifies component data for entities. Use this pattern to perform calculations on component values within a chunk.

```csharp
[BurstCompile]
public struct UpdateTranslationFromVelocityJob : IJobChunk
{
    public ComponentTypeHandle<VelocityVector> VelocityTypeHandle;
    public ComponentTypeHandle<ObjectPosition> PositionTypeHandle;
    public float DeltaTime;

    [BurstCompile]
    public void Execute(in ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask, in v128 chunkEnabledMask)
    {
        NativeArray<VelocityVector> velocityVectors = chunk.GetNativeArray(ref VelocityTypeHandle);
        NativeArray<ObjectPosition> translations = chunk.GetNativeArray(ref PositionTypeHandle);

        var enumerator = new ChunkEntityEnumerator(useEnabledMask, chunkEnabledMask, chunk.Count);
        while(enumerator.NextEntityIndex(out var i))
        {
            float3 translation = translations[i].Value;
            float3 velocity = velocityVectors[i].Value;
            float3 newTranslation = translation + velocity * DeltaTime;

            translations[i] = new ObjectPosition() { Value = newTranslation };
        }
    }
}
```

--------------------------------

### Define an unmanaged component for chunk usage

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/components-chunk-create.html

Define a struct that inherits from IComponentData to create a component that can be used as a chunk component. This example shows a simple component with an integer value.

```csharp
public struct ExampleChunkComponent : IComponentData
{
    public int Value;
}
```

--------------------------------

### Instantiate Prefabs with EntityManager or ECB

Source: https://docs.unity3d.com/Packages/com.unity.entities%406.5/manual/baking-prefabs.html

Demonstrates using an EntityCommandBuffer to instantiate an entity referenced by a component and adding a tag component to the new instance.

```csharp
// A tag component to add to each new instance
public struct Instantiated : IComponentData { }

public partial struct InstantiatePrefabSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var ecb = new EntityCommandBuffer(Allocator.Temp);

        // Get all Entities that have the component with the Entity reference
        foreach (var prefab in
                 SystemAPI.Query<RefRO<EntityPrefabComponent>>())
        {
            // Instantiate the prefab Entity
            var instance = ecb.Instantiate(prefab.ValueRO.Value);
            // Note: the returned instance is only relevant when used in the ECB
            // as the entity is not created in the EntityManager until ECB.Playback
            ecb.AddComponent<Instantiated>(instance);
        }

        ecb.Playback(state.EntityManager);
        ecb.Dispose();
    }
}
```
Tokens:
Raw