Skip to content

blockUtility


=== Author: Assaf Ben Zur ===
BLOCK Core Utility Library.
This library contains all utility methods used primarily by BLOCK.
The objective of this library is mainting most Block-Core abilities external and independent.


Classes


MnsRigInfo [Class]

Mansur - About dialog

Constructor: MnsRigInfo(parent(str) ; [default: mnsUIUtils.get_maya_window()],rigInfoData(dict) ; [default: {}])
Inherits from: QtWidgets.QDialog
Class Members:
    • iconsDir
    • close_btn

Defenitions


addDefaultAttrsToPlg

For a newly created plg, create all of it's default predefined attributes.

Constructor: addDefaultAttrsToPlg(plg, kwargs)
Return: None
Arguments:
  • plg
  • kwargs
Keyword Arguments:

alignPLGuides

This is the main 'align' trigger to all 'align tools' in BLOCK.
This method will calidate and collect the current scene slection, then align the collected PLG's based on the mode passed in.

Constructor: alignPLGuides(border = "left", mode = 0)
Return: None
Arguments:
  • border(str) ; [default: "left"]
  • mode(int) ; [default: 0]
Keyword Arguments:

attemptModulePathFixForRootGuide

Constructor: attemptModulePathFixForRootGuide(guideRoot, existingBtns)
Return: None
Arguments:
  • guideRoot
  • existingBtns
Keyword Arguments:

attemptModulePathFixFroRigTop

Run through all existing rig component (in rigTop) and validate the module directories against all existing module directories.
If a module path was found invalid, attempt to re-find it in the existing modules.

Constructor: attemptModulePathFixFroRigTop(rigTop, existingBtns, kwargs)
Return: None
Arguments:
  • rigTop
  • existingBtns
  • kwargs
Keyword Arguments:

bakeSlaveControls

