MEL Scripting a Character Rig in Maya: Adding Advanced Rig Controls

Dec 22, 2008

📄 Contents

␡

Enhancing the IK Limb Controls
Upgrading the Legs and Feet
Creating Advanced Head and Torso Controls

⎙ Print

< Back Page 3 of 3

This chapter is from the book 

MEL Scripting a Character Rig in Maya

Learn More Buy

Creating Advanced Head and Torso Controls

This section covers the rest of the advanced controls, including skeleton controls for the head, face, and torso. Important new techniques will be shown in the interface, such as using spline IK for the backbone controls. At the end of the section advanced scripts for the main controls are explained in detail.

Upgrading the Head and Face Rig

In the basic rig only two skeletons were used for simple head controls: the main head skeleton and the jaw skeleton that was child to it. If you did a test bind of the basic rig and rotated the jaw joint, you would have noticed that the whole face collapsed in an unnatural way. If your head rig is too simple with too few joints, Maya is forced to guess at how to assign the weighting of the points. It will assign percentages of influence to the closest joint in 3D space. Because the jaw joint is close to many of the face points, Maya will automatically assign the joint too much influence, causing the face to collapse when the jaw is moved (see FIGURE 4.20).

Figure 4.20 Binding just the head and jaw joints on the basic rig makes the whole face collapse when the jaw is rotated, and requires extensive manual weighting to improve the deformation.

Adding Skeletons to the Face

To improve the face deformations without a lot of tedious manual weighting of points, it is best to add skeletons to all the main areas of the face, and then parent them under either the head or jaw joints. This will more clearly tell Maya how to weight the points on the face, and will reduce the amount of manual weighting required after binding. The best way to approach adding these skeletons is to define the main bone structures of the face, and examine how the muscles flex. Look at a good anatomy and physiology book to see how the muscles are structured on the face.

To add some face skeletons to the nose and jaw:

Start by drawing skeletons that contour the main features of the face, holding down the V key as you draw to snap directly to points on the polygon skull and jaw bones. The purpose for adding these skeletons is to define what parts of the face should move with the head, and what should move with the jaw. Although you could snap directly to the skin model if it is available, to build or script a generic rig that will fit most biped characters, use the polygon bones for joint placement.
Add skeletons to improve face deformations. Here are two examples, out of many possibilities:
- To keep the nose points from being assigned to the jaw joint, draw a new skeleton in the nose area from between the eyes to above the mouth, and parent it under the head joint. Name the joints ctNoseRoot, and so on.
- To ensure that points in the jaw area move with the jaw, and not the head, draw a skeleton around the contour of the left jaw edge from below the left ear to the center of the jaw (see FIGURE 4.21). Name the joints lfJawRoot, and so on. Mirror the skeleton to the right side, and parent both skeletons under the center jaw joint.
  
  Figure 4.21 Snap joints to points on the polygon bones to contour the bony parts of the face and define the weighting, and then parent the new skeletons under the main jaw and skull joints.

Creating Muscle-Flexing with Skeletons

Other than adding static skeletons to improve weighting to the head and jaw, you can add skeletons to create muscle movements on the face as well. For instance, muscles on the forehead flex upward and downward to raise and lower the eyebrows. You can simulate this basic motion by adding three two-joint skeletons on the left, middle, and right sides of the forehead.

To add some face skeletons to the forehead that will flex the eyebrow muscles:

Draw the left eyebrow skeleton over the left eye, from a point on top of the forehead area of the skull bone to a point somewhere around the middle of the left brow area. Name the joints lfBrowRoot, and so on. Mirror this skeleton to the right side, and then draw another skeleton down the middle of the forehead between the eyebrows (see FIGURE 4.22). Name the center joints ctBrowsRoot, and so on.

Figure 4.22 Create simple face controls by drawing skeletons in the direction that the muscles flex, such as on the forehead to create eyebrow controls.
Group all three skeletons together, and parent the group node under the head joint (double-group to keep bones from being displayed between the parented skeletons).

Just these three skeletons will let you shape the forehead to create simple brow movements by scaling them in their X axis. These movements can facilitate the creation of facial expressions such as sad, happy, and surprise. Most current facial rigs are a combination of joint transforms, which this chapter covers, and blend shapes, which will be covered in the next chapter.

Rotating Joints Around Facial Features

One reason joints are often used for face controls is that they rotate on arcs, while other methods like blend shapes morph in straight lines from shape to shape. On a basic blend shape without any in-between shapes, this movement could lead to unnatural deformations or intersections of surfaces in the middle of the morph. Joint controls can sometimes bypass this problem on the curved surfaces of the face. For instance, a good place on the face to incorporate the rotation of joints is in opening and closing the eyes.

To add some skeletons to open and close the eyes:

Draw a two-joint skeleton from the center of the eyeball to the middle of the top eyelid. Name the joints lfEyeLidRoot, and so on. Since the eyeball is round, the skeleton will rotate on the correct arc to close the eye without intersecting the eye surface (see FIGURE 4.23). Be aware that points on the lower and side corners of the eye will be assigned to the top eyelid joints if you don't also add other skeletons to these areas.

Figure 4.23 Using the natural arcs produced by rotating joints can create good eyelid controls for opening and closing the eyes.
Experiment with adding other face skeletons, such as a skeleton drawn from the sides of the cheek down to the corner of the mouth, which allows you to scale and rotate the joints to create a smile or grimace expression. Be aware that some manual weighting of the points will still be required when binding, especially to smooth out the deformations on the skin.

Once you've created and parented the skeletons to the rig hierarchy, add custom channels to the head icon to drive the joints using SDKs. In some cases, as on the eyebrow joints, drive the scaling in X to raise and lower the brows; in other cases, like the eyelid joints, drive the rotations to open and close the eyes. Experiment with driving both directions on the driven channel, as this can produce unexpected, but sometimes useful, facial expressions.

Building an Advanced Torso Rig

Upgrading the torso involves adding new skeletons and controls to the backbone, chest, and waist. The backbone skeleton will incorporate a new type of IK solver called spline IK, which has properties of both FK and IK skeletons. After creating the advanced backbone, you will create additional FK skeletons in the chest and stomach, driven with SDKs and expressions. This section also implements some advanced connections to create automatic torso controls for breathing and moving the upper body with the feet.

Preparing to Add Spline IK to the Backbone

Upgrading the backbone will be the most involved setup you do on the biped rig because there are so many nodes and connections involved. The process involves drawing skeletons, adding spline IK, binding spine IK curves to icons, connecting and setting advanced attributes, and parenting all the nodes into the basic rig hierarchy so everything works together.

