Stockmoves Tutorials
Chapter 2 - SoftImage Connection Advanced Techniques -

In this chapter we're going to make you more familiar with some advanced techniques on setting up skeleton structures. Some of these techniques you might already be familiar with because they can also be used in skeletons that are built for keyframe animation. We are showing you here how these skeletons can also be used in conjunction with Stockmoves data.

2.1 Creating Offsets

What we demonstrated in the previous tutorial was how to directly constrain your skeleton to the Stockmoves data. However, in most cases you may want some kind of offset control built in. What this allows you to do, for example, is make an arm bend more or less to prevent it from penetrating other body parts. This is especially useful if your character has drastically different proportions compared to a normal human.

You can do this for all of the different elements, or just for a couple (like the arms). It depends on how much control you want or need.

The whole idea is that instead of directly constraining the skeleton to the Stockmoves element, we parent a null under the Stockmoves element and then constrain the skeleton element to that null. Then we can use that null to have overriding offset control. Let's get started.

Just like in the previous tutorial, we have our Stockmoves data in yellow and our (default) skeleton in blue loaded up in a single scene. We're going to use the offset technique on the left upper arm, forearm, and hand.

We will start by getting three null objects (green) which will be used as the offset controls.

The three offset nulls ready for action

Now make the first null the child of the upper arm.

Parenting the first offset null

Make the second null the child of the forearm.

Parenting the second offset null

And make the third null the child of the hand.

Parenting the third offset null

Translate the nulls into a more comfortable place. The best method is to place them next to the bone they are parented to, but outside of the character so you can still easily pick them if needed. Also, set all of the rotations of the null objects to 0,0,0 so that they line up with the Stockmoves elements they are parented to.

This is what you should end up with:

Offset nulls parented, positioned and rotated correctly

The next step we will have to do is orientation or rotation constrain the skeleton elements for the upper arm, forearm and hand to the three corresponding nulls that we just created. The colour coding in the next three pictures is the same as in the previous tutorial. Constrain the white element to the red one.

Constraining the skeleton to the offset nulls

Select the first null and rotate it. It should now control the rotation of the upper arm skeleton element. Do the same for the second null which controls the forearm and the third null which controls the hand.

Offsets used
play movie (mpg - 145 kb)

Hit the play button and watch how the arm is still moving like it's supposed to, but it gets the offset added to it. The really cool thing is that this technique allows an animator to have overriding keyframe control that goes on top of the Stockmoves Data.

One thing you may have noticed in the MPEG is that we forgot the collar bone movement. We could do the same as in the basic tutorial (position constraint the root of the upper arm to the upper arm element of the Stockmoves data), but we can also introduce an offset in here.

