dots-spawning-patterns

Spawning Patterns — Senior Patterns

Spawning N entities efficiently is the difference between a 60fps shooter and a 6fps slideshow. The correct pattern is batched Instantiate from a baked prefab Entity, recorded into an ECB when called from a job, with a deterministic seed.

Intent

Create entities in bulk, deterministically, without main-thread cost in hot paths.

Senior pattern — main-thread spawner (one batch per trigger)

public partial struct SpawnSystem : ISystem
{
    uint m_UpdateCounter;

    [BurstCompile]
    public void OnCreate(ref SystemState state)
    {
        // Don't run until a Spawner singleton exists (set by baking).
        state.RequireForUpdate<Spawner>();
    }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        var spinningCubesQuery = SystemAPI.QueryBuilder().WithAll<RotationSpeed>().Build();

        // Only spawn when none exist — bursty, not per-frame.
        if (!spinningCubesQuery.IsEmpty) return;

        var prefab = SystemAPI.GetSingleton<Spawner>().Prefab;

        // Batched: instantiate 500 in one call, return a temp NativeArray of entities.
        var instances = state.EntityManager.Instantiate(prefab, 500, Allocator.Temp);

        // Deterministic random: CreateFromIndex hashes the seed so consecutive
        // seeds don't produce visually-similar results.
        var rng = Random.CreateFromIndex(m_UpdateCounter++);

        foreach (var entity in instances)
        {
            var transform = SystemAPI.GetComponentRW<LocalTransform>(entity);
            transform.ValueRW.Position = (rng.NextFloat3() - new float3(0.5f, 0, 0.5f)) * 20f;
        }
        // Allocator.Temp auto-frees at end of frame. No manual Dispose.
    }
}

Senior pattern — spawn from inside a parallel job

When spawn cadence depends on per-entity state (e.g. each turret fires when its cooldown expires):

public partial struct TurretFireSystem : ISystem
{
    [BurstCompile]
    public void OnCreate(ref SystemState state) {
        state.RequireForUpdate<Spawner>();
        state.RequireForUpdate<BeginSimulationEntityCommandBufferSystem.Singleton>();
    }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        var prefab = SystemAPI.GetSingleton<Spawner>().BulletPrefab;
        var ecb = SystemAPI.GetSingleton<BeginSimulationEntityCommandBufferSystem.Singleton>()
                           .CreateCommandBuffer(state.WorldUnmanaged)
                           .AsParallelWriter();

        new FireJob {
            Ecb = ecb,
            Prefab = prefab,
            Dt = SystemAPI.Time.DeltaTime,
        }.ScheduleParallel();
    }
}

[BurstCompile]
partial struct FireJob : IJobEntity
{
    public EntityCommandBuffer.ParallelWriter Ecb;
    public Entity Prefab;
    public float Dt;

    void Execute([ChunkIndexInQuery] int chunkIndex,
                 ref TurretCooldown cd,
                 in LocalTransform t)
    {
        cd.TimeLeft -= Dt;
        if (cd.TimeLeft > 0) return;
        cd.TimeLeft = cd.Interval;

        // Record the spawn; ECB plays back next frame.
        var bullet = Ecb.Instantiate(chunkIndex, Prefab);
        Ecb.SetComponent(chunkIndex, bullet, LocalTransform.FromPosition(t.Position));
    }
}