The main part of the new backbone controls involves using the Spline IK solver, which creates and assigns a curve to a skeleton, so that the shape of the skeleton tries to mimic the shape of the curve. To continuously follow the shape of the curve, the solver calculates how the joints should rotate as the points on the curve are moved. Deforming the curve allows you to bend the skeleton in multiple directions, much like an FK skeleton, only with the ease of IK by moving points instead of an IK handle. Actually, moving points manually is not that easy, but you will be shown how to make icons easily control the curve points instead. Lastly, spline IK does create an IK handle, but it is used only to set spline IK attributes, not to animate transforms.

To better fit the curvature of the polygon vertebrae, you must draw a new spine skeleton that has more joints than currently exist in the basic backbone rig. Such a skeleton will also better follow the points on a spline IK curve, and produce smoother deformations on the skin. Keep in mind, however, that you won't delete the original backbone skeleton, but use it as an FK control for the new spline IK backbone. These types of backbone controls were widely popularized by Jason Schliefer over the years at several Maya master classes held during SIGGRAPH conferences. Since then they have become an industry standard for creating a flexible backbone; as a result, any character rigging artist should know some variation of this type control.

Drawing the New Backbone Skeletons

You'll begin by creating two new FK backbone skeletons in the spine area from center hip to shoulder, and then a separate neck skeleton from center shoulder to head. Two main spine skeletons are necessary to move the neck independently from the back when you add the spline IK in the following section. In addition, several two-joint skeletons will be created in the hip, chest, and head areas to facilitate controlling the spline IK curves.

To create the new backbone skeletons:

In the Joint Tool options dialog box, make sure that standard IK is turned off. Using the polygon vertebrae as a guide, draw both of the new backbone skeletons in Side view, clicking between every other vertebra. This creates a Maya joint for every two polygon bones.

You should draw the back spine skeleton from the center pelvis to the base of the neck (vertebrae 0 to12). You should draw the neck spine skeleton from the base of the neck to the base of the skull (vertebrae 16 to 21). Make sure that the joints are positioned between the vertebrae (see FIGURE 4.24).

Figure 4.24 Draw the new backbone skeletons in Side view to center the joints between every two vertebra of the spine.
Name the new back spine joints ctLowSpineRoot, ctLowSpine1, and so on, and name the neck spine joints ctUpSpineRoot, ctUpSpine1, and so on.
Create a two-joint FK skeleton in the neck area from where the back spine skeleton ends at vertebra 12, up to where the neck spine skeleton starts at vertebra 16. Name the joints ctMidSpineRoot and ctMidSpineEnd. This skeleton will be used to bind the spline IK curves of the other two skeletons, which will partially control the shape of the curves.
Create similar skeletons in the head and hip areas. Actually, these skeletons should be duplicates of the main center head and hip skeletons. Name the skeletons ctTopSpineRoot, ctBotSpineRoot, and so on. These skeletons will also be used to bind the spline IK curves.
So that you can better see the effect of spline IK on the skeletons, re-parent all the polygon vertebrae under the appropriate joints. Because of how the skeletons were drawn, make sure you parent every two joints under the lower and upper skeleton joints. Parent vertebrae 12 to 15 under ctMidSpineRoot, and then make the pelvis and skull polygon bones children of the bottom and top skeletons.
To prevent redundancy and weighting conflicts when binding, rename the original center hip, head, and backbone skeletons so they will not be bound. For instance, in the rigging scripts the joints are given a new suffix indicating they are now control joints (_ctrlRt and _ctrlJt).

Keep in mind that whenever you work on a character, you must choose how much resolution a particular control really needs. On the two main spine skeletons, for instance, too few Maya joints won't be flexible enough, while too many joints will be more difficult to bind and weight. Drawing a Maya joint for every polygon vertebrae produces too many joints. Creating a skeleton with a Maya joint for every two vertebrae produces a much more manageable skeleton, while still being flexible enough for a backbone. Though not an issue when creating a rig through code, working with fewer nodes speeds up the whole manual rigging process.

Adding Spline IK to the Skeletons

To add spline IK to the two main backbone skeletons:

Choose Skeleton > IK Spline Handle Tool to activate the tool, and then click Reset Tool in the dialog box to use the default settings. Once the tool is activated, click Close to close the dialog box.
In Perspective view, click the root joint followed by the end joint of the lower spine skeleton. You should see a new IK handle appear, and if you also look in the Hypergraph you will see a new curve has automatically been created (see FIGURE 4.25). Name the IK handle and curve ctLowSpineIk and ctLowSpineCurve.

Figure 4.25 Adding spline IK to the spine skeleton creates an IK handle and curve that is used to rotate the joints.
Select the spline IK curve in the Hypergraph, and press the F8 key to switch to component mode in Perspective view. The default IK spline handle settings, with a Number of Spans set to 1, creates a curve with four points. This is normally enough points for a human backbone, but if necessary you can increase the number of points, and thus the complexity of the curve, by increasing the span setting. Try moving some of the points to see how that flexes the skeleton by the solver rotating the joints.
Repeat steps 1 to 3 on the upper spine skeleton in the neck area of the character, naming the spline IK nodes ctUpSpineIk and ctUpSpineCurve.

Do not be alarmed if you see a pink warning appear in the feedback field when you add the spline IK to the skeletons. This occurs because the spline IK handle is automatically selected, and you are never supposed to transform it like a standard IK handle. Maya is just indicating that spline IK should be controlled only by transforming the curve components. You'll learn how to do that in the next section

Creating the Spine Icon Controls

Since manually moving points on a curve is tedious, it is best to indirectly control the shape of the curve through icons. In the past, this was often done by creating clusters on the points and parenting the clusters under different icons. Instead, the technique shown here smooth-binds the spline IK curves to the two-joint skeletons created at the bottom, middle, and top of the spine.

Bind the lower spline IK curve by Shift-selecting the root joints of the bottom and middle skeletons followed by the curve, and choose Skin > Bind Skin > Smooth Bind . In the dialog box, set bind to Joint Hierarchy using the Closest Distance method, set the Max Influences to 5, the Dropoff Rate to 4, and turn on all the other check boxes (see FIGURE 4.26). Then click Bind Skin to apply the settings.

Figure 4.26 Binding the spline IK curve to joints parented under the icons allows easy manipulation of the points on the curve.
Repeat the same binding process on the upper spine curve to the middle and top spine joints. After binding, rotating the joints should deform the curves and flex the spline IK skeletons.
To make animating the spline IK easier, parent the two-joint skeletons under icons. You should parent the bottom and top skeletons under the hip and head icons. Since there is no icon for the middle skeleton, you should create a new box icon in the upper chest area.
Run your box icon code, and transform and shape the icon to fit around the upper chest of the character, naming it ctSpine. Then parent the middle skeleton under the spine icon.

Rotating the icons will now flex the lower and upper spine skeletons, but the movement still doesn't look good because the rest of the hierarchy is not yet moving with the controls. Ignore this for now, as you have to complete a few more tasks before parenting all the nodes together.

Making the Lower Spine Stretchy

