Browse the wiki

02. Rigging the torso

In this lesson, we will focus on creating the rig for the torso.

Introduction

Now that we’ve had a brief overview of what a rig will consist of, let’s actually start creating the rig for our model. We’ll be building the rig up in parts: the torso, the neck and head, the arms, the hands and so on. Through a combination of parenting and constraints, we will then link these parts together. The benefits of this approach is that we can experiment with independent parts of the body without accidentally destroying other parts. It also makes it very easy to do things like space switching (more on this later). Lastly, if later on I find that part of the rig is not behaving as it should, I can go in and fix that region without too much of a knock-on effect on the rest of the rig.

We’ll kick off our rigging conquest with the torso. I like to start with this portion as it creates the framework to which we can attach the neck, the head, the upper limb and the lower limb. The torso that we’ll be creating will be an FK/IK setup, will have independent hip and chest controls, and we’ll also be adding additional joints to simulate breathing and create the illusion that our character has a ribcage.

Throughout the rigging process, we’ll be using a few scripts which you will find in the scripts directory of the Maya project.

001. Referencing the model

 

Let’s start by bringing in the model as a reference. That way, should any changes be made to the model, we can automatically pick them up without having to go hunting for the latest file. To do this, go File > Create Reference (Options). Under the Namespace Options, set the mode to “Use selected namespace as parent and add new namespace string”, and then pop the word “mod” into the box. Then click the Reference button and select the file paul_mod_PUBLISHED.ma, which you should find under /02_PUBLISHED/01_MODELLING_SCULPTING.

With the model in the scene, take the mod:paul_body_mr_geo (the mid-resolution model) and hit Ctrl + D to duplicate it. Then hit Shift + P to bring it out from its current hierarchy, and rename it paul_body_temp_geo. This model will be used for testing whilst we rig, and we will continue to duplicate this model and then chop it up into parts. The chopped up parts will then be parented to the skeleton of the rig so we can quickly evaluate how it is articulating.

Next pop the model paul_body_temp_geo into a new Display Layer and call that layer temp_geo_layer. The last thing to do for now is to save this scene file. Make sure to save it in the 01_WIP/03_RIGGING directory. I actually created a new folder in here called 01_torso and popped the file in there as 01_start. As we create each part of the rig, I’ll be creating a new folder and dropping the latest scene files in there for you to pick up.

002. Straight v s-shaped spine

 

Before we build the actual joint structure for the spine, I just want to explain why I’ll be stepping away from what is anatomically correct here. The human spine, as we’ve already seen, is situated closer to the back than the front of the torso, consists of 24 bones, and is S-shaped. We could mimic this, but as with everything in CG, we should aim at simplifying it to make things easier for both the rigger and the animator. Therefore, straight away we’ll want to reduce the number of joints we’re adding. Next, consider the position of the spine: placing a digital spine closer to the back of the torso doesn’t always yield the best deformation, so I’ll be placing our spine closer to the middle of the torso.

Lastly, what about the S shape? When creating realistic characters, it’s usually advised to follow the natural shape of the spine, and I myself have done this on many occasions and got more than adequate results. For a while, though, I’ve pushed away from this and gone for a straighter spine because it simplifies the process when twisting the character.

With an S-shaped spine, I always found that I had to use two rotational axes to achieve a clean twisting motion (anatomically referred to as left or right rotation) due to the orientation of the joints. With a straight spine, I could handle this with just one axis. And did I lose anything, deformation-wise, by going from the S-shaped to the straight spine? No – or if I did, it was so minute that wasn’t noticeable to my simple eyes.

Again, it all comes to trying things out and evaluating the results. Give yourself time to experiment as you rig and try out different techniques and methods.

003. Creating the FK joint chain

 

Now that you know why we’ll be creating a straight spine, let’s do just that for the FK side of things. To aid in your joint placement, feel free to create a sphere, re-shape it, and pop it into the area where the rib cage would sit. That way, you can use it to guide you on where you should place more joints (the lumbar region) and where you should place fewer joints (the thoracic region).

Switch to the Animation menu (F2) and in the side view, go Skeleton > Joint Tool. Using the LMB, click once in the middle of the torso (in line with the ASIS points) to create the first joint. Then hold the Shift key (allowing you to create a straight joint chain) and LMB-click three more times to go from the root joint up to the bottom of the rib cage. Continuing to hold the Shift key, click again at the middle of the rib cage, and then make a last click at the base of the neck. When you have six joints created, hit Enter on the keyboard to terminate the tool.

