eCtrl#

eCtrl Features

:Advanced Control Maker Module:

The eCtrl module, like the asNode module, is a custom Python module tailored for use in VFX, specifically in rigging and animation within Autodesk Maya. Here are a few potential uses or features of the eCtrl module:

1. Animation Control Rigging: eCtrl is designed to assist in building control rigs for animation. These rigs are crucial for animators to effectively manipulate 3D models.

2. Custom Control Creations: The module provides tools or functions for creating custom controls in a rig, allowing for more tailored and efficient animation setups.

3. User-Friendly Interface: eCtrl offers a user-friendly interface to interact with complex rigging and control systems in Maya, making it accessible to users with varying levels of scripting knowledge.

4. Efficiency in Rigging Process: By automating aspects of control rigging, the module significantly improve workflow efficiency, saving time and effort in the rigging process.

5. Integration with Maya’s API: It is designed to work seamlessly with Maya’s API, providing a more intuitive and Pythonic approach to rigging and animation tasks.

6. Enhanced Animation Workflow: eCtrl streamline the animation workflow by simplifying the process of setting up and manipulating control rigs.

7. Support for Complex Rigs: The module include features that support the creation and management of complex rigs, which are often required in detailed character animations.

eCtrl.__init__(self)#

To Support main auto rig scripts via eCtrl

as_eCtrlMain_v1.5

About

Author: (Subbaiah) Subbu Addanki
Character Supervisor (Rigging) & Programmer

Visit

http://www.pythonscripting.com
http://subbuadd.blogspot.com

Contact

Mail Id: subbu.add@gmail.com
Mobile No: +91-9741454400 / +91-9949005359

Copyright (c) as_eCtrlMain

** (Subbaiah) Subbu Addanki. All Rights Reserved. **

eCtrl.addAngleAttr(self, nodeList, name, value=0, k=1, h=0, **shArgs)#

[shArgs : nl=nodeList, na=name, v=value, k=keyable, h=hidden]

Purpose:

:: Adds an angle attribute to a specified node in Autodesk Maya.

• Enhances nodes with angle attributes, useful in rigging and animation processes.

Parameters:

• nodeList – <str/list> # The name or list of names of nodes to which the angle attribute will be added.

• name – <str> # The name of the angle attribute to be added.

• value – <float, optional> # The default value of the angle attribute, set to 0 by default.

• keyable – <int, optional> # Whether the attribute is keyable, set to 1 (True) by default.

• hidden – <int, optional> # Whether the attribute is hidden, set to 0 (False) by default.

Returns:

<pm.Attribute> # The newly added angle attribute on the node.

Code Examples:

>>> node_list = ["pCube1"]
>>> attr_name = "rotationAngle"
>>> default_value = 45.0
>>> keyable = 1
>>> hidden = 0
>>> added_attr = addAngleAttr(node_list, attr_name, default_value, keyable, hidden)
# Adds an angle attribute named 'rotationAngle' with a default value of 45.0 to 'pCube1', making it keyable and visible.

Flow Chart Description:

This flowchart illustrates the addAngleAttr function:

1. Checks if shArgs exist, and if so, parses the nodeList, name, value, k, and h from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of nodes to which the angle attribute will be added.

4. Iterates through the node list.

5. Adds an angle attribute with the specified name, value, k, and h to each node.

6. Ends the process.

eCtrl.addBoolAttr(self, nodeList, name, value=True, **shArgs)#

[**shArgs : nl=nodeList, n=name, v=value]

Purpose:

:: Adds a boolean attribute to a node in Autodesk Maya.

• This function is designed to create custom boolean attributes on nodes, allowing for enhanced node interactivity and control.

• Useful in rigging, custom tools creation, and scene setup where boolean flags are required.

Parameters:

• nodeList – <str/list> # The name or list of names of nodes to which the attribute will be added.

• name – <str> # The name of the boolean attribute to be added.

• value – <bool, optional> # The default value of the boolean attribute. Defaults to True.

Returns:

None # The function does not return a value but adds the attribute to the specified node(s).

Code Examples:

>>> nodes = ["node1", "node2"]
>>> attributeName = "isVisible"
>>> defaultValue = True
>>> addBoolAttr(nodes, attributeName, defaultValue)
# Adds a boolean attribute named 'isVisible' with a default value of True to 'node1' and 'node2'.

Flow Chart Description:

This flowchart illustrates the addBoolAttr function:

1. Checks if shArgs exist, and if so, parses the nodeList, name, and value from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of nodes to which the attribute will be added.

4. Iterates through the node list.

5. Adds a boolean attribute with the specified name to each node.

6. Sets the default value of the added boolean attribute.

7. Ends the process.

eCtrl.addEnumAttr(nodeList, name, enumNames, k=1, h=0, **shArgs)#

[shArgs : n=nodeList, na=name, en=enumNames, k=keyable, h=hidden]

Purpose:

:: Adds an enumeration attribute to a node in Autodesk Maya.

• Ideal for creating custom dropdown menus or selection options on Maya nodes.

Parameters:

• nodeList – <str> # The node to which the enumeration attribute will be added.

• name – <str> # The name of the enumeration attribute to be added.

• enumNames – <list> # A list of strings representing the names for the enumeration options.

• keyable – <int, optional> # Whether the attribute is keyable, set to 1 (True) by default.

• hidden – <int, optional> # Whether the attribute is hidden, set to 0 (False) by default.

Returns:

<pm.Attribute> # The newly added enumeration attribute on the node.

Code Examples:

>>> node = "pCube1"
>>> attr_name = "colorOptions"
>>> enum_options = ["Red", "Green", "Blue"]
>>> keyable = 1
>>> hidden = 0
>>> addEnumAttr(node, attr_name, enum_options, keyable, hidden)
# Adds an enumeration attribute named 'colorOptions' to 'pCube1' with options 'Red', 'Green', 'Blue'.

Flow Chart Description:

This flowchart illustrates the addEnumAttr function:

1. Checks if shArgs exist, and if so, parses the nodeList, name, enumNames, k, and h from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves the node to which the enumeration attribute will be added.

4. Adds an enumeration attribute with the specified name, enumNames, k, and h to the node.

5. Ends the process.

eCtrl.addFloatAttr(self, nodeList, name, value=0, k=1, h=0, minValue=None, maxValue=None, **shArgs)#

[shArgs : nl=nodeList, na=name, v=value, k=keyable, h=hidden, min=minValue, max=maxValue]

Purpose:

:: Adds a floating-point attribute to a node in Autodesk Maya.

• Useful for adding custom float attributes to nodes, enabling finer control over various attributes and parameters.

Parameters:

• nodeList – <str/list> # The name or list of names of nodes to which the float attribute will be added.

• name – <str> # The name of the float attribute to be added.

• value – <float, optional> # The default value of the float attribute, set to 0 by default.

• keyable – <int, optional> # Whether the attribute is keyable, set to 1 (True) by default.

• hidden – <int, optional> # Whether the attribute is hidden, set to 0 (False) by default.

• minValue – <float, optional> # The minimum value for the attribute.

• maxValue – <float, optional> # The maximum value for the attribute.

Returns:

<pm.Attribute> # The newly added float attribute on the node.

Code Examples:

>>> node_list = ["pCube1"]
>>> attr_name = "customFloat"
>>> default_value = 3.5
>>> keyable = 1
>>> hidden = 0
>>> min_value = 0.0
>>> max_value = 10.0
>>> added_attr = addFloatAttr(node_list, attr_name, default_value, keyable, hidden, min_value, max_value)
# Adds a float attribute named 'customFloat' to 'pCube1' with specified parameters.

Flow Chart Description:

This flowchart illustrates the addFloatAttr function:

1. Checks if shArgs exist, and if so, parses the nodeList, name, value, k, h, minValue, and maxValue from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of nodes to which the float attribute will be added.

4. Iterates through the node list.

5. Adds a float attribute with the specified name, value, k, h, minValue, and maxValue to each node.

6. Ends the process.

eCtrl.addIntAttr(self, nodeList, name, value=0, **shArgs)#

[**shArgs : nl=nodeList, na=name, v=value]

:: Adds an integer attribute to one or more nodes in Autodesk Maya.

Parameters:

• nodeList – (<type str/list>) # The name or list of names of nodes to which the attribute will be added.

• name – (<type str>) # The name of the integer attribute to be added.

• value – (<type int>, optional) # The default value of the integer attribute. Defaults to 0.

Returns:

(<type pm.Attribute>) # The added integer attribute.

Flow Chart Description:

This flowchart illustrates the addIntAttr function:

1. Checks if shArgs exist, and if so, parses the nodeList, name, and value from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of nodes to which the attribute will be added.

4. Iterates through the node list.

5. Adds an integer attribute with the specified name to each node.

6. Sets the default value of the added integer attribute.

7. Ends the process.

eCtrl.addMatrixAttr(self, nodeList, name, **shArgs)#

[shArgs : nl=nodeList, na=name]

Purpose:

:: Adds a matrix attribute to a specified node in Autodesk Maya.

• Facilitates the addition of complex matrix attributes to nodes for advanced operations and transformations.

Parameters:

• nodeList – <str/list> # The name or list of names of nodes to which the matrix attribute will be added.

• name – <str> # The name of the matrix attribute to be added.

Returns:

<pm.Attribute> # The newly added matrix attribute on the node.

Code Examples:

>>> node_list = ["pCube1", "pSphere1"]
>>> attr_name = "transformationMatrix"
>>> added_attr = addMatrixAttr(node_list, attr_name)
# This will add a matrix attribute named 'transformationMatrix' to 'pCube1' and 'pSphere1'.

Flow Chart Description:

This flowchart illustrates the addMatrixAttr function:

1. Checks if shArgs exist, and if so, parses the nodeList and name from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of nodes to which the matrix attribute will be added.

4. Iterates through the node list.

5. Adds a matrix attribute with the specified name to each node.

6. Ends the process.

eCtrl.addStringAttr(self, nodeList, name, value='', **shArgs)#

[**shArgs : nl=nodeList, n=name, v=value]

Purpose:

:: Adds a string attribute with a specified name and optional initial value to one or more nodes in Autodesk Maya.

Parameters:

• nodeList – (<type list>) # List of nodes to which the attribute will be added.

• name – (<type str>) # Name of the string attribute to be added.

• value – (<type str>, optional) # Initial value for the string attribute. Defaults to an empty string.

Returns:

(<type pm.Attribute>) # The added string attribute.

Flow Chart Description:

This flowchart illustrates the addStringAttr function:

1. Checks if shArgs exist, and if so, parses the nodeList, name, and value from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of nodes to which the attribute will be added.

4. Iterates through the node list.

5. Adds a string attribute with the specified name to each node.

6. Sets the initial value of the added string attribute.

7. Ends the process.

eCtrl.add_Attrs(self, ctrlList=None, attr='RotateOrder', attrDivider=True, **shArgs)#

[**shArgs : ctrlList =cl, attr =a, attrDivider =ad]

