HyperRig#

HyperRig Features

:Advanced Rigging -Hyper Modular Rigging System:

The HyperRig module, designed as a comprehensive rigging tool for Autodesk Maya, encapsulates the functionalities of the previously discussed modules (asNode, eCtrl, eTest, eSpec, eMath, eRig, and eMod) into a user-friendly UI. This approach makes advanced rigging tools accessible to artists, streamlining their workflow. Here are some key features of the HyperRig module:

1. Integrated UI for Rigging Tools: HyperRig consolidates various rigging tools into a singular, intuitive user interface, making advanced rigging functionalities easily accessible to artists.

2. Body Rigging Tab: A dedicated tab for body rigging, incorporating tools from modules like eRig and eMod, allows for efficient creation and management of body rigs.

3. Facial Rigging Utilities: The module includes a specialized tab for facial rigging, offering tools for detailed facial expressions and head movements, essential for character animation.

4. Control Setup: HyperRig provides a tab for setting up and customizing rig controls, facilitating easy manipulation of character rigs during animation.

5. Skinning Features: A dedicated skinning tab in the UI helps artists efficiently bind geometry to rigs, crucial for realistic character movement.

6. Utility Tools: HyperRig includes a utilities tab, which encompasses various support tools and functions for rigging, enhancing overall workflow efficiency.

7. Motion Capture (MoCap) Integration: The module offers functionalities for integrating and working with motion capture data, essential for animating characters with real-life movements.

8. Customization and Flexibility: HyperRig allows for customization and flexibility in rigging, catering to the specific needs of different characters and animation styles.

9. Seamless Workflow Integration: The module is designed to integrate seamlessly with Maya’s environment, ensuring a smooth workflow for rigging and animation tasks.

10. User-Friendly for Artists: By providing a UI for complex rigging operations, HyperRig makes it more accessible for artists who may not be deeply familiar with scripting or technical aspects of rigging.

HyperRig represents a significant advancement in rigging tools for Maya, offering a comprehensive, user-friendly solution that streamlines the rigging process for artists and technical directors alike.

HyperRig.__confirmAction(self, action)#

HyperRig.__init__(self)#

as_Update_BuildBodyModule - For UI options in Body Module as_CreateTemplate - To go to ‘Create Template’ Button Function as_BuildBodyModule - To go to ‘Build Module’ Button Function

HyperRig._compileHyperRig(self, userFolder='$_Free_asEB')#

import shutil

mayaVer =HyperRig._mayaVer() userPath =’D:/My_Scripts/$_as_HyperRig/$_Scripts_Sold/{}/’.format(userFolder) verPath =userPath + str(mayaVer) if not os.path.exists(verPath):

os.makedirs(verPath)

scriptPath =’D:/My_Scripts/as_Scripts/’ pycFiles =[‘as_HyperRigMain.pyc’, ‘asNode.pyc’, ‘as_eRigMain.pyc’, ‘as_eCtrlMain.pyc’, ‘as_eSpecMain.pyc’, ‘as_eModMain.pyc’, ‘as_eMathMain.pyc’, ‘as_eTestMain.pyc’]

import asNode importlib.reload(asNode) from asNode import *

import as_eRigMain importlib.reload(as_eRigMain) from as_eRigMain import *

import as_eCtrlMain importlib.reload(as_eCtrlMain) from as_eCtrlMain import *

import as_eSpecMain importlib.reload(as_eSpecMain) from as_eSpecMain import *

import as_eTestMain importlib.reload(as_eTestMain) from as_eTestMain import *

import as_eMathMain importlib.reload(as_eMathMain) from as_eMathMain import *

import as_eModMain importlib.reload(as_eModMain) from as_eModMain import *

from as_HyperRigMain import * import as_HyperRigMain importlib.reload(as_HyperRigMain)

from as_HyperRigMain import * import as_HyperRigMain importlib.reload(as_HyperRigMain) #HyperRig.as_HyperRig()

HyperRig._isInTime(self, startDate=[2017, 1, 1], endDate=[2018, 1, 1], onlineTime=1, showDaysLeft=1, bufferTime=1)#

HyperRig._mayaVer(self)#

HyperRig.add_AttrDivider(self, ctrlList=None, **shArgs)#

[shArgs : cl=ctrlList]

Purpose:

:: Adds an attribute divider to organize custom attributes in the channel box of a controller.

• Provides a clean and organized way to separate custom attributes from default ones.

• Enhances readability and usability of the channel box in complex rigs.

• Useful in rigs with a high number of custom attributes.

Parameters:

ctrlList – <list> # List of controllers to add the attribute divider to.

Returns:

None # This function does not return a value but modifies the channel box of the specified controllers.

Code Examples:

>>> add_AttrDivider(ctrlList=['ctrl1', 'ctrl2'])
# Adds an attribute divider to the specified controllers.

Flow Chart Description:

This flowchart illustrates the add_AttrDivider function:

1. The process begins by selecting controllers to which an attribute divider will be added.

2. Checks if a list of controllers is provided.

   • If a controller list is provided, it proceeds to add an attribute divider to each controller in the list.

   • If no specific controller list is provided, it adds an attribute divider to the currently selected controllers.

3. Completes the process and ends.

HyperRig.add_Attrs(self, attr='RotateOrder', onOffSwitch=0, **shArgs)#

[shArgs : a=attr, oos=onOffSwitch]

Purpose:

:: Adds custom attributes to selected controls, such as ‘RotateOrder’ or on/off switches.

• Enhances control rig functionality by allowing for custom attribute creation.

• Facilitates the animation process by providing additional control over rig components.

• Customizable to fit specific rigging and animation needs.

Parameters:

• attr – <str> # The name of the attribute to add. Default is ‘RotateOrder’.

• onOffSwitch – <bool> # Whether to add an on/off switch attribute.

Returns:

None # This function does not return a value but modifies the selected controllers.

Code Examples:

>>> add_Attrs(attr='RotateOrder', onOffSwitch=0)
# Adds a 'RotateOrder' attribute to the selected controllers.

Flow Chart Description:

This flowchart illustrates the add_Attrs function:

