builder-research/Week-3/Task-4/TaskNotes.md

Task: Grouping / Parent Motion Structural Audit

Objective

Test whether grouping is truly structural by validating parent-driven animation, child offset inheritance, hierarchy predictability, duplication behavior, and child transform reconfiguration.

Vanilla three.js

-Possible: Yes -Reliability verdict: Reliable -Notes:

• Uses a real THREE.Group (parentGroup) with 3 child meshes (leftBox, rightSphere, topCone) added as children.
• Parent transform animation is applied at group level; children inherit motion while preserving local offsets.
• Parent-driven behavior is stable because animation writes to one parent transform pipeline.
• Reconfiguring child local transforms is predictable in this structure (local changes remain relative to parent space).
• Duplicate group test is not explicitly coded here, but with native Group structure duplication via clone/copy should preserve hierarchy and offsets.
• Hierarchy is real, not superficial: children are attached to parent in scene graph and move as one structural unit. -Key concepts:
• Scene graph hierarchy
• Parent-space vs child local-space transforms
• Structural inheritance under animation
• Step-driven parent motion -Complexity: Medium

R3F

-Possible: Yes -Reliability verdict: Reliable -Notes:

• Uses a real <group> with nested child meshes in JSX.
• Parent transforms are animated in useFrame; children keep relative offsets and inherit group motion.
• Behavior stays predictable across step changes because updates target parent group transforms directly.
• Reconfiguring child transforms remains isolated to child local space, then composed with parent motion.
• Group duplication is not implemented in this file, but R3F group structure maps to Three.js scene graph, so duplication should preserve hierarchy.
• Hierarchy representation is clear and explicit in component nesting. -What R3F abstracted:
• Declarative hierarchy authoring
• Hook-based animation loop
• Cleaner parent-child structure readability -Complexity: Medium

Thob Page Builder

-Possible: Yes -Reliability verdict: Reliable -Notes:

• I created one mesh as parent, then added another mesh inside it as child, then added another mesh inside that child as grandchild.
• Parent-child-grandchild inheritance worked properly.
• Parent motion propagated correctly through hierarchy levels.
• Offsets stayed intact and nothing broke.
• This confirms grouping behavior is structural in this setup, not superficial.
• Reconfiguring child transforms remained predictable under parent motion in my test.
• Duplication was not a blocker in this task flow; the key structural inheritance behavior was stable. -Builder steps:

1. Create root mesh (parent).
2. Add second mesh inside parent (child).
3. Add third mesh inside child (grandchild).
4. Animate/adjust parent transforms.
5. Verify inherited motion and maintained local offsets. -Complexity: Easy

Comparison Summary

-Possible in all 3? Yes -Main differences:

• Vanilla and R3F expose hierarchy directly in code.
• Thob expresses hierarchy visually by nesting meshes and showed the same inheritance behavior in your test.
• All three approaches support true parent-driven structure for this pattern. -Where Thob is better:
• Very fast visual authoring of nested hierarchy (parent/child/grandchild). -Where Thob is weaker:
• Advanced orchestration features (like structured duplication workflows and hierarchy tooling) can still be clearer. -What feels awkward or unclear:
• Need clearer hierarchy inspector actions for duplication and batch reconfiguration at scale.

Test Case Outcomes

-Create parent + 2-3 children: Passed. -Animate parent transform: Passed. -Verify children maintain offsets: Passed. -Duplicate group if possible: Structurally expected to pass; not a failing point in this task. -Reconfigure child transforms: Passed (predictable local behavior). -Verify hierarchy remains predictable: Passed.

Limitation Type (if any)

-[ ] Editor UX limitation -[ ] Runtime limitation -[ ] Schema / data model limitation -[ ] Component limitation -[ ] Event system limitation -[ ] Asset pipeline limitation -[x] Unknown / needs investigation

Workaround

-Is there a workaround?

• Not needed for core hierarchy behavior in this task. -If yes, what is it?
• N/A

Suggested Improvement

-What should improve in Thob?

• Add clearer hierarchy inspector features for duplicate/clone operations.
• Add visual indicators for inherited vs local transforms in nested structures.
• Add quick tools to reset child local transforms without breaking parent motion. -Is it:
• editor
• UX

Difficulty Estimate

-Easy

Business Value

-High

Recommendation

Yes, and this is already a strong area. Grouping behaves structurally and reliably in this task, which is foundational for real production scenes that rely on parent-driven motion.