Purpose:

:: Adds specified attributes to a list of controllers in Autodesk Maya.

Parameters:

• ctrlList – (<type list, optional>) # The list of controllers to add the attribute to. Defaults to None.

• attr – (<type str>) # The name of the attribute to add.

• attrDivider – (<type bool, optional>) # Flag to add a divider for the attribute. Defaults to True.

Returns:

(<type None>) # None

Flow Chart Description:

This flowchart illustrates the mirrorCtrlShapes function:

1. Checks if shArgs exist, and if so, parses the ctrlList, srcStr, repStr, repCount, and letters from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of selected controls (control curves).

4. For each selected control:

   • Checks if it’s a curve shape (control shape).

   • If it’s not a curve shape, continues to the next control.

   • If it’s a curve shape, proceeds to mirror it.

5. If letters are considered in the mirroring process:

   • Snaps vertices to their opposite positions.

   • Centers the pivot of the mirrored control.

   • Snaps the shape to the opposite location.

6. If letters are not considered:

   • Mirrors vertices by changing their X-coordinates to the opposite side.

7. Appends the mirrored control to the list of mirrored controls.

8. After processing all controls, selects the mirrored controls if the list is not empty.

eCtrl.applyCtrlColor(self, ctrlList=None, colorNum=None, LPrefix=None, RPrefix=None, CPrefix=None, **shArgs)#

[**shArgs : cl=ctrlList, cn=colorNum, lp=LPrefix, rp=RPrefix, cp=CPrefix]

Purpose:

:: Changes control colors based on prefix, colorVal

Parameters:

• ctrlList – (<type list>) # List of control names or a single control name.

• colorNum – (<type int>) # The color value to set for the controls.

• LPrefix – ([<type str>, <type int>]) # Left side prefix and its value for controls.

• RPrefix – ([<type str>, <type int>]) # Right side prefix and its value for controls.

• CPrefix – ([<type str>, <type int>]) # Custom prefix and its value for controls.

Returns:

(<type None>) # None

Code Examples:

>>> control_list = ['LeftArm_Ctrl', 'RightArm_Ctrl']  # Specify a list of control names
>>> color_number = 17  # Specify the color value
>>> left_prefix = ['L', 6]  # Specify the prefix and color value for controls on the left side
>>> right_prefix = ['R', 13]  # Specify the prefix and color value for controls on the right side
>>> custom_prefix = ['C', 10]  # Specify the prefix and color value for custom controls

Flow Chart Description:

This flowchart illustrates the applyCtrlColor function:

1. Checks if shArgs exist, and if so, parses the arguments.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves a list of control names.

4. If ctrlList is not provided, selects the control list interactively.

5. Processes each control in the control list:

   • Checks if the control name matches the specified prefixes (LPrefix, RPrefix, CPrefix).

   • Sets the color of the control based on the prefix or uses the default color.

6. Prints a success message after applying color to the controls.

eCtrl.arrowCtrl(self, ctrlName=None, grpLevel=3, snapPiv=True, numArrows=4, initRot=[0, 0, 0], ctrlType=1, grpSufxList=None, colorVal=None, **shArgs)#

[**shArgs : ctrlName=n, grpLevel=gl, snapPiv=sp, numArrows=na, initRot=ir, ctrlType=ct, grpSufxList=gs, colorVal=cv]

Purpose:

:: Creates arrow-shaped control objects in Autodesk Maya with customizable properties such as number of arrows, initial rotation, and control type.

• Ideal for rigging scenarios where arrow-shaped controls are required.

• Offers a variety of control shapes and configurations for diverse rigging needs.

Parameters:

• ctrlName – <str, optional> #Name for the arrow control. Default naming used if not provided.

• grpLevel – <int, optional> #Specifies the hierarchy level for grouping the control. Default is 3.

• snapPiv – <bool, optional> #Determines whether to snap the pivot of the groups to the control. Default is True.

• numArrows – <int, optional> #Specifies the number of arrows in the control. Default is 4.

• initRot – <list, optional> #Initial rotation of the control, specified as [x, y, z]. Default is [0, 0, 0].

• ctrlType – <int, optional> #Type of arrow control to create, with various shape options. Default is 1.

• grpSufxList – <list, optional> #List of suffixes for the control’s groups. Default is None.

• colorVal – <int, optional> #Color value to apply to the control. Default is None.

Returns:

<list> #A list containing the arrow control and its top group as Maya nodes, based on grpLevel.

Flow Chart Description:

This flowchart illustrates the arrowCtrl function:

1. The process starts by checking if a control name is provided.

2. If not specified, a default control name is set.

3. The control type is selected from six available options.

4. Based on the chosen type, an arrow-shaped control is created.

5. The control is then finalized with initial rotation, group level, pivot snapping, suffix list, and color value.

6. The function concludes with the return of the control and its top group.

eCtrl.as_eCtrl(self)#

To Support writing main tools while there are repetitive tasks like creating controls with eCtrl module

eCtrl.attrDivider(self, ctrlList=None, dividerName=None, **shArgs)#

[shArgs : cl=ctrlList, dn=dividerName]

Purpose:

:: Adds a divider attribute to a list of controls in Autodesk Maya, enhancing organization and readability.

• Useful for segregating control attributes in complex rigs or scripts.

• Adds divider ‘_’ * (4 to 12 range)

Parameters:

• ctrlList – <None/str/list, optional> # The list of control nodes to add the divider to. If None, operates on the selected nodes.

• dividerName – <None/str, optional> # The name of the divider attribute. If None, uses a sequence of underscores.