1. Starts by selecting the relevant controls to add attributes to.

2. Checks the type of attribute to be added, either ‘RotateOrder’ or an on/off switch.

   • If ‘RotateOrder’, adds the ‘RotateOrder’ attribute and connects it to the control’s rotate order attribute.

   • If on/off switch, prompts for the attribute name and creates an on/off switch attribute.

3. In case of cancellation during on/off switch creation, the action is canceled.

4. Completes the process and ends.

HyperRig.add_ClusterToTF(self, textFld, btnName=None, **shArgs)#

[shArgs: tf=textFld, bn=btnName]

Purpose:

:: Adds the name of the selected object with a ‘_ClustCluster’ suffix to a specified text field in Maya UI.

• Useful for rigging and animation workflows where cluster names need to be inputted or tracked in the Maya UI.

Parameters:

• textFld – <str> # Name of the text field where the cluster name is to be added.

• btnName – <str, optional> # Name of the button associated with the action, used for UI feedback.

Returns:

None # This function does not return any value but updates the text field with the selected object’s cluster name.

Code Examples:

>>> text_field_name = "clusterNameField"
>>> button_name = "applyClusterButton"
>>> add_ClusterToTF(text_field_name, button_name)
# Adds the cluster name of the selected object to 'clusterNameField'.

Flow Chart Description:

This flowchart illustrates the add_ClusterToTF function:

1. The function begins by checking if any objects are selected in Maya.

2. If an object is selected, it retrieves the object’s name and updates the specified text field with the object name followed by ‘_ClustCluster’.

3. If no object is selected, the text field is cleared.

4. The function then checks if a button name is provided for UI feedback.

5. If a button is present, its state is queried and updated based on the selection status.

6. The process ends once the text field and button (if any) are updated.

HyperRig.add_Prefix(self, txtFldName, btnName=None, **shArgs)#

[shArgs: tfn=txtFldName, bn=btnName]

Purpose:

:: Adds a prefix of the selected object to a specified text field in Maya UI.

• Useful for automating naming conventions and ensuring consistency in naming objects within Maya.

Parameters:

• txtFldName – <str> # Name of the text field where the prefix is to be added.

• btnName – <str, optional> # Name of the button associated with the action, used for UI feedback.

Returns:

None # This function does not return any value but updates the text field with the selected object’s prefix.

Code Examples:

>>> text_field_name = "myTextField"
>>> button_name = "myButton"
>>> add_Prefix(text_field_name, button_name)
# Adds the prefix of the selected object to 'myTextField'.

Adds prefix of selected object as Input in any Window for <== button

Usage:

Left_Hand                 # Adds 'Left_' While pressing Enter.. <== button
Hand                    # Adds '' While pressing Enter.. <== button

Flow Chart Description:

This flowchart illustrates the add_Prefix function:

1. The process begins by checking if any objects are selected.

2. If objects are selected, it extracts the prefix from the selected object.

3. The prefix is then added to the specified text field.

4. If no objects are selected, it clears the text field to an empty state.

5. Finally, the function updates the appearance of the associated button based on the action performed.

HyperRig.add_Selection(self, textFld, btnName=None, **shArgs)#

[shArgs: tf=textFld, bn=btnName]

Purpose:

:: Adds the name of the selected object to a specified text field in Maya UI.

• Ideal for workflows that require quick input of selected object names into Maya’s UI elements.

Parameters:

• textFld – <str> # Name of the text field where the selected object’s name is to be added.

• btnName – <str, optional> # Name of the button associated with the action, used for UI feedback.

Returns:

None # This function does not return any value but updates the text field with the selected object’s name.

Code Examples:

>>> text_field_name = "objectNameField"
>>> button_name = "addButton"
>>> add_Selection(text_field_name, button_name)
# Adds the name of the selected object to 'objectNameField'.

Adds selected object’s name as Input in any Window for <== button

Usage:

obj10             # Adds 'obj10' While pressing Enter.. <== button
box25           # Adds 'box25' While pressing Enter.. <== button

Flow Chart Description:

This flowchart illustrates the add_Selection function:

1. The process begins by checking if any objects are selected.

2. If objects are selected, it extracts the name from the selected object.

3. The object name is then added to the specified text field.

4. If no objects are selected, it clears the text field to an empty state.

5. Finally, the function updates the appearance of the associated button based on the action performed.

HyperRig.add_ToesTemplate(self, **shArgs)#

[shArgs : ]

Purpose:

:: Adds toe templates to a foot rig in Autodesk Maya.

• This function creates additional toe templates based on the given foot name prefix.

• It duplicates and positions toe curves to create a series of toe templates.

Parameters:

toesPrefix – <str> #Prefix for the foot name to which toes templates are added.

Returns:

None #No return value, it adds toe templates to the existing foot rig.

Code Examples:

>>> toesPrefix = 'Foot'
>>> add_ToesTemplate()

Flow Chart Description:

This flowchart illustrates the add_ToesTemplate function:

1. The function begins by retrieving the toes prefix from the user input.

2. It then checks if the digit curve for the toe already exists in the scene.

3. If the digit curve exists, it duplicates the last curve in the series; otherwise, it duplicates the pinky curve.

4. The duplicated curve is then renamed appropriately.

5. Positions the newly created curve relative to the last toe or the pinky toe.

6. Performs a basic setup for the new toe curve using the eMod class.

7. Completes the process by adding the new toe template to the existing foot rig.

HyperRig.advSkel_mirrorOrientCtrlGrps(self, **shArgs)#

[shArgs : ]

Purpose:

:: Mirrors orientation and control groups of a selected skeletal structure to the opposite side.

• Aids in symmetrically rigging characters by automating the mirroring of control groups.

• Ensures consistent orientation and setup between corresponding parts of a character.

• Streamlines the rigging process for complex characters with symmetrical features.

Returns:

None # This function does not return a value but mirrors the orientation and control groups.

Code Examples:

>>> advSkel_mirrorOrientCtrlGrps()
# Mirrors the orientation and control groups of selected controllers to the opposite side.

Flow Chart Description:

This flowchart illustrates the advSkel_mirrorOrientCtrlGrps function:

1. The process begins by selecting controllers whose orientation and control groups need to be mirrored.

2. Mirrors the orientation groups of the selected controllers.

3. Iterates through each selected controller to handle mirroring individually.

   • Retrieves the control group of the current controller.

   • Identifies and sets up the corresponding mirror group.

   • Sets the rotation attributes for the mirror group.

   • Reparents the joint to the mirrored controller.

   • Adds the mirrored controller to the list for selection.

4. Completes the process by selecting the mirrored controllers and ends.

HyperRig.applyDeltaMushScale(self, animCtrl=None, **shArgs)#

[shArgs: ac=animCtrl]

Purpose:

:: Applies global scale to all ‘deltaMush’ nodes in a Maya scene, using a specified animation control.

• This function is particularly useful in rigging workflows to maintain consistency in deformation effects when scaling characters or assets.

Parameters:

animCtrl – <str/PyNode, optional> # The animation control used to apply the global scale. If not provided, it will default to the selected control or ‘Global_Control’.

Returns:

None # This function does not return any value but applies global scale to all ‘deltaMush’ nodes.

Code Examples:

>>> animation_control = "characterGlobalCtrl"
>>> applyDeltaMushScale(animation_control)
# Applies global scale to all 'deltaMush' nodes using 'characterGlobalCtrl'.

HyperRig.as_AboutHyperRig(self, **shArgs)#

[shArgs: ]

Purpose:

:: Displays information about the as_HyperRig tool, including credits, contact details, and version.

• This function provides a UI window that showcases the author’s information and additional resources related to as_HyperRig.

Returns:

None # This function does not return any value but displays a UI window with as_HyperRig information.

Code Examples:

>>> as_AboutHyperRig()
# Opens a window displaying information about as_HyperRig.

Flow Chart Description:

This flowchart illustrates the as_AboutHyperRig function:

1. The process starts by checking if the HyperRig information window already exists.

2. If it exists, the existing window is deleted.

3. A new window is created to display the HyperRig information.

4. Relevant HyperRig information and credits are added to the window.

5. The window is then displayed to the user.

6. After a brief pause, the window is automatically closed.

HyperRig.as_ApplyCBS_cvShapeInv(self, rAttr='ry', selectedAttr=False, **shArgs)#

[shArgs : ]

Purpose:

:: Applies corrective blend shapes (CBS) using curve shape inversion in Autodesk Maya, primarily used in advanced character rigging.

• This function is utilized to apply corrective blend shapes to a skinned mesh based on various transformation attributes of controllers or joints.

• It handles different object types like joints, locators, and plusMinusAverage nodes to determine the pose for applying the corrective shape.

• The function supports selective attribute application, where users can choose specific attributes from a channel box for corrective action.

• It includes options to manage group names, pose mesh names, and blend shape node names for precise control over the corrective process.

• The setup is adaptable, allowing for the integration of corrective blend shapes into complex rigging systems.

Returns:

None # This function configures corrective blend shapes but doesn’t return a value.

Code Examples:

>>> as_ApplyCBS_cvShapeInv(rAttr='ry', selectedAttr=False)
# Applies corrective blend shapes based on rotation or transformation attributes of a rig component.

Flow Chart Description:

This flowchart illustrates the as_ApplyCBS_cvShapeInv function:

1. The function starts by checking for the necessary objects like skin mesh, pose control, and joints.

2. It initializes variables and filters lists based on selected objects.

3. The process then determines if a corrective blend shape (CBS) name exists, or creates one if it doesn’t.

4. It checks and prepares the pose mesh for applying corrective blend shapes.

5. The function applies corrective blend shapes based on various transformation attributes of controllers or joints.

6. The process concludes after applying the corrective blend shapes.

HyperRig.as_AttachBodyPartsToSkin(self, **shArgs)#

[shArgs : ]

Purpose:

:: Attaches non-skinned geometry, like nails or accessories, to skinned meshes, ensuring they move correctly with the character’s animation.

• This function is designed for attaching non-skinned geometries like accessories or clothes to already skinned character meshes.

• It ensures that these additional geometries deform correctly in sync with the underlying skinned mesh.

• The function automatically detects and binds the closest joints to the non-skinned geometry for accurate skinning.

• It is particularly useful in complex character setups where additional geometries need to be added post the initial skinning process.

• The setup enhances the rig’s functionality by allowing additional elements to be included without compromising the rig’s integrity.

Returns:

None # This function performs skinning of additional geometries but doesn’t return a value.

Code Examples:

>>> as_AttachBodyPartsToSkin()
# Attaches non-skinned geometries like nails or clothes to skinned character meshes in Autodesk Maya.

HyperRig.as_B4SkinMirrorCheck(self, precision=5, **shArgs)#

[shArgs: ]

Purpose:

:: Performs a pre-mirroring check on skin weights for a selected mesh in Autodesk Maya.

• Similar to as_B4SkinMirrorCheck02, this function ensures that skin weights are properly set up before performing a skin weight mirroring operation.

Parameters:

precision – <int> # The precision level for comparing vertex positions.

Returns:

None # This function does not return any value but performs a check on the skin weights of the selected mesh.

Code Examples:

>>> precision_level = 5
>>> as_B4SkinMirrorCheck(precision_level)
# Performs a pre-mirroring check on skin weights with specified precision.

HyperRig.as_B4SkinMirrorCheck02(self, precision=4, manageJunk=1, **shArgs)#

[shArgs: ]

Purpose:

:: Performs a pre-mirroring check on skin weights for a selected mesh in Autodesk Maya.

• This function is designed to ensure that skin weights are in a proper state before performing a skin weight mirroring operation.

Parameters:

• precision – <int> # The precision level for comparing vertex positions.

• manageJunk – <bool> # Determines if additional cleanup or management actions should be performed.

Returns:

None # This function does not return any value but performs a check on the skin weights of the selected mesh.

Code Examples:

>>> precision_level = 4
>>> manage_junk = True
>>> as_B4SkinMirrorCheck02(precision_level, manage_junk)
# Performs a pre-mirroring check on skin weights with specified precision and management actions.

Flow Chart Description:

This flowchart illustrates the as_B4SkinMirrorCheck02 function:

1. The process begins by verifying if a mesh is selected.

2. It retrieves the associated skin cluster of the selected mesh.

3. The skin deformer is activated to maintain skin influences.

4. The function iterates through all mesh vertices with the skin deformer on, storing their positions.

5. The skin deformer is then deactivated for subsequent operations.

6. It iterates through the vertices again with the skin deformer off, comparing their positions.

7. Any mismatch in vertex positions, indicating vertices not at the bind pose, are identified.

8. The result of the check is displayed, showing whether the mesh is ready for skin weight mirroring.

9. The process concludes after displaying the result.

HyperRig.as_BakeDeformers_ToSkinClust(self, skinGeo=None, fastMethod=True, **shArgs)#

[shArgs: ]

Purpose:

:: Bakes deformers into a skin cluster, optimizing rig performance and reducing computation overhead.

• Ideal for complex rigs where multiple deformers are used and performance optimization is crucial.

• Follows a specific set of guidelines and settings to ensure smooth weight distribution and performance improvement.

Parameters:

• skinGeo – <str, optional> #The name of the skin geometry to which deformers are to be baked.

• fastMethod – <bool, optional> #Determines whether to use a faster method for baking. Default is True.

Returns:

None # This function does not return any value but bakes deformers into the skin cluster of the specified geometry.

Code Examples:

>>> as_BakeDeformers_ToSkinClust('character_mesh', True)
# Bakes deformers into the skin cluster of 'character_mesh' using the fast method.

Usage:

1. Make sure max influences per vertex are set in advance so that after baking, weights distribution happens smoothly
2. Remove unused influences, Export Weights, Rebind and Import Weights (Performance imp: 30 Min to 30 Secs)
3. Mesh should be at bind pose before Baking starts
4. After baking without errors, if weights transfer is bad, lookout for non-unique names of skinned joints
5. Bind Settings:
        *Selected Joints
        *Closest in Hierarchy
        *Weight Blended
        *Interactive
        *Neighbours
        *Allow Multiple Bind Poses - OFF
        *Max Influences - 10
        *Maintain Max Influences - OFF
        *Colorise Skeleton - OFF
        *Remove Unused Infs - OFF
        *Include Hidden Selection - OFF
        *Drop Off Rate - 8.5

Flow Chart Description:

This flowchart illustrates the as_BakeDeformers_ToSkinClust function:

1. The process begins by checking if the skin geometry is selected. If no skin geometry is selected, the function ends.

2. It retrieves the skin cluster from the selected geometry.

3. The function checks for unique joint names. If non-unique names are found, an error is displayed and the process ends.

4. If all joint names are unique, the function duplicates each skinned joint.

5. The duplicated joints are added to the skin cluster.

6. The baking process starts, analyzing weights for each joint.

7. Weights are re-applied from duplicated joints to the original joints.

8. Duplicated joints are removed after the baking process.

9. The function performs clean-up tasks and concludes.

HyperRig.as_BakeLattice_ToSkinClust(self, skinGeo=None, **shArgs)#

[shArgs: ]

Purpose:

:: Converts lattice deformations to skin cluster weights, streamlining the rig and enhancing performance.

• Useful in situations where lattice deformers are initially used for shaping but need to be converted to skin clusters for animation.

• The function targets the specified or selected skin geometry for the conversion.

Parameters:

skinGeo – <str, optional> #The name of the skin geometry to which lattice deformations are to be baked.

Returns:

None # This function does not return any value but converts lattice deformations to skin cluster weights on the specified geometry.

Code Examples:

>>> as_BakeLattice_ToSkinClust('character_mesh')
# Converts lattice deformations to skin cluster weights on 'character_mesh'.

Flow Chart Description:

This flowchart illustrates the as_BakeLattice_ToSkinClust function:

1. The process begins by checking if the skin geometry is selected. If no skin geometry is selected, the function ends.

2. It retrieves the lattice deformer from the selected geometry.

3. The function checks for the presence of a lattice deformer. If no lattice deformer is found, an error is displayed and the process ends.

4. If a lattice deformer is found, the function duplicates each skinned joint.

5. The duplicated joints are added to the skin cluster.

6. The baking process starts, analyzing weights for each joint.

7. Weights are re-applied from duplicated joints to the original joints.

8. Duplicated joints are removed after the baking process.

9. The function performs clean-up tasks and concludes.

HyperRig.as_BendySetupBiped_Hands(self, **shArgs)#

[shArgs : ]

Purpose:

:: Sets up a bendy rig for the hands of a biped character, enhancing the naturalism and flexibility of hand animations.

• Essential for detailed hand movements and gestures in bipedal character animation.

• Bendy controls provide smooth deformation for fingers and palms, contributing to more lifelike and expressive hand motions.

• Adaptable to various biped characters with different hand rigging needs.

Returns:

None # This function does not return a value but sets up a bendy rig for the hands of a biped character.

Code Examples:

>>> as_BendySetupBiped_Hands()
# Sets up a bendy rig for the hands of a biped character.

Flow Chart Description:

This flowchart illustrates the as_BendySetupBiped_Hands function:

1. The process begins with initializing the bendy setup for biped hands.

2. Implements bendy controls for the left elbow, designed for enhanced hand animation.

3. Sets up bendy controls for the left shoulder.

4. Configures bendy controls for the right elbow, focusing on hand movements.

5. Establishes bendy controls for the right shoulder.

6. Completes the setup process by finalizing the bendy rig for the hands of a biped character and ends.

HyperRig.as_BendySetupBiped_Legs(self, **shArgs)#

[shArgs : ]

Purpose:

:: Creates a bendy setup for the legs of a biped character, providing enhanced control and flexibility for leg animations.

• Ideal for biped characters that require detailed leg movements and deformations.

• Bendy controls allow for smooth and natural leg bending, crucial for realistic character animation.

• Customizable setup to accommodate various bipedal characters and animation styles.

Returns:

None # This function does not return a value but creates a bendy setup for the legs of a biped character.

Code Examples:

>>> as_BendySetupBiped_Legs()
# Creates a bendy setup for the legs of a biped character.

Flow Chart Description:

This flowchart illustrates the as_BendySetupBiped_Legs function:

1. The process begins with initializing the bendy setup for the legs of a biped character.

2. Bendy controls are created for the left knee, enhancing flexibility in leg movements.

3. The setup then proceeds to create bendy controls for the left hip.

4. Following the left side, bendy controls are created for the right knee.

5. Finally, the process completes with the creation of bendy controls for the right hip.

HyperRig.as_BendySetup_FrntLegs_RearPV(self, **shArgs)#

[shArgs : ]

Purpose:

:: Configures a bendy setup for the front legs of a quadruped character with rear pole vector (PV) orientation.

• Enhances the realism and flexibility of front leg movements in quadrupedal characters, especially those requiring rear PV orientation.

• Incorporates bendy controls to provide smooth deformations and more natural limb movements.

• Adaptable to various quadruped characters with different anatomical structures and animation requirements.

Returns:

None # This function does not return a value but configures a bendy setup for the front legs of a quadruped character.

Code Examples:

>>> as_BendySetup_FrntLegs_RearPV()
# Configures a bendy setup for the front legs of a quadruped character with rear PV.

Flow Chart Description:

This flowchart illustrates the as_BendySetup_FrntLegs_RearPV function:

1. The process begins with initializing the bendy setup for the front legs.

2. Sets up bendy controls for the left elbow with rear PV orientation.

3. Configures bendy controls for the left shoulder.

4. Proceeds to set up bendy controls for the right elbow with rear PV orientation.

5. Establishes bendy controls for the right shoulder.

6. Completes the bendy setup for the front legs of a quadruped character and ends.

HyperRig.as_BendySetup_RearLegs_FrontPV(self, **shArgs)#

[shArgs : ]

Purpose:

:: Implements a bendy setup for the rear legs of a quadruped character with front pole vector (PV) orientation.

• Tailored for quadruped characters that require front PV orientation in their rear legs for realistic animation.

• Provides a smooth deformation system with bendy controls for enhanced flexibility and natural leg movements.

• Easily adaptable to various quadruped designs and rigging requirements.

Returns:

None # This function does not return a value but implements a bendy setup for the rear legs of a quadruped character.

Code Examples:

>>> as_BendySetup_RearLegs_FrontPV()
# Implements a bendy setup for the rear legs of a quadruped character with front PV.

Flow Chart Description:

This flowchart illustrates the as_BendySetup_RearLegs_FrontPV function:

1. Begins with initializing the bendy setup for the rear legs.

2. Implements bendy controls for the left knee with front PV orientation.

3. Sets up bendy controls for the left hip.

4. Configures bendy controls for the right knee with front PV orientation.

5. Establishes bendy controls for the right hip.

6. Completes the process by finalizing the bendy setup for the rear legs of a quadruped character and ends.

HyperRig.as_BuildArm_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Constructs a complete arm rig setup in Autodesk Maya, suitable for characters with a variety of arm configurations.

• This function creates an arm rig, which includes options for stretch and squash, auto clavicle, and bendy setups.

• It supports mirror symmetry, enabling the creation of rigs for both left and right arms in a symmetrical fashion.

• The setup is adaptable to different types of characters, including bipeds and creatures with unique arm structures.

• Additional options like bendy setup provide enhanced control over arm deformation for more realistic character movement.

• The function is part of a larger rigging system, ensuring seamless integration with other body parts like hands and torso.

Returns:

None # This function doesn’t return a value but configures an arm rig in the Maya scene.

Code Examples:

>>> as_BuildArm_Setup()
# Initializes and configures an arm rigging setup for characters in Autodesk Maya.

Flow Chart Description:

This flowchart illustrates the as_BuildArm_Setup function:

1. The process starts with a check for the existence of a Global Control hierarchy.

2. If not present, the necessary hierarchy is created including the Global Control.

3. The basic arm setup is then constructed, which includes options like stretch and squash, and auto clavicle.

4. The process checks if a bendy setup is enabled.

5. If enabled, the bendy setup is applied to the arm rig, enhancing arm deformation control.

6. The process concludes after setting up the arm rig, with or without the bendy setup.

HyperRig.as_BuildBirdFeathers_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Creates a feather control system for bird characters in Autodesk Maya, allowing for detailed animation of feather movements.

• This function is specialized in setting up feather controls for bird characters, providing animators with precise control over feather movements.

• It enhances the realism of bird animations by allowing individual feather manipulation.

• The setup is designed to work with a variety of bird species, making it versatile for different types of avian characters.

• It integrates smoothly with existing bird rigs, ensuring feathers move in sync with the body and wing animations.

• The function simplifies the complex task of animating feathers, making it more accessible for animators.

Returns:

None # This function configures feather controls but doesn’t return a value.

Code Examples:

>>> as_BuildBirdFeathers_Setup()
# Initiates a feather control system for bird characters in Autodesk Maya.

Flow Chart Description:

This flowchart illustrates the as_BuildBirdFeathers_Setup function:

1. The process starts by checking for the existence of a Global Control hierarchy.

2. If not present, the necessary hierarchy including the Global Control is created.

3. The feather control setup is then initiated, focusing on individual feather manipulation for bird characters.

4. The process concludes after completing the feather control setup, integrating with existing bird rigs for realistic feather movements.

HyperRig.as_BuildBirdWing_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Constructs a bird wing rig in Autodesk Maya, incorporating features like stretch and squash, and bendy setup for enhanced realism.

• This function is designed to create a detailed bird wing rig, suitable for animating bird characters with realistic wing movements.

• It includes options for stretch and squash, allowing the wings to extend and compress naturally during animation.

• The bendy setup feature adds additional control for nuanced wing deformations, enhancing the quality of the animation.

• The function works seamlessly with other rig components, ensuring the wing rig integrates well with the overall character rig.

• It is adaptable to various bird species, offering flexibility in rigging different types of bird characters.

Returns:

None # This function sets up a bird wing rig but doesn’t return a value.

Code Examples:

>>> as_BuildBirdWing_Setup()
# Sets up a bird wing rig with stretch, squash, and bendy features in Autodesk Maya.

Flow Chart Description:

This flowchart illustrates the as_BuildBirdWing_Setup function:

1. The process begins with checking for the existence of a Global Control hierarchy.

2. If not present, the necessary hierarchy including the Global Control is created.

3. The bird wing setup is then initiated, incorporating stretch and squash features for realistic wing movements.

4. It checks if a bendy setup is enabled for the wings.

5. If enabled, the bendy setup is applied, adding nuanced control for wing deformations.

6. The process concludes after completing the bird wing rig setup, with or without the bendy setup.

HyperRig.as_BuildBodyModule(self, **shArgs)#

[shArgs : ]

Purpose:

:: Constructs body modules in Autodesk Maya based on the selected module from the UI radio button groups.

• This function dynamically constructs a body module based on user interface selections.

• It supports constructing various body parts like Spine, Arm, Leg, Hand, Neck, Eyes, Tongue, and more.

• Utilizes the HyperRig class to build different types of rig modules.

Parameters:

module – <int> #Module number selected from the UI, determines the type of body module to build.

Returns:

None #No return value, it builds body modules in the Maya scene.

Code Examples:

>>> module = 1
>>> as_BuildBodyModule(module)

Flow Chart Description:

This flowchart illustrates the as_BuildBodyModule function:

1. The process starts by checking if a module number is selected from the UI.

2. If a module is selected, the function constructs a body module based on the selected module type, such as Spine, Arm, Leg, Hand, Neck, Eyes, Tongue, etc.

HyperRig.as_BuildDynChain_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Configures a dynamic chain setup in Autodesk Maya, typically used for creating dynamic effects in rigging, like tails, ropes, etc.

• This function initializes and configures a dynamic chain setup based on various input parameters from the user interface.

• It checks the computer’s hostname to ensure the module isn’t executed on unauthorized machines (WIP module check).

• The setup involves creating various dynamic attributes and controls, adjusting settings for stretch and squash, flex at ends, control types, etc.

• The function manages the creation of FK controls, dynamic IK control groups, and other necessary rigging components for the dynamic chain.

• It is capable of handling both joint-based and curve-based dynamic chains.

Returns:

None # This function doesn’t return a value but establishes a dynamic chain setup in the Maya scene.

Code Examples:

>>> as_BuildDynChain_Setup()
# Executes the process of setting up a dynamic chain rigging system in Autodesk Maya.

Flow Chart Description:

This flowchart illustrates the as_BuildDynChain_Setup function:

1. The process starts by checking the hostname to confirm if the module is Work-In-Progress (WIP).

2. If the hostname matches, it displays a WIP module message and ends the process.

3. If not, it sets up initial variables and conditions for dynamic chain creation.

4. Determines if the initial selection is a joint and either renames joints or creates a spine setup based on the selection.

5. Assigns a switch for dynamic attributes.

6. Creates the dynamic chain setup.

7. Constructs FK control groups for the dynamic chain.

8. Parents the FK top group to the appropriate parent group.

9. Constrains the FK and IK groups to an upstream joint if specified.

10. Updates the hair systems in the scene.

HyperRig.as_BuildEyes_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Sets up a comprehensive eye rig in Autodesk Maya, enabling detailed control over eye movements and expressions.

• This function constructs an eye rig, essential for character animation, providing control over eye direction, blink, and expressions.

• It includes features that allow for realistic eye movements, critical for conveying emotions and reactions in character animation.

• The setup is designed to be compatible with various character types, from humans to creatures, offering flexibility in rigging.

• The eye rig can be integrated with facial rigs and head setups, ensuring cohesive and natural eye movements in relation to other facial features.

• It simplifies the complex process of eye rigging, making it more accessible for animators and riggers.

Returns:

None # This function creates an eye rig but doesn’t return a value.

Code Examples:

>>> as_BuildEyes_Setup()
# Initiates an eye rig setup for detailed control over eye movements in Autodesk Maya.

Flow Chart Description:

This flowchart illustrates the as_BuildEyes_Setup function:

1. The process starts by checking the existence of a Global Control hierarchy.

2. If the Global Control is not present, it creates a new hierarchy including Global Control.

3. The function then initiates the creation of the eye rig setup.

4. This setup includes establishing eye controls and constraints for detailed eye movement control.

5. The comprehensive eye rig is now integrated, enabling precise control over eye direction, blink, and expressions.

HyperRig.as_BuildHand_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Establishes a complete hand rig setup in Autodesk Maya, including finger joints and additional palm controls for enhanced realism.

• This function creates a detailed hand rig, providing intricate control over finger movements and palm gestures.

• It includes the creation of finger joints, ensuring realistic finger bending and articulation.

• The option for palm extras adds extra functionality, allowing for more nuanced hand expressions and gestures.

• The hand rig setup is integral for character animation, enabling the animator to convey emotions and actions through hand movements.

• It seamlessly integrates with arm rigs, ensuring a cohesive and functional upper limb rigging system.

Returns:

None # This function sets up a hand rig but doesn’t return a value.

Code Examples:

>>> as_BuildHand_Setup()
# Constructs a detailed hand rig with finger joints and palm controls in Autodesk Maya.

Flow Chart Description:

This flowchart illustrates the as_BuildHand_Setup function:

1. The process begins by checking if a Global Control hierarchy exists in the Maya scene.

2. If not present, the necessary hierarchy including the Global Control is created.

3. Subsequently, finger joints are set up to ensure realistic articulation and movement.

4. The finger setup, including palm controls, is then created to provide detailed hand rigging.

5. The setup concludes with the integration of the hand rig with the overall character rig for cohesive animation capabilities.

HyperRig.as_BuildLeg_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Creates a leg rig in Autodesk Maya for biped or quadruped characters, featuring stretch and squash, auto clavicle, and bendy setup options.

• Tailored for both biped and quadruped characters, this function provides a versatile solution for leg rigging.

• The stretch and squash feature allows for dynamic leg movements, enhancing the realism of animations.

• An auto clavicle option is included for added rigging control, particularly beneficial for characters with complex leg-to-body connections.

• The bendy setup offers additional control over leg deformations, crucial for detailed character animations.

• The function also supports the creation of toe joints, further extending the rig’s capabilities for intricate foot animations.

Returns:

None # This function configures a leg rig but doesn’t return a value.

Code Examples:

>>> as_BuildLeg_Setup()
# Sets up a leg rig for biped or quadruped characters with advanced features in Autodesk Maya.

Flow Chart Description:

This flowchart depicts the as_BuildLeg_Setup function:

1. Starts with checking the existence of a Global Control hierarchy in the scene.

2. If not present, a new hierarchy including Global Control is created.

3. The character type (biped or quadruped) is then selected to determine the leg setup process.

4. For bipeds, a specific leg setup is initialized, followed by checking for the bendy setup option.

5. If the bendy setup is selected for bipeds, it is applied; otherwise, the process ends for biped characters.

6. Similarly, for quadrupeds, a leg setup is created with a check for the bendy setup option.

7. The bendy setup is applied for quadrupeds if selected, concluding the process for quadruped characters.

HyperRig.as_BuildNeckHead_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Constructs a rigging setup for the neck and head of a character, adaptable to various rig types and character styles.

• Enables detailed control over neck and head movements, crucial for expressive character animation.

• Supports different setup types to cater to a wide range of character designs and animation requirements.

• Integrates seamlessly with existing rig structures, such as spine and shoulder setups.

Returns:

None # This function does not return a value but constructs a neck and head rigging setup.

Code Examples:

>>> as_BuildNeckHead_Setup()
# Constructs a rigging setup for the neck and head of the selected character.

Flow Chart Description:

This flowchart illustrates the as_BuildNeckHead_Setup function:

1. The process begins with initializing parameters such as setupType, charType, numCtrls, neckCurv, jawCurv, ikGrp, chestJnt, jointsGrp, globalCtrl, primAxis, secAxis, and secAxisDir.

2. Checks if a setup type is provided.

   • If a setup type is provided, it creates neck curves for the setup.

   • If no setup type is given, an error message is displayed.

3. Defines axis settings based on primary and secondary axis choices.

4. Creates neck and head controls based on the chosen control shape.

5. Sets up joints for the neck and head rig.

6. Finalizes the neck and head rig setup.

7. Completes the process and ends.

HyperRig.as_BuildQuadFLeg_FrontPV(self, **shArgs)#

[shArgs : ]

Purpose:

:: Sets up a quadruped front leg rig with a front pole vector (PV), specifically designed for creatures with front-pivoting legs.

• Enhances the realism and flexibility of quadrupedal characters, especially those that require front-pivoting leg movements.

• Facilitates a natural and accurate range of motion for animal characters in animation.

• Integrates with the overall quadruped rig, maintaining consistency and functionality.

Returns:

None # This function does not return a value but sets up a front-pivoting leg rig for a quadruped.

Code Examples:

>>> as_BuildQuadFLeg_FrontPV()
# Sets up a front-pivoting leg rig for a quadruped character.

Flow Chart Description:

This flowchart illustrates the as_BuildQuadFLeg_FrontPV function:

1. The process begins by initializing the setup parameters.

2. It defines the names for left and right leg joints.

3. Creates base joints for the leg setup.

4. Generates joints for the left leg.

5. Mirrors the joints to create the right leg setup.

6. Duplicates leg joints for IK, FK, and auto setups.

7. Creates IK/FK mix joints for a bendy setup.

8. Generates IK handles for the leg joints.

9. Creates IK/FK switches for controlling the leg rig.

10. Establishes FK controls for the leg joints.

11. Implements a reverse foot setup for detailed foot control.

12. Sets up foot controls for IK handling.

13. Creates pole vector controls for IK leg chains.

14. Finalizes the setup by creating clavicle controls and setups.

15. Completes the quadruped front leg rigging setup and ends.

HyperRig.as_BuildQuadFLeg_RearPV(self, **shArgs)#

[shArgs : ]

Purpose:

:: Constructs a rigging setup for the front legs of a quadruped character with rear pole vector orientation, including reverse foot and bendy options.

• Customizes the rigging of quadruped front legs to accommodate rear PV orientation, crucial for certain animal locomotion.

• Integrates reverse foot setup for enhanced control over foot and toe movements.

• Incorporates bendy controls for smoother leg deformations and natural leg movements.

• Option to include toe rigging for additional animation detail.

Returns:

None # This function does not return a value but constructs a comprehensive rigging setup for the front legs of a quadruped character.

Code Examples:

>>> as_BuildQuadFLeg_RearPV()
# Constructs a rigging setup for the front legs of a quadruped character with rear PV orientation.

Flow Chart Description:

This flowchart illustrates the as_BuildQuadFLeg_RearPV function:

1. Begins with initializing the setup for the front legs of a quadruped with rear PV orientation.

2. Proceeds to create the initial joint structure for the legs.

3. Duplicates joints for FK and IK setups.

4. Creates IKFK mix joints for bendy control.

5. Optionally creates toe joints if enabled.

6. Sets up IK handles for leg motion control.

7. Implements an IKFK switch for flexibility between IK and FK animations.

8. Creates FK controls for manual manipulation of leg joints.

9. Establishes a reverse foot setup for advanced foot control.

10. Sets up foot controls for dynamic foot and toe animation.

11. Adds pole controls for IK leg behavior adjustments.

12. Implements visibility switches for control display options.

13. Optionally creates an auto clavicle setup, if enabled.

14. Develops clavicle control for shoulder and upper leg movement.

15. Optionally sets up bendy controls for smoother leg deformations, if enabled.

16. Checks if toe setup is required and proceeds accordingly.

17. Finalizes the setup process and ends.

HyperRig.as_BuildQuadFLeg_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Builds a quadruped front leg rigging setup, with options for different pivot setups to suit various quadrupedal creatures.

• Tailors the rigging of quadruped front legs for enhanced realism and flexibility in animal movement.

• Provides options for front and rear pivot setups to match the anatomical and movement requirements of different animals.

• Streamlines the process of rigging quadrupedal characters, saving time and ensuring consistency.

Returns:

None # This function does not return a value but builds a rigging setup for quadruped front legs.