The curves stretch a little when you rotate the controls. This effect is not very obvious on the neck, but is more noticeable on the lower spine skeleton when the spine icon is moved and rotated. Too much movement causes the joints to become separated from the curve. For this reason, it is advisable to add some stretchy qualities to the skeleton joints. Of course, this is also a very useful technique for creating cartoon-style squash and stretch effects. However, even realistic character rigs look better with a little stretchiness added to their main backbone skeleton.

An easy way to add stretchiness to the lower spine is to write a math expression that uses the length of the curve to drive the scaling in local X axis of the spine joints. If you translate the joints in this direction, it effectively lengthens the skeleton. Translation propagates down the skeleton hierarchy differently than actually scaling the joints, but either technique can produce good stretching controls.

To add stretchiness to the lower spine joints:

Create a node on the ctLowSpineCurve curve that contains a channel that registers its length. Select the curve, and run the following MEL command on the command line: arclen -ch 1;
With the curve still selected, choose Window > Hypergraph: Connections to find a node named curveInfo1, and open it in the Attribute Editor. You will see an arcLength channel that registers the length of the curve (see FIGURE 4.27).

Figure 4.27 To add some stretch to the spine, you must first create a curveInfo1 node that has a channel that registers the length of the spline IK curve.

The 7.47 value displayed is the default length of the curve, and will be used in the expression to make the skeleton stretch. Keep in mind that this value will change for different-sized characters.
Open the Expression Editor, and write an expression line for each joint in the lower spine skeleton, starting at the second joint. Here is what each line of the expression should look like:
```
ctLowSpine1.tx = 1.36 * ((curveInfo1.arcLength / 7.47) / topNode.sy);
```
The main part of this expression divides the current length channel value by the default value to determine if the curve has been stretched or compressed. This is multiplied by the joint's default translateX value, in this case 1.36, to drive the actual translation. Finally, dividing by the top node scaling in Y will keep the joints sized correctly in relation to the overall rig size. If the top node of the character is scaled to better fit the scene, for instance, the expression will compensate.
Copy and paste this expression line for each joint of the lower spine skeleton, only changing the joint name and the default X translation value. When you have finished, name the expression node stretchySpine, and click Create and Close.
Move and rotate the spine icon to test the stretching on the joints of the skeleton. You should see the Maya skeleton stretch while every two polygon bones move with the joints. When the skin is bound, this movement will produce a smooth stretch.

Setting the Advanced Spline IK Twist Attributes

Currently, if you rotate the icons in Y, the spine skeleton won't rotate in its local X axis to twist the backbone. This is because spline IK twisting is not controlled by the points on the curve, but instead by a special attribute on the IK solver. In the past, it was common to drive the twist-and-roll channels on the handle to control twisting. Now Maya has an even easier option available on the IK handle, called the advanced twist attributes.

To set advanced spline IK twist attributes:

In the Hypergraph, right-click the ctLowSpineIk IK handle to open the handle in the Attribute Editor, and click the IK Solver Attributes section to display the disabled Advanced Twist Controls.
Turn on the Enable Twist Controls option and set these Advanced Twist controls (see FIGURE 4.28):
- Since you are using icons to twist the skeletons, set the World Up Type to Object Rotation Up (Start/End).
- Then set negative Z as the Up Axis and Vector in the next three options. This relates to the X orientation of the skeleton joints.
- Most importantly, type the full name of the hips icon into the first World Up Object field, and type the spine icon name in the second World Up Object field.
  
  Figure 4.28 Spline IK curves won't twist unless you drive special attributes on the IK handle. You can easily do this by setting the advanced twist attributes in the Attribute Editor.
Click Close to close the Attribute Editor, and repeat steps 1 through 2 on the upper spine IK handle.

This gives you all the nodes required to put together the hierarchy for the advanced backbone and finalize the torso rig.

Completing the Advanced Torso Rig

To connect all the advanced backbone nodes into the basic hierarchy:

All the parts of the rig that used to move with the original backbone skeletons, such as the head and arms, should now move with the spline IK skeletons. The easiest way to do this is to re-parent the ctBackPad0 group node under the end joint of the new lower spine skeleton.
To make the original FK backbone joints control the new spline IK, simply parent the spine icon under the ctBack2 joint. Since you are parenting the icon under a joint, insert group node pads between these controls to make sure that the spine icon generates world values when rotating.
Rotate the original backbone joints to see if they move the spine icon, which in turn should move the spline IK skeletons. This setup gives you two levels of controls for manipulating the backbone. You should streamline the advanced backbone controls by adding custom channels on the icon; these channels will drive the FK rotation of the backbone joints using SDKs (see FIGURE 4.29).

Figure 4.29 Parent the new spine icon under the original FK backbone joints to create two levels of backbone controls.
Parent all other new spline IK nodes under the DoNotMove node at the top of the rig hierarchy. Since you are already controlling the new skeletons through the spline IK curves, it is not necessary to have them also move with parent transformations; that latter could move the nodes twice as far as they should move, called a double transform.

In addition to creating spline IK spine controls, upgrading the torso should also involve adding skeletons to the chest, ribs, and stomach to improve deformations on the skin when the backbone bends (see FIGURE 4.30). Draw the skeletons in the same way as done on the advanced face controls, and parent them to the closest spline IK backbone joints.

Figure 4.30 Add and drive skeletons in the chest, ribs, and torso to improve deformations, and to create muscle and skin effects.

Exercise 4.2: Scripting the Advanced Head and Torso

This exercise examines important details in the head and torso advanced rigging scripts. These two scripts complete the advanced controls, and make the rig ready for binding and adding a character GUI in the next two chapters.

As these scripts follow the same format as previously shown scripts, this exercise examines only the sections that show new techniques. For instance, the code that creates, parents, and drives skeletons in the face and chest will not be shown here. See the actual scripts for more details on this code.

Step 1: Create an Eye Jitter Control

The only new technique used in the CMaraffi_advHead script is a math expression that randomly moves the eye controls to make the eyes shake or jitter. The expression incorporates a rand function, similar to a MEL command, that generates random values between the minimum and maximum limits set in parentheses. For instance, in the following example, the function generates random float values between -10 and 10:

rand (-10.0, 10.0);

In the advanced head script application, custom channels with a range of -1 to 1 are used in the parentheses instead of static numbers. The random values generated are used to translate the target locators constraining the eyeballs. The code runs three addAttr commands to create three custom channels to use in the expression. The eyeJitter channel is the master channel on the eyes icon for animating the effect, and goes from 0 to 1. This channel drives the jitterMin and jitterMax channels to input values into the random function. Here is the MEL code (starting about line 222 in the cm_advHead procedure):

//Eye Jitter: Use expressions to create eye jitter controls:
   addAttr -ln "eyeJitter" -sn "ejt" -at "double" -min 0.0
           -max 1.0 -dv 0.0 -r 1 -w 1 -s 1 -k 1 $eyesIcon;
   addAttr -ln "jitterMin" -sn "jmn" -at "double" -min -1.0
           -max 0.0 -dv 0.0 -r 1 -w 1 -s 1 -k 1 $jitterGp;
   addAttr -ln "jitterMax" -sn "jmx" -at "double" -min 0.0
           -max 1.0 -dv 0.0 -r 1 -w 1 -s 1 -k 1 $jitterGp;
   string $jitExpLn1 = ($jitterGp + ".jitterMin = 0 - " +
          $eyesIcon + ".eyeJitter;\n");
   string $jitExpLn2 = ($jitterGp + ".jitterMax = 0 + " +
          $eyesIcon + ".eyeJitter;\n");
   string $jitExpLn3 = ($jitterGp + ".ty = 0 + rand(" +
          $jitterGp + ".jitterMin," + $jitterGp
          + ".jitterMax);\n");
   string $jitExpLn4 = ($jitterGp + ".tx = 0 + rand(" +
          $jitterGp + ".jitterMin," + $jitterGp
          + ".jitterMax);\n");
   string $jitterExp = ($jitExpLn1 + $jitExpLn2 + $jitExpLn3 +
          $jitExpLn4);
   expression -n "eyeJitter_exp" -s $jitterExp;

Running the script creates the following expression in the Expression Editor:

ctEyeJitter_group.jitterMin = 0 - ctEyes_icon.eyeJitter;
ctEyeJitter_group.jitterMax = 0 + ctEyes_icon.eyeJitter;
ctEyeJitter_group.ty = 0 +
   rand(ctEyeJitter_group.jitterMin,ctEyeJitter_group.jitterMax);
ctEyeJitter_group.tx = 0 +
   rand(ctEyeJitter_group.jitterMin,ctEyeJitter_group.jitterMax);

Once the expression is implemented, you simply increase the eyeJitter channel on the eyes icon to see the eyes move. The reversed signs on the first two lines of the expression cause the minimum and maximum channels to go in different directions when the master eyeJitter channel on the eyes icon is increased, which in turn increases the limits in the random function, producing more jitter. Since the expression requires the interface to update, play the timeline to see the full jitter effect. A large amount of jitter is obviously a very cartoony look, and a common effect used on anime characters. But you can use a little eye jitter on realistic characters to add subtle tension to the eyes.

Step 2: Create the New Backbone Skeletons

The CMaraffi_advTorso script contains a single local procedure that creates all the advanced torso controls, including the spline IK backbone. The first step in creating the advanced torso controls (not shown here) is sourcing scripts, declaring all required names in variables; and renaming joints in the backbone, head, and hips that will become control joints rather than bind joints. This section in the cm_advTorso procedure also creates a new spine icon and fits it around the upper chest area using a circular curve that is part of the FK rig hierarchy.

The next section of code, starting around line 109 in the script, creates the spline IK backbone skeletons. Two loops are used to create the new lower and upper skeletons. The polygon vertebrae intentionally were numbered from 0 to 21 to facilitate running these loops. The code in the loops reference center points on the polygon bones, to position the joints in the center between each vertebra. Lastly, in addition to creating the two main spine skeletons, three new two-joint skeletons also are created in the hips, chest, and head areas. These skeletons will bind the spline IK curves in the next section of the script.

//Skels: Create the lower spine skeleton using poly vertebrae 0-12:
   string $targetObj[];
   string $targetPt[];
   int $i;
   for ($i = 0; $i < 13; $i++){//Open loop...
     $targetObj[size($targetObj)] = $vertebrae[$i];
     $targetPt[size($targetPt)] = ".vtx[24]";
     $i = ($i + 1);
   }//Close loop.
   string $lowSpineSkels[] = cm_skelCreate (7,$targetObj,$targetPt,
          $lowSpineName,0,"xdown",0,1);
   string $lowSpineJts[] = sort (`listRelatives -ad -typ "transform"
          $lowSpineSkels[0]`);
 //Create the bottom spine skeleton using the polygon pelvis:
   string $targetObj[] = {$pelvisPoly,$hipsEnd};
   string $targetPt[] = {".vtx[0]","obj"};
   string $botSpineSkel[] = cm_skelCreate (2,$targetObj,$targetPt,
          $botSpineName,0,"xup",0,1);
 //Create the middle spine skeleton using polygon vertebrae 12-15:
   string $targetObj[] = {$vertebrae[12],$vertebrae[15]};
   string $targetPt[] = {".vtx[24]",".vtx[25]"};
   string $midSpineSkel[] = cm_skelCreate (2,$targetObj,$targetPt,
          $midSpineName,0,"xdown",0,1);
 //Create the top spine skeleton using main head skeleton:
   string $targetObj[] = {$headRoot,$headEnd};
   string $targetPt[] = {"obj","obj"};
   string $topSpineSkel[] = cm_skelCreate (2,$targetObj,$targetPt,
          $topSpineName,0,"xdown",0,1);
 //Create the upper spine skeleton using polygon vertebrae 15-21:
   clear $targetObj;
   clear $targetPt;
   for ($i = 15; $i < 22; $i++){//Open loop...
     $targetObj[size($targetObj)] = $vertebrae[$i];
     $targetPt[size($targetPt)] = ".vtx[25]";
     $i = ($i + 1);
   }//Close loop.
   string $upSpineSkels[] = cm_skelCreate (4,$targetObj,$targetPt,
          $upSpineName,0,"xdown",0,1);
   string $upSpineJts[] = sort (`listRelatives -ad -typ "transform"
          $upSpineSkels[0]`);

Step 3: Add Spline IK to the Spine Skeletons

The next section of the cm_advTorso procedure adds spline IK to the two spine skeletons, and smooth-binds the resulting curves. Since the spline IK options are the defaults, it is not necessary to explicitly specify all the flags on the ikHandle commands. The rename commands are renaming the spline IK curves, since there is no flag on the ikHandle command for naming the curves. Finally, the section ends by running skinCluster commands to smooth-bind the two curves to the appropriate joints created in the last section of code.

//Spline IK: Add spline Ik to the two new spine skeletons:
   string $lowSpineIk[] = `ikHandle -n ($lowSpineName + "_spIk")
          -sol "ikSplineSolver" -pcv false
          -sj $lowSpineSkels[0] -ee $lowSpineSkels[1]`;
   string $upSpineIk[] = `ikHandle -n ($upSpineName + "_spIk")
          -sol "ikSplineSolver" -pcv false
          -sj $upSpineSkels[0] -ee $upSpineSkels[1]`;
 //Rename the spline ik curves from default names:
   string $lowSpineCurve = `rename $lowSpineIk[2]
          ($lowSpineName + "_curve")`;
   string $upSpineCurve = `rename $upSpineIk[2]
          ($upSpineName + "_curve")`;
 //Bind the curves to the hips, spine, and head root joints:
   skinCluster -n ($lowSpineName + "_smBind") -dr 4 -mi 5 -omi 1 -rui 1
               $botSpineSkel[0] $midSpineSkel[0] $lowSpineCurve;
   skinCluster -n ($upSpineName + "_smBind") -dr 4 -mi 5 -omi 1 -rui 1
               $midSpineSkel[0] $topSpineSkel[0] $upSpineCurve;