Constructor: bakeSlaveControls(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

buildShapes

This method will be called from a rig construction.
This method will look for any contol shapes stored within the given rig (rigTop), and replace the default shapes with any corresponding control shape.
Shape replacement method will be done according to the 'mode' flag (relative/absulote).

Constructor: buildShapes(ctrls = [], rigTop = None, kwargs)
Return: None
Arguments:
  • ctrls(list) ; [default: []]
  • rigTop(str) ; [default: None]
  • kwargs
Keyword Arguments:
  • mode(int)

characterizeHumanIK

Constructor: characterizeHumanIK(charDefData = {}, mode = 0, kwargs)
Return: None
Arguments:
  • charDefData(dict) ; [default: {}]
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

collectCtrlRelatives

Collect ctrls based on given state:
0: All
1: Modules
2: Selected

Constructor: collectCtrlRelatives(mode = 0, kwargs)
Return: list (controls)
Arguments:
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

collectCtrls

Collect ALL related controls for th given rigTop.

Constructor: collectCtrls(rigTop = None)
Return: list (controls)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

collectGuides

Based on the oprional arguments passed in, collect all matching related guides to the input root list.

Constructor: collectGuides(roots = pm.ls(sl = 1), kwargs)
Return: dict (Related guides), list (sparseGuides, guide without any relations)
Arguments:
  • roots(str) ; [default: selection]
  • kwargs
Keyword Arguments:
  • rigTop(str) ; [default: None]
  • includeDecendents(bool)
  • includeDecendentBranch(bool)
  • getGuides(bool) ; [default: True]
  • getCustomGuides(bool) ; [default: True]
  • allAsSparse(bool)

collectModuleControls

Collect all related controls for the given module.

Constructor: collectModuleControls(moduleTop, kwargs)
Return: list (controls)
Arguments:
  • moduleTop
  • kwargs
Keyword Arguments:

collectModuleRootsBasedOnMode

0: All
1: Branch
2: Module

Constructor: collectModuleRootsBasedOnMode(mode = 0)
Return: list (root guides (modules) to build)
Arguments:
  • mode(int) ; [default: 0]
Keyword Arguments:

collectPLGuidesToAlign

This is the main collect wrapper for all 'align plg' tools in BLOCK.
This methods will validate and collect all PLG to align from the current scene selection

Constructor: collectPLGuidesToAlign(mode = 0)
Return: dict (PLGs to align)
Arguments:
  • mode(int) ; [default: 0]
Keyword Arguments:

collectPartialModules

This method will collect module root objects based on the input data.
If you need to run MnsRig class internal methods, which can operate on partial modules as well as the entire rig, use this method to collect the partial data to be passed into MnsRig class methods.
In case fromNodes argument is Null, this method will return data based on the current scene selection.

Constructor: collectPartialModules(fromNodes = [], mode = 0)
Return: None
Arguments:
  • fromNodes(list) ; [default: []]
  • mode(int) ; [default: 0]
Keyword Arguments:

collectPartialModulesRoots

This method will be called in case a partial build was requested.
Using methods within 'blockUtility', this method will collect the requested modules to build based on the UI state.

Constructor: collectPartialModulesRoots(mode)
Return: list (root guides (modules) to build)
Arguments:
  • mode
Keyword Arguments:

collectPickerDataForRigTop

mode 0 = All
mode 1 = Brnach
mode 2 = module
mode 3 = selected

Constructor: collectPickerDataForRigTop(rigTop = None, mode = 0)
Return: dict (plgs data)
Arguments:
  • rigTop(str) ; [default: None]
  • mode(int) ; [default: 0]
Keyword Arguments:

collectPlgsBasedOnMode

mode 0 = All
mode 1 = Brnach
mode 2 = module
mode 3 = selected

Constructor: collectPlgsBasedOnMode(rigTop = None, mode = 0, kwargs)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

collectSlavesFromNdr

Collect all slaves related to the passed in 'mnsNodeRelationship' node.

Constructor: collectSlavesFromNdr(ndrNode)
Return: list (slave nodes)
Arguments:
  • ndrNode
Keyword Arguments:

compileCnsCtrlsAttrString

Constructor: compileCnsCtrlsAttrString(exsitingCnsCtrlsDict = {})
Return: None
Arguments:
  • exsitingCnsCtrlsDict(dict) ; [default: {}]
Keyword Arguments:

connectIfNotConnected

Constructor: connectIfNotConnected(attrA, attrB)
Return: None
Arguments:
  • attrA
  • attrB
Keyword Arguments:

connectPlgToVisChannel

This method handles the vis channel connection of a plg to it's related layoutBase attributes based on it's type.

Constructor: connectPlgToVisChannel(plg)
Return: None
Arguments:
  • plg
Keyword Arguments:

connectSlaveToDeleteMaster

Connect the passed in 'slave' node to the passed in 'master' node using 'mnsNodeRelationship'.
This method will be successfull only if the master already has a related 'mnsNodeRelationship' node.

Constructor: connectSlaveToDeleteMaster(slave, master)
Return: None
Arguments:
  • slave
  • master
Keyword Arguments:

connectTargetSkeleton

Constructor: connectTargetSkeleton(defenitionDict = {}, blockNameSpace = "", targetNameSpace = "")
Return: None
Arguments:
  • defenitionDict(dict) ; [default: {}]
  • blockNameSpace(str) ; [default: ""]
  • targetNameSpace(str) ; [default: ""]
Keyword Arguments:

constrainObjectsToSurface

Constructor: constrainObjectsToSurface(MnsBuildModule = None, ctrlMasters = [], jointsToAttach = [], surface = None)
Return: list (new ctrls)
Arguments:
  • MnsBuildModule(str) ; [default: None]
  • ctrlMasters(list) ; [default: []]
  • jointsToAttach(list) ; [default: []]
  • surface(str) ; [default: None]
Keyword Arguments:

constructRig

API style scripted construction method.
If you wish to construct a rig from an external command instead of Block's UI, use this method.
You can pass in a fromNodes argument to specify the rig you wish to construct.
In case the fromNodes argument isn't valid, the construction will be selection based.
Also, use the mode argument to specify which mode you wish to construct in:
mode 0 = ALL
mode 1 = Branch
mode 2 = Module
fromNodes is a list argument.
In case any input is passed, this method will attempt to aquire the modules to construct based on the mode selected.
You can pass in any Block-Node names into this method.

Constructor: constructRig(fromNodes = [], mode = 0)
Return: None
Arguments:
  • fromNodes(list) ; [default: []]
  • mode(int) ; [default: 0]
Keyword Arguments:

convertInputObjToSpace

Constructor: convertInputObjToSpace(obj = None)
Return: PyNode (Space object if found)
Arguments:
  • obj(str) ; [default: None]
Keyword Arguments:

convertModuleAuthorityToSurface

Constructor: convertModuleAuthorityToSurface(MnsBuildModule)
Return: list (new ctrls)
Arguments:
  • MnsBuildModule
Keyword Arguments:

copyShape

copy shape utility.
This method is operation on selection.
Copy the control shape of the first selected component, to the rest of the selection.

Constructor: copyShape(source = None, targets = [], reposition = True, kwargs)
Return: None
Arguments:
  • source(str) ; [default: None]
  • targets(list) ; [default: []]
  • reposition(bool) ; [default: True]
  • kwargs
Keyword Arguments:

createAndConnectModuleVisChannelsToPuppetRootCtrl

This method will create and connect the pedefined visibility graph to a given 'Module Top Group'.
The driver attribute will be created within the puppet's 'world control', and the connection graph (using animCurvesUU node) will input into the group's visibility channels.
The channels are split (predefined) as follows:
0. None
1. primaries
2. Secondaries
3. Tertiaries
4. Secondaries Only
5. Tertiaries Only
6. No Primaries

Constructor: createAndConnectModuleVisChannelsToPuppetRootCtrl(moduleTopNode = None)
Return: None
Arguments:
  • moduleTopNode(str) ; [default: None]
Keyword Arguments:

createCnsForCtrls

This method is used to create CNS controls/sub-controls for existing puppet controls.
In case you need to add extra offset controls in order to constraint them to other components, you can use this method.
Pass in a list of controls you want to add sub-controls to, and run.
This method is also the one used by the CNS Tool.

Constructor: createCnsForCtrls(ctrls = [])
Return: bool (success state)
Arguments:
  • ctrls(list) ; [default: []]
Keyword Arguments:

createOffsetSkeleton

Constructor: createOffsetSkeleton(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

createPickerLayoutGuide

The main creation method for PLG creation.
This method will create a new 'Pikcer Layout Guide' based on the passed in parameters.
1. get picker layout base.
2. collect projection position if requested.
3. create and set all attributes

Constructor: createPickerLayoutGuide(ctrl, override, rigTop = None, kwargs)
Return: MnsNameStd (plg)
Arguments:
  • ctrl
  • override
  • rigTop(str) ; [default: None]
  • kwargs
Keyword Arguments:

createPickerLayoutGuides

Warpper method that handles multiple PLGs creation.

Constructor: createPickerLayoutGuides(ctrlsToProject, rigTop, msgPrompt = True, kwargs)
Return: None
Arguments:
  • ctrlsToProject
  • rigTop
  • msgPrompt(bool) ; [default: True]
  • kwargs
Keyword Arguments:

createPlgBaseVisChannels

Constructor: createPlgBaseVisChannels(baseLayoutGuide = None)
Return: None
Arguments:
  • baseLayoutGuide(str) ; [default: None]
Keyword Arguments:

createVisibilityBridgeMdl

This method will check wether the 'target' has a visibility channel connection.
In the case the given 'target' has input visibility connection, a 'bridge' multiplyDoubleLinear node will be created.
The brigde node will accomidate both sources as an input, instead of replacing the original visibility by simple multiplication.
By creating the 'bridge', both old and new sources will be kept as drivers, setting the visibility to 'False' if ANY of the given sources is 'False'.
In case there is no connection input to the target's visibility channel, a simple connection will be made using the input source.

Constructor: createVisibilityBridgeMdl(source = None, target = None)
Return: None
Arguments:
  • source(str) ; [default: None]
  • target(str) ; [default: None]
Keyword Arguments:

createVolumeJoint

Constructor: createVolumeJoint(parentJoint = None, childJoint = None, kwargs)
Return: mnsNameStd (volumeJoint)
Arguments:
  • parentJoint(str) ; [default: None]
  • childJoint(str) ; [default: None]
  • kwargs
Keyword Arguments:

createVolumeJointForSelection

Constructor: createVolumeJointForSelection()
Return: mnsNameStd (volumeJoint)
Arguments:
Keyword Arguments:

ctrlPickerGuideToggle

Atempt to toggle between a selection "control" and "PLG" if possible.

Constructor: ctrlPickerGuideToggle(kwargs)
Return: None
Arguments:
  • kwargs
Keyword Arguments:

deconstructRig

API style scripted deconstruction method.
If you wish to construct a rig from an external command instead of Bloxk's UI, use this method.
You can pass in a fromNodes argument to specify the rig you wish to construct.
In case the fromNodes argument isn't valid, the deconstruction will be selection based.
Also, use the mode argument to specify which mode you wish to construct in:
mode 0 = ALL
mode 1 = Branch
mode 2 = Module
fromNodes is a list argument.
In case any input is passed, this method will attempt to aquire the modules to construct based on the mode selected.
You can pass in any Block-Node names into this method.

Constructor: deconstructRig(fromNodes = [], mode = 0)
Return: None
Arguments:
  • fromNodes(list) ; [default: []]
  • mode(int) ; [default: 0]
Keyword Arguments:

deleteDefaultsForCtrl

Delete all set custom attributes for the given ctrl.

Constructor: deleteDefaultsForCtrl(ctrl, kwargs)
Return: None
Arguments:
  • ctrl
  • kwargs
Keyword Arguments:

deleteFreeJntGrpForModule

Constructor: deleteFreeJntGrpForModule(guideRoot = None, kwargs)
Return: None
Arguments:
  • guideRoot(str) ; [default: None]
  • kwargs
Keyword Arguments:

deleteOffsetSekeleton

Constructor: deleteOffsetSekeleton(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

deletePoseForGuides

Block's delete pose wrapper.

Constructor: deletePoseForGuides(guides = [], poseSet = "T", kwargs)
Return: None
Arguments:
  • guides(list) ; [default: []]
  • poseSet(str) ; [default: "T"]
  • kwargs
Keyword Arguments:

deletePuppetName

This method will filter and delete the rigTops' puppet curves title.

Constructor: deletePuppetName(rigTop, kwargs)
Return: None
Arguments:
  • rigTop
  • kwargs
Keyword Arguments:

deleteRigDefaults

Load controls predefined and custom defaults:
0: All
1: Modules
2: Selected

Constructor: deleteRigDefaults(mode = 0, kwargs)
Return: None
Arguments:
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

detrmineSymmetryDelta

Constructor: detrmineSymmetryDelta(sourceA = None, sourceB = None, kwargs)
Return: None
Arguments:
  • sourceA(str) ; [default: None]
  • sourceB(str) ; [default: None]
  • kwargs
Keyword Arguments:

disconnectSlaveFromMaster

Disconnect the slave passed in from it's master, if there is one.

Constructor: disconnectSlaveFromMaster(slave)
Return: None
Arguments:
  • slave
Keyword Arguments:

disconnectTargetSkeleton

Constructor: disconnectTargetSkeleton(defenitionDict = {}, blockNameSpace = "", targetNameSpace = "", kwargs)
Return: None
Arguments:
  • defenitionDict(dict) ; [default: {}]
  • blockNameSpace(str) ; [default: ""]
  • targetNameSpace(str) ; [default: ""]
  • kwargs
Keyword Arguments:

duplicatePlg

Block "PLG duplicate" trigger.
This method will handle PLG validation and duplication.

Constructor: duplicatePlg(guide = None)
Return: None
Arguments:
  • guide(str) ; [default: None]
Keyword Arguments:

duplicatePlgs

A simple wrapper mwthod to handle multiple PLG duplication (Based on scene selection).

Constructor: duplicatePlgs()
Return: None
Arguments:
Keyword Arguments:

executeActionScript

Constructor: executeActionScript(plgNode)
Return: None
Arguments:
  • plgNode
Keyword Arguments:

exportCtrlShapes

mode = 0 - All
mode = 1 - Branch
mode = 2 - module
Simple export method for control shapes.
The relevant control shapes are collected, duplicated and exported to MA.

Constructor: exportCtrlShapes(mode = 0)
Return: None
Arguments:
  • mode(int) ; [default: 0]
Keyword Arguments:

exportPickerData

mode 0 = All
mode 1 = Brnach
mode 2 = module
mode 3 = selected

Constructor: exportPickerData(rigTop = None, mode = 0)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • mode(int) ; [default: 0]
Keyword Arguments:

extractControlShapes

Trigger method for BLOCK - 'extract control shapes' method.
This method will extract and store the current state of control shapes within the given rig (rigTop).
The extracted shapes will be re-constructed once a rig-rebuild is initiated.
In case of any control shape already exists, it will be replaced by default.

Constructor: extractControlShapes(ctrls = [], rigTop = None, kwargs)
Return: list (controls)
Arguments:
  • ctrls(list) ; [default: []]
  • rigTop(str) ; [default: None]
  • kwargs
Keyword Arguments:

extractSkeleton

Constructor: extractSkeleton(rigTop = None, mode = 0, bakeAnim = False, kwargs)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • mode(int) ; [default: 0]
  • bakeAnim(bool) ; [default: False]
  • kwargs
Keyword Arguments:

extractSkeleton2

Constructor: extractSkeleton2(rigTop = None, mode = 0, kwargs)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

filterCreationOnlyFromArgs

A simple method to filter out the "creationOnly" flag for an argument.
This method is called on a dynamicUI creation call if it NOT a "new creation" mode in BLOCK.
In case any arguments within the list passed in is flagged as "creationOnly", it is removed from the list

Constructor: filterCreationOnlyFromArgs(argsList)
Return: list (filtered arguments)
Arguments:
  • argsList
Keyword Arguments:

filterSettings

Filter all pre-defined settings to their corresponding gathering methods, and re-collect

Constructor: filterSettings(fileSettings, node)
Return: list (settings), string (current side place holder)
Arguments:
  • fileSettings
  • node
Keyword Arguments:

findNamingIssuesInHierarchy

Constructor: findNamingIssuesInHierarchy()
Return: None
Arguments:
Keyword Arguments:

gatherAllControlsCustomDefaults

Gather custom defaults for all ctrls within the given rig.
This method is used on rig deconstruction, to store all set default values, in order to restore them on construction.

Constructor: gatherAllControlsCustomDefaults(rigTop)
Return: dict (All rig custom defaults)
Arguments:
  • rigTop
Keyword Arguments:

gatherCustomDefaultDictForCtrl

Constructor: gatherCustomDefaultDictForCtrl(ctrl)
Return: dict (Custom Defaults Dict)
Arguments:
  • ctrl
Keyword Arguments:

gatherMnsRigObject

This method will gather an MnsRig class object based on the passed in input, in order to use all of it's methods.
If you need to run any method from MnsRig class, use this method to gather the class object, the run any internal method within.

Constructor: gatherMnsRigObject()
Return: None
Arguments:
Keyword Arguments:

gatherModuleCustomDefaults

Gather custom defaults for all ctrls within the given module.
This method is used on rig deconstruction, to store all set default values, in order to restore them on construction.

Constructor: gatherModuleCustomDefaults(moduleTop)
Return: dict (module custom defaults)
Arguments:
  • moduleTop
Keyword Arguments:

getAllCtrlsFromRigTop

Get all controls for the given rig top.

Constructor: getAllCtrlsFromRigTop(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getAllGuideRootsForRigTop

Gather all guide roots for the passed in rigTop node.

Constructor: getAllGuideRootsForRigTop(rigTop)
Return: list (rootGuides)
Arguments:
  • rigTop
Keyword Arguments:

getAllPlgsForRigTop

Collect all 'picker layout guides' from the rig passed in (as rigTop)

Constructor: getAllPlgsForRigTop(rigTop)
Return: list (All PLGs)
Arguments:
  • rigTop
Keyword Arguments:

getAllcolCtrlforRigTop

Collect all 'color associated' nodes within the passed in rigTop.
All returned nodes are considered 'color associated', meaning they are nodes that all of their shapes need to be directly colored.

Constructor: getAllcolCtrlforRigTop(rigTop)
Return: list (colorControls)
Arguments:
  • rigTop
Keyword Arguments:

getChildModules

Recusrsivly collect all child modules from the given rootGuide's decendents.

Constructor: getChildModules(rootGuide)
Return: list (module decendents)
Arguments:
  • rootGuide
Keyword Arguments:

getCompundChildren

Constructor: getCompundChildren(rootGuide = None)
Return: None
Arguments:
  • rootGuide(str) ; [default: None]
Keyword Arguments:

getConstructionState

Constructor: getConstructionState(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getCsGrpFromRigTop

Attempt to collect the 'Control Shapes Group' from the passed in rigTop.

Constructor: getCsGrpFromRigTop(rigTop = None)
Return: MnsNameStd (ctrlShapes group)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getCtrlAuthFromRootGuide

Constructor: getCtrlAuthFromRootGuide(rootGuide = None)
Return: None
Arguments:
  • rootGuide(str) ; [default: None]
Keyword Arguments:

getCtrlAuthFromRootGuides

Constructor: getCtrlAuthFromRootGuides(rGuides = [])
Return: None
Arguments:
  • rGuides(list) ; [default: []]
Keyword Arguments:

getCtrlCol

Get the passed in node's color based on it's type, heirarchy and attributes.

Constructor: getCtrlCol(ctrl, rigTop, kwargs)
Return: tuple[3] (color)
Arguments:
  • ctrl
  • rigTop
  • kwargs
Keyword Arguments:

getCtrlShapesForModueRoot

Constructor: getCtrlShapesForModueRoot(guideRoot)
Return: None
Arguments:
  • guideRoot
Keyword Arguments:

getCtrlsFromModuleRoot

Constructor: getCtrlsFromModuleRoot(guideRoot)
Return: None
Arguments:
  • guideRoot
Keyword Arguments:

getDeleteMasterFromSlave

Collect the delete master from a slave's related 'mnsNodeRelationship' node, if there is one.
This method will collect the master connected to the 'deleteMaster' attribute of the node.

Constructor: getDeleteMasterFromSlave(slave)
Return: MnsNameStd (master)
Arguments:
  • slave
Keyword Arguments:

getExisingCnsCtrlsForRigTop

Constructor: getExisingCnsCtrlsForRigTop(rigTop)
Return: None
Arguments:
  • rigTop
Keyword Arguments:

getExistingCpomNodeFromSurface

Constructor: getExistingCpomNodeFromSurface(surface)
Return: None
Arguments:
  • surface
Keyword Arguments:

getExistingSpaceConstraintForControl

Collect existing 'spaces' constraints for a passed in (built) control, in order to re-build them in turn, after correct filtering and validation (in case of a partial build for example).

Constructor: getExistingSpaceConstraintForControl(ctrl = None)
Return: list (mnsMatrixConstraint nodes)
Arguments:
  • ctrl(str) ; [default: None]
Keyword Arguments:

getExistingSpaceConstraintForControls

Wrapper mwthod to collect 'spaces' constraints for multiple controls.

Constructor: getExistingSpaceConstraintForControls(controls = [])
Return: dict (constraintSpaces dictionary)
Arguments:
  • controls(list) ; [default: []]
Keyword Arguments:

getExistingVolumeJointNodeForJoint

Constructor: getExistingVolumeJointNodeForJoint(joint = None)
Return: None
Arguments:
  • joint(str) ; [default: None]
Keyword Arguments:

getExistingVolumeJointNodeForVolumeJoint

Constructor: getExistingVolumeJointNodeForVolumeJoint(joint = None)
Return: None
Arguments:
  • joint(str) ; [default: None]
Keyword Arguments:

getGlobalScaleAttrFromTransform

This method is used to retreive any output decompose matrix node to be used as global scale input connection.
If this method fails to retreive such attribute, it creates one and returns it.

Constructor: getGlobalScaleAttrFromTransform(transform = None)
Return: Attribute
Arguments:
  • transform(str) ; [default: None]
Keyword Arguments:

getGuideParent

Collect a ctrl type object's 'Guide Authority', or related guide object.

Constructor: getGuideParent(objectSel = None)
Return: PyNode
Arguments:
  • objectSel(str) ; [default: None]
Keyword Arguments:

getJointStructGrpFromRigTop

Attempt to collect the 'Picker Title Group' from the passed in rigTop.

Constructor: getJointStructGrpFromRigTop(rigTop = None)
Return: MnsNameStd (Offset Skeleton Grp)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getKeyboardModifiersState

Constructor: getKeyboardModifiersState()
Return: None
Arguments:
Keyword Arguments:

getLimbModuleControls

mode 0: fk controls and attrHost
mode 1: ik controls and attrHost
mode 2: both and attrHost
mode 3: attrHost only

Constructor: getLimbModuleControls(limbCtrl, mode = 2)
Return: None
Arguments:
  • limbCtrl
  • mode(int) ; [default: 2]
Keyword Arguments:

getModuleAnimGrp

Constructor: getModuleAnimGrp(obj = None)
Return: None
Arguments:
  • obj(str) ; [default: None]
Keyword Arguments:

getModuleDecendentsWildcard

Collect all given module dendents using a 'wild-card' search method.
This will collect all relatives using a * search within the root decendents, and return all of the passed in node types.

Constructor: getModuleDecendentsWildcard(guideRoot, kwargs)
Return: list (matching decendents)
Arguments:
  • guideRoot
  • kwargs
Keyword Arguments:

getModuleFromGuide

This method will attempt to collect a related PyModule from the given guideRoot passed in.
This method will not return the module's methods, only the PyModule as an object.
This method also contains override optional arguments to specify a direct path or module name.

Constructor: getModuleFromGuide(guideRoot, kwargs)
Return: PyModule (object)
Arguments:
  • guideRoot
  • kwargs
Keyword Arguments:
  • methodName(str) ; [default: jointStructure]
  • modPath(str) ; [default: None]
  • modName(str) ; [default: None]

getModuleGuideDecendents

Collect all of the root guide module relatives for the passed in moduleRoot (or rootGuide).

Constructor: getModuleGuideDecendents(guideRoot)
Return: list (sorted by ID module decendents)
Arguments:
  • guideRoot
Keyword Arguments:

getModuleInterpJoints

Collect all the given moduleRoot's 'interpolationJoints' relatives.

Constructor: getModuleInterpJoints(guideRoot, kwargs)
Return: list (matching interJoints)
Arguments:
  • guideRoot
  • kwargs
Keyword Arguments:

getModuleRoot

Attempt to collect the root guide relative from the given node.

Constructor: getModuleRoot(objectA)
Return: PyNode (rootGuide)
Arguments:
  • objectA
Keyword Arguments:

getModuleRootCtrl

Constructor: getModuleRootCtrl(obj = None)
Return: None
Arguments:
  • obj(str) ; [default: None]
Keyword Arguments:

getModuleRootForSel

Attempt to collect a 'root guide' relative from the current selection

Constructor: getModuleRootForSel()
Return: PyNode (moduleRoot)
Arguments:
Keyword Arguments:

getModuleScale

Constructor: getModuleScale(MnsBuildModule)
Return: None
Arguments:
  • MnsBuildModule
Keyword Arguments:

getModuleSettings

Get passed in module settings.
First get the default settings and values from the build-module directory,
then compare against the rootGuide attributes, and return the filtered and altered settings.

Constructor: getModuleSettings(rootGuide, firstAttempt = True, kwargs)
Return: dict,int (optionalArguments, spilt index - for dynUI)
Arguments:
  • rootGuide
  • firstAttempt(bool) ; [default: True]
  • kwargs
Keyword Arguments:

getModuleTopForCtrl

Collect the 'Module Top Group' related to the passed in control.

Constructor: getModuleTopForCtrl(ctrl = None, nameMatch = None)
Return: MnsNameStd (Module Top Group)
Arguments:
  • ctrl(str) ; [default: None]
  • nameMatch(str) ; [default: None]
Keyword Arguments:

getModuleTopFromRootGuide

Attempt to collect 'Module Top Group' from a given root guide.

Constructor: getModuleTopFromRootGuide(rootGuide = None)
Return: MnsNameStd (Module Top Group)
Arguments:
  • rootGuide(str) ; [default: None]
Keyword Arguments:

getNodeRelationshipNodeFromObject

Collect the related 'mnsNodeRelationship' node from the given input node.

Constructor: getNodeRelationshipNodeFromObject(node)
Return: PyNode
Arguments:
  • node
Keyword Arguments:

getOffsetGrpForCtrl

Collect the offsetGroup related to the passed in control, if it exists.

Constructor: getOffsetGrpForCtrl(ctrl, kwargs)
Return: MnsNameStd (offset group)
Arguments:
  • ctrl
  • kwargs
Keyword Arguments:
  • type(str) ; [default: offsetGrp]

getOffsetSkeletonGrpFromRigTop

Attempt to collect the 'Picker Title Group' from the passed in rigTop.

Constructor: getOffsetSkeletonGrpFromRigTop(rigTop = None)
Return: MnsNameStd (Offset Skeleton Grp)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getOppositeSideControl

Attempt to collect the opposite related mns object if it exists.
Only non 'ceneter components' will be tested of course.

Constructor: getOppositeSideControl(obj = None)
Return: MnsNameStd (Opposite object)
Arguments:
  • obj(str) ; [default: None]
Keyword Arguments:

getPickerGuidesGrpFromRigTop

Attempt to collect the 'Picker Guide Group' from the passed in rigTop.

Constructor: getPickerGuidesGrpFromRigTop(rigTop = None)
Return: MnsNameStd (Picker Guide Group)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getPickerLayoutBaseFromRigTop

Attempt to collect the 'Picker Layout Base guide' from the passed in rigTop.

Constructor: getPickerLayoutBaseFromRigTop(rigTop = None)
Return: MnsNameStd (Picker Layout Base guide)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getPickerLayoutCamFromRigTop

Attempt to collect the 'Picker Layout Camera' from the passed in rigTop.

Constructor: getPickerLayoutCamFromRigTop(rigTop = None)
Return: MnsNameStd (Picker Layout Base guide)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getPickerProjectionCamFromRigTop

Attempt to collect the 'Picker Projection Camera' from the passed in rigTop.

Constructor: getPickerProjectionCamFromRigTop(rigTop = None)
Return: MnsNameStd (Picker Projection Camera)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getPickerTitleGrpFromRigTop

Attempt to collect the 'Picker Title Group' from the passed in rigTop.

Constructor: getPickerTitleGrpFromRigTop(rigTop = None)
Return: MnsNameStd (Picker Title Group))
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getPuppetBaseFromRigTop

Attempt to collect the 'puppet group' from the passed in rigTop.

Constructor: getPuppetBaseFromRigTop(rigTop = None)
Return: MnsNameStd (puppet base)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getPuppetRootFromRigTop

Attempt to collect the 'Puppet World Control' from the passed in rigTop.

Constructor: getPuppetRootFromRigTop(rigTop = None)
Return: MnsNameStd (Puppet world control)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getPyModuleFromGuide

Attempt to collect a 'Python Module' (or package) related to the given guide node passed in.
If a related module was found, this method will return it as a PyModule object not as a directory.
This method will also return the module's methods in a dictionary in order to run directly from it.

Constructor: getPyModuleFromGuide(guide)
Return: PyModule, dict (module methods as keys and method objects as entries)
Arguments:
  • guide
Keyword Arguments:

getRelatedNodeFromObject

Collect a related node from the 'messageOut' attribute of the given node's 'mnsNodeRelationship' node.

Constructor: getRelatedNodeFromObject(node)
Return: PyNode
Arguments:
  • node
Keyword Arguments:

getRelatedVolJntSourcesForSelection

Constructor: getRelatedVolJntSourcesForSelection()
Return: None
Arguments:
Keyword Arguments:

getRelationMasterFromSlave

Collect the delete master from a slave's related 'mnsNodeRelationship' node, if there is one.
This method will collect the master connected to the 'masterIn' attribute of the node.

Constructor: getRelationMasterFromSlave(slave)
Return: MnsNameStd (master)
Arguments:
  • slave
Keyword Arguments:

getRigTop

Attempt to get a rigTop node from the passed in node to check.

Constructor: getRigTop(objectA)
Return: MnsNameStd (rigTop)
Arguments:
  • objectA
Keyword Arguments:

getRigTopAssemblies

Constructor: getRigTopAssemblies()
Return: None
Arguments:
Keyword Arguments:

getRigTopForSel

Attempt to get a rigTop node from current selection

Constructor: getRigTopForSel(kwargs)
Return: MnsNameStd (rigTop)
Arguments:
  • kwargs
Keyword Arguments:

getRootGuideFromCtrl

Attempt to collect the related 'rootGuide' from the given control passed in.

Constructor: getRootGuideFromCtrl(obj)
Return: MnsNameStd (rootGuide)
Arguments:
  • obj
Keyword Arguments:

getRootGuideFromRigTop

Attempt to collect the rig's root guide from the passed in rigTop node

Constructor: getRootGuideFromRigTop(rigTop = None)
Return: MnsNameStd (rig root guide)
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

getRootJointsFromModuleRoot

Constructor: getRootJointsFromModuleRoot(guideRoot)
Return: None
Arguments:
  • guideRoot
Keyword Arguments:

getSettings

Get setting for the requested setting path.
The settings are being filtered and set according to a node passed in.

Constructor: getSettings(settingsPath, node, blkType)
Return: list (optionalArgumentsFromFile), string (current side place holder)
Arguments:
  • settingsPath
  • node
  • blkType
Keyword Arguments:

getSideModuleBranchRoot

For a non "center" component passed in, recursively attempt to collect the 'side-branch' root guide.
In essence look for the highest rootGuide in the selected 'side' heirarchy that has a 'center' component parent- meaning it's the top of the requested branch.

Constructor: getSideModuleBranchRoot(guide = None)
Return: MnsNameStd (branch root)
Arguments:
  • guide(str) ; [default: None]
Keyword Arguments:

getSimpleRivetsNodeForMesh

Constructor: getSimpleRivetsNodeForMesh(mesh = None)
Return: PyNode
Arguments:
  • mesh(str) ; [default: None]
Keyword Arguments:

getSymAttrBasedOnSymMapping

Constructor: getSymAttrBasedOnSymMapping(attr = None, attrMapping = {})
Return: None
Arguments:
  • attr(str) ; [default: None]
  • attrMapping(dict) ; [default: {}]
Keyword Arguments:

getSymmetricalVolumeJoint

Constructor: getSymmetricalVolumeJoint(vJnt = None, kwargs)
Return: mnsNameStd (symmetrical volume-joint)
Arguments:
  • vJnt(str) ; [default: None]
  • kwargs
Keyword Arguments:

getVJntSources

Constructor: getVJntSources(vJnt = None)
Return: None
Arguments:
  • vJnt(str) ; [default: None]
Keyword Arguments:

getVJointData

Constructor: getVJointData(vJnt)
Return: None
Arguments:
  • vJnt
Keyword Arguments:

handleInterpLocsStructureReturn

Constructor: handleInterpLocsStructureReturn(rigTop = None, interpLocs = [], guides = [], kwargs)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • interpLocs(list) ; [default: []]
  • guides(list) ; [default: []]
  • kwargs
Keyword Arguments:

importCtrlShapes

Simple import method for control shapes.

Constructor: importCtrlShapes()
Return: None
Arguments:
Keyword Arguments:

importGuidePreset

Constructor: importGuidePreset(presetName = None)
Return: None
Arguments:
  • presetName(str) ; [default: None]
Keyword Arguments:

importPickerData

Constructor: importPickerData(kwargs)
Return: None
Arguments:
  • kwargs
Keyword Arguments:

injectPlgPropertiesFromData

Constructor: injectPlgPropertiesFromData(plg = None, data = {})
Return: None
Arguments:
  • plg(str) ; [default: None]
  • data(dict) ; [default: {}]
Keyword Arguments:

insertGuides

This method is used primarily through Block UI, to insert guides above/below any guide selection.
This will handle all exceptions, as well as re-analyze and re-orgenize each module based on the action performed.

Constructor: insertGuides(amount = 0, mode = "above", kwargs)
Return: None
Arguments:
  • amount(int) ; [default: 0]
  • mode(str) ; [default: "above"]
  • kwargs
Keyword Arguments:

jointRotateToOrientTrigger

Constructor: jointRotateToOrientTrigger(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

limbMatchFkIK

mode 0 - Match FK to IK
mode 1 - Match IK to FK

Constructor: limbMatchFkIK(limbCtrl, mode = 0, kwargs)
Return: None
Arguments:
  • limbCtrl
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

loadDefaultsForCtrl

Load all default attributes for the given control, taking mnsDefaults (custom) into acount

Constructor: loadDefaultsForCtrl(ctrl, kwargs)
Return: None
Arguments:
  • ctrl
  • kwargs
Keyword Arguments:

loadPerspCam

Set Maya's main camera panel, to the default 'persp' camera.

Constructor: loadPerspCam()
Return: None
Arguments:
Keyword Arguments:

loadPickerProjectionCam

Set the main maya camera view to the 'picker projection camera', based on the scene selection (or the related rigTop to selection).

Constructor: loadPickerProjectionCam()
Return: None
Arguments:
Keyword Arguments:

loadPoseForGuides

Block's load pose wrapper.

Constructor: loadPoseForGuides(guides = [], poseSet = "T", kwargs)
Return: None
Arguments:
  • guides(list) ; [default: []]
  • poseSet(str) ; [default: "T"]
  • kwargs
Keyword Arguments:

loadResetValuesForOffsetJoint

Constructor: loadResetValuesForOffsetJoint(offsetJnt = None)
Return: None
Arguments:
  • offsetJnt(str) ; [default: None]
Keyword Arguments:

loadRigDefaults

Load controls predefined and custom defaults:
0: All
1: Modules
2: Selected

Constructor: loadRigDefaults(mode = 0, kwargs)
Return: None
Arguments:
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

loadRigInfo

Constructor: loadRigInfo(puppetRoot = None)
Return: None
Arguments:
  • puppetRoot(str) ; [default: None]
Keyword Arguments:

locateCnsForCtrl

Constructor: locateCnsForCtrl(ctrl = None, kwargs)
Return: None
Arguments:
  • ctrl(str) ; [default: None]
  • kwargs
Keyword Arguments:

locatePLGBaseVisMdNodes

Constructor: locatePLGBaseVisMdNodes(baseLayoutGuide = None)
Return: MnsNameStd (bodyMdNode), MnsNameStd (facialMDNode)
Arguments:
  • baseLayoutGuide(str) ; [default: None]
Keyword Arguments:

matchExtractedSkeletonToBaseSkeleton

Constructor: matchExtractedSkeletonToBaseSkeleton()
Return: None
Arguments:
Keyword Arguments:

matchGuidesToTargetSkeleton

Constructor: matchGuidesToTargetSkeleton(defenitionDict = {}, blockNameSpace = "", targetNameSpace = "")
Return: None
Arguments:
  • defenitionDict(dict) ; [default: {}]
  • blockNameSpace(str) ; [default: ""]
  • targetNameSpace(str) ; [default: ""]
Keyword Arguments:

matchKeyableAttributes

Constructor: matchKeyableAttributes(source = None, target = None)
Return: None
Arguments:
  • source(str) ; [default: None]
  • target(str) ; [default: None]
Keyword Arguments:

mirrorCtrls

Constructor: mirrorCtrls(ctrls = [], direction = 0, kwargs)
Return: None
Arguments:
  • ctrls(list) ; [default: []]
  • direction(int) ; [default: 0]
  • kwargs
Keyword Arguments:

missingModuleActionTrigger

Action trigger for an invalid module path fix attempt

Constructor: missingModuleActionTrigger(rigTop, missingModuleName, existingBtns)
Return: None
Arguments:
  • rigTop
  • missingModuleName
  • existingBtns
Keyword Arguments:

muteLocalTransformations

Constructor: muteLocalTransformations(ctrl = None, kwargs)
Return: None
Arguments:
  • ctrl(str) ; [default: None]
  • kwargs
Keyword Arguments:

namePuppet

This method is used to create the rig's curves puppet title and connect it to to it's world control as additional shape nodes.

Constructor: namePuppet(rigTop, kwargs)
Return: None
Arguments:
  • rigTop
  • kwargs
Keyword Arguments:

orientGuides

Constructor: orientGuides(guides = [], kwargs)
Return: None
Arguments:
  • guides(list) ; [default: []]
  • kwargs
Keyword Arguments:

pickerButtonClickAction

The global action trigger for any picker UI button click trigger.
This method will trigger the "controls selection" and the "action script" for the passed in QPushButton passed in.

Constructor: pickerButtonClickAction(btn, kwargs)
Return: None
Arguments:
  • btn
  • kwargs
Keyword Arguments:

pickerLayoutAdjust

Load a new Maya panel, with the 'Picker Layout Camera' related to the scene selction.
This will also set the panel settings before loading it, based on the rigTop and 'layout base' attributes.

Constructor: pickerLayoutAdjust()
Return: None
Arguments:
Keyword Arguments:

pickerTitleToggle

Toggle between PLG 'control' view, to 'title' view.

Constructor: pickerTitleToggle()
Return: None
Arguments:
Keyword Arguments:

preCheckNameForUI

A simple method to check for argument duplicates within an argument dict

Constructor: preCheckNameForUI(arguments, suffix)
Return: dict (recompiled arguments)
Arguments:
  • arguments
  • suffix
Keyword Arguments:

projectPickerLayout

A wrapper method that handles plg projection from scene objects based on mode.
mode 0 = selected
mode 1 = module
mode 2 = branch

Constructor: projectPickerLayout(mode = 0, msgPrompt = True)
Return: None
Arguments:
  • mode(int) ; [default: 0]
  • msgPrompt(bool) ; [default: True]
Keyword Arguments:

projectPickerLayoutPos

Get the passed in Ctrl PLG position, relative to the rig's 'layoutBase'.
This method 'projects' the ctrl position based on the rig's 'Projection Camera' into the layout base space, and returns it's processed position.

Constructor: projectPickerLayoutPos(ctrl, cam, layoutBase)
Return: tuple[3] (posX), tuple[3] (posY)
Arguments:
  • ctrl
  • cam
  • layoutBase
Keyword Arguments:

projectSelectedPickerLayout

A wrapper method that handles plg projection from selected scene objects.

Constructor: projectSelectedPickerLayout(msgPrompt = True)
Return: None
Arguments:
  • msgPrompt(bool) ; [default: True]
Keyword Arguments:

rebuildJointStructure

modes:
0 = All
1 = Branch
2 = Module

Constructor: rebuildJointStructure(mode = 0)
Return: None
Arguments:
  • mode(int) ; [default: 0]
Keyword Arguments:

recGetModuleTopForCtrl

Recursively attempt to collect the 'Module Top Group' related to the ctrl passed in within it's related parents.

Constructor: recGetModuleTopForCtrl(ctrl = None)
Return: MnsNameStd (Module Top Group)
Arguments:
  • ctrl(str) ; [default: None]
Keyword Arguments:

recGetParentJoint

Recursivly attempt to get a parent joint starting with a given root object, scaling up the heirarchy.

Constructor: recGetParentJoint(rootObject = None)
Return: mnsNameStd
Arguments:
  • rootObject(str) ; [default: None]
Keyword Arguments:

recRenameLowerIndex

Constructor: recRenameLowerIndex(root = None, moduleGuides = [], moduleJoints = [])
Return: None
Arguments:
  • root(str) ; [default: None]
  • moduleGuides(list) ; [default: []]
  • moduleJoints(list) ; [default: []]
Keyword Arguments:

recSearchForGuideRootInParents

Recusrsivly look for a 'rootGuide' from the given node's parent relatives.

Constructor: recSearchForGuideRootInParents(obj)
Return: PyNode (rootGuide)
Arguments:
  • obj
Keyword Arguments:

removeAlienMatchesFromList

Constructor: removeAlienMatchesFromList(guideRoot, currentMatches = [])
Return: None
Arguments:
  • guideRoot
  • currentMatches(list) ; [default: []]
Keyword Arguments:

removeAllAuthority

This method is used to delete all 'Authority' from the passsed in slave, if there are any.

Constructor: removeAllAuthority(slave = None, kwargs)
Return: MnsNameStd (oldAuthority)
Arguments:
  • slave(str) ; [default: None]
  • kwargs
Keyword Arguments:

removeCnsFromCtrls

This method is used to remove existing CNS controls/sub-controls for existing puppet controls.
If you have CNS controls you want to remove, use this method.
Pass in a list of controls you want to remove sub-controls from, and run.
This method is also the one used by the CNS Tool.

Constructor: removeCnsFromCtrls(ctrls = [])
Return: bool (success state)
Arguments:
  • ctrls(list) ; [default: []]
Keyword Arguments:

removeGuides

Constructor: removeGuides(kwargs)
Return: None
Arguments:
  • kwargs
Keyword Arguments:

removeModuleVisAttrFromPuppetTop

This method will remove the corresponding "module vis" channel from the given puppet base control.
This method is used when a 'partial deconstruction' is initiated, keeping only relevant vis channels in place, removing the 'deconstructed' modules vis channels.

Constructor: removeModuleVisAttrFromPuppetTop(moduleTopNode = None, puppetTop = None)
Return: None
Arguments:
  • moduleTopNode(str) ; [default: None]
  • puppetTop(str) ; [default: None]
Keyword Arguments:

repositionShape

Simple method to re-center a control shape to its natural pivot

Constructor: repositionShape(targets = [])
Return: None
Arguments:
  • targets(list) ; [default: []]
Keyword Arguments:

resetAllControlForRigTop

Constructor: resetAllControlForRigTop(rigTop = None, kwargs)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • kwargs
Keyword Arguments:

resetControls

reset all keyable attributes to default value.

Constructor: resetControls(controls=[], kwargs)
Return: None
Arguments:
  • controls(list) ; [default: []]
  • kwargs
Keyword Arguments:

resetOffsetSkeleton

Constructor: resetOffsetSkeleton(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

saveLoadDagPose

mode 0 = Save
mode 1 = Load
mode 2 = Delete

poses: Bind, T, A

Constructor: saveLoadDagPose(rootJoint = None, mode = 1, poseName = "Bind")
Return: None
Arguments:
  • rootJoint(str) ; [default: None]
  • mode(int) ; [default: 1]
  • poseName(str) ; [default: "Bind"]
Keyword Arguments:

saveLoadPose

This is the main wrapper for all pose 'save & load' triggers of BLOCK.

Constructor: saveLoadPose(guides = [], kwargs)
Return: None
Arguments:
  • guides(list) ; [default: []]
  • kwargs
Keyword Arguments:
  • rigTop(str) ; [default: None]
  • mode(int)
  • saveLoad(int)
  • msgPrompt(bool)
  • pose(str) ; [default: T]

savePoseForGuides

Block's save pose wrapper.

Constructor: savePoseForGuides(guides = [], poseSet = "T", msgPrompt = False, kwargs)
Return: None
Arguments:
  • guides(list) ; [default: []]
  • poseSet(str) ; [default: "T"]
  • msgPrompt(bool) ; [default: False]
  • kwargs
Keyword Arguments:

searchForRootGuideInRelatives

Search for a 'guide authority' or 'rootGuide' in the given node's decendents

Constructor: searchForRootGuideInRelatives(obj)
Return: PyNode (rootGuide)
Arguments:
  • obj
Keyword Arguments:

selectAllCtrls

Select all controls for the given rig top.

Constructor: selectAllCtrls(rigTop = None, kwargs)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • kwargs
Keyword Arguments:

selectRelatedControls

Constructor: selectRelatedControls(controlsToSelect, mode = "replace")
Return: None
Arguments:
  • controlsToSelect
  • mode(str) ; [default: "replace"]
Keyword Arguments:

selectSlaveControls

Constructor: selectSlaveControls(rigTop = None, kwargs)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
  • kwargs
Keyword Arguments:

setCtrlCol

Attempt to collect the passed in node's color (based on its type), and set it if seccessfull.

Constructor: setCtrlCol(ctrl, rigTop, kwargs)
Return: MnsNameStd (ctrl)
Arguments:
  • ctrl
  • rigTop
  • kwargs
Keyword Arguments:

setCurrentStateAsDefaultForCtrl

Set custom defaults for keyable attributes for the given control, based on it's current state.

Constructor: setCurrentStateAsDefaultForCtrl(ctrl, kwargs)
Return: None
Arguments:
  • ctrl
  • kwargs
Keyword Arguments:

setResetValuesForOffsetJoint

Constructor: setResetValuesForOffsetJoint(offsetJnt = None)
Return: None
Arguments:
  • offsetJnt(str) ; [default: None]
Keyword Arguments:

setRigDefaults

Set controls custom defaults based on given state:
0: All
1: Modules
2: Branches

Constructor: setRigDefaults(mode = 0, kwargs)
Return: None
Arguments:
  • mode(int) ; [default: 0]
  • kwargs
Keyword Arguments:

setgCtrlColorForModule

For all relevant decendents of the passed in moduleRoot, get and set it's color.

Constructor: setgCtrlColorForModule(rigTop, moduleRoot)
Return: None
Arguments:
  • rigTop
  • moduleRoot
Keyword Arguments:

setgCtrlColorForRigTop

Set ALL relevnt controls within a rigTop, to their color based on their type.

Constructor: setgCtrlColorForRigTop(rigTop)
Return: None
Arguments:
  • rigTop
Keyword Arguments:

symmetrizeCGShape

A simple method to symmetrize custom guides nurbs shapes when aplicable
Mode=
0: All
1: Modules
2: Branches
3: selection
Direction=
0: L -> R
1: R -> L

Constructor: symmetrizeCGShape(mode = 0, direction = 0, cGuides = [])
Return: None
Arguments:
  • mode(int) ; [default: 0]
  • direction(int) ; [default: 0]
  • cGuides(list) ; [default: []]
Keyword Arguments:

symmetrizePlg

Block 'plg symmetrize' button trigger.
This method will handle validation and creation of PLG related symmetrical plg.

Constructor: symmetrizePlg(guide = None)
Return: None
Arguments:
  • guide(str) ; [default: None]
Keyword Arguments:

symmetrizePlgs

A simple wrapper method to symmetrize multiple PLG's (based on scene selection).

Constructor: symmetrizePlgs()
Return: None
Arguments:
Keyword Arguments:

symmetrizeVJ

Constructor: symmetrizeVJ(vJnt = None, kwargs)
Return: None
Arguments:
  • vJnt(str) ; [default: None]
  • kwargs
Keyword Arguments:

toggleGuideCtrl

Atempt to toggle between a selection guide and main joint if possible.

Constructor: toggleGuideCtrl(kwargs)
Return: None
Arguments:
  • kwargs
Keyword Arguments:

toggleGuideJoint

Atempt to toggle between a selection guide and main joint if possible.

Constructor: toggleGuideJoint(kwargs)
Return: None
Arguments:
  • kwargs
Keyword Arguments:

togglePickerCtrlBodyFacial

Constructor: togglePickerCtrlBodyFacial()
Return: None
Arguments:
Keyword Arguments:

transferAuthorityToCtrl

This is a very important method used in BLOCK cosntruction.
This method will find the current 'guide control' from the given joint slave. and transfer it's authority to a newly created 'control authority'.
This method will be called on every module build and it is the main trigger to flag a module construction.
The 'authority' attribute for every guide or control is used to distiguish the module state, and jnt state.
When transfering an authority to a ctrl, a 'old authority' attr (of sort) is created, in order for the procedural 'deconstruct' to look for and tranfer the jnt authority back to it's orignal guide,
before deleting the constructed module.
See also parallel: 'transferAuthorityToGuide' Method.

Constructor: transferAuthorityToCtrl(slave = None, ctrlMaster = None, kwargs)
Return: None
Arguments:
  • slave(str) ; [default: None]
  • ctrlMaster(str) ; [default: None]
  • kwargs
Keyword Arguments:

transferAuthorityToGuide

This is a very important method used in BLOCK de-construction.
This method will find the current 'control' from the given joint slave. and transfer it's authority to a it's original 'guide' authority.
This method will be called procedurally on any module deconstruction, before deleting the constructed module.
See also parallel: 'transferAuthorityToCtrl' Method.

Constructor: transferAuthorityToGuide(ctrl = None, kwargs)
Return: None
Arguments:
  • ctrl(str) ; [default: None]
  • kwargs
Keyword Arguments:

transferAuthorityToOffsetSkeleton

Constructor: transferAuthorityToOffsetSkeleton(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

transferAuthorityToPuppet

Constructor: transferAuthorityToPuppet(rigTop = None)
Return: None
Arguments:
  • rigTop(str) ; [default: None]
Keyword Arguments:

upParentAllPlgTrigger

OBSELETE. PLG parenting is no longer in use.

Constructor: upParentAllPlgTrigger()
Return: None
Arguments:
Keyword Arguments:

updateRigStructure

Rig structure update required trigger.
This method will be called in case any 'jntStructMember' attribute was altered, which means the internal joint structure of the module needs to be rebuilt.
This method will locate and filter the existing module related joint structure, destroy it, and re-build it using the updated settings.

Constructor: updateRigStructure(softMod = False, kwargs)
Return: None
Arguments:
  • softMod(bool) ; [default: False]
  • kwargs
Keyword Arguments:

volumeJointAngleSymmetryMapping

Constructor: volumeJointAngleSymmetryMapping(symmetryDelta = pm.datatypes.Vector(1.0, 1.0, 1.0))
Return: None
Arguments:
  • symmetryDelta(str) ; [default: pm.datatypes.Vector(1.0]
  • 1.0
  • 1.0)
Keyword Arguments: