ecs-fundamentals-transformusageflags

TransformUsageFlags — Senior Patterns

Every GetEntity() call in a Baker<T> takes a TransformUsageFlags. The choice is silent — pick wrong, no exception, just wrong behavior or wasted memory. At small scale it doesn't matter; at thousands of entities, it's the difference between a clean archetype layout and chunks bloated with LocalTransform and Parent components on entities that never move.

Intent

Make the transform-component footprint of each baked entity exactly match its runtime needs — no more, no less — so TransformSystemGroup only processes the entities that actually need processing.

Use when

• Writing any Baker<T> — every GetEntity() requires a flag choice. There is no "default" the system picks for you.
• Auditing archetype memory: oversized chunks frequently trace back to unnecessary TransformUsageFlags.Dynamic on config or tag entities.
• Designing a custom transform-driving system that overrides the default math.
• Reviewing a Baker — flag selection is a code-review item, not a "looks fine" detail.

Avoid when

There is no "avoid" case — the choice is mandatory at every GetEntity(). The skill is picking the right value, not deciding whether to pick at all.

The four values, at senior level

Flag	Components baked	When
None	No LocalTransform, no LocalToWorld, no Parent	Config singletons, registries, manager entities, anything without a world position
Renderable	LocalToWorld only	Static visuals — rendered in world space but never move or reparent at runtime
Dynamic	Full transform set (LocalTransform + LocalToWorld + Parent plumbing as needed)	Anything that moves, rotates, scales, or reparents at runtime
ManualOverride	None baked by the system — you opt out of the default transform stack and own LocalToWorld writes yourself	Custom transform systems, GPU-driven instancing, special-case math

Senior pattern — picking the flag

public class EnemyAuthoring : MonoBehaviour
{
    public float Speed;

    class Baker : Baker<EnemyAuthoring>
    {
        public override void Bake(EnemyAuthoring a)
        {
            // Enemies move — Dynamic.
            var e = GetEntity(TransformUsageFlags.Dynamic);
            AddComponent(e, new EnemyTag());
            AddComponent(e, new MoveSpeed { Value = a.Speed });
        }
    }
}

public class GameConfigAuthoring : MonoBehaviour
{
    public float Gravity;

    class Baker : Baker<GameConfigAuthoring>
    {
        public override void Bake(GameConfigAuthoring a)
        {
            // Config singleton — no position, no transform components.
            var e = GetEntity(TransformUsageFlags.None);
            AddComponent(e, new GameConfig { Gravity = a.Gravity });
        }
    }
}

public class StaticDecorationAuthoring : MonoBehaviour
{
    class Baker : Baker<StaticDecorationAuthoring>
    {
        public override void Bake(StaticDecorationAuthoring a)
        {
            // Rendered in world space, never moves — Renderable.
            var e = GetEntity(TransformUsageFlags.Renderable);
            // ...
        }
    }
}