Step 4: Create a Stretchy Spine

Once the spline IK skeletons are created, the joints can be made to stretch when the curve is manipulated. Code in the next section of the cm_advTorso procedure does this by first running the arclen command to add a curveInfo node to the lower spine curve, and then using a getAttr command to establish the default length. This length is ultimately used in the math expression to drive the X translation of the lower spine joints. Then the expression lines are created by running several loops. The first loop runs a getAttr command to query each joint's default X translation value; these values are used in each line of the expression. The lines are generated by the second loop and added to the positions in the $spineExpLines string array. Lastly, the array strings are combined in the third loop into a single string, and then run in the expression command.

//Spine Stretch: Use expression to drive joint movement:
   string $lengthNode = `arclen -ch 1 $lowSpineCurve`;
   float $lengthVal = `getAttr ($lengthNode + ".arcLength")`;
 //Use loop to get tx values on all joints in array:
   float $txValues[];
   string $joint;
   for ($joint in $lowSpineJts){//Open loop...
        $txValues[size($txValues)] = `getAttr ($joint + ".tx")`;
   }//Close loop.
 //Use loop to create each line of expression string:
   string $spineExpLines[];
   int $i;
   for ($i = 0; $i < size($lowSpineJts); $i++){//Open for loop...
        $spineExpLines[$i] = ($lowSpineJts[$i] + ".tx = " +
        $txValues[$i] + " * ((" + $lengthNode + ".arcLength / " +
        $lengthVal + ") / " + $topNode + ".sy);\n");
   }//Close loop.
 //Use loop to combine expression strings into single string:
   string $expLine;
   string $spineExp;
   for ($expLine in $spineExpLines){//Open loop...
        $spineExp = ($spineExp + $expLine);
   }//Close loop.
   expression -n "spineStretch_exp" -s $spineExp;

Step 5: Set the Advanced Twist Attributes

The next section of the cm_advTorso procedure uses a loop to set the advanced twist attributes on both spline IK skeletons. Within the loop, a series of connectAttr commands connect the worldMatrix channels of the icons to the dWorldUpMatrix and dWorldUpMatrixEnd channels of the curves. Channels like these are somewhat obscure, and do not always appear in the History field when you make these connections in the Attribute Editor. Instead, other Maya procedures come up, and you must track down these channels inside those procedures.

//Adv Twist: Use loop to set the advanced spline IK controls:
   string $splineIks[] = {$lowSpineIk[0],$upSpineIk[0]};
   string $splineIk;
   for ($splineIk in $splineIks){//Open loop...
     setAttr ($splineIk + ".dTwistControlEnable") 1;
     setAttr ($splineIk + ".dWorldUpType") 4;
     setAttr ($splineIk + ".dWorldUpAxis") 4;
     setAttr ($splineIk + ".dWorldUpVectorY") 0;
     setAttr ($splineIk + ".dWorldUpVectorEndY") 0;
     setAttr ($splineIk + ".dWorldUpVectorZ") -1;
     setAttr ($splineIk + ".dWorldUpVectorEndZ") -1;
   }//Close loop.
 //Connect the new spline IK to the hips, spine, and head icons:
   connectAttr -f ($hipsIcon + ".worldMatrix")
               ($lowSpineIk[0] + ".dWorldUpMatrix");
   connectAttr -f ($spineIcon[0] + ".worldMatrix")
               ($lowSpineIk[0] + ".dWorldUpMatrixEnd");
   connectAttr -f ($spineIcon[0] + ".worldMatrix")
               ($upSpineIk[0] + ".dWorldUpMatrix");
   connectAttr -f ($headIcon + ".worldMatrix")
               ($upSpineIk[0] + ".dWorldUpMatrixEnd");

Step 6: Parent the Advanced Backbone Nodes

To finalize the advanced spine controls in the cm_advTorso procedure, the main spline IK nodes are first grouped and parented under the DoNotMove node. Then the polygon vertebrae are parented under the appropriate joints, and the new skeletons in the hips, chest, and head are parented under the hips, spine, and head icons. Finally, a parent constraint forces the backPad0 group node to move with the new lower spine skeleton, which in turn makes all the controls in the head and arms follow the new backbone controls. This technique is a variation of the parenting done in the "Building an Advanced Torso Rig" section.

The last two setAttr commands in this section keep the curves from inadvertently being animated through any of the parenting connections, by blocking them from inheriting transforms; this prevents a double transform on the spline IK skeletons.

//Hierarchy: Create groups for the new icon and skeletons:
   group -p $doNotMove -n "ctSpine_group" $lowSpineSkels[0]
         $upSpineSkels[0] $lowSpineIk[0] $upSpineIk[0]
         $lowSpineCurve $upSpineCurve;
 //Parent the vertebrae under the new skeletons:
   parent $vertebrae[0] $vertebrae[1] $lowSpineSkels[0];
   parent $vertebrae[2] $vertebrae[3] $lowSpineJts[0];
   parent $vertebrae[4] $vertebrae[5] $lowSpineJts[1];
   parent $vertebrae[6] $vertebrae[7] $lowSpineJts[2];
   parent $vertebrae[8] $vertebrae[9] $lowSpineJts[3];
   parent $vertebrae[10] $vertebrae[11] $lowSpineJts[4];
   parent $vertebrae[12] $vertebrae[13] $vertebrae[14]
          $vertebrae[15] $midSpineSkel[0];
   parent $vertebrae[16] $vertebrae[17] $upSpineSkels[0];
   parent $vertebrae[18] $vertebrae[19] $upSpineJts[0];
   parent $vertebrae[20] $vertebrae[21] $upSpineJts[1];
   parent $pelvisPoly $botSpineSkel[0];
   parent $skullPoly $topSpineSkel[0];
   parent $topSpineSkel[0] $headIcon;
 //Parent all other nodes:
   parent $backPad0 $doNotMove;
   parent $botSpineSkel[0] $hipsIcon;
   parent $midSpineSkel[0] $spineIcon[0];
 //Parent constrain the back pads to the new lower spine skel:
   parentConstraint -n "ctBackPad0_paCnst" -mo
                    $lowSpineSkels[1] $backPad0;
 //Set transform attributes on curves:
   setAttr ($lowSpineCurve + ".inheritsTransform") 0;
   setAttr ($upSpineCurve + ".inheritsTransform") 0;

Step 7: Create Pivot Controls for the Spine Icon