If you need to edit the position of any of the joints, remember that you can translate the root joint on any axis (although for the spine, you should not do so in the X-axis as this would de-center it) and you should only use the length of the joint to position any children joints. So far, the length is still being determined by the Translate X attribute.

To rename the joints, we could do so one at a time, but this can be a laborious process. To speed things up, we’ll be using the cometRename tool by Michael Comet (www.comet-cartoons.com). If you have yet to load his tools in, I would recommend you do so now. His tools and scripts are fantastic and will, without a doubt, save you hours if not days.

With the tools now installed on your Menu Bar, go Comet > Tools > cometRename. Select all the joints that need renaming from root to tip, and in the Rename box of the tool, type spine_fk. Leave the Start# at 1 and hit Rename and Number. With the joints still selected, pop _jnt into the Suffix box and hit Add Suffix. Easy peasy.

004. Creating the IK joint chain

 

To create the IK joint chain, select the spineFK1_jnt and hit Ctrl + D. We won’t be working with the FK joint chain now, so select it and then hide it by hitting Ctrl + H. Select all the joints of the duplicated joint chain. In the cometRename tool, type _fk in the Search field and _ik in the Replace field, then hit Search And Replace. We are now going to add more joints to the current IK joint chain as this will yield better results when used in conjunction with the splineIK that we’ll be adding.

To add more joints, we will be using the truly awesome jointSplitter.mel script by Brian Escribano (www.meljunky.com). With this tool, we can add a single joint or multiple joints that will be evenly distributed between two existing joints. For this tool to work, you have to ensure that the joints you wish to apply them to all have unique names within the scene.

Open up the script in a MEL tab in the Script Editor. To execute the script, highlight all the text (Ctrl + A) and hit Enter on the numpad. Alternatively, hit Ctrl + E. A third way is to go Command > Execute. Once you have executed the script, a small GUI should pop up.

Now select spine_ik1_jnt1 and hit Select Start Joint on the GUI. With the Jnt Qty set to 1, hit Split Joints. An additional joint should now be created, sitting perfectly between the two joints. Do the same for select spine_ik2_jnt and for spine3_ik_jnt. For spine_ik4_jnt and spine_ik5_jnt, increase the Jnt Qty to 2 and then hit Split Joints. You now have your IK joint chain.

The next thing to do is correctly rename the joints. To do this, select the joints in order from root to tip. Using the cometRename tool, type spine_ik into the Rename field and hit Rename and Number. Then add the suffix of _jnt. You should now have an IK chain that consists of 13 joints and an FK chain that consists of 6 joints.

005. Adding the spline IK

 

Now go to Skeleton > IK Spline Handle Tool (Options). Reset the settings for the tool and then increase the Number of spans to 2. If you pop your cursor into the 3D viewport, you’ll notice there’s a crosshair present, indicating that you’re in the tool.

Click on the root joint (spine_ik1_jnt) and then click on the joint at the tip (spine_ik13_jnt) of the chain. If you pop into the Outliner, you will notice that you now have an ikHandle1 and a curve. Rename them to spine_ik and spine_crv respectively. Unlike the IK that we explored previously in the Rigging Fundamentals section, with Spline IK, it’s not the IK Handle that’s used to manipulate the joints, but the curve itself. To experiment with this, switch to component mode (F8), select the CVs of the curve and translate them around. Make sure to undo this so you go back to the default state. So, how do we deform the curve that in turn deforms the joints? There are a few ways to do this, such as using clusters, but for this rig, we’re simply going to skin the curve to some joints.

In the side view, use the Joint Tool to create a single joint. Click anywhere in the view but keep it far away from the current joint chain, so it doesn’t automatically parent itself to it. In the Channel Box, increase the Radius of the joint so we can easily pick it out from the rest. We now want to position this joint at the base of the spine. To do this, hold down the V key (Snap to Points) and drag and drop it into place. Rename this joint spine_hip_ik_jnt.

Now duplicate this joint and snap it to the same position as spine_ik7_jnt. Rename this joint spine_mid_ik_jnt. Duplicate this joint one more time and position it at the tip of the IK joint chain. Rename this joint spine_chest_ik_jnt. You should now have three independent joints in place.