Returns:

None # This function does not return a value but modifies the control nodes directly.

Code Examples:

>>> control_list = ["ctrl1", "ctrl2"]
>>> divider_name = "SECTION"
>>> attrDivider(control_list, divider_name)
# Adds a divider named 'SECTION' to 'ctrl1' and 'ctrl2'.

Flow Chart Description:

This flowchart illustrates the attrDivider function:

1. Checks if shArgs exist, and if so, parses the ctrlList and dividerName from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Retrieves the list of control nodes to which the divider attribute will be added.

4. Adds a divider attribute with the specified dividerName or a sequence of underscores to the control nodes.

5. Ends the process.

eCtrl.ballCtrl(self, ctrlName=None, grpLevel=3, initRot=[0, 0, 0], ctrlType=1, grpSufxList=None, **shArgs)#

[shArgs : ctrlName=n, grpLevel=gl, initRot=ir, ctrlType=ct, grpSufxList=gsl]

Purpose:

:: Generates a ball-shaped control in Autodesk Maya, providing a versatile tool for rigging and animation tasks.

• Useful for creating controls that require a spherical shape, such as for eye rigs or pivot points in mechanical rigs.

• The ability to define control types and group suffixes allows for greater adaptability in rig setups.

Parameters:

• ctrlName – <str, optional> # Name for the ball control. If not specified, a default name is used.

• grpLevel – <int, optional> # Specifies the hierarchy level for grouping the control. Default is 3.

• initRot – <list, optional> # Initial rotation of the control, specified as [x, y, z]. Default is [0, 0, 0].

• ctrlType – <int, optional> # Determines the style of the ball control. Default is 1.

• grpSufxList – <list, optional> # List of suffixes for group names, if needed. Default is None.

Returns:

<list> # A list containing the ball control and its top group as Maya nodes, structured as per grpLevel.

Code Examples:

>>> ball_control = ballCtrl(ctrlName="myBallCtrl", grpLevel=2, ctrlType=1)
# Creates a ball control with specified name, group level, and control type.

:param ctrlName : name(str) #_ name for the control which is going to be created :param grpLevl : num(int) #_ Number of top groups on control to be created :param initRot : [float, float, float] #_ Rotates the shape initially :param ctrlType : 1|2 (Max: 2) #_ Shape1 : Single Circle, Shape2 : Dual Circle :param grpSufxList (list, optional): List of suffixes for group names. Defaults to None. :return: List of Nodes (control and top group) as asNodes.

Usage:

ctrl              =eCtrl.ballCtrl(ctrlName)[0]
ctrlGrp           =eCtrl.ballCtrl(ctrlName)[-1]
ctrl, ctrlGrp =eCtrl.ballCtrl(ctrlName)

Returns:

if grpLevel:
        return [ctrl, ctrlGrp(topGrp)]  #_ asNodes
else:
        return [ctrl, ctrl]                     #_ asNodes

Flow Chart Description:

This flowchart illustrates the ballCtrl function:

1. Checks if shArgs exist, and if so, parses the function arguments from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Generates a ball-shaped control in Autodesk Maya based on the specified control type.

4. Rotates the control based on the initRot parameter.

5. Groups the control based on the grpLevel and grpSufxList parameters.

6. Applies color to the control using the applyCtrlColor method.

7. Ends the process.

eCtrl.boxCtrl(self, ctrlName=None, grpLevel=1, snapPiv=False, grpSufxList=None, grpPrfxList=None, ctrlType=1, ctrl2Axis='x', **shArgs)#

[**shArgs : ctrlName =n, grpLevel =gl, snapPiv =sp, grpSufxList =gsl, grpPrfxList =gpl, ctrlType =ct, ctrl2Axis =c2a]

Purpose:

:: Creates a box-shaped control in Autodesk Maya, offering flexibility in design and application. The control can be customized in terms of size, group level, pivot snapping, and axis orientation.

• This function is beneficial for rigging and animation where box-shaped controls are needed.

• It allows for adjustments in grouping, pivot snapping, and control axis to suit various rigging requirements.

Parameters:

• ctrlName – <str, optional> #Name for the control to be created. If not provided, defaults to ‘as_Box_Ctrl’.

• grpLevel – <int, optional> #Number of top groups for the control. Default is 1.

• snapPiv – <bool, optional> #Determines if group’s pivot should snap to the control. Default is False.

• grpSufxList – <list, optional> #List of suffixes for group names. Defaults to None.

• grpPrfxList – <list, optional> #List of prefixes for group names. Defaults to None.

• ctrlType – <int> #Defines the type of the control shape. Default is 1.

• ctrl2Axis – <str> #Axis for the control orientation. Defaults to ‘x’.

Returns:

<list> #List of Nodes (control and top group) as asNodes, depending on the specified grpLevel.

Flow Chart Description:

This flowchart illustrates the boxCtrl function:

1. The function starts by checking if a control name is specified.

2. If not, a default control name is assigned.

3. The control type is selected between two options.

4. For Type 1, a simple box control is created.

5. For Type 2, the function checks the specified axis for alignment.

6. The control is then aligned according to the chosen axis (X or Y).

7. The control is finalized with group levels, pivot snapping, suffixes, and prefixes.

8. The function ends by returning the control and its top group.

eCtrl.bulletCtrl(self, ctrlName=None, grpLevel=1, initRot=[0, 0, 0], ctrlType=1, **shArgs)#

[**shArgs : ctrlName =n, grpLevel =gl, initRot =ir, ctrlType =ct]

Purpose:

:: Creates a bullet-shaped control in Autodesk Maya, ideal for specific rigging needs such as projectiles or fast-moving objects.

• The bullet control is perfect for animations involving projectiles or for rigging characters with bullet-like features.

• The control’s shape and size can be adjusted to match various design requirements, making it versatile for different scenarios.

Parameters:

• ctrlName – <str, optional> #Name for the control which is going to be created

• grpLevel – <int, optional> #Number of top groups on control to be created

• initRot – <list, optional> #Rotates the shape initially

• ctrlType – <int, optional> #Shape options. Shape1: Single Circle, Shape2: Dual Circle

Returns:

<list> #A list containing the control and its top group as Maya nodes, based on grpLevel.

Flow Chart Description:

This flowchart illustrates the bulletCtrl function:

1. The process starts by checking if a control name is specified.

2. If not specified, a default control name is set.

3. Depending on the control type, either a bullet curve or a circle is created.

4. The control is rotated and its transformations are frozen.

5. The control is finalized by creating its group and applying color.

6. The process ends with the creation of the bullet control and its group.

eCtrl.circleCtrl(self, ctrlName=None, grpLevel=2, initRot=[0, 0, 0], ctrlType=1, grpSufxList=None, **shArgs)#

[shArgs : ctrlName=n, grpLevel=gl, initRot=ir, ctrlType=ct, grpSufxList=gsl]

Purpose:

:: Efficiently generates a circular control in Autodesk Maya, ideal for rigging and animation purposes.

• The circle control serves as a versatile rigging element for various animation needs, providing intuitive manipulation for animators.

• Customizable rotation, group levels, and multiple shape options enhance the utility and adaptability of the control in a rigging context.

Parameters:

• ctrlName – <str, optional> # Name to assign to the circle control. Defaults to ‘as_Circle_Ctrl’ if None.

• grpLevel – <int, optional> # Number of grouping levels for organizing the control in the scene. Default is 2.

• initRot – <list> # Initial rotation of the control, specified as [x, y, z].

• ctrlType – <int, optional> # Type of circle control, with options 1 for a single circle and 2 for a dual circle. Default is 1.

• grpSufxList – <list, optional> # List of suffixes for naming the control groups. Defaults to None.

Returns:

<list> # A list containing the circle control and its top group as asNodes.

Code Examples:

>>> circle_control = circleCtrl(ctrlName="myCircleCtrl", grpLevel=3, initRot=[45, 0, 0], ctrlType=2)
# Creates a dual circle control named "myCircleCtrl" with specific rotation and group level.

eCtrl.clavicleCtrl(self, ctrlName=None, sidePos='L_', grpLevel=1, ctrlType=1, initRot=[0, 0, 0], **shArgs)#

[shArgs : cn=ctrlName, sp=sidePos, gl=grpLevel, ct=ctrlType, ir=initRot]

Purpose:

:: Creates a clavicle control in Autodesk Maya, typically used in character rigging for shoulder movement.

• The clavicle control assists in creating realistic shoulder and upper torso animations.

• Offers customization in terms of side position, group level, control type, and initial rotation.

Parameters:

• ctrlName – <str, optional> # Name for the clavicle control. Default is generated if not provided.

• sidePos – <str, optional> # Side position for the control, typically ‘L_’ for left or ‘R_’ for right. Default is ‘L_’.

• grpLevel – <int, optional> # Hierarchy level for grouping the control. Default is 1.

• ctrlType – <int, optional> # Type of the clavicle control to be created. Default is 1.

• initRot – <list, optional> # Initial rotation of the control, given as [x, y, z]. Default is [0, 0, 0].

Returns:

<list> # A list containing the control and its top group as Maya nodes, based on grpLevel.

Code Examples:

>>> control_name = "clavicleControl"
>>> side_position = "L_"
>>> group_level = 1
>>> control_type = 1
>>> initial_rotation = [0, 45, 0]
>>> clavicle_control = clavicleCtrl(control_name, side_position, group_level, control_type, initial_rotation)
# Creates a left-sided clavicle control with specified parameters.

Flow Chart Description:

This flowchart illustrates the clavicleCtrl function:

1. The process begins by checking the sidePos (’L_’ or ‘R_’).

2. Based on the side position, the corresponding clavicle control is created.

3. The control is then finalized by applying initial rotation, freezing transformations, and setting the group level.

4. The function concludes by returning the control and its top group as Maya nodes.

eCtrl.cogCtrl(self, ctrlName=None, grpLevel=1, ctrlType=1, **shArgs)#

[shArgs : cn=ctrlName, gl=grpLevel, ct=ctrlType]

Purpose:

:: Creates a cog control in Autodesk Maya, suitable for Center of Gravity (COG) setups.

• This control is ideal for rigging characters or objects where a COG control is required.

• Offers flexibility in control design with options for different types and group levels.

Parameters:

• ctrlName – <str, optional> # Name for the cog control. Default is ‘as_COG_Ctrl’.

• grpLevel – <int> # The number of top groups on the control to be created.

• ctrlType – <int> # Type of COG control to create. Options include 1 for Single Circle, 2 for Dual Circle.

Returns:

<list> # A list containing the control and its top group as Maya nodes, based on grpLevel.

Code Examples:

>>> control_name = "COG_Control"
>>> group_level = 2
>>> control_type = 1
>>> cogControl = cogCtrl(control_name, group_level, control_type)
# This creates a COG control with specified name, group level, and type.

Flow Chart Description:

This flowchart illustrates the cogCtrl function:

1. Checks if shArgs exist and parses them if present.

2. Initializes parameters for control creation, including ctrlName, grpLevel, and ctrlType.

3. Creates a COG control with the specified ctrlName and ctrlType.

4. Creates a control group based on the grpLevel.

5. Snaps the pivot of the control to the control itself.

6. Applies control color to the control.

eCtrl.coneCtrl(self, ctrlName=None, grpLevel=3, ctrlType=2, initRot=[0, 0, 0], snapPiv=1, grpSufxList=None, colorVal=None, **shArgs)#

[**shArgs : ctrlName =n, grpLevel =gl, ctrlType =ct, initRot =ir, snapPiv =sp, grpSufxList =gsl, colorVal =cv]

Purpose:

:: Creates a cone-shaped control with customization options for initial rotation, type, group suffixes, pivot snapping, and color. :: Useful for rigging and animation control setups in Autodesk Maya.

Parameters:

• ctrlName – (<str>, optional) # Name for the control. Defaults to ‘as_Cone_Ctrl’ if not provided.

• grpLevel – (<int>) # Number of top groups on the control to be created.

• ctrlType – (<int>) # Defines the type of cone control to create.

• initRot – (<list of floats>, optional) # Initial rotation of the control shape. Defaults to [0, 0, 0] if not provided.

• snapPiv – (<int>) # Determines if the pivot is snapped (0 or 1).

• grpSufxList – (<list>, optional) # List of suffixes for the control groups.

• colorVal – (<any>, optional) # Color value for the control.

Returns:

(<list>) # If grpLevel is provided, returns [ctrl, ctrlGrp(topGrp)] as asNodes; otherwise, returns [ctrl, ctrl].

Code Examples:

>>> ctrl_name = "myConeCtrl"
>>> group_level = 3
>>> control_type = 2
>>> initial_rotation = [45, 0, 0]
>>> snap_pivot = 1
>>> group_suffix_list = ["grp1", "grp2"]
>>> color_value = "red"
>>> ctrl, ctrl_grp = eCtrl.coneCtrl(ctrl_name, group_level, control_type, initial_rotation, snap_pivot, group_suffix_list, color_value)
# Creates a cone control with specified parameters.

Flow Chart Description:

This flowchart illustrates the coneCtrl function:

1. Checks if shArgs exist and parses them if present.

2. Initializes parameters for control creation, including ctrlName, grpLevel, ctrlType, initRot, snapPiv, grpSufxList, and colorVal.

3. Creates a cone control with the specified parameters.

4. Finalizes the control by calling the finalizeCtrl function.

5. Ends the process.

eCtrl.createCtrlDir(self, trgtObj=None, ctrlName=None, **shArgs)#

[shArgs: to=trgtObj, cn=ctrlName]

Purpose:

:: Facilitates the creation of direction controls, essential for rigging joints like eyes, knees, or elbows.

• Offers a streamlined approach to setting up directional constraints for rigging.

• Enhances rigging precision, especially for pivotal joints requiring directional guidance.

Parameters:

• trgtObj – <str> #The target object, usually a joint, for the control direction (e.g., eyeJnt, kneeJnt).

• ctrlName – <str, optional> #The name for the control to be created. If not specified, derived from the target object.

Returns:

<Maya Node> #The created control direction node, typically an annotation object.

Code Examples:

>>> createCtrlDir(trgtObj="eyeJnt", ctrlName="eyeDirectionCtrl")
# Creates a direction control for the 'eyeJnt' named 'eyeDirectionCtrl'.

>>> createCtrlDir(trgtObj="kneeJnt")
# Creates a direction control for the 'kneeJnt' with an auto-generated name.

Flow Chart Description:

This flowchart illustrates the createCtrlDir function:

1. The function starts by checking if shArgs are provided and updates arguments accordingly.

2. If no arguments are provided, it checks the current selection and assigns targets if two objects are selected.

3. Determines the target object and control name, then creates a locator for direction.

4. An annotation object is created and positioned according to the target.

5. The annotation object is parented to the target and the locator is snapped and parented to the control.

6. Constraints are applied to establish the directional relationship.

7. The annotation is set to template mode for visual guidance.

8. The function returns the annotation object as the control direction node.

eCtrl.defCtrl(self, ctrlName=None, grpLevel=1, snapPiv=True, **shArgs)#

[shArgs : cn=ctrlName, gl=grpLevel, sp=snapPiv]

Purpose:

:: Creates a control with specified naming, grouping, and pivot snapping options.

Parameters:

• ctrlName – <str, optional> # Name for the control to be created.

• grpLevel – <int, optional> # Hierarchy level for grouping the control. Default is 1.

• snapPiv – <bool, optional> # Whether to snap the control’s pivot. Default is True.

Returns:

<list> # If grpLevel is provided, returns [control, top group] as asNodes; otherwise, returns [control, control].

Flow Chart Description:

This flowchart illustrates the defCtrl function:

1. The process begins by checking if a control name is specified.

2. If not specified, a default control name is assigned.

3. Three circles are created to form the control.

4. The circles are combined into a single control.

5. The control is grouped according to the specified group level, with an option to snap the pivot.

6. The control color is applied.

7. The process concludes with the return of the control and its group.

eCtrl.dimondCtrl(self, ctrlName=None, grpLevel=3, initRot=[0, 0, 0], ctrlType=3, grpSufxList=None, snapPiv=0, colorVal=None, **shArgs)#

[shArgs : cn=ctrlName, gl=grpLevel, ir=initRot, ct=ctrlType, gsl=grpSufxList, sp=snapPiv, cv=colorVal]