The next section of code in the cm_advTorso procedure uses constraints to create pivot controls for the spine icon. Constraints are useful because they can simulate parenting, but they also have weight channels that let you control the amount of the connection. Constraining a single node to multiple objects, for instance, lets you use a custom channel to drive the weight channels in opposite directions. The result is the connection to one node increases, while the other decreases. You can even make this type of connection to the center pivot of a node, rather than the normal transform channels.

The code first creates and positions three locators at the bottom, middle, and top of the spine icon. The middle locator is then point-constrained to the top and bottom locators, which positions it midway between the two. Then a connectAttr command connects the rotatePivot channel of the spine icon to the translation of the middle locator. This causes the center pivot of the icon to follow the locator, which in turn follows the other locators through the constraints. The SDK section later in this script creates a custom channel on the spine icon to drive the weight channels on these constraints, which will move the middle locator up and down, and in turn move the pivot of the icon. Because all these channels are keyable, the animator will be able to animate the pivot to rotate the icon in a variety of ways.

//Use constraints to control pivot of spine icon:
   string $locNames[] = {$lowSpineName,$midSpineName,$upSpineName};
   string $targets[] = {$lowSpineJts[2],$spineIcon[0],$upSpineSkels[0]};
 //Use loop to create locators:
   string $pivotLocs[];
   for ($i = 0; $i < 3; $i++){//Open loop...
     string $locs[] = `spaceLocator -n
          ("ct" + $locNames[$i] + "_loc")`;
     print ("locator created: " + $locs[0] + "\n");
     cm_runLocals ("nodeMover",{$targets[$i],$locs[0],
                "0","0","0"});
     $pivotLocs[size($pivotLocs)] = $locs[0];
   }//Close loop.
 //Point constrain the center locator to the other two locators:
   group -p $spineGps[1] -n "ctSpinePivs_group" $pivotLocs[0]
       $pivotLocs[1] $pivotLocs[2];
   string $spineCnst[] = `pointConstraint -n "ctSpinePiv_poCnst"
          $pivotLocs[0] $pivotLocs[2] $pivotLocs[1]`;
 //Make the connection to make the locator control the pivot:
   connectAttr -f ($pivotLocs[1] + ".translate")
             ($spineIcon[0] + ".rotatePivot");

Step 8: Use Expressions to Create a Spine Stretch Color Warning

Skipping down to about line 500 in the cm_advTorso procedure, there is an expression for creating another color warning on the polygon bones. This warning tells the animator when the lower spine has been stretched too far. Similar to the warnings set on the limbs, the expression uses the curve channel to drive the warning, and incorporates an or (||) symbol in the expression to enable triggering the warning whenever the curve is either stretched or compressed beyond set values. Here is what the expression looks like:

if (curveInfo1.arcLength > 7.97 || curveInfo1.arcLength < 6.97)
       ctVertabrae_mat.incandescenceR = 1;
else ctVertabrae_mat.incandescenceR = 0;

This expression should be read as, "If the arcLength channel of curveInfo1 becomes greater than 7.97 or less than 6.97, then set the vertebrae materials incandescence red channel to 1. Else, set the incandescence red channel to 0."

Reading expressions in plain English like this makes it easy to see what the math expression is actually doing, and is a good starting point for composing your own expressions. Since this is not a cartoon character, the values used for the upper and lower limits in the expression are just slightly beyond the default size of the curve. But the values are really up to you: Feel free to adjust these based on the realism of your character. Here is the code in the script:

//Expressions: Spine stretch color warning:
   float $upLimit = ($lengthVal + 0.5);
   float $lowLimit = ($lengthVal - 0.5);
   string $warnColor = "ctVertabrae_mat";
   string $warnExpLine1 = ("if (" + $lengthNode + ".arcLength > "
          + $upLimit + " || " + $lengthNode + ".arcLength < "
          + $lowLimit + ") " + $warnColor + ".ir = 1;\n");
   string $warnExpLine2 = ("else " + $warnColor + ".ir = 0;\n");
   expression -n "stretchWarn_exp" -s ($warnExpLine1 + $warnExpLine2);

Step 9: Create an Automatic Breathing Control

The next expression in the cm_advTorso procedure is designed to create breathing controls on several skeletons that were added to the chest area previously in this script. A cosine function is used to create a wave that drives the scaling in X of the joints, making the character appear to breathe in and out. The final expression looks like this:

ctChestFront_rootJt.sx = 1 - cos(time * ctTorso_icon.breathSpeed) * .03;
ctStomachFront_rootJt.sx = 1 - cos(time * ctTorso_icon.breathSpeed) * .03;
lfRibSide_rootJt.sx = 1 - cos(time * ctTorso_icon.breathSpeed) * .03;
rtRibSide_rootJt.sx = 1 - cos(time * ctTorso_icon.breathSpeed) * .03;

Notice that a time function is being input into the cos or cosine function, and multiplied by a breathSpeed channel on the torso icon. Time references the animation timeline, and makes the character breathe whenever the timeline is played. Multiplying by the breathSpeed channel creates a control for animating the speed of the breathing. Increasing the channel speeds up the breathing, and is only constrained by the limits you set on the driver channel in the initial addAttr command. Here is the code that creates the expression:

//Create breathing controls:
   addAttr -ln "breathSpeed" -sn "bsp" -at "double" -min 0.0
           -max 3.0 -dv 0.7 -r 1 -w 1 -s 1 -k 1 $torsoIcon;
   string $breathers[] = {$chestSkel[0],$stomachSkel[0],$ribSkels[0],
          $ribSkels[2]};
   //string $breathSizes[] = {};
   string $breathExpLines[];
   for ($i = 0; $i < 4; $i++){//Open loop...
   $breathExpLines[size($breathExpLines)] = ($breathers[$i] +
      ".sx = 1 - cos(time * " + $torsoIcon + ".breathSpeed) * .03;\n");
   }//Close loop.
   string $breathExpression = stringArrayToString($breathExpLines,"");
   expression -n "breathing_exp" -s $breathExpression;

Step 10: Create Optional Auto-Locomotion Torso Controls

The last sections in the cm_advTorso procedure create automatic controls for the torso to follow the leg icons when they move. These controls force the torso to follow the legs when they step, dip when the feet move apart, and shift weight to the opposite leg when a foot is raised. These are optional controls that are turned off by default, but can be turned on if useful for a specific scene. An autoControls channel is created on the torso icon to control the effect, and all the connections are multiplied by this master channel to globally turn the expressions on and off. By default, the channel is set to 0 or turned off.

The first automatic control in the code is created by direct node connections to keep the torso positioned between the leg icons in X and Z. This is done by an average operation using a plusMinusAverage node. In the script a createNode command is run, and then a setAttr command to the operation channel sets the node to 3, which indicates averaging. The translate channels of the leg icons are connected through the average node to the group node parent of the torso icon named torsoAuto0. This keeps the torso averaged between the two leg icons as the leg icons are moved. The multiplyDivide node is used to multiply the effect by the autoControls channel so that it can be turned off.