Next, select the three new joints and the spine_crv (it’s easier to do this in the Outliner) and go Skin > Smooth Bind (Options). Set Bind to to Selected joints. Leave everything else as it is and hit Bind Skin. You can now use the three new joints to drive the IK spine. Again, if you translate them around, make sure you use the undo to get them back to the default pose.

006. Creating the low-res mesh

 

As you build the rig, you need to test it as thoroughly as possible. What I like to do is chop up the model into slices and parent those slices to the joints. Not only will this allow you to test the rig, but in turn it will create a low-res mesh that the animator can use. As this geometry will be simply parented to the joints, the playback of this rig should be pretty snappy in comparison to a rig that has to calculate the bind information.

There are a few ways to chop up the model, so feel free to use whatever method best suits you. I tend to use a combination of the following techniques depending on the task at hand. Firstly, you can select the faces you’d like to chop off and go Mesh > Extract. Alternatively, you can select some faces and go Edit Mesh > Duplicate (found under the face section). A third option is to simply duplicate the model and delete all the unwanted faces. As you chop up the model though, do think about where the joints are and try to separate the different parts of the mesh to coincide with the placement of the joints.

For the torso, I end up duplicating paul_mr_mod_geo, then deleting unwanted faces from around the arm and hip. I use the Mesh Tools > Cut Faces Tool with the Shift key on the keyboard held down (to create straight cuts), and slice through the geometry horizontally at the same position for every joint. I select the faces of each slice and go Edit > Extract to separate the parts. Next, make sure to select all the sliced parts and go Edit > Delete by Type > History.

You’ll also notice in the Outliner that a few transform nodes are usually created from the extraction process. Sometimes they get deleted when you delete the history; other times, they’ll still be there. Make sure to delete them. You can then parent each relevant piece of geometry under the relevant joint. I really recommend that you go in and rename all the parts. Again, use the jointRename tool and use the same naming convention to match the joints for the geometry. Also add a suffix of _lr_geo to all the pieces.

With the geometry parented to the joints, you should be able to translate the spine_hip_ik_jnt, the spine_mid_ik_jnt or the spine_chest_ik_jnt around and get a good idea of how the character will deform. Remember to undo the joints back to their default positions.

007. Creating the IK controls

 

For each of the IK joints, we’ll create a control. As the controls are intended primarily for translation, I would like to have shapes that resemble a cube. We could create a polygon cube to use as a reference for this, by activating the CV Curve tool and, with the curve angle set to 1, snapping points to the polygon cube to create our cube-like curve. But to speed things up, I’ll simply be creating a cube shape using cometTools. To do this, go Comet > Shapes > cube.

Either way, you should end up with a curve shaped like a cube in the centre of the World space. If your cube is not centered, make sure to pop a value of 0 into all the Translate and Rotate channels, and leave the scale with a uniform value of 1.

Rename this curve to spine_hip_IK_ctrl and then, with the curve selected, hit Ctrl + G twice to create two group nodes above it. Call the top-most node spine_hip_ik_ctrl_offset and the node below spine_hip_ik_ctrl_auto. Select spine_hip_ik_ctrl_offset and then Shift-select spine_hip_ik_jnt. Then hit P to parent spine_hip_ik_ctrl_offset under spine_hip_ik_jnt.

You should now see that there are some values in the translate channels for spine_hip_ik_ctrl_offset, indicating how far away the _offset node is away from the joint. Zero out the translate values on the spine_hip_ik_ctrl_offset and your control should pop into the correct position.

Now select spine_hip_ik_ctrl_offset and hit Shift + P to unparent it from the joint. We now want the control to drive the joint. To do this, select spine_hip_ik_ctrl and spine_hip_ik_jnt (in that order) and go Constraint > Parent (Options). In the Options, make sure Maintain Offset is disabled, and then hit Apply. You should now be able to drive the hip with the control and get it back into the default position by zeroing out the Translate and Rotate values.

At the moment, our control is very small. To shape our control, we need to switch to component mode (F8) and translate the CVs. This will ensure that we don’t add any transform values to our control. To do this, simply grab the control and hit F8 to switch to component mode.

Feel free to shape the control however you see fit. I’ve just made sure that it is easily selectable from most angles by scaling the CVs around the mass of the pelvis. That’s one control down. Now do the same for the spine_mid_ik_jnt and the spine_chest_ik_jnt. Remember to name the controls using the same conventions that we have done for the hip control.