Purpose:

:: Constructs a diamond-shaped control in Autodesk Maya, suitable for various rigging applications. Offers customization in terms of control name, group level, initial rotation, control type, group suffixes, pivot snapping, and color.

• This function is ideal for creating visually distinctive and functional control handles in rigging scenarios.

• The diamond shape can provide an intuitive and user-friendly control for animators and riggers.

Parameters:

• ctrlName – <str, optional> # Name for the diamond control. Defaults to ‘as_Dimond_Ctrl’.

• grpLevel – <int, optional> # Specifies the hierarchy level for grouping the control. Default is 3.

• initRot – <list of float, optional> # Initial rotation of the control, specified as [x, y, z]. Default is [0, 0, 0].

• ctrlType – <int, optional> # Determines the shape of the diamond control. Options include different diamond shapes. Default is 3.

• grpSufxList – <list of str, optional> # Suffix list for the control’s groups.

• snapPiv – <int> # Determines if the pivot is snapped (0 or 1). Default is 0.

• colorVal – <any, optional> # Color value for the control. Defaults to None.

Returns:

<list of asNode> # A list with the control and its top group as Maya nodes, based on grpLevel.

Usage Examples:

>>> diamond_control = dimondCtrl(ctrlName="myDiamondCtrl", ctrlType=3)[0]
# Creates a diamond control with a specific shape and default settings.

>>> diamond_control, diamond_control_group = dimondCtrl(ctrlName="customDiamond", ctrlType=4, grpLevel=2, colorVal=6)
# Creates a custom diamond control with a specific group level, control type, and color.

:param ctrlName : name(str) #_ name for the control which is going to be created :param grpLevl : num(int) #_ Number of top groups on control to be created :param initRot : [float, float, float] #_ Rotates the shape initially :param ctrlType : 1|2|3 etc #_ One of 5 Shapes can be returned :param grpSufxList (list, optional): List of suffixes for the control groups. :param snapPiv (int): Determines if the pivot is snapped (0 or 1). :param colorVal (any, optional): Color value for the control. :return: If grpLevel is provided, returns [ctrl, ctrlGrp(topGrp)] as asNodes; otherwise, returns [ctrl, ctrl].

Flow Chart Description:

This flowchart illustrates the dimondCtrl function:

1. Checks if shArgs exist and parses them if present.

2. Initializes parameters for control creation, including ctrlName, grpLevel, initRot, ctrlType, grpSufxList, snapPiv, and colorVal.

3. Creates a diamond control based on the specified ctrlType.

4. Rotates the diamond control based on the provided initRot values.

5. Freezes the transformations of the control.

6. Deletes the history of the control.

7. Creates a control group based on the grpLevel.

8. Applies control color to the control.

9. Finalizes the control by calling finalizeCtrl from the eCtrl module.

eCtrl.edgeLoopCtrl(self, ctrlName=0, closeLoop=1, grpLevel=0, edgeList=0, oneShape=1, curvDegree=1, stepVal=1, offset=0, snapPiv=1, multiCtrls=0, **shArgs)#

[shArgs : n=ctrlName, cl=closeLoop, gl=grpLevel, el=edgeList, os=oneShape, cd=curvDegree, sv=stepVal, sp=snapPiv, o=offset, mc=multiCtrls]

Purpose:

:: Generates a control based on an edge loop in Autodesk Maya, with various customization options for shape, grouping, and pivot settings.

• This function is particularly useful for rigging and animation tasks where edge loop based controls are needed.

• Offers flexibility to create single or multiple controls based on edge loops, with adjustable degree, step value, and offset.

Parameters:

• ctrlName – <int/str, optional> # Name for the control to be created. Defaults to 0 if not provided.

• closeLoop – <bool, optional> # Specifies whether to close the first and last edges. Defaults to True.

• grpLevel – <int, optional> # Hierarchy level for grouping the control. Defaults to 0.

• edgeList – <list/str, optional> # List of edges or a single edge to create the control from. If None, selection is used.

• oneShape – <bool, optional> # Determines if a single shape or multiple shapes should be created. Defaults to True.

• curvDegree – <int, optional> # Degree of the curve for the control. Ranges from 1 to 5. Defaults to 1.

• stepVal – <int, optional> # Step value to skip vertices. Defaults to 1 (no skip).

• offset – <int, optional> # Offset value for scaling the control. Defaults to 0.

• snapPiv – <bool, optional> # If True, snaps group pivot to the control. Defaults to True.

• multiCtrls – <bool, optional> # If True, creates multiple controls for each edge in edgeList. Defaults to False.

Returns:

<list> # A list containing the control and its top group as Maya nodes, based on grpLevel.

Code Examples:

>>> ctrl_name = "myEdgeLoopCtrl"
>>> edge_loop = ["edge1", "edge2", "edge3"]
>>> control, control_group = edgeLoopCtrl(ctrlName=ctrl_name, edgeList=edge_loop, grpLevel=2)
# This will create a control based on the specified edge loop with 2 group levels.

:param ctrlName : name(str) #_ name for the control which is going to be created :param closeLoop : True | False #_ Closes the first and last edges :param grpLevl : num(int) #_ Number of top groups on control to be created :param edgeList : None | strList | str #_ If edgeList is not given, edges are selected from selection

#_ If singe edge is given, edgeLoop will be selected