Here is the code for averaging the torso between the leg icons:

//Torso Auto-Connections: Create optional auto controls:
   addAttr -ln "autoControls" -sn "aut" -at "double" -min 0.0
           -max 1.0 -dv 0.0 -r 1 -w 1 -s 1 -k 1 $torsoIcon;
 //Create nodes needed for operation:
   string $average = `createNode plusMinusAverage
          -n "average_util"`;
   string $multiply = `createNode multiplyDivide
          -n "average2_util"`;
 //Set operation to average:
   setAttr ($average + ".operation") 3;
 //Connect the output of the left leg to the average node:
   connectAttr -f ($lfLegIcon + ".tx") ($average
               + ".input3D[0].input3Dx");
   connectAttr -f ($lfLegIcon + ".tz") ($average
               + ".input3D[0].input3Dz");
 //Connect the output of the right leg to the average node:
   connectAttr -f ($rtLegIcon + ".tx") ($average
               + ".input3D[1].input3Dx");
   connectAttr -f ($rtLegIcon + ".tz") ($average
               + ".input3D[1].input3Dz");
 //Set operation to multiply:
   setAttr ($multiply + ".operation") 1;
 //Connect the average node to the multiply node:
   connectAttr -f ($average + ".output3D") ($multiply + ".input1");
 //Connect the auto channel to the multiply node:
   connectAttr -f ($torsoIcon + ".aut") ($multiply + ".input2X");
   connectAttr -f ($torsoIcon + ".aut") ($multiply + ".input2Z");
 //Connect the multiply node to the torsoAuto group node:
   connectAttr -f ($multiply +".outputX") ($torsoAuto0 + ".tx");
   connectAttr -f ($multiply +".outputZ") ($torsoAuto0 + ".tz");

The next code in the automatic torso controls section uses math expressions to create a dip and weight-shift effect when the leg icons are moved. These expressions subtract the value of one leg from the other to find out how far the feet are apart from each other to drive the effect. The abs, or absolute value, function removes any negative signs from the distance value.

Here is the final dip expression that controls the Y translation of the group node parented over the torso icon. The expression subtracts the amount that the leg icon moves, dividing the effect by 6 to make the dip more subtle:

ctTorsoAuto0_group.ty = (0 - ((abs (lfLeg_icon.tx - rtLeg_icon.tx) + abs
(lfLeg_icon.tz - rtLeg_icon.tz)) / 6)) * ctTorso_icon.aut;

And here is the MEL code that creates the expression:

//Use expression to create an automatic dip on the torso:
   string $dipExpression = ($torsoAuto0 + ".ty = (0 - ((abs ("
          + $lfLegIcon + ".tx - " + $rtLegIcon + ".tx) + abs ("
          + $lfLegIcon + ".tz - " + $rtLegIcon + ".tz)) / 6)) * "
          + $torsoIcon + ".aut;\n");
   expression -n "dip_exp" -s $dipExpression;

The weight-shift conditional expression evaluates how much a leg has been raised in Y, and translates the group node in X. Again, the effect is divided by 4 to make the shift more subtle:

if (lfLeg_icon.ty > rtLeg_icon.ty) ctTorsoAuto1_group.tx = (0 –
   (abs (lfLeg_icon.ty - rtLeg_icon.ty) / 4) * ctTorso_icon.aut);
else ctTorsoAuto1_group.tx = (0 + (abs (lfLeg_icon.ty - rtLeg_icon.ty)
    / 4) * ctTorso_icon.aut);

And the code that creates the weight-shift expression:

//Use expression to create an automatic weight shift on the torso:
   string $wtShiftExp1 = ("if (" + $lfLegIcon + ".ty > "
          + $rtLegIcon + ".ty) " + $torsoAuto1
          + ".tx = (0 - (abs (" + $lfLegIcon + ".ty - "
          + $rtLegIcon + ".ty) / 4) * " + $torsoIcon
          + ".aut);\n");
   string $wtShiftExp2 = ("else " + $torsoAuto1
          + ".tx = (0 + (abs (" + $lfLegIcon + ".ty - "
          + $rtLegIcon + ".ty) / 4) * " + $torsoIcon
          + ".aut);\n");
   expression -n "wtShift_exp" -s ($wtShiftExp1 + $wtShiftExp2);

The final code in the cm_advTorso procedure creates a control to drive the global scaling of the whole character using a custom channel created on the character icon. This simply scales the top node of the character to better fit the scene, or to export the character to other programs like Motion Builder.

//Add global scaling channel on char icon to scale topNode:
   addAttr -ln "globalScale" -sn "sca" -at "double" -min 0.5
           -max 5.0 -dv 1.0 -r 1 -w 1 -s 1 -k 1 $charIcon;
   connectAttr -f ($charIcon + ".sca") ($topNode + ".sx");
   connectAttr -f ($charIcon + ".sca") ($topNode + ".sy");
   connectAttr -f ($charIcon + ".sca") ($topNode + ".sz");

The rest of the CMaraffi_advTorso script cleans up the channels on all the remaining icons, lists all the names in the torso hierarchy, and runs the procedure to create the torso rig. This process is similar to that used on all the other advanced scripts, so it will not be reviewed in this chapter. However, take a look at this code to make sure that you are clear on the details.

Wrapping Up

You should now be familiar with the advanced rigging techniques and scripts. Make sure that you compare the results in the interface with the code that is being run to fully understand the technical process. At this point, you have completed the iconic biped rig, and the character is ready for binding in the next chapter. You will also add other deformers such as blend shapes, geometry-based influence objects, and wrap deformers.

10 Important Points to Remember from this Chapter

Add skeletons to the basic rig to improve bind deformations and to avoid extensive manual weighting of points.
To ensure that channel numbers generate correctly on joints, insert group node parents that are oriented the same as the child joint.
Rather than make icons for every control, add custom channels to the main icons, and use them to drive secondary controls.
Use SDKs to drive any controls that don't require math computations. SDKs have the advantages of creating animation curves that allow you to edit timing in the connection.
Use either math expressions or direct node connections for complex controls, depending on the needs of the production.
Lock and hide any channels that animators shouldn't keyframe on the icons, and set some kind of limits on all other icon channels.
Use spline IK when you want to combine the flexibility of FK with the ease of IK. In spline IK, you manipulate the points on the curve, not the IK handle.
Try to make your advanced scripts modular, so that they create controls for particular body areas.
For easy reference, organize global procedures that will be used in all the advanced scripts into one script file.
Design your advanced scripts so that they create the center and left-side controls first, and then have arguments to mirror the controls to the right side.

< Back Page 3 of 3

🔖 Save To Your Account

Peachpit Promotional Mailings & Special Offers

I would like to receive exclusive offers and hear about products from Peachpit and its family of brands. I can unsubscribe at any time.

Privacy Notice

Overview

