I design my pipeline tools for longevity. I want both the artist and the programmer to easily extend the tool’s use to be applicable as project goals shift over time.
On the software side, this means leveraging inheritance and composition of classes where possible to streamline applicability to new characters or assets.
For the artist, data structures like rig systems and skeletons can be created with Pyside UI tools, then saved out as templates to be reused as starting points for more complex assets in the future.
Specific applications of these design principles are discussed in the project breakdowns below.
Skeleton Editor
Auto Control Rig
Code samples on my GitHub.
My Control Rig tools are designed to able to expand to any rig type. The Python code structure allows the system to be extended by creating new module classes from an abstract base class that defines generalized creature parts like arms or legs. This way, a standardized character type like a human only needs to be designed for once, and then any future character with a similar skeletal structure can reuse the script logic. Artists who use the tool are also given the ability to package the work they have done into template .json files, so rigging logic like FK/IK, and control shapes can be saved and standardized between rigs.
Module Builder
The first tool is a PySide2 UI that allows the user to create and define modules, control system logic, and connections between body parts. When the UI is opened, it checks the scene for bind joints with specific string attributes that define what module they belong to. If they exist in the scene, the UI pulls a reference to the corresponding module class from a registry and allows the user to interact with its methods.
Nodes are given a variety of extra attributes when created, so their identity is more specific then their string name or kNode internal identity. Joints can be bind joints, driver joints, FK joints, etc., which makes them easier to find by helper functions.
All node logic is done with matrix math, meaning no Maya constraints are used in my rigs. This allows be to have flat hierarchies for performance gain, and cleaner node connections.
The tool is designed to give more bidirectional freedom to the user than Maya usually allows. If an arm is given the FK and IK features, a switch is automatically created for that module. If the user later wants to remove the FK feature, the tool responds to this by removing the FK and the switch, while leaving the IK fully functional.
If the setup reaches a point that would make a good foundation for future rigs, the user can make a .json template file with “Save as Template.” This can be read by the UI later to call all of the same methods to make the same rig with the “Load Template” button.
Templates add module logic and temporary curves to be replaced later.
Shape Factory
Feature systems created with the Module Builder leave temporary NURBS circles that can be replaced using the Shape Factory. The user selects one, and then chooses a base shape, a starting scale, and a line thickness. From there, the CVs can be transformed for additional design, and assigned a color. Shapes can be mirrored with the “mirror” button, respecting the shape and orientation, as well as assigning the color standard (red on right side, blue on left).
As with the Module Builder, a template file can be created that holds the NURBS data for all shapes in a rig, like CVs, knots, degree, etc. This can be loaded again on future rigs. Because the NURBS are rebuilt from their primitives with OpenMaya, any shape design can be saved without issue.
Select a .json template created earlier to automatically recreate the control shapes.