:param oneShape : True | False #_ If not oneShape, multiple shapes equal to no of edges will be created :param curvDegree : 1|2|3|4|5 #_ Used for the degree of the curve :param stepVal : 1|2|etc #_ Skips number of vertices (stepVal-1), if stepVal is more than 1 :param offset : num(int) #_ Keeps the created ctrl with the offset in scaling :param snapPiv : True | False #_ Snaps Group pivot to ‘edgeLoopCtrl’

Flow Chart Description:

This flowchart illustrates the edgeLoopCtrl function:

1. The function starts by checking if a control name is provided. If not, a default name is assigned.

2. It then checks if an edge list is provided. If not, edges are selected from the current selection.

3. The function determines whether to create a single control or multiple controls based on the ‘multiCtrls’ parameter.

4. For a single control, it creates one control based on the provided edge loop.

5. For multiple controls, it creates individual controls for each edge in the edge list.

6. Finally, the function finalizes the control with group levels, pivot snapping, and color application.

7. The process ends by returning the control and its top group.

eCtrl.executeFile(self, filePath, fileName=None, **shArgs)#

[shArgs : fp=filePath, fn=fileName]

Purpose:

:: Executes a script file in Autodesk Maya, allowing for dynamic loading and running of external Python or MEL scripts.

• Facilitates the execution of external scripts, enhancing the flexibility of workflow in Maya.

Parameters:

• filePath – <str> # Path of the file to execute.

• fileName – <str, optional> # Name of the file to execute, if not included in the filePath.

Returns:

None # This function does not return a value but executes the script and prints any missing lines or execution status.

Code Examples:

>>> file_path = "/path/to/script.py"
>>> executeFile(file_path)
# Executes the script located at '/path/to/script.py'.

Flow Chart Description:

This flowchart illustrates the executeFile function:

1. Checks if shArgs exist, and if so, parses the filePath and fileName from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Checks if the file specified by filePath exists.

4. If the file exists, opens and processes the file.

5. If the file does not exist, displays a missing file warning.

6. Ends the process.

eCtrl.exportCtrlShapes(self, filePath=None, fileName=None, ctrlList=None, sufxList='_Ctrl', exFolder='AHSS_Lib', **shArgs)#

[shArgs : fp=filePath, fn=fileName, cl=ctrlList, sl=sufxList, ef=exFolder]

Purpose:

:: Exports control shapes from Autodesk Maya to a specified file, allowing for easy backup and reuse in different projects.

• Essential for preserving custom control shapes and transferring them between scenes or Maya installations.

Parameters:

• filePath – <str, optional> # Path to the file where control shapes are to be exported.

• fileName – <str, optional> # Name of the file for exporting control shapes.

• ctrlList – <list, optional> # List of controls to export.

• sufxList – <str, optional> # Suffix for the controls to be exported.

• exFolder – <str, optional> # Folder for exporting the control shapes.

Returns:

<str> # The path of the exported control shapes file.

Code Examples:

>>> export_path = "/path/to/export"
>>> export_file = "control_shapes"
>>> control_list = ["ctrl1", "ctrl2"]
>>> exportCtrlShapes(export_path, export_file, control_list)
# Exports control shapes of 'ctrl1' and 'ctrl2' to '/path/to/export/control_shapes_ctrlShapes.mel'.

Returns:

filePath + fileName + '_CtrlShapes.mel'

Usage:

if not ctrlList:
        try:
                mc.select ('*' + ctrlSufx, r=1)
                ctrlList =asN._selected()
        except:
                eRig.error('No Ctrls are selected with this suffix %s' %ctrlSufx)

Flow Chart Description:

This flowchart illustrates the exportCtrlShapes function:

1. Checks if shArgs exist, and if so, parses the filePath, fileName, ctrlList, sufxList, and exFolder from it.

2. If shArgs do not exist, initializes parameters with default values.

3. Checks if the ctrlList exists.

4. If the ctrlList exists, exports control shapes from the specified controls.

5. If the ctrlList does not exist, selects controls by suffix and then exports their control shapes.

6. Ends the process.

eCtrl.eyesCtrl(self, ctrlName=None, grpLevel=3, snapPiv=True, ctrlType=2, **shArgs)#

[shArgs : cn=ctrlName, gl=grpLevel, sp=snapPiv, ct=ctrlType]

Purpose:

:: Creates an eye control in Autodesk Maya, allowing for customized group levels, pivot snapping, and control types.

• This function is essential for rigging eyes in characters, providing a simple way to manage eye movements.

• The flexibility in control type and group hierarchy makes it suitable for different rigging requirements.

Parameters:

• ctrlName – <str, optional> # Name for the eye control. Defaults to None.

• grpLevel – <int, optional> # Hierarchy level for grouping the control. Default is 3.

• snapPiv – <bool, optional> # Determines if the control’s pivot should be snapped. Default is True.

• ctrlType – <int, optional> # Type of eye control to create. Default is 2.

Returns:

<list> # A list containing the control and its top group as Maya nodes, based on grpLevel.

Code Examples:

>>> control_name = "myEyeCtrl"
>>> control, control_group = eyesCtrl(ctrlName=control_name, ctrlType=1)
# Creates a type 1 eye control with the specified name.

Flow Chart Description:

This flowchart illustrates the eyesCtrl function:

1. The process starts by checking if a control name is provided. If not, a default name is assigned.

2. The function then determines the type of eye control to create, based on the ‘ctrlType’ parameter.

3. For Type 1, a specific eye control shape is created using circle and modification commands.

4. For Type 2, a different eye control shape is created using curve and closeCurve commands.

5. After creating the control, the function deletes any history attached to it.

6. The control is then finalized with group levels, pivot snapping, and color application.

7. The process ends by returning the control and its top group as Maya nodes.