Skeleton for Face Rig

A jaw opens around a hinge. Moving its vertices directly between a closed shape and an open shape can produce a different path, with an unwanted loss of apparent volume during the transition. This lesson starts a joint-based head and jaw system so that jaw opening can come from rotation while the existing blendshapes continue to provide expression shapes.

The recording is an extended tool-building session: it first reduces clutter from repeated blendshape imports, then creates a small skeleton, makes its positions editable, rebuilds its hierarchy, and performs an initial skin bind. The final result is an initial bound skeleton. Weight refinement, attachments such as hair, and integration with the existing face controls remain unfinished. No exact Maya release is established.

Reduce repeated-import clutter before building the skeleton

During 00:00–07:00, the instructor identifies two sources of scene growth: retained target meshes and repeated imported materials. The importer previously hid each target after adding it to the head’s blendshape setup. In the revised sequence, the imported target is deleted after it has been assigned, and the recording verifies that the expression controls still affect the head.

The order is essential. The demonstrated deletion happens after the target has been incorporated into the blendshape history. It is not an instruction to delete source geometry before its shape data has been used, nor proof that every possible live target connection can be removed without consequence. Check the existing expression behavior after this importer change, before adding a second deformation system.

Materials are a separate problem. In the lesson’s import folder, OBJ files sit beside material files and associated images. Removing the unnecessary companion assets from that particular import set prevents the repeated material imports seen in the recording. Unused scene nodes are also cleaned up. For an actual asset library, make the geometry-only import set deliberately; the demonstration does not establish that every non-OBJ file elsewhere in a project is disposable.

Changing the retained objects also changes cleanup assumptions. The old clear-scene function still expects the target objects it used to remove and produces an error after those objects are no longer retained. That obsolete cleanup step is removed. Whenever a build stage stops creating something, review its corresponding teardown stage as well.

Create a small chain with deliberate selection and placement

At 07:00–15:02, a separate Python working tab isolates the skeleton experiment. The lesson imports maya.cmds, creates a function, and begins with the joint command. The first test exposes a selection dependency: a newly created joint can be parented beneath the currently selected object. Clearing the selection before beginning gives the new rig its own root.

The proposed chain contains a neck base, a middle neck joint, a head joint, a jaw hinge, and a final jaw-aim joint. Names include a head-rig identifier to distinguish this local setup from a future whole-body skeleton. That distinction matters because later functions find the joints by name.

The initial coordinates are fitted to the example character. The instructor estimates a starting position, inspects the head from useful views, adjusts the joint, and transfers the resulting coordinates back into the script. Those numbers are not a reusable anatomical prescription. The goal is to locate the neck supports and jaw hinge appropriately for the supplied mesh.

Parented transforms introduce another issue: the translation shown for a child is relative to its parent. The lesson temporarily unparents joints to inspect the world-level values needed for its placement setup. A small local translation is not evidence that the joint is near the scene origin. Keep the coordinate space explicit when transferring a position from the viewport into a script.

Use the final jaw point to establish a useful orientation

During 15:02–23:04, the instructor tests the joints’ axes rather than assuming that their positions alone establish a usable skeleton. The Orient Joint operation is inspected, and an attempt to apply its orientation flag during creation is corrected: the demonstrated operation needs to be applied afterward in edit mode.

The extra point at the front of the jaw supplies a child direction for the jaw hinge. Its purpose is to help establish the jaw’s rotation axes, not to add another independently animated facial feature. The lesson positions the hinge near the jaw’s pivot and the aim point along the intended direction, then records those example positions.

This separates two questions that can otherwise become confused: where does the joint pivot, and how are its local axes oriented? A correctly placed hinge with unsuitable axes can still make the animator’s intended rotation awkward. Inspect both before binding, and do not copy the recording’s coordinates without fitting them to the character.

The terminal joint is different from an interior joint because it has no child in this chain to provide the same orientation relationship. That distinction becomes important again when the orientation loop is implemented later.

Add labels that follow the placement joints

