|
Features

Giving
Life to Ratchet & Clank:
Enabling Complex Character Animations by Streamlining Processes
At
first, we were thrilled. As character animators, we couldn't have
asked for a better project. There were two heroes, dozens of enemies,
scores of NPCs, and more than 100 character-driven cutscenes. Enthusiasm
and artistic latitude made it all ours for the taking.
But
staying true to our shared vision of Ratchet & Clank
meant that our digital actors needed to become more than mere cycling
automatons. We regarded each character as an intermediary through
which we could reach out to players and draw them deeper into our
universe. This meant our characters needed to blend physically into
their environments, emotionally into their situations, and expressively
into our narrative. It was on these principles that we based both
our objectives and our standard of success.
Our
team acknowledged that a rift existed between the level of complexity
we desired and the time we had scheduled to implement it. In order
to surmount this obstacle, we developed several methods for using
Maya, our artistic skills, and our time more effectively.
This
article will discuss these methods both in terms of their functionality
and their implementation. To this end, it will provide technical
details on our testing practices, our MEL shortcuts, and our real-time
animation procedures.
Furthermore,
it will explain how each of these methods saved us valuable production
time, enabling us to achieve our artistic goals.
Testing
with Prototypes: Why and How
Part
of achieving our goal of tying our characters closely to their environments
and gameplay meant prototyping low-resolution versions of our characters
and their respective animations. Like coalmine canaries, we sent
proto-models into our new levels to nose out potential animation,
programming, and design problems. We relied on prototyping throughout
the course of our production as a means of refining a character's
move set. This process of refinement was key to winnowing down unworkable
ideas before animating a character's high-resolution incarnation.
As
a rule, our prototypes emphasized function over style. And although
we set the aesthetic threshold low, these previsualization models
still needed to be built and animated accurately enough to function
as valid test cases. For the animators, this meant that prototype
characters needed to jump to their correct heights, attack to their
design specifications, and run at their proper speeds.
Generally,
we created prototypes using a character design sketch as a guide.
These proto-characters were constructed with primitive objects and
only roughly resembled their future incarnations, as you can see
in Figure 1. Since previsualization models were so simple
to construct, every animator could assist in building them, regardless
of their modeling experience. Accuracy was required only in the
representation of the character's height, proportions, and posture.
For
the most part, our prototypes had extremely simple skeletons: all
geometric components were assigned to a single bone with no special
deformation. Though such simplicity made for blocky-looking models,
in practice our animators had all the flexibility they needed to
test out a move set.
Animating
our proto-characters was similar to sketching a traditional pencil
test. Although animators were given a designer-approved move set,
it was understood that animations needed only to be rendered into
their roughest forms. One pass was often sufficient, as polish and
overlap were unnecessary.
The
areas where precision did count were timing, measurement, and interaction
with other characters. As they have the greatest direct impact on
gameplay, these attributes were considered critical to testing a
new character's behavior accurately.
Timing
has a major effect on both the readability of an animation and on
gameplay. From a distance, a poorly timed idle can look muddy. An
attack animation can be too slow to make an enemy a worthy opponent,
or too fast to be registered. Emphasis or a lack thereof on just
a few frames can make or break any animation, especially within
the short cycles of the real-time universe we were creating. We
discovered that by testing and fine-tuning our timings in the prototype
stage, we could often avoid reworking polished animations on final
characters.
Making
sure that proto-characters adhered to design measurements was also
important. For example, if the design document called for an enemy
to attack at a range of 4 meters, animators would ensure that the
prototype did exactly this. Designers could then get an accurate
idea of whether an enemy traveled at the correct speed, was tuned
to the appropriate difficulty, and was scaled appropriately in relation
to the main characters.
Prototyping
also gave us a means of pretesting character behaviors and interactions.
Whether it was with Ratchet or Clank, with the environment, or with
another character, proto-models provided invaluable early glances
at interactive behavior. For artists, programmers, and designers,
previsualization served to telegraph character behaviors both in
terms of their technical feasibility and their gameplay value.
Ultimately
we found that our previsualization process was beneficial not just
to animators but to our design and programming staff as well. It
gave our programmers a head start on coding gameplay, while designers
could test, tune, and ask for changes at a very early stage, allowing
room for refinements.
Prototyping
saved animators time and energy that otherwise would have been spent
painstakingly modifying or redoing final multi-pass animations.
It provided a relatively simple means for evaluating character behaviors
with respect to their timing, specifications, and interactivity.
Moreover, it provided our animators with a practice run, complete
with feedback, before moving on to a high-resolution character (Figure
2).
MEL
Shortcuts: Automating Our Setups
Maya
Embedded Language (MEL) scripts were essential for bridging the
gap between the level of complexity we desired and the time we had
scheduled to implement it. Through MEL scripts, we were able to
streamline setup operations, customize animation processes, and
level our technological playing field.
Two
such scripts (examined later in this article) allowed our team to
take advantage of driven key functionality that otherwise would
have been too cumbersome to animate or too tedious to rig by hand.
Another tool enabled our artists, regardless of technical experience,
to fit characters with IK systems automatically.
Most
of our bipedal characters had leg setups like the one pictured in
Figure 3. As seen in the hierarchy (Figure 4) our
legs had standard hip, knee, and ankle joints, a heel joint, and
two to three bones in the feet. (For clarity purposes, please note
that we referred to our foot bones as "toes.")
Our
IK-rig consisted of three to four RP (Rotate Plane) IK-handles.
These connected hip-to-ankle, ankle-to-toe, toe-to-toe and/or toe-to-null.
All were configured into a hierarchy (Figure 5) that specified
relationships between the IK-handles, a set of locators, and several
NURBS constraint objects.
Though
relatively simple, setting this IK-system up by hand for every NPC,
enemy, and prototype would have taken more time than we had. Moreover,
we knew that this time would be better spent bringing our characters
to life.
An
actual tools programmer might scoff at the artist-authored MEL script
we developed to make our leg chains. In the end, however, our "IK
Setup Tool" reduced an hourlong technical chore to a simple
task that took seconds. Furthermore, the script did not require
setup expertise, and our relatively simple code could be customized
and refined entirely from within the art department.
Using
the IK Setup Tool (Figure 6) was a three-step process. First,
an artist checked their characters' leg joint names against the
tool's presets, making any necessary changes. Next, a scale factor
for the constraint objects was entered, based loosely on a character's
size. The artist then hit nine buttons in sequence. These buttons
would auto-attach the IK handles and instantly build the constraint
hierarchy.
|