Tip:
Highlight text to annotate it
X
In the previous video, we created point cache files for our zombie in Face Robot
and then applied them to a matching head and its parts in Softimage.
In this video, we'll continue from this point and cover two ways
in which you can use this cache-driven head with a rigged character in Softimage:
Either constrain this head to the zombie's headless body,
or use it to drive only the head of the full zombie using the Cage deformer.
We'll start with the constraint method.
Open the FR11_Start_Constraint scene, which contains the zombie's separated head and body.
The body, head, and face parts are all in the same model, with the face parts as children of the head.
The head and its parts are driven by cache files,
And the body geometry is enveloped (or skinned) to this skeleton-like hierarchy of nulls.
We'll constrain the head geometry to the neck null in this skeleton hierarchy.
This method is quick to set up and allows you to continue updating the cache files from Face Robot on the head
while seeing the results on the full zombie character.
The head will stay as a separate object so that its points match what's stored in the cache files.
We'll use a Pose constraint, which links the translation, orientation, and scaling of one object
to that of another object.
Before you constrain the head, it's important to click the Constraint Compensation button,
which maintains the object's current transform values when you constrain it.
Without the compensation, the head's center would snap to the same location as the neck null,
which would move the head up.
At frame 0, select the head geometry, choose Pose from the Constrain menu,
and pick the Neck null as the constraining object.
The head is constrained, but stays in place.
You can see its Position values reflecting the offset between the head's current and original positions.
Make sure to click the Constraint Compensation button again to deactivate it when you're done.
When you use a Pose constraint, you can choose which of the transforms you want to constrain on the Options tab.
For example, if you didn't want to constrain the Scaling, just deselect that option.
Another way of constraining the head is to simply parent it and its parts to the head null.
This gives the same effect as a pose constraint, but a constraint is easier to remove
and doesn't change the character's hierarchy.
You can now animate the zombie's null skeleton and see his head follow along.
The cache files that we currently have on the zombie include the head's translation
from the original mocap files that we applied in Face Robot in part 7 of this series.
Depending on your setup, it may be simpler to have no head translation coming from Face Robot,
and then animate the head as necessary once it's integrated in your character rig.
To address this issue, we created another set of cache files in Face Robot containing no head translation,
to apply onto our zombie's head.
Open the cache manager, and select all the existing cache files at the bottom.
Then click the Delete Sources/Clips button to remove them from the mixer for the head and its parts.
Now you can load the new cache files from the browser.
Make sure that the head and each part matches up with its appropriate cache file.
And then apply the cache files.
With the cache files swapped, you can see that the zombie's head doesn't move around anymore,
but his facial expressions are still the same.
Seeing as the head object is separate from the body,
it can lead to gaps between these two objects when they move or rotate.
You can address that by adjusting the weighting in the neck region of both the head and body objects.
The head isn't enveloped yet, so we need to do that first.
Select the head geometry and choose Envelope > Set Envelope from the Animate menu.
A message appears prompting you to put the Envelope operator in either the Animation region of the stack,
or the Modeling region.
Click Yes to put it in the Animation region, which is typical for using an envelope for character animation.
Pick the Head, Neck, upper spine, and two clavicle nulls to be the envelope deformers.
Then right-click to finish picking.
Accept the defaults in the Automatic Envelope Assignment property page and close it.
With the envelope set for the head, you're ready to start painting weights on its vertices.
Click the Weight Paint Panel icon and select the Zombie_Neck in the deformers list.
Press W to activate the paint tool,
then paint around the neck to make sure that all the vertices below the jaw line are weighted to the neck null.
Make sure that no vertices are weighted to the neck from the jaw up,
or else they will be distorted during animation.
Use a larger brush and right-click to erase them.
Press the Alt key to smooth the weights between the neck and the head.
The bottom part of the neck leading to the collarbone should be weighted to either the neck null,
or divided between the neck, clavicle, and spine nulls.
Select each deformer from the list and paint accordingly.
Select the Zombie_Head deformer and paint over the head area so that the vertices are weighted properly to it.
Then create a smooth weight transition between the head and the neck.
Make sure that there are no vertices weighted to the other deformers in the head area
to avoid distortion during animation.
One last thing to do is to parent the face parts to the head null by dragging them under its node in the explorer.
Parenting all the objects at once is faster than pose-constraining each of them individually to the head null.
Now when you rotate the head null, the rest of the face comes along for the ride.
With these constraints in place, you can now animate the zombie's skeleton to have it move freely around in space.
Let's move on to an alternative way of working with a cache-driven head and a character rig
using the Cage deformer.
Open the FR11_Start_Cage scene, which features our zombie's cache-driven head, as well as a complete zombie.
The full zombie is made of a single mesh enveloped to a hierarchy of nulls,
with the face parts as children of the head null.
We'll use a Cage deformer to drive the head of the fully-rigged zombie using the cache-driven head.
While this method is more computationally intense than a simple pose constraint,
it lets you use a single body mesh for your character
and leaves the head separate for the facial animators to continue working on.
Cage deformers are often used to deform a high-res mesh based on a low-res version, such as for a character.
This deformer uses any object to deform another object, model, group, or point cluster.
In our case, we're going to apply it to a point cluster.
Before you start, make sure that the positions of the separate head and the head on the body match up.
The Cage deformer works by taking the source object's resulting shape at the top of its Modeling stack
as the deformation base shape.
Right now, the Mixer operator that drives the cache files is at the top.
This means that the head's shape changes at every frame, which won't work as the base shape.
So, we need to temporarily disable this operator before we apply the Cage deformer
by right-clicking it and choosing Disable from Here.
This mutes the effect of any operators from this one, going up the stack.
Now we can apply the Cage deformer to the cluster of points on the full zombie
that matches the points on the separate head.
With the head_points cluster selected, choose Deform > by Cage from the Model toolbar,
then select the separate head.
Right-click to finish.
In the Automatic Cage Assignment property editor, deselect the "Use polygon deformer components" option
so that the deformation is driven by the head's points, not its polygons.
We'll set the Strength to 2 so that the points are weighted a little less strongly
to the deformation coming from the cache file.
This is so that the mouth area doesn't distort too much.
Set the Falloff to 0 so that there's no averaging of the weight assignment around the points.
When you're done setting the values, you can right-click and Freeze the Automatic Cage Assignment operator
that's under the point cluster's Envelope_Weights property.
If you don't freeze this operator, the playback speed can be affected.
Now you can bring life back to our zombie by right-clicking the Mixer operator and choosing "Enable from Here".
Hide the original head and its parts,
then scrub the timeline to see the animation from the cache file driving the head points on the body.
If you update the cache files and reapply them to the original head,
the changes are automatically fed to the Cage deformer.
You can see that only the head geometry is deforming right now, which looks a bit odd.
We need to have the rest of our zombie's face follow along.
Since the geometry of the eyeballs, teeth, and tongue match what's stored in the cache files,
you can simply apply the cache files to these parts.
The weights around the mouth may need a bit of adjusting
if there are any vertices that are displaced from the Cage deformer.
Select the Envelope Weights property under the head_points cluster to paint on its vertices.
Activate the Weight Paint tool, and smooth out the weights where necessary.
You can now animate the zombie's skeleton to have it move freely around in space.
The Cage deformer can still drive the face's deformations,
while the envelope controls the whole character's deformation according to the skeleton's animation.
This is because the Envelope operator is above the Cage Deform operator in the body's construction stack,
which means that it gets evaluated last.
Even though our zombie will live on forever, this video wraps up the Face Robot Basic Workflow series
that covered the complete process from creating the initial Face Robot rig, to exporting its resulting animation.
We hope you enjoyed this series, and will continue on with your own Face Robot adventures!