Code Examples:

>>> as_BuildQuadFLeg_Setup()
# Builds a quadruped front leg rigging setup based on the selected setup type.

Flow Chart Description:

This flowchart illustrates the as_BuildQuadFLeg_Setup function:

1. The process starts with initializing parameters such as setupType.

2. It checks the setup type selected by the user.

   • If the ‘Front PV’ setup is chosen, the function proceeds to build a quadruped front leg rig using the Front PV setup.

   • If the ‘Rear PV’ setup is chosen, the function builds the quadruped front leg rig using the Rear PV setup.

3. Completes the quadruped front leg rigging process and ends.

HyperRig.as_BuildQuadRearLeg_FrontPV(self, **shArgs)#

[shArgs : ]

Purpose:

:: Constructs a comprehensive rigging setup for the rear legs of a quadruped character with a front pole vector orientation.

• This function facilitates the creation of a detailed and functional rig for the rear legs of quadruped characters, focusing on front pole vector orientation.

• It includes the creation of IK handles, FK controls, reverse foot setup, auto knee setup, and clavicle control for the legs.

• Additionally, it offers optional bendy and toe setups for enhanced flexibility and realism in character animation.

Returns:

None # This function does not return a value but establishes a detailed rigging system for the rear legs of a quadruped character.

Code Examples:

>>> as_BuildQuadRearLeg_FrontPV()
# Executes the process of setting up the rear leg rigging with a front pole vector orientation for a quadruped character.

Flow Chart Description:

This flowchart illustrates the as_BuildQuadRearLeg_FrontPV function:

1. The process starts by creating joints for the rear legs of a quadruped character.

2. It involves duplicating joints for FK, IK, and auto systems.

3. IKFK mix joints are created for bendy setup, followed by the creation of leg IK handles.

4. IK-FK switch controls are set up for seamless switching between IK and FK modes.

5. FK joint controls are then created for animating the FK system.

6. The reverse foot setup is implemented for detailed foot control.

7. Foot controls are created, including pole controls for IK leg movement.

8. An auto knee setup is added for dynamic knee control.

9. Clavicle control is established for additional leg movement.

10. Optional bendy and toe setups are implemented if selected, for enhanced flexibility and realism in character animation.

HyperRig.as_BuildQuadRearLeg_RearPV(self, **shArgs)#

[shArgs : ]

Purpose:

:: Implements a comprehensive rigging setup for the rear legs of a quadruped character with a rear pole vector orientation.

• This function provides a detailed rigging structure for the rear legs of quadruped characters, focusing on rear pole vector orientation.

• It encompasses creating IK handles, FK controls, reverse foot setup, auto knee setup, clavicle control, and optional toes setup for the rear legs.

• The setup is designed to offer a high level of control and flexibility for animating quadruped characters, ensuring realistic movement and poses.

Returns:

None # This function doesn’t return a value but establishes a sophisticated rigging system for the rear legs of a quadruped character.

Code Examples:

>>> as_BuildQuadRearLeg_RearPV()
# Executes the process of setting up the rear leg rigging with a rear pole vector orientation for a quadruped character.

Flow Chart Description:

This flowchart illustrates the as_BuildQuadRearLeg_RearPV function:

1. The process begins with creating joints for the rear legs of a quadruped character, focusing on rear pole vector orientation.

2. It duplicates joints for FK, IK, and auto systems.

3. IKFK mix joints are then created for bendy setup, followed by the creation of leg IK handles.

4. IK-FK switch controls are established for smooth switching between IK and FK modes.

5. FK joint controls are created for animating the FK system.

6. The reverse foot setup is implemented for detailed foot control.

7. Foot controls are then created, including pole controls for IK leg movement.

8. Finally, clavicle control is established for additional leg movement.

HyperRig.as_BuildQuadRearLeg_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Establishes the rigging setup for the rear legs of a quadruped character, offering options for front or rear pole vector orientation.

• Facilitates the creation of a functional and versatile rig for the rear legs of quadruped characters.

• Provides options for pole vector orientation, allowing customization based on the specific movement requirements of the character.

• Simplifies the rigging process for animators and riggers working on quadruped models.

Returns:

None # This function does not return a value but sets up the rigging for the rear legs of a quadruped character based on the selected pole vector orientation.

Code Examples:

>>> as_BuildQuadRearLeg_Setup()
# Sets up the rigging for the rear legs of a quadruped character based on the selected pole vector orientation.

Flow Chart Description:

This flowchart illustrates the as_BuildQuadRearLeg_Setup function:

1. The process begins by checking the selected setup type for the rear legs of a quadruped character.

2. Based on the selection, it either sets up the rear legs with a Front PV orientation or a Rear PV orientation.

3. The setup concludes once the appropriate pole vector orientation is applied and configured.

HyperRig.as_BuildSnake_Setup(self, **shArgs)#

[shArgs : ]

Purpose:

:: Implements a specialized rigging setup for snake-like characters in Autodesk Maya.

• This function is specifically designed to create a rigging setup for snake characters, taking into account the unique movement and flexibility of such creatures.

• It supports various options like stretch and squash, control shapes, joint axis orientation, etc., allowing for a customizable rig.

• The setup includes the creation of a spine setup with FK/IK controls, offering full control over the snake’s movement and posing.

• Additional options like mirror setup, bendy setups, and extra control groups are available for enhanced rigging flexibility.

• The function is adaptable for different types of snake characters, ensuring versatility in rigging scenarios.

Returns:

None # This function doesn’t return a value but configures a comprehensive rigging setup for snake characters.

Code Examples:

>>> as_BuildSnake_Setup()
# Sets up a rigging system for snake characters with customized options in Autodesk Maya.

Flow Chart Description:

This flowchart illustrates the as_BuildSnake_Setup function:

1. The process begins by setting up initial variables required for snake rigging.

2. It then determines if there is an initial selection in the scene.

3. If no initial selection is found, an error message is displayed, and the process ends.

4. If an initial selection exists, the function checks if a global control hierarchy is present and creates one if not.

5. Finally, it creates the spine setup for the snake character, tailoring the rigging to the specific requirements of snake-like movement.