008. Adding the twist

 

To allow for some twisting motion, select spine_ik and jump into the Attribute Editor. Open up the IK Solver Attributes > Advanced Twist Controls tab and check the Enable Twist Controls box. This will allow us to pick two controls to drive the twisting from the root and the tip of the IK joint chain. To begin with, things may look a little crazy.

To fix this, set the World Up Type to Object Rotation Up (Start/End) and set the Twist Value Type to Start/End. Next, in the World Up Object field, type spine_hip_ik_ctrl and in the World Up Object 2 field, type spine_chest_ik_ctrl. These are the two controls that will drive the twisting; one at the root of the IK chain and one at the tip. Set our Up Axis to Negative Z, and then the Up Vector and Up Vector 2 to 0, 0, -1. You should now be able to twist using the two controls.

009. Adding some stretch

 

At the moment, if we translate the spine_hip_ik_ctrl, the entire spine comes along with it when really we’d like it to stay between the hip and chest joints. You should notice, however, that the spine_crv does stay between the hip and the chest, growing in length to accommodate this. We’d like to have our joints do the same thing, and we’ll use the curve to help us do so.

First we need to find out the length of the spine_crv. To do this, select the curve and in the MEL box in the bottom-left corner, type:

arclen –ch 1;

This will reveal a hidden node that houses the information on how long the curve is. If you select the curve now and jump into the Atttribute Editor, you should find a tab called curveInfo1. Alternatively, you can select the curve, open up the Hypershade or the Node Editor, and click on the Inputs/Outputs button to bring it up. Quickly rename the curveInfo1 node to spine_curveInfo.

On examination, the Arc Length for my spine is 52.526. Your length may be slightly different, so do note it down and use that value for the upcoming steps. Next we’ll use the Arc Length value to drive the stretching of the joints.

First we need to neutralise the Arc Length value so we can pass it through to the joints. Let’s do this with utility nodes. In the Node Editor (Window > Node Editor), press TAB, type multiplyDivide and hit Enter to create that node. Double-click the node to drop it into the Attribute Editor, rename it spineLength_md, and then set the Operation to Divide. Now expand both the spine_curveInfo and the spineLength_md nodes in the Node Editor by clicking on the expand icons on the right of each node. This will allow you to see the attributes associated with both nodes.

LMB-click on the output of ArcLength (on the spine_curveInfo node) and feed it into the Input > Input 1X of the spineLength_md. If you examine the spineLength_md in the Attribute Editor, you should see that the Arc Length value is being fed into the Input 1X attribute. Now copy the same value of Input 1X and paste it into Input 2X. By taking Input 1X (52.526) and dividing by Input 2X (52.526), we will output a value of 1. As the length of the spine_crv varies, the spineLength_md node will figure out the difference, and we can feed this value into the joints to have them lengthen correctly.

In the Node Editor, create a new multiplyDidive node and call it spine_ik2_md. Now select spine_ik2_jnt and copy the value from the Translate X channel (its length) and paste it into the Input 2X of the spine_ik2_md. Then, plug the Output X attribute from the spineLength_md node into the Input X attribute on the spine_ik2_md. We now want to pass the output of spine_ik2_md onto the spine_ik2_jnt. To bring spine_ik2_jnt into the Node Editor, select it from the Outliner and MMB drag and drop it into the Node Editor. Then feed the Output X of spine_ik2_md into the Translate X of the spine_ik2_jnt.

If the length of all the joints in the spine was the same, we could simply pass the output of the final node into the Translate X for all the joints. Failing that, we could plug the Output X of the spineLength_md into the Scale X of all the joints. However, as the majority of the joints all have different lengths, we’ll have to create a multiplyDivide node for each joint and make sure the length of each joint is being passed into those multiply divide nodes.

If you lose any of your nodes as you do this, open up the Hypershade and have a look under the Utilities tab. Once you’ve done this, you should be able to translate any of the IK controls, and the spine should no longer pull away from the spine_crv.

010. Craeting the FK controls

 

Now let’s move on to the FK controls, which will eventually drive the IK controls. Start by un-hiding the FK joint chain by selecting the root joint in the Outliner and pressing Shift + H. The first thing we want to do is orient the FK joint chain so flexion is created by positive X rotation. This will be the case for most of the joint chains from now on. The reason we avoided this for the IK spine joint chain was so we could easily set up the advanced twisting.

