Publishers of technology books, eBooks, and videos for creative people

Home > Articles > Design

  • Print
  • + Share This
This chapter is from the book

This chapter is from the book

Advanced IK Arms and Clavicular Triangle

In the next exercise, you will see how I chose to rig The Jerk's shoulders and arms. The technique used enables the arms to stretch and the shoulder to rotate as if it were an FK arm. Separate controls exist for posing the arm using IK from the scapula, the clavicle, and the shoulder, as well as the traditional IK handle at the wrist. Two locators both have the wrist's IK handle constrained to them, adding the capability to plant the character's hand any place we choose. Two extra joints were inserted as children of the shoulder and elbow but were not connected (not made parents) with the rest of the hierarchy of the arm. These unparented children joints were used for better deformations on the twisting of the shoulder and the wrist, to avoid the painful washboard effect.

Exercise 17.6 Advanced Stretchy IK Arms and the Clavicular Triangle

Begin by opening the file Jerk_ArmSetup_Begin.mb, which you'll find on the accompanying CD. Take a look at how the arm joints are laid out to create the hierarchy.

Examine this file closely: It contains the joint placement for the entire skeletal hierarchy that will create the final arm for The Jerk. The only thing missing is the controls, which you will add to the rig now. You begin with the shoulder area of the character, which I refer to as "the clavicular triangle." Then you tackle the advanced stretchy IK arm controls that will allow the character's arms to stretch to any length. You'll also transition the hand to be stuck on any object and stay there while the rest of the body is animated. So, let's get started with the clavicular triangle.

  1. Beginning with the file Jerk_ArmSetup_Begin.mb from the CD, create an IK handle from the clavicularTriangle joint node to the scapulaJoint node. Do this by clicking Skeleton, IK Handle Tool Options; first hit the Reset Tool button and then select the nodes in order from the 3D view port window. Rename the newly created IK handle scapulaClavicle_IkControl.

  2. Next, select the scapulaJoint and use the Ctrl+h key combination to temporarily hide it so that you can select the correct node in the view port window. Now, using the same settings in the IK Handle tool from above, create another IK handle from the clavicleJoint node to the clavToShoulder joint node. Rename the newly created IK handle clavicleStretch_IkHandle.

  3. Next, use the Ctrl+Shift+h keyboard combination to unhide the last hidden node (the scapulaJoint node). Then select the clavicleJoint node and use Ctrl+h to temporarily hide it.

  4. Using the same settings, create an IK handle from the scapulaJoint node to the shoulderJoint node. Rename this newly created IK handle clavicleShoulder_IkControl.

  5. Create one last IK handle from the shoulderJoint node all the way down to the bottom of the arm to the wristJoint node. Rename the newly created IK handle armWrist_IkControl. Now Ctrl+Shift+h to unhide the previously hidden clavicleJoint.

  6. Next, parent the clavicleShoulder_IkControl under the scapulaClavicle_IkControl node. Then parent the clavicleStretch_IkHandle and the armWrist_IkControl nodes to the clavicleShoulder_IkControl. Finally, parent the entire group of the scapulaClavicle_IkControl node to the connectToSpine joint node. Your hierarchy so far should look like Figure 17.45.

  7. Figure 17.45Figure 17.45 Hierarchy for the clavicle shoulder setup.

  8. Now that you've parented all your IK appropriately, select all four IK handles and perform the Modify, Freeze Transformations menu command. Next, with all the IK still selected, highlight the poleVectorX, poleVectorY, and poleVectorZ attributes in the Channel box and set them all to 0 (zero).

  9. Next, click Create, Measure Tools, Distance Tool. While holding down the v key on your keyboard (Snap mode), snap a distance locator from the clavicleJoint to the clavToShoulder joint. Rename each locator appropriately: clavicleJointPoint and clavToShoulderPoint. Also rename the distanceDimension node that was created to clavToShoulder_distanceDimension.

  10. Select the shoulderJoint and the clavToShoulderPoint and perform the Constrain, Point menu command. Next, select clavicleJoint and then clavicleJointPoint, and again perform the Constrain, Point menu command. Now select the two locators and the distance dimension, and hit the Ctrl+g keyboard combination to group them. Rename the group clavicleDistanceGroup and make it a child of the connectToSpine joint node. Your hierarchy so far should look like Figure 17.46.

  11. Figure 17.46Figure 17.46 IK handles for the clavicle shoulder setup.

  12. Next, execute this command:

  13. createNode multiplyDivide; 
  14. Be sure to hold down the Shift key, and Shift+click, selecting the clavToShoulder_distanceDimension node. Open the Hypergraph window and click Graph, Input and Output Connections.

  15. Your screen should look like Figure 17.47.

    Figure 17.47Figure 17.47 Connecting the distanceDimension node.

  16. Next, using Shift plus the middle mouse button, drag and drop the clavToShoulder_distanceDimensionShape onto the multiplyDivide1 node. This should bring up the Connection Editor window. Inside the Connection Editor, connect the distance attribute from the clavToShoulder_distanceDimensionShape into the Input1X attribute of the multiplyDivide node.

  17. Next, select the multiplyDivide node and open the Attribute Editor. Change Operation to Divide, and copy the yellow input1X attribute (using the Ctrl+c keyboard combination) and paste it into the input2X field so that you are dividing the current distance by the initial distance. This creates a ratio that you can use to scale the clavicle joint down its axis. Your hierarchy so far should look like Figure 17.48.

  18. Select the multiplyDivide node and Shift+select the clavicleJoint. Open the Hypergraph window and click Graph, Input and Output Connections. Using Shift and the middle mouse button, drag and drop the multiplyDivide node onto the clavicleJoint node. Again, this opens the Connection Editor for you to connect the appropriate attributes.

  19. In the Connection Editor, highlight the OutputX attribute from the multiplyDivide node, and connect it with the scaleX attribute of the clavicleJoint node. This should appear to do nothing because the outputX attribute should be currently equal to 1.

  20. Figure 17.48Figure 17.48 Connecting the multiplyDivide node.

  21. Finally, select the shoulderJoint, Shift+select the clavicleStretch_IkHandle, and perform Constrain, Point.

  22. That is about it for the clavicle setup. If you move or rotate the clavicleShoulder_IkControl IK handle, you will see that the clavicleJoint actually scales to keep its length between the shoulder and its point of origin at the clavicle. Although this is not anatomically correct, it can prove very helpful for achieving appealing deformations in this area when the character points his arm forward in front of his body, reaches his hand across his chest, or lifts his arm above his head. The key is to spread the weighting of this joint smoothly and sparingly across certain portions of the frontal geometry.

