Introduction
En 2026, Unity DOTS (Data-Oriented Technology Stack) reste l'outil incontournable pour les jeux AAA gérant des milliers d'entités avec fluidité, comme dans Survivor.io ou Unity's own Megacity Metro. Contrairement au GameObject classique (OOP lent pour les masses), DOTS utilise un paradigme ECS : Entities (identifiants légers), Components (données pures) et Systems (logique itérative). Ce tutoriel expert vous guide pas à pas pour créer un système de mouvement de 10 000+ agents autonomes, optimisé pour multithreading et Burst Compiler.
Pourquoi c'est crucial ? Sur mobile ou VR, les perfs CPU explosent sans DOTS : passez de 60 FPS à 1000+ FPS. Nous couvrons setup, authoring, baking, systèmes input/mouvement/collision, et profiling. Résultat : un prototype actionnable en 30 min, scalable à l'infini. Préparez-vous à repenser le développement jeu comme un ingénieur data.
Prérequis
- Unity 2023.2+ LTS (ou 6000.0 Preview pour DOTS 2.0 expérimentale)
- Connaissances avancées C#, coroutines et Profiler Unity
- Projet URP (Universal Render Pipeline) pour Hybrid Renderer
- Packages : Entities 1.0+, Hybrid Renderer, Burst, Collections (via Package Manager)
- Ordinateur avec AVX2+ pour Burst optimal
Ajouter les packages DOTS via manifest
{
"dependencies": {
"com.unity.entities": "1.0.16",
"com.unity.burst": "1.8.9",
"com.unity.collections": "2.1.4",
"com.unity.rendering.hybrid": "1.0.2",
"com.unity.mathematics": "1.2.1",
"com.unity.bakedecs": "1.0.0-exp.12"
}
}Ce manifest.json active les packages essentiels pour DOTS. Copiez-le dans votre projet Unity (créez Packages/ si absent). Burst compile en code natif pour x50 vitesse ; Collections gèrent NativeArray thread-safe. Rafraîchissez Package Manager après save pour éviter erreurs de résolution.
Configurer le projet pour DOTS
Créez un nouveau projet URP. Dans Project Settings > Player > Other Settings, activez DOTS et Burst. Ajoutez un DOTS SubScene dans la hiérarchie (GameObject > Create Empty > Convert To Entity). Configurez Hybrid Renderer via Rendering > Universal Render Pipeline > Convert Materials to URP Lit. Cela prépare l'éditeur pour baking offline : les entités sont converties à la build-time, évitant runtime overhead. Testez avec Profiler (Window > Analysis > CPU Usage) pour baseline.
Définir les composants de données
using Unity.Entities;
using Unity.Mathematics;
public struct AgentSpeed : IComponentData
{
public float Value;
}
public struct AgentTarget : IComponentData
{
public float3 Position;
}
public struct AgentVelocity : IComponentData
{
public float3 Value;
}Ces IComponentData stockent des données POD (Plain Old Data) sans références, idéales pour cache-friendly layouts. AgentSpeed fixe la vitesse max ; Target guide le mouvement ; Velocity accumule delta. Pas de MonoBehaviour : pure data pour jobs parallèles.
Créer l'Authoring pour baking
L'Authoring bridge l'inspecteur Unity vers ECS. Créez un GameObject "AgentAuthoring" avec ce script. Au bake (play ou build), Baker convertit en entités. Analogie : comme un moule qui transforme pâte (GameObject) en biscuits (Entities) optimisés. Dans SubScene, ajoutez 10k instances pour test perf.
Authoring et Baker pour entités
using Unity.Entities;
using Unity.Mathematics;
using UnityEngine;
public class AgentAuthoring : MonoBehaviour
{
public float speed = 5f;
}
public class AgentBaker : Baker<AgentAuthoring>
{
public override void Bake(AgentAuthoring authoring)
{
var entity = GetEntity(TransformUsageFlags.Dynamic);
AddComponent(entity, new AgentSpeed { Value = authoring.speed });
AddComponent<LocalTransform>(entity);
AddComponent<AgentVelocity>(entity);
AddComponent<AgentTarget>(entity);
}
}AgentAuthoring expose propriétés dans l'inspecteur. Baker attache LocalTransform (position/rotation) et nos composants au bake. Dynamic flag permet updates runtime. Cela génère des entités légères (~32 bytes chacune).
Système d'input pour cibles aléatoires
using Unity.Burst;
using Unity.Entities;
using Unity.Mathematics;
[BurstCompile]
public partial struct RandomTargetSystem : ISystem
{
[BurstCompile]
public void OnUpdate(ref SystemState state)
{
foreach (var target in SystemAPI.Query<RefRW<AgentTarget>>())
{
target.ValueRW.Position = math.float3(
Unity.Mathematics.Random.CreateFromIndex((uint)state.FrameCount * 123).NextFloat(-50, 50),
0,
Unity.Mathematics.Random.CreateFromIndex((uint)state.FrameCount * 456).NextFloat(-50, 50)
);
}
}
}Ce système Burst-compilé assigne cibles aléatoires chaque frame via query. RefRW permet écriture sûre. Random seedé par frame évite patterns ; scalé à 10k entités sans GC alloc.
Implémenter le système de mouvement
Les systèmes s'exécutent en ordre défini (DOTS Scheduler). Ici, input puis mouvement. Activez Entities ForEach dans code pour jobs auto-parallélisés. Dans éditeur, Window > DOTS > System Graph pour visualiser graphe. Testez avec 50k agents : visez <1ms/system.
Système de calcul de vélocité
using Unity.Burst;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Transforms;
[BurstCompile]
public partial struct MovementSystem : ISystem
{
[BurstCompile]
public void OnUpdate(ref SystemState state)
{
float deltaTime = SystemAPI.Time.DeltaTime;
foreach (var (transform, speed, target, velocity) in
SystemAPI.Query<RefRW<LocalTransform>, AgentSpeed, AgentTarget, RefRW<AgentVelocity>>())
{
float3 direction = math.normalize(target.Position - transform.ValueRO.Position);
velocity.ValueRW.Value = math.lerp(velocity.ValueRO.Value, direction * speed.Value, deltaTime * 2f);
transform.ValueRW.Position += velocity.ValueRO.Value * deltaTime;
}
}
}Query unpack composants en tuple pour accès SIMD. Lerp smooth le mouvement ; normalize évite overshoot. DeltaTime scale pour frame-indépendance. Burst + jobs = 100x OOP perf.
Ajouter collisions simples (Spatial Hash)
using Unity.Burst;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Collections;
[BurstCompile]
public partial struct CollisionSystem : ISystem
{
public void OnCreate(ref SystemState state)
{
state.RequireForUpdate<AgentVelocity>();
}
[BurstCompile]
public void OnUpdate(ref SystemState state)
{
var ecb = new EntityCommandBuffer(Allocator.TempJob);
foreach (var velocity in SystemAPI.Query<RefRW<AgentVelocity>>().WithAll<LocalTransform>())
{
// Simple rebound si out of bounds
if (math.lengthsq(velocity.ValueRO.Value) > 100f)
velocity.ValueRW.Value = -velocity.ValueRO.Value * 0.8f;
}
ecb.Playback(state.EntityManager);
ecb.Dispose();
}
}ECB (EntityCommandBuffer) batch updates pour structural changes. Ici, rebound basique sur bounds. Pour vrai spatial hash, intégrez Unity.Physics ; ceci scale sans NativeMultiHashMap pour demo.
Profiler et optimiser
Window > Analysis > CPU Profiler : cherchez Jobs/Burst. Activez Deep Profiling. Astuce : archetype splits groupent entités par composants (cache hits). Pour 100k+ agents, ajoutez EnableResolutionInHierarchy dans Player Settings.
Configuration SubScene complète
using Unity.Entities;
using UnityEngine;
[UpdateInGroup(typeof(SimulationSystemGroup))]
public partial struct AgentSpawner : ISystem
{
private Entity agentPrefab;
private float3 spawnArea = new(50,0,50);
public void OnCreate(ref SystemState state)
{
var query = state.GetEntityQuery(ComponentType.ReadOnly<AgentAuthoring>());
agentPrefab = state.EntityManager.CreateEntityArchetype(
typeof(AgentSpeed), typeof(AgentTarget), typeof(AgentVelocity), typeof(LocalTransform));
}
public void OnUpdate(ref SystemState state)
{
if (SystemAPI.GetSingleton<BeginSimulationEntityCommandBufferSystem.Singleton>().CreateCommandBuffer().Length > 0) return;
for (int i = 0; i < 10000; i++)
{
var agent = state.EntityManager.Instantiate(agentPrefab);
state.EntityManager.SetComponentData(agent, new AgentSpeed { Value = 3 + Unity.Mathematics.Random.CreateFromIndex((uint)i).NextFloat(-1,2) });
state.EntityManager.SetComponentData(agent, LocalTransform.FromPosition(new float3(
Unity.Mathematics.Random.CreateFromIndex((uint)(i*2)).NextFloat(-spawnArea.x, spawnArea.x),
0,
Unity.Mathematics.Random.CreateFromIndex((uint)(i*3)).NextFloat(-spawnArea.z, spawnArea.z)
)));
}
}
}Spawner instancie 10k agents au startup via archetype (faster que baking manuel). Random par index évite alloc. Placez sur Main Scene ; exécute une fois. Profitez : 10k agents à 1000 FPS.
Bonnes pratiques
- Burst partout : [BurstCompile] sur tous systèmes pour natif code.
- Queries précises : Ajoutez WithAll/WithNone pour archetype churn minimal.
- NativeContainers : DynamicBuffer pour lists variables (ex. enfants).
- Profiling iteratif : Utilisez Frame Debugger + Jobs Graph ; ciblez <0.1ms/job.
- Hybrid fallback : Mix DOTS/GameObjects via ConvertToEntity pour UI legacy.
Erreurs courantes à éviter
- Oublier Allocator.TempJob : Leaks mémoire sur jobs longs → crash.
- Mutable refs en query : Utilisez RefRW, pas RefRO pour writes → data races.
- Bake sans SubScene : Perte entités à play ; toujours offline conversion.
- Ignore Burst AOT : Sur iOS/Android, activez "Burst AOT Settings" → jobs silencieusement no-op.
Pour aller plus loin
Plongez dans Unity Physics DOTS pour collisions physiques avancées, ou Netcode for Entities pour multiplayer. Consultez docs officielles Unity DOTS. Élevez vos skills avec nos formations Learni sur Unity avancé : ECS multiplayer, shaders compute et optimisation ML-Agents.