So now, grab spine_fk1_jnt and go Skeleton > Orient Joint (Options). Set the Primary Axis to Y, the Secondary Axis to Z, and the Secondary Axis World Orientation to Y (+). Test out the joints to make sure that you’re getting the correct behavior.

By setting the orientations like this, you will have probably noticed that Y is now aiming down the chain, and the Translate Y attribute now relates to the length of the joints. Instead you could have this as X pointing down the chain with positive Z rotation creating flexion. To be honest, it doesn’t matter. The only thing that matters is that you keep it consistent throughout the rig.

Now we need to create the FK spine controls. We could do this manually, like we did for the IK controls, but to speed up the process, let’s use a quick script I knocked together. In the Script Editor, open up a clean Python tab and bring in the createControls.py script from the scripts directory of this project.

This script will look for any joint with the suffix of _jnt, and create a control with the same name, only replacing the _jnt with _ctrl. It will then create two group nodes above the control and rename them appropriately. Then it will correctly place the control by using a parentConstraint. Lastly, the parentConstraint will be deleted and the joint will be constrained to the control using the constraint defined in the final line of code.

I know it sounds like a lot of work, but for 10 lines of code (I’m not including the comments), it should really help to speed things up.

Before using the script, edit the final line to read as follows, because we only want to orient constrain the FK joints to their respective controls:

21 cmds.orientContraint(ctrl, s, mo=0)

 

Now, select spine_fk1_jnt, spine_fk2_jnt, spine_fk3_jnt, spine_fk4_jnt, highlight all the text in the Script Editor, and hit Enter on the numpad. If you look in the Outliner now, hopefully you’ll have a control for each of the four joints, and each control will consist of a hierarchy. You should now be able to edit the shape/size of the controls, but please remember to do so in component mode.

Next we need the control hierarchy to mimic the joint hierarchy. To do this, parent spine_fk4_ctrl_offset under spine_fk3_ctrl. Then parent spine_fk3_ctrl_offset under spine_fk2_ctrl, and lastly parent spine_f2_ctrl_offset under spine_fk1_ctrl. Test out the rotations and hopefully everything will be working in order.

011. FK IK setup

 

Now we want to drive the IK spine with the FK spine. To do this, start by parenting spine_mid_ik_ctrl_offset under spine_fk3_ctrl. Then take spine_chest_ik_ctrl_offset and parent it under spine_fk4_ctrl. Now test out all the controls by translating and rotating them. Make sure that when you zero out the values for the Translate and the Rotate channels, the controls revert back to their default positions.

012. Quick cleanup

 

We’ve got joints, controls, group nodes, curves, etc., in our scene at the moment. Although we’ve been labeling everything, Now let’s do a bit of housework so the Outliner is less cluttered. It may sound boring, but the more often you do this, the easier it will be to create and maintain the rig in the long run.

So let’s start by selecting spine_ik1_jnt, spine_fk1_jnt, spine_hip_ik_jnt, spine_mid_ik_jnt and spine_chest_ik_jnt, and hitting Ctrl + G. Rename this group torso_jnt_grp. Next, select spine_hip_ik_ctrl_offset and spine _fk1_ctrl_offset, and hit Ctrl + G. This time, rename the group to torso_ctrl_grp. Now select spine_crv and spine_ik, group them together and call this group torso_doNotTouch_grp.

013. Rib cage test

014. Rib cage joints

 

To help give a sense of a skeletal structure beneath the model, let’s add some joints that will be used to simulate the effects of a rib cage. So that we can easily draw the joints, un-hide the high-resolution model and set it as a Live surface. We can now use this model to snap the joints to.

On the character’s left side, start from the back of the torso and create a four-joint chain that works its way towards the front. Create two additional joint chains, each consisting of four joints, one beneath the other, to represent the rib cage, as illustrated in Fig.14a. For now, just work on the character’s left-hand side, as we’ll simply mirror these joints later on.

With the joints in place, disable the high-res mesh as a Live surface and select the root joint of each new joint chain, translating them in slightly so that they sit within the character. Next we need to take care of the orientation of the joints so that positive X rotation allows for the rib cage to expand.