In the next exercise, you will set up some of the controls for the entire arm itself.

Exercise 17.7 Arm Twist Setup

Begin by connecting the joints that will help the arm's twisting deformations look more believable.

  1. Using the Connection Editor, connect the wristJoint.rotateX attribute to control the wristTwistHelper.rotateX attribute (highlighting in the Connection Editor, just like in the last example). Then connect the shoulderJoint.rotateX attribute to control the shoulderTwistHelper.rotateX attribute using the same method (see Figure 17.49).

  2. Figure 17.49Figure 17.49 Connecting the joints that will help the arm's twisting deformations.

    Next, you will create a standard IK control for the arm, which will enable the animator to control the twisting of the shoulder and the orientation that the elbow is pointing. You will pole vector–constrain the wrist's IK handle onto a locator that is situated behind the character, which can be grabbed and translated around to control the arm's orientation.

  3. Create a locator (click Create, Locator) and rename it armPoleVectorConstraint. Now, with the Move tool activated, hold down the v key (Point Snap mode) on the keyboard and, holding down the middle mouse button, click and drag the locator toward the shoulderJoint until it snaps into place on top of the shoulderJoint. Then, no longer holding the v key, translate it backward a few units behind the character.

  4. Make the armPoleVectorConstraint locator a child of the connectToSpine node by selecting the armPoleVectorConstraint and then the connectToSpine; then hit the p key on your keyboard.

  5. Select the armPoleVectorConstraint locator and Shift-click the armWrist_IkControl node to add it to the selection. Create a pole vector constraint by using the menu command Constrain, Pole Vector.

  6. Select the armPoleVectorConstraint locator and perform Modify, Freeze Transformations to zero the locator's transforms.

  7. Next, you will create the extra controls that will allow the hand to be "planted" or stuck on any object. For example, if the character needs to lean his hand against the wall, grab onto a pole and swing around on it, or even just hold on to a steering wheel, this setup will easily allow for it.

    The way you'll accomplish this is very simple indeed. First, you'll create two locators and parent them under the same group as the armWrist_IkControl. Then you will create weighted point and orient constraints from these two locators onto the armWrist_IkControl node. Finally, you will add an attribute that will control the weight of the constraints that were added, to determine which locator the IK handle gets constrained onto. Let's get started.

  8. First, create two locators. Rename one locator plantIkHand. Rename the other locator freeIkHand.

  9. With the Move tool activated, hold down the v key (Point Snap mode) on the keyboard and, holding down the middle mouse button, click and drag both locators toward the wrist's armWrist_IkControl in the 3D view port until they snap into place directly on top of the armWrist_IkControl.

  10. Next, parent both the plantIkHand and freeIkHand locators under the same parent as the armWrist_IkControl node (the scapulaClavicle_IkControl) by selecting the two locators and Shift+selecting the scapulaClavicle_IkControl to add it to the selection last; then hit the p key on your keyboard.

  11. Next, you will create an empty "null" transform node that you'll use to parent the IK handle and both locators under so that they are in the same orientation and position as the wristJoint node. You can then orient-constrain the wrist to the IK handle without changing the current orientation of the wrist.

  12. Create the null transform by first being sure that nothing is selected and then hitting the Ctrl+g keyboard combination.

  13. With the new null node created, point-snap it to the wristJoint node using the Snap mode of the Move tool by holding down the v key while clicking and dragging with the middle mouse button held down. Zero the null node's transforms by selecting it and performing Modify, Freeze Transformations.

  14. To put this null node into the same orientation as the wristJoint, you will point- and orient-constrain it and immediately delete these constraints by executing a single line of MEL code supplied in the next step.

  15. A quick and easy way to do this is to execute the following MEL command in the command line (first select the wristJoint node and Shift+select the null node to add to the selection). Now execute the following bit of tricky code (which actually creates constraints for you and then automatically deletes them immediately afterward so that they will line up your nodes but not keep them controlled via a constraint relationship—all at the same time):

  16. delete 'orientConstraint';  delete 'pointConstraint';
  17. Rename the null node to be called wristTransformCompensation. Parent it under the same node as the armWrist_IkControl IK handle and plantIkHand and freeIkHand locators by first selecting the wristTransformCompensation, Shift+selecting the clavicleShoulder_IkControl node, and hitting the p key on the keyboard.

  18. The null transform is now in the same orientation space as the wristJoint, but it will travel correctly under the clavicleShoulder_IkControl IK handle node. You will now make this new wristTransformCompensation null node the parent of the armWrist_IkControl IK handle and plantIkHand and freeIkHand locators.

  19. Select all three of these nodes (armWrist_IkControl, plantIkHand, and freeIkHand), and Shift+select the wristTransformCompensation null node to add it to the selection last. Hit the p key to parent the IK and locators to this null node.

  20. NOTE

    If the wrist and elbow seem to pop into a different spot when you parent the armWrist_IkControl IK handle, you can correct this. Simply select the armPoleVectorConstraint, highlight all its translate channels in the Channel box, and then hit 0 and the Enter key. This update problem occurs because of the nature of Maya's lazy dependency graph evaluations.

  21. Now select the armWrist_IkControl, plantIkHand, and freeIkHand nodes; perform Modify, Freeze Transformations to zero out the IK handle and locator's transforms; and put them in the same transformation space as the wristTransformCompensation null node. You should remember that this is also in the same orientation space as the wristJoint node. This whole step is important because you will next orient-constrain the wrist to the armWrist_IkControl IK handle node.

  22. Select the armWrist_IkControl, Shift+select the wristJoint node, and perform the menu command Constrain, Orient. So far, your nodes should look like Figure 17.50 in the Hypergraph window.

  23. Figure 17.50Figure 17.50 Arm and wrist IK control hierarchy.

    Now that you have all your controls in the proper transformation space, you will finally create the constraints that enable you to animate the hand freely and then plant it so that it sticks somewhere. Again, you'll do this by using the weights of orient and point constraints.

  24. Select the plantIkHand and freeIkHand nodes, and Shift+select the armWrist_IkControl to add it to the selection last. Now perform the two menu commands Constrain, Point and Constrain, Orient.

  25. So far, if everything was done properly, you should have your wristJoint orient constrained to your arm's IK handle. The IK handle, in turn, is point- and orient-constrained to both plantIkHand and freeIkHand locators, which both currently constrain it with a weighted average of 1.

  26. Next, select the armWrist_IkControl and use Modify, Add Attribute to create a float attribute. Name that float attribute handPlant, and give it a min of 0, max of 1, and default of 0. The settings should look like those in Figure 17.51.

  27. Figure 17.51Figure 17.51 Adding attributes to the armWrist_IkControl.

    Now that you have created the handPlant attribute on the armWrist_IkControl IK handle, you want to make it control the weights of the constraints between the plantIkHand and freeIkHand locators. This is achieved using set-driven keys.

  28. Go to the menu item Animate, Set-Driven Key, Set option box to bring up the UI for creating set-driven keys.

  29. Next, select the armWrist_IkControl IK handle and click the Load Driver button. Be sure to highlight the handPlant attribute in the upper-left section of the window.

  30. Open the Hypergraph and select the two bottom constraints that are children of the armWrist_IkControl node (the point and orient constraints that you just finished creating in Step 16). These should be named armWrist_IkControl_pointConstraint1 and armWrist_IkControl_orientConstraint1. Hold the Shift key and add to the selection the plantIkHand and freeIkHand nodes. Next, in the Set-Driven Key window, click Load Driven. Your window should look like Figure 17.52.

  31. Figure 17.52Figure 17.52 Preparing to use the Set-Driven Key window.

    The next few steps are very important for applying the set-driven keys correctly.

  32. First, be sure that the armWrist_IkControl IK handle's handPlant attribute is set to 0 and is loaded as the driver node/attribute. Also be sure that the node name armWrist_IkControl is highlighted on the upper left and that the attribute name handPlant is highlighted on the upper right of the Set-Driven Key window.

  33. Now set the attributes on your nodes to the following values:

  34. Driver attribute:

    armWrist_IkControl.handPlant: 0

    Driven attributes:

    freeIkHand.visibility: on

    plantIkHand.visibility: off

    armWrist_IkControl_pointConstraint1.plantIkHandW0: 0

    armWrist_IkControl_pointConstraint1.freeIkHandW1: 1

    armWrist_IkControl_orientConstraint1.plantIkHandW0: 0

    armWrist_IkControl_orientConstraint1.freeIkHandW1: 1

  35. Now that your attributes are set exactly from the previous list, with your driver node actively highlighted, go through the driven nodes in the Set-Driven Key window and, one by one, click each node/attribute in the Driven section. Highlight each name on the lower left, highlight the attribute that you just set on the lower right, and hit the Key button. For example, the first node to highlight on the bottom left is the freeIkHand; on the bottom right, it is the attribute visibility. With both highlighted, hit the Key button. Do this for each node's attribute that you previously loaded and set, including each constraint separately (see Figure 17.53).

  36. Figure 17.53Figure 17.53 Using the Set-Driven Key window.

    Now that you have hit the Key button for each driven attribute value when the driver is set to 0, you will set the values for the driven attributes when the driver is set to 1.

  37. Set the following node attribute's values:

  38. Driver attribute:

    armWrist_IkControl.handPlant: 1

    Driven attributes:

    freeIkHand.visibility: off

    plantIkHand.visibility: on

    armWrist_IkControl_pointConstraint1.plantIkHandW0: 1

    armWrist_IkControl_pointConstraint1.freeIkHandW1: 0

    armWrist_IkControl_orientConstraint1.plantIkHandW0: 1

    armWrist_IkControl_orientConstraint1.freeIkHandW1: 0

  39. Finally, repeat the previous step, but using the current values, and set a driven key on each one of your driven node/attributes. One by one, highlight them in the Driven section of the Set-Driven Key window; one by one, highlight their attributes. Then hit the Key button to set the driven node's attribute key at the current driver node's attribute value.

