In computer graphics, a character rig refers to the group of joints and controls
that allow you to pose a character for animation.
When designed and built carefully, a good rig can make an animator’s life quicker and easier.
Conversely, a bad rig can lead to frustration, as animators find themselves fighting against it
rather than working with it.
In fact, the difference in animating the same sequence with one versus the other
can be a matter of hours, days, or even weeks.
Rigging is a very non-standard process. There is no such thing as a “one rig fits all” solution.
The type of rig you build will depend largely on the types of motion
your character is expected to perform, as well as the production pipeline it has to comply to.
For example, biped rigs differ from quadruped rigs,
or custom rigs may be needed to animate wings or tentacles.
In this set of movies, we’ll show you how to build a robust base rig for a typical bipedal character
that you can use, and reuse, in future productions.
However, before we do that, let’s take a closer look at some of the common pitfalls
that can befall less experienced character riggers.
Here is a fairly typical base character rig.
As you can see, it includes Forward and Inverse Kinematics controls for the arms…
…legs…
…and torso.
The first thing you’ll notice when manipulating any of these controls
is that the primary skeleton is already skinned to our character’s geometry.
However, calculating smooth skin is a highly system-intensive process
that can impact interactive performance in your scene
depending on the resolution of your character.
In this case, our character has a lower resolution than what you would expect in, say,
a big budget movie, so this is less of a concern here.
However, if you were to put several of them into a scene at once,
your interactive performance would still slow considerably.
Since an animator’s job is to achieve detailed and subtle motions
that depend on rhythm and pacing,
it is crucial for them to have as close to real-time performance as possible.
Thus, to address this, many riggers build a much lighter “character proxy rig”.
Rather than being skinned, the geometry is cut into pieces and parented to the bones
to give a rough sense of the character’s deformation and volume proportions.
An animator can then animate using the much faster proxy,
and later apply those animations back to their fully skinned rig
when ready for later stages of their production, such as simulation and rendering.
You’ll also notice that our character rig was built using a single skeleton
with every joint connected to the root.
Whether you work with a full skeleton or not will depend largely on the purpose of the rig
for example, games vs movies,
the dependencies of the system
for example, an attached physics engine,
and the specifications outlined by your technical director.
That said, when possible,
it can often be quite useful to organize your rig in a more modular setup.
This way, you can isolate specific body parts for troubleshooting
as well as re-use them on another character at a later time.
Next, let’s look at the IK/FK controls.
Notice that the rig can look a little confusing
when we have to view both sets of controls at the same time.
Even with the color coordination, there is so much visual information being thrown at the animator.
Sure, we can use the Layer Editor to toggle the controls off and on,
but doing that all the time can quickly become tedious.
Ideally, our rig should really hide the IK controls automatically
as soon as we enter FK mode and vice versa.
While still providing the option to display all the controls for those who prefer it this way.
Next, let’s look at our joints and controls themselves.
Notice how all FK controls are parented into the corresponding FK joint structure.
While this parenting does allow us to move the arm as we’d expect,
introducing an extra transform node in our joint structure
can cause unpredictable rotation space issues.
That’s why we’d prefer to strip out these controls’ transform nodes
and parent their shapes directly to the FK joints themselves.
By selecting any of the FK controls,
you can also see that all their attributes, like Translate and Scale, are visible.
However, the rigger never intended for us to actually use these attributes.
As you can see, modifying them actually breaks the rig.
In general, riggers should really lock and hide any and all attributes and nodes
that we don’t want the animator accidentally manipulating.
The next thing to take note of is that all our FK control attributes are not correctly frozen.
For example, the shoulder’s default state has a non-zero Rotate Y value.
This means that it will be hard to return the rig to its original bind state.
You’ll have to remember this value specifically.
In fact, if we try to simply rotate the arm down to her side, all three rotation values are affected.
This will become even more apparent if we switch to "Gimbal" rotation mode.
Most animators prefer using Gimbal mode
to keep rotations consistent and on-axis,
On-axis rotations make working in the Animation Graph Editor a lot simpler,
since it greatly reduces the number of rotation curves when the character performs an action.
Gimbal mode also helps you avoid flipped rotations as a result of under-the-hood math.
But notice now that our shoulder control’s axis is no longer in-line with the body.
This highlights a problem with the local rotation axes
and is also the reason that our shoulder FK control has non-zero default values.
As a result, it will be very difficult, bordering impossible, to achieve natural looking movement.
Staying in Gimbal mode, let’s try to bend the arm at the elbow.
While we can still twist the arm, we’ve lost the ability to turn it up and down.
By rotating 90 degrees, we've ended up in a situation where one axis is right on top of another.
This is a problem known as “Gimbal Lock”
and is caused by the rotation order of this control and joint.
In any 3D application, rotations must be handled one axis at a time in a specified order,
as different orders can produce completely different results.
While impossible to eliminate completely,
you can mitigate this problem with well thought out rotation orders
that take care of all the most common cases on a limb-by-limb bases.
Moving to the hand, note how we have individual FK controls for every finger.
This can be a little overkill and tedious to animate.
Just imagine trying to fold the hand into a fist like this.
As a result, many animators prefer to have custom attributes to control the fingers instead .
Turning our attention from the hand to the foot, imagine trying to animate a simple walk cycle.
Because the foot IK control’s pivot is at the ankle, and not at the ball or toe,
we’d have to continually raise and rotate the foot for each keyframe.
Again this would make a tedious and choppy process for the animator.
Instead, a rig should provide them with custom attributes to control the foot’s range of motion
like foot roll and toe lift.
Taking a look at the body as a whole,
notice that if we try to rotate the shoulder control, the head goes with it.
Same for the FK arm.
This is because those appendages exist within the shoulders' local space.
However, what if the animator wanted to keep them straight?
They’d have to readjust these controls each time the shoulders moved
In a proper rig, the appendages can move in spaces relative to other parts of the body,
to eliminate the need for such readjustments.
Next, look at what happens if we pull any of the IK controls
beyond their maximum length.
They stop following along.
This is because the joints are a fixed length.
However, in many cases it would be better to allow the joints to stretch
to meet the control requirements.
This gives your character a squash and stretch property that is not only easier to work with,
but also allows it to meet certain poses, as well as add dynamism and and realism.
Secondly, notice that if we switch back and forth from FK to IK,
the geometry snaps from one position to the other.
While this is expected, given that the IK and FK are driven by two different sets of joints,
imagine trying to keyframe an animation that required a switch from one to the other.
You’d have to try and pose the IK arm to match the position of the FK arm manually.
Now imagine having to do this every time you wanted to switch modes.
That’s a lot of hours you’re losing to such a rudimentary task.
Thus, it’s practically essential to provide some sort of tool
that can automatically match IK joints to FK joints and vice versa.
Finally, notice that we cannot manipulate this rig at its basest level.
The rig falls apart when attempting to translate, rotate, or scale the root node.
This is happening because Maya is performing a number of double transformations,
first on the joints which affect the geometry, then again on the geometry itself.
That means if an animator needed to adapt this rig to a new scene,
he or she would have to tweak all of the individual controls
just to have it line up in its default stance.
Combining all these factors together,
attempting to animate this rig in a scene would be a nightmare.
However, just by being aware of the problems with it,
you can make better decisions when designing your own rigs.
In the movies to follow,
we’ll show you how to build a rig that solves each of these issues.