Select the root joint of the first chain and go Skeleton > Orient Joint (Options). Set the Primary Axis to Y, the Secondary Axis to Z, the Secondary Axis World Orientation to Z (-), and hit Apply. Check the joint and then move on to the next joint in the chain. For this joint, use the Joint Orient in the Attribute Editor to orient the joint until it gives you the desired behavior. To interactively edit the values in the Attribute Editor, hover the cursor over the box you’d like to edit, hold down the Ctrl key and use either the LMB, MMB, or RMB to edit the values.

You could also use the cometJointOrient tool under Comet > Joints/Hierarchy, which would usually yield faster results, or simply rotate the joints and then use Freeze Transforms so that the Rotate channels end up with a default value of 0. Make sure to do this for all the joints and also test out the rotations.

With all the joints orientated correctly, let’s rename them using cometRename. Select all the joints from the first chain from root to tip, and type l_ribA in the Rename field. Hit Rename and Number, and then with the same joints selected, add the Suffix of _jnt. Follow the same naming convention for the remaining joint chains, replacing the A with B and then C.

We now want to mirror the joints over to the other side. Select l_ribA1_jnt and go Skeleton > Mirror Joint. Set the Mirror across to YZ and the Mirror Function to Behavior. Then, in the Search for field, type l_ and in the Replace with field, type r_. Hit Apply and then repeat the step for the remaining joint chains.

Now it’s time for some parenting. Select both l_ribA1_jnt and r_ribA1_jnt and parent them under spine_ik10_jnt. Then select l_ribB1_jnt and r_ribB1_jnt and parent them under spine_ik9_jnt. Lastly, select l_ribC1_jnt and r_ribC1_jnt and parent them under spine_ik8_jnt.

015. Adding rib controls

 

Right now, I’d like to add a control for each joint of the rib cage (minus the end joints). This may make it look like we have more controls than is necessary, but it will give the animator an additional set of controls with which to deform the character. Later on, we’ll be hiding certain controls to simplify the rig, but we’ll also allow the animator to reveal these controls as and when he/she desires to obtain the additional control.

Let’s use the create Controls.py script again to create the controls. Load that script into the Script Editor and edit the following lines to read like so:

16 ctrl = cmds.circle( nr=(0, 1, 0), r=1.5, n=ctrlName) [0]
21 cmds.orientContraint(ctrl, s, mo=0)

This will change the radius of the circle and orient-constrain each joint to its control. Now select l_ribA1_jnt, l_ribA2_jnt and l_ribA3_jnt and run the script.

Jump into the Outliner and create the parent-child relationship between our new controls so they deliver the correct behavior. To do this, parent l_ribA3_ctrl_offset under l_ribA2_ctrl. Then parent l_ribA2_ctrl_offset under l_ribA1_ctrl. Do this for all six control hierarchies. Then select the _offset nodes for all six rib control hierarchies, group them together (Ctrl + G) and call that group rib_ctrl_grp.

To have the rib controls follow the spine joints, but keep the controls and joints as two separate hierarchies, we’ll use constraints. In this order, select spine_ik10_jnt and l_ribA1_ctrl_offset and go Constrain > Parent (Options). Enable Maintain Offset (so the control doesn’t flip out) and hit Apply. Once you’ve completed and checked the first joint chain, repeat the process for the remaining rib-cage joints.

016. Adding the COG Control

 

The COG (centre of gravity) control is usually the main control that drives a character. In most cases, this would be positioned at the hip. In reality, however, the centre of gravity for a person will change depending on the pose or the action. For example, when standing with both legs parted and the hips spaced in between, the centre of gravity would be around the hip. But now imagine doing a forward roll. Your body would be in the shape of a ball, and therefore the centre of gravity for this motion would be in the centre of that form.

However, if you did want to add the effects of editing the position of the COG, have an experiment with some curves, some locators and some constraints.

Now, to create this control, go Comet > Shapes > arrow. Make sure it’s in the World centre and rename it to COG_ctrl. Now create the control hierarchy by grouping it to itself twice. Rename the top group to COG_ctrl_offset and the next node down to COG_ctrl_auto. Then parent COG_ctrl_offset under spine_hip_ik_ctrl, zero out the Rotate and Translate values and then unparent it. Next, jump into component mode (F8) and edit the shape of hip_ ctrl so that it’s more easily selectable.

017. Rigging the hips

 

At the moment, we can use the spine_hip_ik_ctrl to move the hip around. That’s all good but it also affects some of the spine. Although this behaviour is intended, I’d also like to rotate the hips without having any effect on the spine, as it makes it easier to handle tasks such as having the character sit down.