At 23:04–30:00, the tool selects the root hierarchy, stores the selected joints, and loops over them to create text curves. An early test displays the literal word item; removing the string quotes lets the loop variable supply each joint’s actual name.

The text-curve command returns a collection of values. The instructor prints the result and selects its first returned item as the object to manipulate. Inspecting the return value avoids assuming that every Maya command returns the same kind of object reference.

A parent constraint then aligns each label to its joint with maintain offset disabled. The first attempt reverses the arguments and moves the joints to the labels instead. Reversing the order makes the joint drive the text, which is the intended relationship. This is a concrete reminder to distinguish the constraint’s driver from the object being constrained before testing it on a placement rig.

The text is set to template display so it remains a guide while the joints are positioned. The labels help the user identify the neck base, head, hinge, and aim point without turning the labeling geometry into another object they must continually avoid selecting.

Separate joint placement from hierarchy reconstruction

During 30:00–40:00, a small window makes the intended sequence explicit: create the face skeleton, position its joints, then bind the skeleton. The interface is arranged as numbered steps using a grid layout. The third button will eventually run more than a bind operation; it also prepares the hierarchy for that bind.

The initially parented chain is inconvenient for placement because moving an ancestor also moves its descendants. The tool therefore stores the joint list, unparents the placement joints to world level, and lets the user position them independently. The labels continue to identify those separate points.

This design has a contract: the joints must keep their generated names. Local Python variables inside the creation function are not available as persistent references in the later function, so the reconstruction stage addresses the scene nodes by name. Renaming a placement joint breaks that lookup even if its position is correct.

At 40:00–45:00, the reconstruction function restores the chain from the end upward: jaw aim beneath jaw, jaw beneath head, head beneath middle neck, and middle neck beneath the base. The lesson checks the result by walking through the hierarchy. Label cleanup is added using the naming pattern assigned to the head-rig text. That pattern is part of this tool’s bookkeeping and should identify only its own labels.

Repair orientation and unparenting loops at their boundaries

During 45:00–51:02, the rebuilt hierarchy is selected and stored for an orientation loop. Each relevant joint is edited with the demonstrated xyz orientation setting. The instructor switches the Move tool to object space to inspect the axes rather than relying on the absence of a script error.

The loop initially encounters an error at the chain’s final joint. The lesson excludes the last stored item from the orientation operation. That works with the simple hierarchy and list order used here; it should not be read as a general method for identifying every leaf in an arbitrary branched skeleton. Inspect which joint the final list entry actually represents.

A separate warning comes from trying to parent the already world-level root to world again. The creation-stage loop is adjusted to skip the first stored item. Another error reveals that the selection-dependent parent operation needs the current loop item selected before it runs.

These repairs address different boundaries. Skipping the terminal joint concerns orientation. Skipping the root concerns unparenting. Selecting the current item concerns command context. Keeping those causes distinct makes the sequence easier to maintain than treating every warning as a reason to add another broad exception.

Bind the selected head, then evaluate the unfinished result

At 51:02–56:17, the tool needs a mesh as well as the known skeleton root. The user selects the base head, the function captures that selection, and the bind stage uses it with the root joint. The window instruction is clarified so that this selection happens after positioning and before the final button is pressed.

The recording uses a controlled test scene and clears history during part of that testing. It does not demonstrate a general history-cleanup procedure that preserves an already finished blendshape stack. Treat the integration with the earlier face rig as unfinished, as the instructor explicitly does at the end.

The initial bind produces movement, but that is only the first check. The instructor says the weights need work, other pieces such as hair need appropriate attachment, and the tool’s bind behavior still needs checking; a duplicate is also noticed near the end. The article therefore does not present the final click as a completed deformation solution.

Before advancing, inspect the restored hierarchy, local axes, selected head mesh, and resulting skin relationship. Test the head and jaw separately to see which regions move, then identify the weight corrections and attachments still required. The next stage must refine those deformations and connect the skeleton into the existing facial interface. This lesson establishes the editable placement-and-build workflow on which that work depends.