Pearson Education, Inc., 221 River Street, Hoboken, New Jersey 07030, (Pearson) presents this site to provide information about Peachpit products and services that can be purchased through this site.

This privacy notice provides an overview of our commitment to privacy and describes how we collect, protect, use and share personal information collected through this site. Please note that other Pearson websites and online products and services have their own separate privacy policies.

Collection and Use of Information

To conduct business and deliver products and services, Pearson collects and uses personal information in several ways in connection with this site, including:

Questions and Inquiries

For inquiries and questions, we collect the inquiry or question, together with name, contact details (email address, phone number and mailing address) and any other additional information voluntarily submitted to us through a Contact Us form or an email. We use this information to address the inquiry and respond to the question.

Online Store

For orders and purchases placed through our online store on this site, we collect order details, name, institution name and address (if applicable), email address, phone number, shipping and billing addresses, credit/debit card information, shipping options and any instructions. We use this information to complete transactions, fulfill orders, communicate with individuals placing orders or visiting the online store, and for related purposes.

Surveys

Pearson may offer opportunities to provide feedback or participate in surveys, including surveys evaluating Pearson products, services or sites. Participation is voluntary. Pearson collects information requested in the survey questions and uses the information to evaluate, support, maintain and improve products, services or sites; develop new products and services; conduct educational research; and for other purposes specified in the survey.

Contests and Drawings

Occasionally, we may sponsor a contest or drawing. Participation is optional. Pearson collects name, contact information and other information specified on the entry form for the contest or drawing to conduct the contest or drawing. Pearson may collect additional personal information from the winners of a contest or drawing in order to award the prize and for tax reporting purposes, as required by law.

Newsletters

If you have elected to receive email newsletters or promotional mailings and special offers but want to unsubscribe, simply email ask@peachpit.com.

Service Announcements

On rare occasions it is necessary to send out a strictly service related announcement. For instance, if our service is temporarily suspended for maintenance we might send users an email. Generally, users may not opt-out of these communications, though they can deactivate their account information. However, these communications are not promotional in nature.

Customer Service

We communicate with users on a regular basis to provide requested services and in regard to issues relating to their account we reply via email or phone in accordance with the users' wishes when a user submits their information through our Contact Us form.

Other Collection and Use of Information

Application and System Logs

Pearson automatically collects log data to help ensure the delivery, availability and security of this site. Log data may include technical information about how a user or visitor connected to this site, such as browser type, type of computer/device, operating system, internet service provider and IP address. We use this information for support purposes and to monitor the health of the site, identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents and appropriately scale computing resources.

Web Analytics

Pearson may use third party web trend analytical services, including Google Analytics, to collect visitor information, such as IP addresses, browser types, referring pages, pages visited and time spent on a particular site. While these analytical services collect and report information on an anonymous basis, they may use cookies to gather web trend information. The information gathered may enable Pearson (but not the third party web trend services) to link information with application and system log data. Pearson uses this information for system administration and to identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents, appropriately scale computing resources and otherwise support and deliver this site and its services.

Cookies and Related Technologies

This site uses cookies and similar technologies to personalize content, measure traffic patterns, control security, track use and access of information on this site, and provide interest-based messages and advertising. Users can manage and block the use of cookies through their browser. Disabling or blocking certain cookies may limit the functionality of this site.

Do Not Track

This site currently does not respond to Do Not Track signals.

Security

Pearson uses appropriate physical, administrative and technical security measures to protect personal information from unauthorized access, use and disclosure.

Children

This site is not directed to children under the age of 13.

Marketing

Pearson may send or direct marketing communications to users, provided that

Pearson will not use personal information collected or processed as a K-12 school service provider for the purpose of directed or targeted advertising.
Such marketing is consistent with applicable law and Pearson's legal obligations.
Pearson will not knowingly direct or send marketing communications to an individual who has expressed a preference not to receive marketing.
Where required by applicable law, express or implied consent to marketing exists and has not been withdrawn.

Pearson may provide personal information to a third party service provider on a restricted basis to provide marketing solely on behalf of Pearson or an affiliate or customer for whom Pearson is a service provider. Marketing preferences may be changed at any time.

Correcting/Updating Personal Information

If a user's personally identifiable information changes (such as your postal address or email address), we provide a way to correct or update that user's personal data provided to us. This can be done on the Account page. If a user no longer desires our service and desires to delete his or her account, please contact us at customer-service@informit.com and we will process the deletion of a user's account.

Choice/Opt-out

Users can always make an informed choice as to whether they should proceed with certain services offered by Adobe Press. If you choose to remove yourself from our mailing list(s) simply visit the following page and uncheck any communication you no longer want to receive: www.peachpit.com/u.aspx.

Sale of Personal Information

Pearson does not rent or sell personal information in exchange for any payment of money.

While Pearson does not sell personal information, as defined in Nevada law, Nevada residents may email a request for no sale of their personal information to NevadaDesignatedRequest@pearson.com.

Supplemental Privacy Statement for California Residents

California residents should read our Supplemental privacy statement for California residents in conjunction with this Privacy Notice. The Supplemental privacy statement for California residents explains Pearson's commitment to comply with California law and applies to personal information of California residents collected in connection with this site and the Services.

Sharing and Disclosure

Pearson may disclose personal information, as follows:

As required by law.
With the consent of the individual (or their parent, if the individual is a minor)
In response to a subpoena, court order or legal process, to the extent permitted or required by law
To protect the security and safety of individuals, data, assets and systems, consistent with applicable law
In connection the sale, joint venture or other transfer of some or all of its company or assets, subject to the provisions of this Privacy Notice
To investigate or address actual or suspected fraud or other illegal activities
To exercise its legal rights, including enforcement of the Terms of Use for this site or another contract
To affiliated Pearson companies and other companies and organizations who perform work for Pearson and are obligated to protect the privacy of personal information consistent with this Privacy Notice
To a school, organization, company or government agency, where Pearson collects or processes the personal information in a school setting or on behalf of such organization, company or government agency.

Links

This web site contains links to other sites. Please be aware that we are not responsible for the privacy practices of such other sites. We encourage our users to be aware when they leave our site and to read the privacy statements of each and every web site that collects Personal Information. This privacy statement applies solely to information collected by this web site.

Requests and Contact

Please contact us about this Privacy Notice or if you have any requests or questions relating to the privacy of your personal information.

Changes to this Privacy Notice

We may revise this Privacy Notice through an updated posting. We will identify the effective date of the revision in the posting. Often, updates are made to provide greater clarity or to comply with changes in regulatory requirements. If the updates involve material changes to the collection, protection, use or disclosure of Personal Information, Pearson will provide notice of the change through a conspicuous notice on this site or other appropriate way. Continued use of the site after the effective date of a posted revision evidences acceptance. Please contact us if you have questions or concerns about the Privacy Notice or any objection to any revisions.

Last Update: November 17, 2020

Email Address