To create the joint chain that will handle this, jump into the side view and load the Joint tool. Holding down the V key (snap to points), LMB-click close to the spine_hip_ik_jnt (but not on it). It should draw the joint on top of the spine_hip_ik_jnt. Hold down the Shift key and draw a second joint at the base of the pelvic mass. Rename the two joints, from root to tip: hip_fk_jnt and hipEnd_fk_jnt.

Next, let’s orient the joint. Select hip_fk_jnt and go Orient Joint (Options). In here, set the Primary Axis to Y, the Secondary Axis to Z, and the Secondary Axis World Orientation to Z (+).

Now select hip_fk_jnt and use the createControls.py script to create a control for it. Make sure to edit the final line of the script to read like so:

21 cmds.parentConstraint (ctrl, s, mo=0)

Although we’re only going to drive the hip_fk_jnt by rotations, using a parent constraint will allow us to connect it to the rest of the rig with little bother, while keeping the lower portion of the rig (we’ll add the legs later) separate from the torso.

So to get everyone playing happily, take hip_fk_ctrl_offset and parent it under spine_hip_ik_ctrl. Make sure to add some geometry to the hips, as we did for the torso, and to re-shape the new hip control in component mode so the animator can grab it easily.

018. Finalising the torso rig

 

Now let’s bring everything together and also clean up the Outliner. Start by selecting both spine_fk1_ctrl_offset, spine_hip_ik_ctrl_offset, and parenting both of them under COG_ctrl. Select spine_fk1_ctrl, Shift-select spine_fk_jnt, and go Constrain > Point. You should now be able to translate the COG control around and have everything follow along.

To stop the torso rig breaking later on (when we add the global_SRT_ctrl), select spine_crv and disable Inherits Transform in the Attribute Editor. You’ll find this on the left-most tab that houses the transforms. If you don’t disable this, you can end up adding a double transformation to your rig, which isn’t what you want. Next, take COG_ctrl and drop it under torso_rig_ctrl to keep things organized.

We now want to lock and hide both attributes that we don’t want to hand over to the animator, and also parts of the rig that we don’t want anyone to accidentally grab in the viewport. Select all the FK controls (including the rib controls), highlight the Translate and Rotate Scale attributes in the Channel Box, hold down the RMB, and go Lock and Hide Selected. Then select all the IK controls and lock and hide the Scale attributes. Next, select the spine_ik, spine_crv, disable the Visibility attribute, and then lock it off.

At this stage, we should have completed the torso portion of our rig. Next, we move on to the neck and the head.

Tip 001. Test things out

As you create your rig, do make sure to test things out. I tend to save scenes in a temp directory and do little experiments; there are as many ways to rig a character as there are to skin a cat. The important thing is to find what works best for you and the animator.

Tip 002. Learn some scripting

Rigging is full of repetition, and I mean a lot of it. This is fine for simple characters, but when you’re tasked with rigging a 6-armed, 12-fingered, 7-headed monster, it ain’t gonna be fun doing everything manually. This is where a little scripting can go a long way. With a few lines of code, you can save yourself hours. With a bit more, you can save yourself days. It makes the rigging process a more enjoyable, less repetitive experience.

Tip 003. Using wildcards in the Outliner

At this stage, rigging is an easy enough experience. But when we start to rig the arms, legs, and so on, it can get very busy and become a struggle to find one joint amongst all the group nodes, or one locator buried between all the constraints. To help filter your search, why not use wildcards in the Outliner?

To use wildcards, simply pop an * either side of the name of an object you’re searching for in the Outliner. Let’s say you’re struggling to find the spine joints in your hierarchy. Using wildcards, you would type *spine* or maybe *_jnt* in the Outliner. Try it out yourself.

Tip 004.  Color-coding controls

I like to color the controls to differentiate one group from another. For example, the IK torso controls will be blue, the FK controls will be orange; the left-sided controls will be green, and the right-sided will be red. By doing this, it’s simpler for the animator to figure out what side of the body he’s working with.

To color the controls, select one, jump into the Attribute Editor, and navigate to the Object Display section in either the Shape tab or the Transform tab. Open up Drawing Overrides and check the Enable Overrides box. You can now use the Color slider to pick the color for your controls.

Leave a Comment