We could choose to use another null object for that. However, we could also use the first null (the one that's controlling the upper arm rotation at the moment). In order to do this, first select that null and position it roughly to the place where the arm is connected to the shoulder.

Repositioning the first offset null

Now constrain the root of the upper arm of the skeleton to the null that we just repositioned (again colour coded white and red).

Parenting the shoulder

This is what we end up with:

The results

Now go ahead and translate the first null to displace the arm from the body (ouch!). Play the animation to see that the arm keeps the same distance throughout the whole animation.

The resulting animation with offset.
play movie (mpg - 145 kb)

Imagine a really bulky character with a huge chest. With this technique you could make his shoulders as wide as you would want.

2.2 Scaling joints

If your character has different proportions compared to the normal humanoid proportions of the Stockmoves skeleton you can easily scale the joints of your constrained skeleton. If you introduced offset nulls in your setup (mentioned in the previous section), you can come up with virtually any proportions you want.

In extreme cases you may need to fiddle around with some of the offsets to prevent body parts from colliding. Here are two examples that show what can be accomplished.

A chubby, dwarf-like skeleton play movie (mpg - 145 kb)

A tall alien character play movie (mpg - 145 kb)

2.3 Dual bone forearm setup

A common problem that arises, especially with humanoid characters, is the deforming of the skin in the forearm area. When the arm bends, or when the hand bends at the wrist, there is a tight area where the actual bend occurs. But when the arm twists it happens gradually along the length of the whole forearm.

There are several techniques for addressing that. They all consist of using not one but two bones for the forearm. One of these bones is used for making the arm bend and the other is solely used for twisting motions.

The arm towards the back has a conventional two bone setup; one for the upper arm (red) and one for the forearm (yellow). The bone in the front has a three bone setup; one for the upper arm (red), one for the bending of the forearm (yellow), and one for the twisting of the forearm (orange).

The two bone setup was the one that was shown in the previous tutorials. The three bone setup can also be used with Stockmoves data, but it takes a little bit more work. What you need to do is link the bending motion of the Stockmoves forearm element to the first forearm skeleton element (yellow in the picture) and link the twisting motion of the Stockmoves forearm element to the second forearm skeleton element (orange in the picture).

This could also be easily be done using expressions. Consult your 3D package manual for the correct way to write expressions. Some other programs also have other ways that can accomplish this. Either by orientation or rotation constraining just one axis or by using a "link with" functionality. Once again consult your 3D package manual for this

2.4 Multi bone spine setups

Spines are an area where people tend to use different kind of setups. Some people like a basic setup with two bones (like with the Stockmoves data), others like to do a setup of three, four, or more bones.  Another method is using two or more bones which aren't even connected in a chain to allow for some squash or stretch motion in the belly area. All of these setups can be used with Stockmoves.

If you like to use a "flexible spine solution" with a high resolution spine chain controlled by a spline, we will explain that in the next section.

We'll do a three bone spine as an example but the technique works just as well for any amount of bones. Suppose your spine looks like the blue skeleton in the picture and the two Stockmoves spine elements look like the yellow ones in the picture.

Three bone spine and Stockmoves elements

What we first need to do is bring in nulls for each bone segment of our chain (except for the beginning and end because they already have a root and an effector). In this case we will get two nulls, which are displayed in white in the next picture.

Positioning the nulls

Next we will have to make these nulls children of the closest Stockmoves elements. In this case, the lowest null becomes a child of the lowest Stockmoves element and the highest null will be a child of the highest Stockmoves element.

Parenting the nulls

All we need to do now is position constraint the correct elements. Start by position constraining the root of the skeleton to the lowest Stockmoves element. Then position constraint the effector of the skeleton to Stockmoves neck element (which was not in the pictures up until now). As a last step, position constraint the two bones to the corresponding nulls that we created earlier on.

And there we have it, a moving three bone spine.

The end result
play movie (mpg - 145 kb)

2.5 Flexible spine setups

Representing a human spine with two to four bones is one way of doing it, though another way is by using a control spline which drives a high-resolution skeleton. This method creates a spine which behaves more flexible and more natural.

This technique can be done quite easily in Alias|Wavefront's Maya package by using the "spline IK solver". It's explained quite thoroughly in the manual so I would suggest reading that first and then skipping to the second part of this tutorial for the actual connection to the Stockmoves data.

In Softimage 3D/XSi, it's also possible, but it takes a little bit more work. We'll start by showing you how to do the setup in Softimage and after that we will explain how to do the connection to the Stockmoves data, which is something that can be applied to in both packages.

If you're using 3DMAX or Lightwave, there might be ways to accomplish this by using plugins.....

First of all we will start explaining the flexible spine setup in Softimage. What we first have to do is create a low resolution spline which will act as our spine. Draw a curve (B-spline or Nurbs) similar to the one shown. The Stockmoves spine, neck, and head are shown in yellow as a template, the actual curve is displayed in white.

Drawing the low-res spline

This curve is what we'll be using for controlling our spine. But we need to create a high-resolution skeleton that can be de deformed along this low-res spline. Create a new 2DChain and start drawing from the origin. Turn grid lock on and make each segment three units high. Create eight different segments, or any amount you prefer. You should end up with something like this:

Drawing the hi-res skeleton

Leave grid lock on and draw a curve (B-spline or Nurbs) right on top of the chain and make sure there is a point at the beginning and end of each bone element. You should have something similar to this now:

Drawing the hi-res spline

Now create clusters for each point of the curve (no need for cluster centers). Once you're finished with that you should have nine clusters, each one containing only one point.

Overview of the cluster list after the creation of the clusters

The next thing we need to do is constrain all of the individual bones to the clusters we created so that the skeleton follows the shape of the high-resolution spline when we deform it. Go into the cluster list (while the spline is still selected) by doing Motion>Shape>Cluster List and select the cluster at the top of the spline.

Now select the effector of the chain and do a Motion>Constraint>Object to Cluster. When prompted click on the spline. (It's easier to select it from a schematic view, trust me.)

Now select the spline again and select the next to last cluster (cls7 in this case). Then select the next to last bone and do a Object to Cluster constraint and click the spline when prompted.

Work your way down the whole chain. When you come to the bottom, don't pick the bone but the root of the chain and Object to Cluster constrain that.

To test if it all works, first save the scene and then move some points of the spline around and see if the chain follows.

Testing the clusters constraints

If everything works, be sure to load up your scene again because we need to continue on with the hi-res spline in a straight line.

Next thing we will have to do is make the hi-res spline deform on the low-res spline using a Curve deformation. That way we can use the low-res spline as our control object and we don't need to worry about all the points of the hi-res spline anymore.

To do this, select the hi-res spline and perform a Model>Deformation>By Curve>Node>Create and when prompted pick he low-res spline. It should look kind of weird like this:

The initial result after using the curve deformation

It will look better once we've scaled all the items. Pick the hi-res spline and scale it up in Y until the length matches the low-res spline:

Re-scalingthe hi-res spline

See, it's already starting to look much better.  Now select the skeleton in branch mode (right mouse button) and scale down proportionally in three axes until it also fits.

Re-scaling the skeleton (in branch mode)

Ah, now that's much prettier, isn't it? To test it, select the low-res skeleton and start pulling points around.

Our next task will be connecting the low-res spline to the Stockmoves data. This process is actually quite similar to what we did in the previous section where we connected a three bone spine to the Stockmoves data.

We need two nulls, so get them and position them over the two points sticking out on the low-res spline. (Switch grid snap off if it's still on!)

Bringing in the nulls

Make the lowest null a child of the lowest Stockmoves spine element and make the highest null a child of the highest Stockmoves spine element. After you've done that, select the low-res spline and create clusters for all the points again (you should end up with four single point clusters in this case).

Click Motion>Shape>Cluster list and pick the cluster that's at the top of the spline, just at the base of the neck. Now click Motion>Constraint>Cluster to Object and when prompted click the Stockmoves neck element.

With the low-res spline still selected, once again click Motion>Shape>Cluster list and pick the cluster that's at the bottom of the spline. Now click Motion>Constraint>Cluster to Object again and pick the lowest Stockmoves spine element. Now we have the beginning and end of the spline constrained.

The last two clusters that we have to constrain are the ones right over the blue nulls. Go ahead and select the low-res spline, select one of the clusters, do a Motion>Constraint>Cluster to Object, and when prompted select the corresponding blue null. Repeat for the last cluster.

Nicely done! You should now have a fully operational flexible spine setup. And the beauty is that we can still use these two nulls for extra posing of the spine! Also, as with all other offset nulls we created earlier, we can keyframe them!

Flexible spine play movie (mpg - 145 kb)

Flexible spine with extra offset keys play movie (mpg - 145 kb)

Chapter 3: Importing more Stockmoves data