Unit — Transforms

01why

State the component-grouping rule this module establishes, and how it relates to Module 1's density rule.

1. aOne concept per component, always
2. bOne access-pattern per component — Module 1 says don't store data systems don't read, and the corollary is don't split data that is always read together, since splitting multiplies memory streams without reducing bytes
3. cGroup components to minimize archetype count
4. dAlways prefer fewer, larger components

02how

Give both arguments against storing a 4x4 matrix in LocalTransform.

1. aIt's slower to write, and it uses managed memory
2. bSize — 64 bytes versus 32 for TRS with uniform scale, doubling the most universally present component in the world; and interpolation — component-wise blending of rotation matrices produces something that isn't a rotation, while quaternions blend correctly
3. cMatrices can't represent rotation, and they aren't Burst-compatible
4. dIt breaks the hierarchy, and the GPU rejects it

03why

Why does non-uniform scale live in a separate optional component rather than in LocalTransform?

1. aTo save two floats in the common case only
2. bNon-uniform scale doesn't compose cleanly through a rotated hierarchy — scale a parent non-uniformly and rotate a child and the shape shears, which forces a full matrix at that point; the mathematics pushes it out, not a design preference
3. cIt is deprecated
4. dBecause the quaternion already encodes scale

04why

What did every performance claim in Modules 1 through 4 depend on, and what does a parent link do to it?

1. aBurst compilation; a parent link disables it
2. bOrder-independence — entity 7's data not depending on entity 6's is why chunk iteration parallelizes at all. A parent link makes a child's world transform a function of its parent's result, converting independent data into a dependency graph
3. cChunk contiguity; a parent link fragments chunks
4. dThe 16 KB chunk size; a parent link changes it

05why

Why can't a clever chunk layout remove the top-down ordering constraint?

1. aChunks are immutable once allocated
2. bThe dependency is between entities, not between chunks — a child literally requires its parent's world transform as input, so no arrangement of memory changes what must be computed first
3. cBecause chunks are processed in creation order
4. dIt could, but Unity hasn't implemented it

06how

Within a single depth level, what happens to the independence property?

1. aIt's still lost — everything in a hierarchy is serialized
2. bIt returns — two entities at the same depth with different parents don't depend on each other, so each level parallelizes freely and the barrier sits only between levels
3. cIt depends on whether they share a chunk
4. dIt returns only for leaf nodes

07how

Name the three separate costs a hierarchy imposes and when each is paid.

1. aMemory, bandwidth and latency, all paid at load
2. bArchetype fragmentation paid permanently in chunk density, a structural change paid per reparent, and a sync barrier per depth level paid every frame
3. cCompilation, allocation and serialization, all paid at build time
4. dThere is only one cost: the per-frame composition

08why

Why is the relationship stored twice — Parent on the child and a Child buffer on the parent?

1. aFor redundancy in case one is corrupted
2. bParent points up but the transform system must walk down; with only upward links, finding a parent's children requires scanning every entity per parent, which is quadratic per frame
3. cThe Child buffer is a debug-only feature
4. dTo support entities with multiple parents

09why

Setting Parent and immediately reading world position gives the old position. Which earlier mechanism is this the same pattern as?

1. aBurst compilation being deferred to first call
2. bThe ECB from Module 2 — the system that maintains consistency runs at a scheduled point in the frame, not at the moment you express intent, so effects are deferred to a defined time
3. cBlob asset immutability
4. dChunk allocation being lazy

10why

Lesson 1 argues against storing a matrix. Lesson 4 stores one in LocalToWorld. Why isn't this a contradiction?

1. aLocalToWorld is compressed
2. bInput versus output — LocalTransform is authored, written by gameplay and needs the interpolatable decomposed form; LocalToWorld is derived, written by the transform system, consumed as a matrix, and never interpolated because it's recomputed each frame
3. cThe contradiction is real and LocalToWorld is a legacy component
4. dLocalToWorld only exists on root entities

11how

Why cache the composed matrix instead of having each consumer compute it?

1. aConsumers can't access the parent chain
2. bHigh fan-out — rendering, culling, physics, spatial queries, audio and gameplay all ask where an entity is, and each would walk the parent chain to the root, so depth-5 entities cost five reads and five compositions per consumer per frame
3. cMatrix multiplication is not Burst-compatible
4. dTo keep the transform system's queries small

12why

A system writes LocalToWorld to move an entity. It works when the system runs late in the frame and does nothing when it runs early. Diagnose.

1. aA race condition in the transform system
2. bLocalToWorld is derived data recomputed from LocalTransform and the parent chain every frame; writing the output of a function doesn't change the function. Running after the transform system means the write survives to the next update, running before means it's overwritten immediately
3. cThe entity's archetype is wrong
4. dBurst is reordering the writes

13why

Decode the full TransformUsageFlags table from one principle. What is the principle?

1. aFewer components is always better
2. bDerived data needs inputs, and no inputs means no work — None has neither component and no spatial existence, Renderable has LocalToWorld alone so nothing can be derived, Dynamic has both so one composition per frame, and a parented entity adds ordering by depth
3. cStatic entities are cheaper than dynamic ones
4. dRendering requires a matrix

14howmeasure

Ten thousand entities flat versus ten thousand in chains 16 deep. What did you measure?

15why

A colleague proposes nesting a thousand props under an empty organizational root 'for tidiness'. Give the complete objection.

1. aIt's fine — organizational roots are stripped at bake time
2. bIt adds a Parent component to a thousand entities (archetype fragmentation, permanent) and a depth level (a barrier every frame, forever) in exchange for no spatial relationship, since the props don't move with it — the authoring model's habits leaking into a runtime model optimized against them
3. cIt would exceed the maximum hierarchy depth
4. dThe only cost is a small increase in memory