Two locators control the location of the arm's IK handle as well as the orientation of the wrist. For the most part, the freeIkHand locator can be used to animate the hand when it does not need to be planted on something. But now there's an extra node to use to plant and orient the hand on a shot-by-shot basis, without ever needing to add extra controls to the character. When you need the hand to transition from being free moving to being planted somewhere, simply parent or point-constrain the plantIkHand onto the object that the hand needs to be stuck to and then animate the .handPlant attribute over a couple of frames, from 0 to 1. This hides the freeIkHand locator, which you no longer need to animate, and makes visible the plantIkHand locator, which you have stuck onto something.

In the next exercise, you will tackle the stretchy arm setup, which includes creating all the controls, attributes, and node networks involved to make an automatically stretchy IK arm that will stretch to maintain the distance between the IK handle and the shoulder. Regardless of whether the location of the shoulder or the location of the IK handle causes this distance to become greater, the arm will still stretch automatically. You will also add all the controls needed by an animator to animate this behavior blended on and off, while still exposing manual controls to scale the length on top of these controls.

Exercise 17.8 Stretchy Arm Setup

Begin by creating a distance dimension node for the arm. You will do this the same way you created the distance dimension for the clav to shoulder. This begins the controls that cause the arm to stretch.

  1. Go to Create, Measure Tools, Distance Tool to activate the Distance tool.

  2. Now click with the mouse once in the general area of the shoulder and again in the general area of the wrist. You will get two locators, most likely named locator1 and locator2. Rename these locators shoulderPoint for the locator near the shoulder, and wristPoint for the locator near the wrist. Also rename the distanceDimension node armDistance_distanceDimension.

  3. Select the shoulderJoint node, Shift+select the shoulderPoint locator, and point-constrain the locator to the shoulder by using Constrain, Point. Next, point- constrain the wristPoint locator to the armWrist_IkControl by selecting the armWrist_IkControl, Shift+selecting the wristPoint locator, and again performing the menu command Constrain, Point. Finally, select the two locators and the distanceDimension node, and group them using the Ctrl+g keyboard combination. Name this new group armDistanceGroup (see Figure 17.54).

  4. Figure 17.54Figure 17.54 Setting up the constraints for the stretchy arm.

  5. Parent the armDistanceGroup node under the connectToSpine joint node so that it is part of the hierarchy that will comprise the arm.

  6. Next, you will create a bunch of math utility nodes to create a node-based expression network. These nodes were built in Maya traditionally for rendering, but they are more commonly being used for character rigging as well.

  7. Open the Hypershade window by clicking Window, Rendering Editors, Hypershade, and go to the Create, Create New Node menu. This launches the Create Render Node window. Next, click the tab labeled Utilities and create the following series of nodes (you will create four total utility nodes—see Figure 17.55):

  8. Create three multiplyDivide nodes and rename them armScaleRatio, autoStretchMultiplier, and armScaleMultiplier.

    Create one Condition node and rename it shortenToleranceCondition.

    Figure 17.55Figure 17.55 Setting up the utility nodes for the stretchy arm.

    Next, you will create a few attributes that an animator can use to control the stretchiness of the character's arms.

  9. Select the armWrist_IkControl and load up the Add Attribute window by going to Modify, Add Attribute.

  10. In the Add Attribute window, create three float data type attributes with the following names and settings:

      autoStretch (min 0, max 1, default 1)

      shortenTolerance (min 0, max 1, default 1)

      armScale (min 0, max 10, default 1)

  11. Now it is time to get started connecting some attributes to create our stretchy IK arm.

    Because you already have the Hypershade window open, you will use it (instead of the Hypergraph) to make all of your node connections.

  12. Choose the Utilities tab from the Hypershade, and select all four of the new utility nodes that you just created. Shift+add to the selection the armDistance_distanceDimension node and the armWrist_IkControl node from either the Hypergraph or the 3D view port. Now, with the current active selection in the Hypershade, click the menu item Graph, Input and Output Connections. You get a somewhat disorganized display of nodes. Organize the nodes in your window so that they are visually lined up similar to the order pictured, to make it easier to connect the appropriate attributes (see Figure 17.56).

  13. Figure 17.56Figure 17.56 Preparing the utility nodes for the stretchy arm.

  14. Holding down the Shift key and the middle mouse button, drag and drop the distanceDimensionShape node onto the armScaleRatio multiplyDivide node. Using the Connection Editor, connect the distance attribute to the input1X attribute of the multiplyDivide node.

  15. Now select the armScaleRatio multiplyDivide node that you just connected to, and hit Ctrl+a to launch the Attribute Editor. Change the multiplyDivide node's operation mode from Multiply to Divide. Now copy the number from the input1X channel and paste it into the input2X channel so that you are dividing the current distance by the original distance.

  16. The node's output should currently equal 1; as the distance grows, the output will be a normalized ratio equal to how much the initial distance has scaled (starting from 1). This output will eventually be the number that you use to drive the scale of the arm joints, but you will set up a few extra nodes to add a small amount of logic and control over the stretchiness.

  17. Using the Connection Editor window, connect the following attributes to create an expression-based node network:

    • The armWrist_IkControl.autoStretch attribute into the autoStretchMultiplier.input1X attribute

      The armScaleRatio.outputX attribute into the autoStretchMultiplier.input2X attribute (The output of this autoStretchMultiplier node enables you to blend the stretchy behavior from on to off, and vice versa.)

      The autoStretchMultiplier.outputX attribute into the shortenToleranceCondition.firstTerm attribute

      The autoStretchMultiplier.outputX attribute also into the shortenToleranceCondition.colorIfFalseR attribute

      The armWrist_IkControl.shortenTolerance attribute into the shortenToleranceCondition.secondTerm attribute

      The armWrist_IkControl.shortenTolerance also into the shortenToleranceCondition.colorIfTrueR attribute (The output of the shortenToleranceCondition node's outColorR attribute now keeps the arm from shrinking shorter than the shortenTolerance attribute specifies.)

      The shortenToleranceCondition.outColorR attribute into the armScaleMultiplier.input1X attribute

      The armWrist_IkControl.armScale attribute into the armScaleMultiplier.input2X attribute

  18. Next, select the shortenToleranceCondition node and open the Attribute Editor by hitting Ctrl+a. Change the operation mode of this condition node to Less Than.

  19. This condition node keeps the arm from scaling any shorter than what the armWrist_IkControl.shortenTolerance attribute is set to by making a decision for you. The logic behind how the condition node works is as follows: If the First Term is Less Than the Second Term, use Color If True; otherwise, use Color If False. This output, which goes into the armScaleMultiplier, enables you to manually stretch the arm longer or shorter by changing this attribute.

    All that is left is to connect the output of this scale multiplier to each of the arm joints (the shoulder and the elbow).

  20. Again, using the Connection Editor, connect the armScaleMultiplier.outputX attribute into both the shoulderJoint.scaleX and elbowJoint.scaleX attributes. Figure 17.57 shows a Hypershade and Hypergraph Input and Output Connections view of what your final node network should look like.

  21. Figure 17.57Figure 17.57 A Hypershade and Hypergraph Input and Output Connections view of what your final node network should look like.

    Figure 17.58 shows a Hypergraph Scene Hierarchy view of what your node's groupings should look like.

    Figure 17.58Figure 17.58 A Hypergraph Scene Hierarchy view of what your node's groupings should look like.

Now spend a few minutes testing the controls and attributes that you just created. Try moving around the freeIkHand locator while the handPlant attribute on the IK handle is set to 0. Experiment with your controls to make sure you didn't miss a step and that everything is functioning properly. If something seems to be working incorrectly, go back and retrace your steps to troubleshoot what might have gone wrong. This completed exercise with all the rigging finished is found in the file Jerk_ArmSetup_Finished.mb in the CD folder for this chapter.

In the next exercise, you will add the hand to the arm setup and, finally, put in all the control boxes that the character animator will ultimately use to animate the entire arm and hand.

Exercise 17.9 Rigging an Advanced Additive Hand and Fingers

Before you start this exercise, take a moment to examine the hierarchy of the hands for this setup, as in the file Jerk_HandJoints.mb in this chapter's folder on the CD. Note that at each knuckle there is an additional joint that is directly on top of the child knuckle joint. This technique allows for two things. It zeroes out the transforms of the children knuckles (which will be directly animated), and it also allows for layered animation on the parent knuckles if this becomes necessary for later shot requirements.

Also note that the knuckles have control boxes around them. The technique of using control boxes for the animators to set keys on is a great idea when setting up a character. Control boxes can be added to a character in many ways; this is covered later in this chapter. For now, you should know that these control boxes are actually NURBS curves shape nodes that were made children of the joint's transform by selecting the curve shape and then the joint, and using the –shape flag with the parent MEL command. (See the section in this chapter, " Hooking Up Control Boxes to Your Character Rig," for more information.)

For the hand setup, you want it to be super-easy for an animator to use, as well as have all the extra controls needed for the animator to hit any hand pose necessary. You will set up a hand control that will allow the animator to rotate the fingers individually or together, add a full-finger curl, and add individual controls for each knuckle. You will use added attributes that are connected to plusMinusAverage nodes, which add together the attributes that control the rotations of the knuckles.

  1. Start by opening the completed previous exercise, which is found in the file Jerk_ArmSetup_Finished.mb (or, you can start from your own completed file). With the arm setup file open, import the file Jerk_HandJoints.mb that is on the CD for this chapter.

  2. Select each parent joint node that makes up the fingers and thumb hierarchies. They are the thumb_1, index_DoubleKnuckle, middle_DoubleKnuckle, ring_DoubleKnuckle, and pinkyFinger_1 nodes. Parent them directly to the wristJoint node, and delete the empty handGroup group node that is left.

  3. Now select each knuckle control box from the 3D view port, and go to Modify, Add Attribute. Add the following float data type attributes (just leave the min, max, and default options blank):

    • fingerFullCurl

      fingerMidBend

      fingerTipBend

    Figure 17.59 shows the result.

    You will use the double-jointed knuckle, along with the addition operation of the plusMinusAverage nodes, to allow the fingerCurl attribute to make the whole finger bend each joint. This also will cause the finger to flex closed, while still providing individual control over each joint in each finger so that the animator can pose the hand very explicitly. For each of the four fingers, you will create two plusMinusAverage nodes and then connect the same attributes on each finger. The following steps go through one finger; you should repeat the steps for the rest of the fingers in the exact same fashion (except for the thumb, which is slightly different and is covered separately).

    Figure 17.59Figure 17.59 Knuckle control boxes.

  4. Create two plusMinusAverage nodes by opening the Hypershade window and going to Create, General Utilities, Plus Minus Average.

  5. Select the two new plusMinusAverage nodes that you just created, as well as the pinkyFinger_Knuckle node. Open the Hypergraph window and select Graph, Input and Output Connections.

  6. Use the Hypergraph and Connection Editor to connect the fingerFullCurl attribute of the pinkyFinger_Knuckle node into the input1D[0] attributes of both plusMinusAverage nodes. Also connect the fingerFullCurl attribute to the pinky_DoubleKnuckle rotateX attribute.

  7. Next, connect the fingerMidBend attribute of the pinkyFinger_Knuckle node to the input1D[1] attribute of one of the plusMinusAverage nodes. Now connect the output1D of this node into the rotateX attribute of the pinkyFinger_2 joint.

  8. TIP

    Sometimes array attributes can be tricky to connect to because the Connection Editor doesn't always show you the next available element. To connect an output attribute to the input1D[1] attribute, try selecting and loading both nodes into the Inputs and Outputs view of the Hypergraph. Next, right-click and hold down the mouse on the very rightmost side of the output node. A pop-up menu should appear that displays at the very top Connect Output Of and that gives you a list of attributes. Continuing to hold down the mouse button, highlight the appropriate attribute from the list and then let go of the mouse button. The mouse turns into an active dragging line with a little square icon at the end.

    Now right-click on top of the node that contains the input array attribute, and hold down the mouse button. You should see a menu labeled Connect Input Of. While still holding down the right mouse button on top of your input node, select the appropriate input array attribute. That's it—you just made a connection. This technique takes a little practice, but it is really fast once you get the hang of it. And it takes less effort because you don't need to load the Connection Editor just to connect a few attributes.

  9. Connect the fingerTipBend attribute of the pinkyFinger_Knuckle node to the input1D[1] attribute of the other plusMinusAverage node. Now connect the output1D of this node into the rotateX attribute of the pinkyFinger_3 joint.

  10. Figure 17.60 is an example of what the node network looks like for the finger.

    Figure 17.60Figure 17.60 This is what the node network looks like for the finger.

    Perform steps 2 through 8 for each of the other four fingers.

  11. For the thumb, create three plusMinusAverage nodes. Select them along with the thumb_Knuckle joint, and load them in the Input Output Connections view of the Hypergraph.

  12. Connect (using the Hypergraph and the Connection Editor) the thumb_Knuckle rotateY and rotateZ attributes directly to control the thumb_1 rotateY and rotateZ attributes.

  13. Connect the fingerFullCurl attribute of the thumb_Knuckle to the input1D[0] attribute of one of the unused plusMinusAverage nodes. Then connect the fingerMidBend attribute to the input1D[1] attribute of the same plusMinusAverage node. Now connect the output1D of this plusMinusAverage into thumb_DoubleKnuckle rotateX.

  14. Connect the fingerFullCurl attribute of the thumb_Knuckle to the input1D[0] attribute of one of the other unused plusMinusAverage nodes. Then connect the thumb_Knuckle rotateX attribute to the input1D[1] attribute of the same plusMinusAverage node; connect its output1D into the rotateX of the thumb_1 node.

  15. Connect the fingerFullCurl attribute of the thumb_Knuckle to the input1D[0] attribute of the last unused plusMinusAverage node. Then connect the fingerTipBend attribute to the input1D[1] attribute of the same plusMinusAverage node. Now connect the output1D of this plusMinusAverage into the thumb_2 rotateX attribute. Your result should look like Figure 17.61.

  16. Figure 17.61Figure 17.61 Utility nodes set up for the hand.

This completes the hand setup. For a finished example file of this rig, open the scene file Jerk_HandSetup_Finished.mb, which is included in this chapter's folder of the CD.

  • + Share This
  • 🔖 Save To Your Account