Exercise 1 — The Bouncing Ball Rig

What you're building

A working rig with no joints in it.

Hierarchy, a custom attribute, and one clean top node are the entire architecture of a character
rig. Everything you build later in this course is this, with more parts. Starting here means you
meet the structure before the complexity.

Time: 60–75 minutes
New tools: Add Attribute, Set Driven Key, Expression Editor

Part A — the hierarchy

New scene. Windows → Settings/Preferences → Preferences → Settings: linear unit
centimeter, up axis Y.
Create → Polygon Primitives → Sphere. In the Channel Box under polySphere1, set Radius
to 10.
Set the sphere's translateY to 10 so it rests on the grid. Modify → Freeze
Transformations, then Edit → Delete by Type → History. Confirm all channels read 0 and
the ball is still sitting on the grid.
Rename it ball_geo.
Create → NURBS Primitives → Circle. Set its radius to 14 so it rings the ball's footprint.
Freeze transformations, delete history. Rename it MSR.
In the Outliner, click the + next to MSR. Note the MSRShape node beneath it. This is
the transform / shape distinction — the transform holds position, the shape holds the
geometry. ball_geo has one too.
Create → Empty Group, three times. Rename them ball_translate_grp, ball_scale_grp,
ball_rotate_grp.
Parent them into a chain, child first: middle-mouse-drag ball_rotate_grp onto
ball_scale_grp; that pair onto ball_translate_grp; that onto MSR. Then parent ball_geo
under ball_rotate_grp.
Outliner check: exactly one top-level node besides the default cameras. If there are two,
fix it now. This check happens on every assignment for the rest of the semester.

Part B — the squash pivot

Select ball_scale_grp. Press D (or Insert) to enter pivot-edit mode. Hold V and snap
the pivot to the bottom vertex of the ball. Press D again to exit.
Test: set ball_scale_grp.scaleY to 0.5. The ball should flatten against the grid, not sink
through it. Set it back to 1. A squash pivots at the contact point.

Part C — the squashStretch attribute

Select MSR. Modify → Add Attribute. Long name squashStretch, Data Type Float,
Minimum -10, Maximum 10, Default 0. Add.
Key → Set Driven Key → Set... Select MSR, click Load Driver. Select
ball_scale_grp, click Load Driven.
In the driver list highlight squashStretch. In the driven list highlight scaleX, scaleY,
and scaleZ together.
With squashStretch at 0 and scale at 1, 1, 1, click Key.
Set squashStretch to 10. Set ball_scale_grp scale to 1.35, 0.5, 1.35. Click
Key.
(Perfect volume preservation would be 1.414. Animators usually don't want it perfect — we'll
talk about why.)
Set squashStretch to -10. Set scale to 0.75, 1.8, 0.75. Click Key.
Return squashStretch to 0. Open the Graph Editor, select all driven keys, and set
tangents to Linear so the attribute responds predictably across its range.
Scrub squashStretch from -10 to 10 and confirm the ball squashes against the ground and
stretches upward from it.

Part D — one job per node

Try this, then undo it. Rotate ball_scale_grp 45° in Z, then drive squashStretch to 10.
The squash now happens on a diagonal. Undo. Note in your submission what this tells you about
why the scale node only scales.
Lock and hide the channels each node has no business owning: on ball_translate_grp lock
rotate and scale; on ball_scale_grp lock translate and rotate; on ball_rotate_grp lock
translate and scale. (Right-click the channel → Lock and Hide Selected.)
Select MSR. In the Attribute Editor → Display → Drawing Overrides, enable overrides and
set a color. Controls are color-coded from now on.
Select MSR and move, rotate, and scale it. The entire rig follows. Return all channels to 0.
Save as ball_rig_v01.ma.

Part E — roll without slipping

The math: one full revolution carries the ball a distance equal to its circumference, 2πr.
So degrees of rotation = (distance travelled ÷ 2πr) × 360.

Windows → Animation Editors → Expression Editor. New expression:

ball_rotate_grp.rotateX = -(MSR.translateZ / (2 * 3.14159 * 10)) * 360;

Animate MSR.translateZ from 0 to 200 over 48 frames and playblast. If the ball rolls
backward, flip the sign.
Now scale MSR to 2. The ball slips. The expression still divides by a radius of 10, but
the ball's radius in the world is now 20 — and a bigger ball has a bigger circumference, so it
needs fewer degrees to cover the same ground.
Fix it by scaling the radius term along with the rig. All three axes of MSR scale together,
so any one of them works:
```
ball_rotate_grp.rotateX = -(MSR.translateZ / (2 * 3.14159 * 10 * MSR.scaleX)) * 360;
```
Scale MSR to 2, then 0.5, and roll it again. No slipping at any size.
Note the general point in your submission: the fragile thing was not the rig, it was the
hardcoded dimension. Any number you type into a rig that describes a length has to either
scale with the rig or be derived from something that does. You will meet this again in Week 9.

Submit

ball_rig_v01.ma
A playblast of the ball rolling at least 200 units with the squash attribute in use
Two short notes: what step 20 told you, and the general point from step 31

What you're graded on


One top-level node in the Outliner
All `MSR` channels read 0 with the ball in its rest position
`squashStretch` moves smoothly from -10 to 10 with no popping
Squash flattens against the grid, not through it
Locked channels on all three intermediate groups
Roll expression works at `MSR` scale 0.5, 1, and 2
Both written notes present

Common mistakes

Pivot left at the ball's center, so the squash sinks through the floor
Freeze Transformations skipped on the NURBS circle, so MSR channels don't read 0
Driven keys set on the wrong node — usually ball_geo instead of ball_scale_grp
Expression sign flipped, so the ball rolls the wrong way