Checkpoint — LocalToWorld & derived data

01why

Lesson 1 argued against storing a matrix; lesson 4 stores one. Resolve the apparent contradiction.

1. aLesson 4 supersedes lesson 1
2. bThey have opposite roles — LocalTransform is input, authored and written by gameplay, and needs the decomposed interpolatable form; LocalToWorld is output, computed by the transform system and consumed as a matrix, and nobody interpolates it
3. cThe matrix is only stored in debug builds
4. dLocalToWorld is stored as TRS internally

02how

Why store the composed matrix at all rather than having consumers compute it on demand?

1. aConsumers lack access to the parent chain
2. bFan-out — rendering, culling, physics, spatial queries, audio and gameplay all ask where an entity is; each computing it would walk the parent chain to the root, so an entity at depth 5 costs five reads and five compositions per consumer per frame
3. cComputing a matrix is too slow to do even once
4. dIt is required by the GPU

03why

A system writes LocalToWorld directly to place an entity. Why does this fail?

1. aLocalToWorld is read-only and the write throws
2. bIt is derived data — the transform system recomputes it from LocalTransform and the parent chain every frame, so the write is overwritten by the value the actual inputs imply. You wrote to the output of a function and expected the function to change
3. cThe write succeeds but is not replicated to the GPU
4. dMatrix writes require a command buffer

04why

Why does that same bug sometimes present as 'nothing happens' and sometimes as 'it flickers'?

1. aIt depends on the entity's archetype
2. bSystem ordering — running before the transform system means the write is overwritten immediately, running after means it survives until next frame's update; same bug, two symptoms determined by where your system sits in the frame
3. cFlickering only occurs in builds
4. dIt depends on whether Burst is enabled

05why

An entity carries LocalToWorld but no LocalTransform and no Parent. What does the transform system do with it, and why is this useful?

1. aIt errors, since LocalToWorld requires LocalTransform
2. bNothing — there are no inputs to derive from, so the entity isn't in any transform query. Its matrix stays as baked, which is exactly right for something that must be placed for rendering but never moves
3. cIt generates a default LocalTransform automatically
4. dIt removes LocalToWorld as orphaned data

06how

Decode TransformUsageFlags.Dynamic in terms of this module.

1. aIt marks the entity as physics-enabled
2. bIt adds both LocalTransform and LocalToWorld — inputs plus derived output — so the entity costs one composition per frame in the transform system
3. cIt adds only LocalToWorld
4. dIt enables non-uniform scale