AutoUV Ratio

http://www.renderheads.com/portfolio/UVAutoRatio/

Final character rigging project

Final Project - due week 11

Model or find a character that is over 20k triangles/10k quads.

The mesh should have good, descriptive quad topography.

Rig it. Each item below is worth a total of 10 possible points.

• anatomically sensible skeleton (correct number and placement of joints)
• excellent skin weighting 
• consistent naming convention (ideally the one used in this class)
• IK setup for the legs. Setup should include pole vector controllers and roll/etc set driven keys if needed.
• curve controls for all FK joints that need direct control.
• IK/FK switch for arms, using the method demonstrated in class.
• finger control set up either via SDK, FK curve controls, or both. 
• face rig with controls for eyes, lids, brows, mouth, jaw, etc.
• IK-spline control with twist and roll built into the control
• all "untouchables" locked (and hidden if necessary) 
• all possible controls feature frozen transforms and/or zero-default attributes

These are worth 5 points each:

• non-rendering polygon controls as a replacement for all or most curve controls
• clothing items or accessories bound in an appropriate fashion
• character set(s)

Tips on drawing skeletons

• Use Skeleton>joint tool to draw joints
• Draw joints in orthographic viewports for limbs aligned along an XYZ plane
• Usually, this means choosing a view that bisects the limb's primary plane of motion.
  • side view: spine, neck/head, legs
  • top view: arms
  • front view: fingers
• Draw limb joints with a slight bend in them. Place elbow and knee joints slightly closer to the kneecap/elbow point, rather than directly in the center.
• You can select a joint, activate the move manipulator (w), and hold down "d" while moving the joint. This will allow you to move a joint without effecting the position of the joint's children. 

Project 3 checklist

• everything from project 1 and 2
• skinning - best possible deformations
• IK / FK switch on both arms
• curve controls for FK arms
• facial rig
• jaw and eyelid bones
• blendshapes:
• mouth wide, purse
• brow raise, purse for both sides
• face UI

IK/FK switch tutorial

IK/FK arm setup

1. make sure scene and rig are keyframe-free

2. pick a side to work on (in this example, left)

3. duplicate left arm (JT_arm_L) from arm joint down.

4. on the duplicate, make sure translate channels are unlocked, and unparent (shift-P) from clavicle. Isolate the selected joint in the viewport menu [show>isolate select]

5. in the hyper graph (or the viewport), select the roots of the four finger joint chains and the thumb chain of the duplicated arm chain. Delete them. This chain should now contain the arm, elbow, wrist and wrist end joints. 

6. Rename the joint JT_arm_FK_L, and rename the first three children (easiest to do from the hyper graph): 

• JT_elbow_FK_L, 
• JT_wrist_FK_L, 
• JT_wristEnd_FK_L

6. select JT_arm_FK_L and assign it to a new display layer called "FK", and exit out of isolate select mode. 

7. duplicate JT_arm_FK_L. Rename the joint JT_arm_IK_L, and rename the children: 

• JT_elbow_IK_L, 
• JT_wrist_IK_L, 
• JT_wristEnd_IK_L

8. Assign JT_arm_IK_L to a new display layer called "IK".

Setup IK controls

1. turn off the  visibility of "FK" and "rig" display layers. the JT_arm_IK_L chain should be the only joints visible.

2. create an IK handle [solver: rotate plane, sticky] from JT_arm_IK_L to JT_wrist_IK_L. rename the ik to IK_arm_L

3. create another IK [same options] from JT_wrist_IK_L to JT_wristEnd_IK_L. rename to IK_wrist_L. 

4. create a nurbs circle. this will become the IK controller. play with the options in the channel box and/or adjust the vertices to reshape the curve if you wish. move the curve with V held down (snap to point) to snap the controller to the JT_wrist_IK_L joint. 

5. rename this object CTL_arm_IK_L. freeze the transformations [modify>freeze transformations]. 

6. duplicate the object and move it with V held down, snapping it to JT_elbow_IK_L. from there, move it straight backwards on Z about 5 units. rename this object CTL_arm_PV_L, freeze the transformations. 

7. select CTL_arm_PV_L; shift-select IK_arm_L. Constrain> Pole Vector.

8. parent the two IK handles you just made to CTL_arm_IK_L (select them, select CTL_arm_IK_L last, and press P).

9. turn off the visibility of the two ik handles in the channel box. highlight all the channel names in the channel box, right click, and choose lock and hide selected. 

10. Assign the new ik-related CTL objects to the "IK" layer. 

Setup FK controls

1. turn off the  visibility of "IK" layer. the JT_arm_FK_L chain should be the only joints visible.

2. create a nurbs circle. rename it CTL_arm_FK_L. Group it by itself (ctrl+g) and name the group GRP_CTL_arm_FK_L.

3. select the JT_arm_FK_L joint, shift select the GRP_CTL_arm_FK_L node (find it in the hyper graph). constrain> parent[maintain offset = OFF]. the group and circle should pop up to the JT_arm_FK_L joint. 

4. find the constraint you just made in the hyper graph. delete it. 

5. select CTL_arm_FK_L, and rotate it so it orbits the upper part of the arm, then freeze the transforms. 

6. duplicate GRP_CTL_arm_FK_L, and rename "arm" to "elbow" for the GRP and CTL within. Using the above constrain and delete process, align the GRP to the JT_elbow_FK_L joint. adjust the CTL, freeze its transforms if needed. Repeat once more for the wrist joint. 

7. Parent GRP_CTL_wrist_FK_L to CTL_elbow_FK_L. Parent GRP_CTL_elbow_FK_L to CTL_arm_FK_L.

8. using the connection editor, connect the output rotation of CTL_arm_FK_L to the input rotation of JT_arm_FK_L. Repeat for the JT_elbow_FK_L and JT_wrist_FK_L joints.

Constrain the real arm skeleton to the FK and IK chains

1. Make the "rig" "FK" and "IK" display layers visible. You should be able to see all three arm joint chains.

2. Select the CTL_arm_FK_L, and rotate it so it is not in its neutral pose, such as -45 rotate y.  Move CTL_arm_IK_L in the opposite direction. 

3. Create a nurbs circle and rename it as CTL_IK_FK_L. move it so that it floats above the hand geometry. freeze the transforms. parent constrain [maintain offset = true] this node to the original wrist joint, JT_arm_L. 

4. With CTL_IK_FK_L selected, add a new attribute (modify>add attribute...)

5. Name the attribute "FK_IK" and give it a minimum of 0 and a maximum of 10. 

6. Turn the "IK" and "FK" display layers on. 

7. Select JT_arm_FK_L; shift select JT_arm_IK_L, JT_arm_L.

8. Constrain> orient [maintain offset = false]

9. JT_arm_FK_L should rotate to a position between the FK and IK joint chains.

10. With the joints still selected, press the down arrow key. The selection should migrate down to the elbow joint, but will still include the FK, IK, and original joint chain. Constrain>orient again (or press the g key to repeat let command).

11. Repeat step 10 one more time for the wrist joint. 

Use Set Driven Key to blend the constraints

1. Find the constraint nodes in the hyper graph.

2. Go to animate>set driven key

3. Load the constraint nodes in as "driven"

4. Load the CTL_IK_FK_L node in as "driver", with the "FK_IK" attribute selected.

5. With the "FK_IK" attribute on CTL_IK_FK_L set to 0, go to each constraint and lower the IK bone weight to zero.

6. Key each pair of constraint weights to the "FK_IK" attribute in the set driven key window.

7. Go back to CTL_IK_FK_L, change "FK_IK" to 10, and swap the weight values on each constraint. 

8. Key each weight pair once again.

Circle control generator

This script:

generates a string variable containing all the currently selected joints, and for each joint selected...

1. creates a circle 
2. finds the shape node of the circle
3. renames the circle as "selected joint" + shape
4. creates a new variable for the renamed shape, and parents it to the selected joint
5. deletes the transform node of the circle

You can run this script by copying this into the script editor and executing it. You can then either copy the circleAtJoint command to your shelf and run it from there, or type it into the script editor and execute the function name. Feel free to modify certain flags in the circle creation command, such as -r (radius) and -s (subdivisions).

global proc circleAtJoint()
{
 string $selectedJoints[] = `ls -sl`;
 for ($joint in $selectedJoints)
  {
  string $circle[] = `circle -c 0 0 0 -nr 1 0 0 -sw 360 -r 3 -d 3 -ut 0 -tol 0.01 -s 6 -ch 0`;
  string $circleShape[] = `listRelatives -s $circle[0]`;
  string $newShape = `rename $circleShape ($joint+"Shape")`;
  parent -r -s $newShape $joint;
  delete $circle[0];
  }
}

Smooth bind workflow

Maya offers two main methods of binding a character to a skeleton: Rigid and Smooth bind. We will be using smooth bind for the projects in this class. 

Typical smooth bind workflow:

1. Delete all non-deformer construction history on the character mesh
2. Bind character to the full skeleton using smooth bind, with the following options:
   1. Normalize weights: Interactive
3. Begin establishing initial bind by painting weights. A good initial bind should correct any incorrect weighting (wrist joint influencing hip area)
4. block in areas of 100% weighting on limbs/fingers on ONE side of character
5. Mirror weights to complete initial bind, cleanup any post-mirror weight issues.
6. Set keyframes and animate limbs from bind pose into problem poses
7. Working from the extremities inwards, begin corrective weight painting for joints as needed on ONE side of the character.
8. If needed, paint areas with the paint skin weights brush set to "smooth"
9. Mirror skin weights again, cleanup any post-mirror weight issues. Paint skin weights with smooth option if needed.
10. The easiest areas to establish good deformations on are areas such as the fingers, knee, wrist, head, etc. This is because there are fewer influences per vertex fighting for weight in these areas.
11. The hardest areas to establish good deformations on are areas such as the hips and shoulders. This is because there are more influences per vertex fighting for weight in these areas.

Rigging workflow suggestions

1. Save often.
2. Save MORE often.
3. Save iterative versions (backups) in a separate folder.
4. Break your rig intentionally...it's the only way to truly master rigging!
5. Examine existing rigs and try to understand their structure.
6. Try simple abstract experimental rigging in blank scene files.
7. Non-video game rigs can include a variety of different tools and concepts. It's possible to rig a character without using bones at all!