def create(self):
sGrp = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sRig' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInJnt)
sGrpCtrl = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sCtrl' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInCtrl)
sParent_jnt = sGrp
sParent_ctrl = sGrpCtrl
lJnts = []
lCtrls = []
for i, sBpJnt in enumerate(self._lBpJnts):
oJntName = naming.oName(sBpJnt)
oJntName.sType = 'jnt'
oJntName.sPart = '%s%s' %(oJntName.sPart, self._sName)
sJnt = joints.createJntOnExistingNode(sBpJnt, sBpJnt, oJntName.sName, sParent = sParent_jnt)
lJnts.append(sJnt)
if i < len(self._lBpJnts) - 1:
iRotateOrder = cmds.getAttr('%s.ro' %sJnt)
oCtrl = controls.create(oJntName.sPart, sSide = oJntName.sSide, iIndex = oJntName.iIndex, iStacks = self._iStacks, bSub = self._bSub, sParent = sParent_ctrl, sPos = sJnt, iRotateOrder = iRotateOrder, sShape = 'square', fSize = 8, lLockHideAttrs = self._lLockHideAttrs)
cmds.parentConstraint(oCtrl.sOutput, sJnt, mo = False)
lCtrls.append(oCtrl.sName)
sParent_jnt = sJnt
sParent_ctrl = oCtrl.sOutput
## write rig info
sString_lJnts = self._convertListToString(lJnts)
sString_lCtrls = self._convertListToString(lCtrls)
lRigInfo = ['fkJointChainRig', self._sConnectInJnt, self._sConnectInCtrl, sJnt, oCtrl.sOutput, sString_lJnts, sString_lCtrls, sGrpCtrl, sGrp]
lAttrs = ['sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt', 'sConnectOutCtrl', 'lJnts', 'lCtrls', 'sGrpCtrl', 'sModuleNode']
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
def create(self):
self._lBpJnts = [
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='upperArm').sName,
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='elbow').sName,
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='wrist').sName,
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='wristEnd').sName,
]
super(armRig, self).create()
## create matchers
lIndex_fkik = [0, 1]
lString_fkik = ['fk', 'ik']
for i, iIndex in enumerate(lIndex_fkik):
if iIndex in self._lModuleIndex:
sMatchersString = ''
iIndex_each = self._lModuleIndex.index(i)
sModuleNode_each = self._lModuleNodes[iIndex_each]
if iIndex == 0:
oModule_each = armFkRig.armFkRig(sModuleNode_each)
elif iIndex == 1:
oModule_each = armIkRig.armIkRig(sModuleNode_each)
for j, sCtrl in enumerate(oModule_each.lCtrls):
sMatcher, sOffset = transforms.createTransformMatcherNode(
sCtrl, sParent=self._lJnts[j])
sMatchersString += '%s,' % sMatcher
self._writeRigInfo(self._sModuleNode, [sMatchersString[:-1]],
['lMatchers%s' % lString_fkik[i].title()])
self._writeRigInfo(self._sModuleNode, ['armRig'], ['sModuleType'])
self._getRigInfo(self._sModuleNode)
def __updateStacks(self, iKey):
if iKey < self.__iStacks:
lChilds = cmds.listRelatives(self.__lStacks[-1], c = True, type = 'transform')
cmds.parent(lChilds, self.__lStacks[iKey - 1])
cmds.delete(self.__lStacks[iKey:])
else:
sParentStack = self.__lStacks[-1]
lChilds = cmds.listRelatives(self.__lStacks[-1], c = True, type = 'transform')
for i in range(self.__iStacks, iKey):
sStack = naming.oName(sType = 'stack', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex, iSuffix = i + 1).sName
sStack = transforms.createTransformNode(sStack, sParent = sParentStack)
transforms.transformSnap([sParentStack], [sStack])
sParentStack = sStack
cmds.parent(lChilds, sParentStack)
cmds.setAttr('%s.iStacks' %self.__sName, lock = False)
cmds.setAttr('%s.iStacks' %self.__sName, iKey, lock = True)
cmds.select(self.__sName)
cmds.delete(self.__sMultMatrixStacks)
cmds.createNode('multMatrix', name = self.__sMultMatrixStacks)
for i in range(iKey):
iNum = iKey - i
sStack = naming.oName(sType = 'stack', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex, iSuffix = iNum).sName
cmds.connectAttr('%s.matrix' %sStack, '%s.matrixIn[%d]' %(self.__sMultMatrixStacks, i))
cmds.connectAttr('%s.matrixSum' %self.__sMultMatrixStacks, '%s.matrixIn[2]' %self.__sMultMatrixOutputLocal)
self.__getCtrlInfo(self.__sName)
def createTransformMatcherNode(sNode, sParent=None, bInheritsTransform=True):
oName = naming.oName(sNode)
sOffset = naming.oName(sType='grp',
sSide=oName.sSide,
sPart='%sMatcher' % oName.sPart,
iIndex=oName.iIndex,
iSuffix=oName.iSuffix).sName
sMatcher = naming.oName(sType='null',
sSide=oName.sSide,
sPart='%sMatcher' % oName.sPart,
iIndex=oName.iIndex,
iSuffix=oName.iSuffix).sName
iRotateOrder = cmds.getAttr('%s.ro' % sNode)
sOffset = createTransformNode(sOffset,
sParent=sParent,
iRotateOrder=iRotateOrder)
transformSnap([sNode, sOffset], sType='all')
attributes.lockHideAttrs(
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'],
sNode=sOffset)
sMatcher = createTransformNode(sMatcher,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sOffset,
sPos=sOffset,
iRotateOrder=iRotateOrder,
bInheritsTransform=bInheritsTransform)
return sMatcher, sOffset
def createDriveJoints(lBpJnts, sParent = None, sSuffix = '', sRemove = '', bBind = False, lBindNameOverride = None): lJnts = [] lBindJnts = [] sBindParent = None for i, sBpJnt in enumerate(lBpJnts): ## jnt oJntName = naming.oName(sBpJnt) oJntName.sType = 'jnt' if sRemove: oJntName.sPart = oJntName.sPart.replace(sRemove, '') oJntName.sPart = '%s%s' %(oJntName.sPart, sSuffix) sJnt = joints.createJntOnExistingNode(sBpJnt, sBpJnt, oJntName.sName, sParent = sParent) sParent = sJnt lJnts.append(sJnt) ## bind jnt if bBind: if lBindNameOverride: oJntName = naming.oName(lBindNameOverride[i]) oJntName.sType = 'bindJoint' sBindJnt = joints.createJntOnExistingNode(sBpJnt, sBpJnt, oJntName.sName, sParent = sBindParent) sBindParent = sBindJnt lBindJnts.append(sBindJnt) ## tag drv joint tagBindJoint(sBindJnt, sJnt) return lJnts, lBindJnts
def _editSpaceAttr(self, sCtrl, sType, lKeys, lIndex, lPlugs, iDefaultA, iDefaultB):
iDefaultA_orig = cmds.addAttr('%s.spaceA%s' %(sCtrl, sType.upper()), q = True, dv = True)
iDefaultB_orig = cmds.addAttr('%s.spaceB%s' %(sCtrl, sType.upper()), q = True, dv = True)
sEnumName_orig = cmds.addAttr('%s.spaceA%s' %(sCtrl, sType.upper()), q = True, en = True)
sEnumName_orig += ':'
if iDefaultA == None:
iDefaultA = iDefaultA_orig
if iDefaultB == None:
iDefaultB = iDefaultB_orig
for i, sKey in enumerate(lKeys):
sEnumName_orig += '%s=%s:' %(sKey, lIndex[i])
cmds.addAttr('%s.spaceA%s' %(sCtrl, sType.upper()), e = True, en = sEnumName_orig[:-1], dv = iDefaultA)
cmds.addAttr('%s.spaceB%s' %(sCtrl, sType.upper()), e = True, en = sEnumName_orig[:-1], dv = iDefaultB)
oCtrl = controls.oControl(sCtrl)
sChoiceA = naming.oName(sType = 'choice', sSide = oCtrl.sSide, sPart = '%sSpaceA%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
sChoiceB = naming.oName(sType = 'choice', sSide = oCtrl.sSide, sPart = '%sSpaceB%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
for i, sPlug in enumerate(lPlugs):
sPlug_space = self._spaceMatrix(sCtrl, sPlug, lKeys[i])
cmds.connectAttr(sPlug_space, '%s.input[%d]' %(sChoiceA, lIndex[i]), f = True)
cmds.connectAttr(sPlug_space, '%s.input[%d]' %(sChoiceB, lIndex[i]), f = True)
def enumToSingleAttrs(sEnumAttr,
lAttrs,
iEnumRange=2,
lValRange=[[0, 1]],
sEnumObj=None):
if '.' not in sEnumAttr:
sEnumAttrName = sEnumAttr
sEnumAttr = '%s.%s' % (sEnumObj, sEnumAttr)
else:
sEnumObj = sEnumAttr.split('.')[0]
sEnumAttrName = sEnumAttr.split('.')[1]
oObjName = naming.oName(sEnumObj)
sSide = oObjName.sSide
if not sSide:
sSide = 'middle'
iIndex = oObjName.iIndex
sConditionMain = None
sConditionSave = None
for i in range(iEnumRange):
if iIndex:
sCondition = naming.oName(sType='condition',
sSide=sSide,
sPart='%s%s' %
(sEnumObj, sEnumAttrName.title()),
iIndex=iIndex,
iSuffix=i).sName
else:
sCondition = naming.oName(sType='condition',
sSide=sSide,
sPart='%s%s' %
(sEnumObj, sEnumAttrName.title()),
iIndex=i).sName
cmds.createNode('condition', name=sCondition)
cmds.connectAttr(sEnumAttr, '%s.firstTerm' % sCondition)
cmds.setAttr('%s.secondTerm' % sCondition, i)
if len(lValRange) == iEnumRange:
lValTrue = lValRange[i][1]
lValFalse = lValRange[i][0]
else:
lValTrue = lValRange[0][1]
lValFalse = lValRange[0][0]
cmds.setAttr('%s.colorIfTrueR' % sCondition, lValTrue)
cmds.setAttr('%s.colorIfFalseR' % sCondition, lValFalse)
if i == 0:
sConditionMain = sCondition
if sConditionSave:
cmds.connectAttr('%s.outColorR' % sCondition,
'%s.colorIfFalseR' % sConditionSave)
sConditionSave = sCondition
for sAttr in lAttrs:
connectAttrs(['%s.outColorR' % sConditionMain], [sAttr], bForce=True)
def __init__(self):
super(cogRig, self).__init__()
self._sBpJnt = naming.oName(sType='blueprint', sSide='m',
sPart='cog').sName
oCtrlLocal = controls.oControl(
naming.oName(sType='ctrl', sSide='m', sPart='local').sName)
self._sConnectInCtrl = oCtrlLocal.sOutput
self._sConnectInJnt = 'rigJoints'
self._bSub = True
def __renameCtrl(self):
sZero = naming.oName(sType = 'zero', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sZero, sZero)
sPasser = naming.oName(sType = 'passer', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sPasser, sPasser)
sSpace = naming.oName(sType = 'space', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sSpace, sSpace)
lStacks = []
for i in range(len(self.__lStacks)):
sStack = naming.oName(sType = 'stack', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex, iSuffix = i + 1).sName
cmds.rename(self.__lStacks[i], sStack)
lStacks.append(sStack)
sCtrl = naming.oName(sType = 'ctrl', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sName, sCtrl)
if self.__sSub:
sSub = naming.oName(sType = 'ctrl', sSide = self.__sSide, sPart = '%sSub' %self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sSub, sSub)
cmds.setAttr('%s.sSub' %sCtrl, lock = False)
cmds.setAttr('%s.sSub' %sCtrl, sSub, type = 'string', lock = True)
sMultMatrixOutputLocal = naming.oName(sType = 'multMatrix', sSide = self.__sSide, sPart = '%sMatrixOutputLocal' %self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sMultMatrixOutputLocal, sMultMatrixOutputLocal)
sMultMatrixOutputWorld = naming.oName(sType = 'multMatrix', sSide = self.__sSide, sPart = '%sMatrixOutputWorld' %self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sMultMatrixOutputWorld, sMultMatrixOutputWorld)
sMultMatrixStacks = naming.oName(sType = 'multMatrix', sSide = self.__sSide, sPart = '%sStacksMatrixOutput' %self.__sPart, iIndex = self.__iIndex).sName
cmds.rename(self.__sMultMatrixStacks, sMultMatrixStacks)
self.__getCtrlInfo(sCtrl)
def _twistMatrixDriver(sJnt, oName, sPos='Start'):
sDecomposeMatrix = cmds.createNode(
'decomposeMatrix',
name=naming.oName(sType='decomposeMatrix',
sSide=oName.sSide,
sPart='%sTwist%s' % (oName.sPart, sPos),
iIndex=oName.iIndex).sName)
sQuatToEuler = cmds.createNode('quatToEuler',
name=naming.oName(
sType='quatToEuler',
sSide=oName.sSide,
sPart='%sTwist%s' % (oName.sPart, sPos),
iIndex=oName.iIndex).sName)
cmds.connectAttr('%s.outputQuatX' % sDecomposeMatrix,
'%s.inputQuatX' % sQuatToEuler)
cmds.connectAttr('%s.outputQuatW' % sDecomposeMatrix,
'%s.inputQuatW' % sQuatToEuler)
cmds.connectAttr('%s.rotateOrder' % sJnt,
'%s.inputRotateOrder' % sQuatToEuler)
if sPos == 'Start':
sMultMatrix = cmds.createNode(
'multMatrix',
name=naming.oName(sType='multMatrix',
sSide=oName.sSide,
sPart='%sTwist%s' % (oName.sPart, sPos),
iIndex=oName.iIndex).sName)
cmds.connectAttr('%s.matrix' % sJnt, '%s.matrixIn[0]' % sMultMatrix)
lJntOrient = joints.getJointOrient(sJnt)
mMatrix = apiUtils.createMMatrixFromTransformInfo(lRotate=lJntOrient)
lMatrixInInverse = apiUtils.convertMMatrixToList(mMatrix.inverse())
cmds.setAttr('%s.matrixIn[1]' % sMultMatrix,
lMatrixInInverse,
type='matrix')
cmds.connectAttr('%s.matrixSum' % sMultMatrix,
'%s.inputMatrix' % sDecomposeMatrix)
sMultTwist = cmds.createNode(
'multDoubleLinear',
name=naming.oName(sType='multDoubleLinear',
sSide=oName.sSide,
sPart='%sTwist%s' % (oName.sPart, sPos),
iIndex=oName.iIndex).sName)
cmds.connectAttr('%s.outputRotateX' % sQuatToEuler,
'%s.input1' % sMultTwist)
cmds.setAttr('%s.input2' % sMultTwist, -1)
sTwistPlug = '%s.output' % sMultTwist
else:
cmds.connectAttr('%s.matrix' % sJnt,
'%s.inputMatrix' % sDecomposeMatrix)
sTwistPlug = '%s.outputRotateX' % sQuatToEuler
return sTwistPlug
def __getCtrlInfo(self, sCtrl):
self.__sName = sCtrl
oCtrlName = naming.oName(sCtrl)
self.__sSide = oCtrlName.sSide
self.__sPart = oCtrlName.sPart
self.__iIndex = oCtrlName.iIndex
self.__iSuffix = oCtrlName.iSuffix
self.__sOutput = cmds.getAttr('%s.sOutput' %sCtrl)
sSub = cmds.getAttr('%s.sSub' %sCtrl)
if sSub:
self.__sSub = sSub
self.__bSub = True
else:
self.__sSub = None
self.__bSub = False
iStacks = cmds.getAttr('%s.iStacks' %sCtrl)
self.__lStacks = []
for i in range(iStacks):
sStack = naming.oName(sType = 'stack', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex, iSuffix = i + 1).sName
self.__lStacks.append(sStack)
self.__iStacks = iStacks
self.__sSpace = naming.oName(sType = 'space', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex).sName
self.__sPasser = naming.oName(sType = 'passer', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex).sName
self.__sZero = naming.oName(sType = 'zero', sSide = self.__sSide, sPart = self.__sPart, iIndex = self.__iIndex).sName
self.__sMultMatrixOutputLocal = naming.oName(sType = 'multMatrix', sSide = self.__sSide, sPart = '%sMatrixOutputLocal' %self.__sPart, iIndex = self.__iIndex).sName
self.__sMultMatrixOutputWorld = naming.oName(sType = 'multMatrix', sSide = self.__sSide, sPart = '%sMatrixOutputWorld' %self.__sPart, iIndex = self.__iIndex).sName
self.__sMultMatrixStacks = naming.oName(sType = 'multMatrix', sSide = self.__sSide, sPart = '%sStacksMatrixOutput' %self.__sPart, iIndex = self.__iIndex).sName
def __updateSub(self):
cmds.setAttr('%s.sSub' %self.__sName, lock = False)
if self.__bSub:
lChilds = cmds.listRelatives(self.__sSub, c = True, type = 'transform')
print lChilds
if lChilds:
cmds.parent(lChilds, self.__sName)
cmds.delete(self.__sSub)
cmds.setAttr('%s.sSub' %self.__sName, '', type = 'string', lock = True)
cmds.deleteAttr('%s.subCtrlVis' %self.__sName)
else:
cmds.addAttr(self.__sName, ln = 'subCtrlVis', at = 'long', keyable = False, min = 0, max = 1, dv = 0)
cmds.setAttr('%s.subCtrlVis' %self.__sName, channelBox = True)
sSub = naming.oName(sType = 'ctrl', sSide = self.__sSide, sPart = '%sSub' %self.__sPart, iIndex = self.__iIndex).sName
sSub = transforms.createTransformNode(sSub, sParent = self.__sName)
transforms.transformSnap([self.__sName], [sSub])
attributes.connectAttrs(['%s.subCtrlVis' %self.__sName], ['%s.v' %sSub], bForce = True)
for sAttr in ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']:
if cmds.getAttr('%s.%s' %(self.__sName, sAttr), lock = True):
cmds.setAttr('%s.%s' %(sSub, sAttr), keyable = False, lock = True, channelBox = False)
dCtrlShapeInfo = getCtrlShapeInfo(self.__sName)
addCtrlShape([sSub], '%sShape' %sSub, bVis = True, dCtrlShapeInfo = dCtrlShapeInfo[self.__sName])
scaleCtrlShape(sSub, fScale = 0.9)
cmds.setAttr('%s.sSub' %self.__sName, sSub, type = 'string', lock = True)
cmds.select(self.__sName)
self.__getCtrlInfo(self.__sName)
def create(self):
self._lBpJnts = [
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='upperArm').sName,
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='elbow').sName,
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='wrist').sName,
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='wristEnd').sName,
]
self._sBpCtrl = naming.oName(sType='bpJnt',
sSide=self._sSide,
sPart='handIk').sName
self._sBpPv = naming.oName(sType='bpJnt',
sSide=self._sSide,
sPart='elbowPvIk').sName
self._sBpRoot = naming.oName(sType='bpJnt',
sSide=self._sSide,
sPart='upperArmIk').sName
super(armIkRig, self).create()
sString_lJntsOutput = self._convertListToString(self._lJnts[:-1])
lRigInfo = ['armIkRig', sString_lJntsOutput]
lAttrs = ['sModuleType', 'lJntsOutput']
self._writeRigInfo(self._sModuleNode, lRigInfo, lAttrs)
self._getRigInfo(self._sModuleNode)
def __baseControls(self):
## world control
oCtrl_world = controls.create('world',
sSide='middle',
iStacks=1,
sParent='controls',
sShape='circle',
fSize=10,
sColor='yellow',
lLockHideAttrs=['sx', 'sy', 'sz', 'v'])
## layout control
oCtrl_layout = controls.create('layout',
sSide='middle',
iStacks=1,
sParent=oCtrl_world.sOutput,
sShape='triangle',
fSize=9.5,
sColor='royal heath',
lLockHideAttrs=['sx', 'sy', 'sz', 'v'])
## local control
oCtrl_local = controls.create('local',
sSide='middle',
iStacks=1,
sParent=oCtrl_layout.sOutput,
sShape='triangle',
fSize=7.5,
sColor='royal purple',
lLockHideAttrs=['sx', 'sy', 'sz', 'v'])
#### connect scale
for sCtrl in [
oCtrl_world.sName, oCtrl_layout.sName, oCtrl_local.sName
]:
cmds.addAttr(sCtrl,
ln='rigScale',
at='float',
dv=1,
min=0,
keyable=True)
attributes.connectAttrs([
'%s.rigScale' % sCtrl,
'%s.rigScale' % sCtrl,
'%s.rigScale' % sCtrl,
], ['%s.sx' % sCtrl,
'%s.sy' % sCtrl,
'%s.sz' % sCtrl],
bForce=True)
#### connect with xtrs
for sRes in self.lRes:
sGrpXtrs = naming.oName(sType='grp',
sSide='m',
sRes=sRes,
sPart='xtrs').sName
constraints.constraint([oCtrl_local.sName, sGrpXtrs],
sType='all',
bMaintainOffset=False,
bForce=True)
def clusterSurface(sSurface, sUV = 'u'):
oName = naming.oName(sSurface)
lCvNum = getSurfaceCvNum(sSurface)
lClsHnds = []
if sUV.lower() == 'u':
iCvNum = lCvNum[0]
else:
iCvNum = lCvNum[1]
for i in range(iCvNum):
if sUV.lower() == 'u':
sClusterCV = '%s.cv[%d][0:%d]' %(sSurface, i, lCvNum[1] - 1)
else:
sClusterCV = '%s.cv[0:%d][%d]' %(sSurface, lCvNum[0] - 1, i)
lCls = cmds.cluster(sClusterCV, name = naming.oName(sType = 'cluster', sSide = oName.sSide, sPart = oName.sPart, iIndex = oName.iIndex, iSuffix = i + 1).sName, rel = False)
sClsHnd = naming.oName(sType = 'cluster', sSide = oName.sSide, sPart = '%sHandle' %oName.sPart, iIndex = oName.iIndex, iSuffix = i + 1).sName
cmds.rename(lCls[1], sClsHnd)
cmds.setAttr('%s.v' %sClsHnd, 0)
lClsHnds.append(sClsHnd)
return lClsHnds
def create(self):
self._lBpJnts = [
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='upperLeg').sName,
naming.oName(sType='bpJnt', sSide=self._sSide, sPart='knee').sName,
naming.oName(sType='bpJnt', sSide=self._sSide,
sPart='ankle').sName,
naming.oName(sType='bpJnt', sSide=self._sSide, sPart='ball').sName,
naming.oName(sType='bpJnt', sSide=self._sSide, sPart='toe').sName,
]
super(legFkRig, self).create()
sString_lJntsOutput = self._convertListToString(self._lJnts[:-1])
lRigInfo = ['legFkRig', sString_lJntsOutput]
lAttrs = ['sModuleType', 'lJntsOutput']
self._writeRigInfo(self._sModuleNode, lRigInfo, lAttrs)
self._getRigInfo(self._sModuleNode)
def enumToMultiAttrs(sEnumAttr,
lAttrs,
iEnumRange=2,
lEnumIndex=None,
lValRange=[[0, 1]],
sEnumObj=None):
if '.' not in sEnumAttr:
sEnumAttrName = sEnumAttr
sEnumAttr = '%s.%s' % (sEnumObj, sEnumAttr)
else:
sEnumObj = sEnumAttr.split('.')[0]
sEnumAttrName = sEnumAttr.split('.')[1]
oObjName = naming.oName(sEnumObj)
sSide = oObjName.sSide
if not sSide:
sSide = 'middle'
iIndex = oObjName.iIndex
if not lEnumIndex:
lEnumIndex = range(iEnumRange)
for i, val in enumerate(lEnumIndex):
sCondition = naming.oName(sType='condition',
sSide=sSide,
sPart='%s%s' %
(sEnumObj, sEnumAttrName.title()),
iIndex=iIndex,
iSuffix=i).sName
cmds.createNode('condition', name=sCondition)
cmds.connectAttr(sEnumAttr, '%s.firstTerm' % sCondition)
cmds.setAttr('%s.secondTerm' % sCondition, val)
if len(lValRange) == iEnumRange:
lValTrue = lValRange[i][1]
lValFalse = lValRange[i][0]
else:
lValTrue = lValRange[0][1]
lValFalse = lValRange[0][0]
cmds.setAttr('%s.colorIfTrueR' % sCondition, lValTrue)
cmds.setAttr('%s.colorIfFalseR' % sCondition, lValFalse)
if lAttrs[i]:
connectAttrs(['%s.outColorR' % sCondition], [lAttrs[i]],
bForce=True)
def _writeTwistJointsMatrixInfo(lTwistJnts, iSection, sNode=None):
for i, sJnt in enumerate(lTwistJnts):
## naming info
oName = naming.oName(sJnt)
sMultMatrixLocal = cmds.createNode(
'multMatrix',
name=naming.oName(sType='multMatrix',
sSide=oName.sSide,
sPart='%sOutputMatrixLocal' % oName.sPart,
iIndex=oName.iIndex).sName)
sMultMatrixWorld = cmds.createNode(
'multMatrix',
name=naming.oName(sType='multMatrix',
sSide=oName.sSide,
sPart='%sOutputMatrixWorld' % oName.sPart,
iIndex=oName.iIndex).sName)
cmds.connectAttr('%s.matrix' % sJnt,
'%s.matrixIn[0]' % sMultMatrixLocal)
cmds.connectAttr('%s.matrix' % sJnt,
'%s.matrixIn[0]' % sMultMatrixWorld)
#### plug parent joint local matrix and world matrix
cmds.connectAttr('%s.outputMatrixLocal%03d' % (sNode, iSection),
'%s.matrixIn[1]' % sMultMatrixLocal)
cmds.connectAttr('%s.outputMatrixWorld%03d' % (sNode, iSection),
'%s.matrixIn[1]' % sMultMatrixWorld)
#### add attr
cmds.addAttr(sNode,
ln='output%03dTwistMatrixLocal%03d' % (iSection, i),
at='matrix')
cmds.addAttr(sNode,
ln='output%03dTwistMatrixWorld%03d' % (iSection, i),
at='matrix')
#### connect attr
cmds.connectAttr(
'%s.matrixSum' % sMultMatrixLocal,
'%s.output%03dTwistMatrixLocal%03d' % (sNode, iSection, i))
cmds.connectAttr(
'%s.matrixSum' % sMultMatrixWorld,
'%s.output%03dTwistMatrixWorld%03d' % (sNode, iSection, i))
def _spaceMatrix(self, sCtrl, sPlug, sKey):
oCtrl = controls.oControl(sCtrl)
sMultMatrix = naming.oName(sType = 'multMatrix', sSide = oCtrl.sSide, sPart = '%sSpace%sMatrix' %(oCtrl.sPart, sKey.title()), iIndex = oCtrl.iIndex).sName
if not cmds.objExists(sMultMatrix):
cmds.createNode('multMatrix', name = sMultMatrix)
lPlugMatrix = cmds.getAttr(sPlug)
lMatrixLocal = apiUtils.getLocalMatrixInMatrix(oCtrl.sSpace, lPlugMatrix, sNodeAttr = 'worldMatrix[0]')
cmds.setAttr('%s.matrixIn[0]' %sMultMatrix, lMatrixLocal, type = 'matrix')
attributes.connectAttrs([sPlug], ['%s.matrixIn[1]' %sMultMatrix], bForce = True)
attributes.connectAttrs([self._sWorldMatrixRvsPlug], ['%s.matrixIn[2]' %sMultMatrix], bForce = True)
return '%s.matrixSum' %sMultMatrix
def connectComponents(self, sMatrixPlug):
mMatrixOrig = apiUtils.createMMatrixFromTransformInfo()
lMatrixOrig = apiUtils.convertMMatrixToList(mMatrixOrig)
lMatrixIn = cmds.getAttr(sMatrixPlug)
mMatrix = apiUtils.convertListToMMatrix(lMatrixIn)
mMatrixInverse = mMatrix.inverse()
lMatrixInInverse = apiUtils.convertMMatrixToList(mMatrixInverse)
sMultMatrix = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = self._sSide, sPart = '%sConnectIn' %self._sName, iIndex = self._iIndex).sName)
cmds.setAttr('%s.matrixIn[0]' %sMultMatrix, lMatrixOrig, type = 'matrix')
cmds.setAttr('%s.matrixIn[1]' %sMultMatrix, lMatrixInInverse, type = 'matrix')
cmds.connectAttr(sMatrixPlug, '%s.matrixIn[2]' %sMultMatrix)
cmds.connectAttr('%s.matrixSum' %sMultMatrix, '%s.inputMatrix' %self._sComponentMaster, f = True)
def create(self):
oName = naming.oName(self._sBpJnt)
self._sSide = oName.sSide
self._sPart = oName.sPart
self._iIndex = oName.iIndex
self._lPos = transforms.getNodeTransformInfo(self._sBpJnt)
self._iRotateOrder = cmds.getAttr('%s.ro' %self._sBpJnt)
sGrp = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%sRig' %self._sPart, iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInJnt)
sJnt = joints.createJntOnTransformInfo(naming.oName(sType = 'jnt', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex).sName, self._lPos, iRotateOrder = self._iRotateOrder, sParent = sGrp)
sGrpCtrl = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%sCtrl' %self._sPart, iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInCtrl)
oCtrl = controls.create(self._sPart, sSide = self._sSide, iIndex = self._iIndex, iStacks = self._iStacks, bSub = self._bSub, sParent = sGrpCtrl, iRotateOrder = self._iRotateOrder, sShape = 'circle', fSize = 10, lLockHideAttrs = self._lLockHideAttrs)
transforms.setNodeTransform(oCtrl.sZero, self._lPos)
constraints.constraint([oCtrl.sOutput, sJnt], sType = 'parent')
## write rig info
lRigInfo = ['singleJointRig', self._sConnectInJnt, self._sConnectInCtrl, sJnt, oCtrl.sOutput, sJnt, oCtrl.sName, sGrpCtrl, sGrp]
lAttrs = ['sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt', 'sConnectOutCtrl', 'lJnts', 'lCtrls', 'sGrpCtrl', 'sModuleNode']
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
def createCurveLine(sName, lNodes, bConstraint=False):
oName = naming.oName(sName)
sCrv = cmds.curve(d=1, p=[[0, 0, 0], [0, 0, 0]], name=sName)
sCrvShape = getShape(sCrv)
sCrvShape = cmds.rename(sCrvShape, '%sShape' % sCrv)
cmds.setAttr('%s.overrideEnabled' % sCrvShape, 1)
cmds.setAttr('%s.overrideDisplayType' % sCrvShape, 2)
cmds.setAttr('%s.inheritsTransform' % sCrv, 0)
lClsHnds = []
for i, sNode in enumerate(lNodes):
lCls = cmds.cluster('%s.cv[%i]' % (sCrv, i),
name=naming.oName(sType='cluster',
sSide=oName.sSide,
sPart=oName.sPart,
iindex=i + 1).sName)
cmds.setAttr('%s.v' % lCls[1], 0)
cmds.delete(cmds.pointConstraint(sNode, lCls[1], mo=False))
lClsHnds.append(lCls[1])
if bConstraint:
cmds.pointConstraint(sNode, lCls[1], mo=False)
return sCrv, lClsHnds
def clusterCurve(sCrv, bRelatives=False):
oName = naming.oName(sCrv)
iCvNum = getCurveCvNum(sCrv)
lClsHnds = []
for i in range(iCvNum):
lCls = cmds.cluster('%s.cv[%d]' % (sCrv, i),
name=naming.oName(sType='cluster',
sSide=oName.sSide,
sPart=oName.sPart,
iIndex=oName.iIndex,
iSuffix=i + 1).sName,
rel=bRelatives)
sClsHnd = naming.oName(sType='cluster',
sSide=oName.sSide,
sPart='%sHandle' % oName.sPart,
iIndex=oName.iIndex,
iSuffix=i + 1).sName
cmds.rename(lCls[1], sClsHnd)
cmds.setAttr('%s.v' % sClsHnd, 0)
lClsHnds.append(sClsHnd)
return lClsHnds
def createSkinCluster(sNode, lInfluences):
lJnts = []
lGeos = []
lCrvs = []
sGrp = '_missedSkinJoints_'
oName = naming.oName(sNode)
oName.sType = 'skinCluster'
for sInfluence in lInfluences:
if cmds.objExists(sInfluence):
if cmds.objectType(sInfluence) == 'joint':
lJnts.append(sInfluence)
elif cmds.objExists(sInfluence) == 'nurbsCurve':
lCrvs.append(sInfluence)
else:
lGeos.append(sInfluence)
else:
joints.createJnt(sInfluence)
lJnts.append(sInfluence)
if not cmds.objExists(sGrp):
cmds.group(empty=True, name=sGrp)
cmds.setAttr('%s.v' % sGrp, 0)
cmds.parent(sInfluence, sGrp)
cmds.skinCluster(lJnts,
sNode,
tsb=True,
bindMethod=0,
skinMethod=0,
name=oName.sName)
for i, lComponents in enumerate([lCrvs, lGeos]):
if lComponents:
for sComponent in lComponents:
cmds.skinCluster(oName.sName, e=True, ug=i, ai=sComponent)
oNameGeo = naming.oName(sComponent)
oNameGeo.sPart += 'Base'
cmds.rename('%sBase' % sComponent, oNameGeo.sName)
cmds.setAttr('%s.useComponents' % oName.sName, 1)
return oName.sName
def matrixConnect(sDrvNode,
lDrivenNodes,
sDrvAttr,
lSkipTranslate=[],
lSkipRotate=[],
lSkipScale=[],
bForce=True):
oName = naming.oName(sDrvNode)
oName.sType = 'decomposeMatrix'
sDecomposeMatrix = oName.sName
if not cmds.objExists(sDecomposeMatrix):
sDecomposeMatrix = cmds.createNode('decomposeMatrix', name=oName.sName)
cmds.connectAttr('%s.%s' % (sDrvNode, sDrvAttr),
'%s.inputMatrix' % sDecomposeMatrix)
if len(lSkipRotate) < 3:
oName.sType = 'quatToEuler'
sQuatToEuler = oName.sName
if not cmds.objExists(sQuatToEuler):
sQuatToEuler = cmds.createNode('quatToEuler', name=oName.sName)
cmds.connectAttr('%s.outputQuat' % sDecomposeMatrix,
'%s.inputQuat' % sQuatToEuler)
cmds.connectAttr('%s.ro' % lDrivenNodes[0],
'%s.inputRotateOrder' % sQuatToEuler)
if len(lDrivenNodes) > 1:
for sDriven in lDrivenNodes[1:]:
cmds.connectAttr('%s.ro' % lDrivenNodes[0], '%s.ro' % sDriven)
## connect matrix
for sDriven in lDrivenNodes:
for sAxis in ['X', 'Y', 'Z']:
if sAxis.lower() not in lSkipTranslate and sAxis.upper(
) not in lSkipTranslate:
attributes.connectAttrs([
'%s.outputTranslate%s' % (sDecomposeMatrix, sAxis.upper())
], ['%s.translate%s' % (sDriven, sAxis.upper())],
bForce=bForce)
if sAxis.lower() not in lSkipRotate and sAxis.upper(
) not in lSkipRotate:
attributes.connectAttrs(
['%s.outputRotate%s' % (sQuatToEuler, sAxis.upper())],
['%s.rotate%s' % (sDriven, sAxis.upper())],
bForce=bForce)
if sAxis.lower() not in lSkipScale and sAxis.upper(
) not in lSkipScale:
attributes.connectAttrs(
['%s.outputScale%s' % (sDecomposeMatrix, sAxis.upper())],
['%s.scale%s' % (sDriven, sAxis.upper())],
bForce=bForce)
attributes.connectAttrs(['%s.outputShear' % sDecomposeMatrix],
['%s.shear' % sDriven],
bForce=bForce)
def mirrorCtrlShape(sCtrl):
'''
mirror control's shape node to the other side
'''
oName = naming.oName(sCtrl)
sCtrlShape = getCtrlShape(sCtrl)
oCtrlShapeName = naming.oName(sCtrlShape)
bMirror = True
if 'left' in oName.sSideKey:
oName.sSide = oName.sSideKey.replace('left', 'right')
oCtrlShapeName.sSide = oCtrlShapeName.sSideKey.replace('left', 'right')
elif 'right' in oName.sSideKey:
oName.sSide = oName.sSideKey.replace('right', 'left')
oCtrlShapeName.sSide = oCtrlShapeName.sSideKey.replace('right', 'left')
else:
bMirror = False
if bMirror:
sCtrlMirror = oName.sName
sCtrlShapeMirror = oCtrlShapeName.sName
if cmds.objExists(sCtrlShapeMirror):
iColor = cmds.getAttr('%s.overrideColor' %sCtrlShapeMirror)
else:
iColor = None
dCtrlShapeInfo = getCtrlShapeInfo(sCtrl)
lCtrlPnts = dCtrlShapeInfo[sCtrl]['lCtrlPnts']
lCtrlPntsMirror = []
for lCtrlPnt in lCtrlPnts:
lCtrlPntWorld = transforms.convertPointTransformFromObjectToWorld(lCtrlPnt, sCtrl)
lCtrlPntWorld[0] = -1 * lCtrlPntWorld[0]
lCtrlPntMirror = transforms.convertPointTransformFromWorldToObject(lCtrlPntWorld, sCtrlMirror)
lCtrlPntsMirror.append(lCtrlPntMirror)
dCtrlShapeInfo[sCtrl]['lCtrlPnts'] = lCtrlPntsMirror
dCtrlShapeInfo[sCtrl]['sCtrlShape'] = sCtrlShapeMirror
dCtrlShapeInfo[sCtrl]['iColor'] = iColor
buildCtrlShape(sCtrlMirror, dCtrlShapeInfo[sCtrl], bColor = True, bTop = True)
def importModel(self):
bReturn = rigComponents.importModel(self.dRigData['dModel'],
self.sProject, self.sAsset)
self.sModel = self.sAsset
lChilds = cmds.listRelatives(self.sAsset, c=True, type='transform')
self.lRes = []
for sChild in lChilds:
lMeshes = meshes.getMeshesFromGrp(sChild)
if lMeshes:
oNameGrp = naming.oName(sChild)
if oNameGrp.sRes not in self.lRes:
self.lRes.append(oNameGrp.sRes)
return bReturn
def _addSpaceAttr(self, sCtrl, sType, lKeys, lIndex, lPlugs, iDefaultA, iDefaultB):
oCtrl = controls.oControl(sCtrl)
sEnumName = ''
for i, sKey in enumerate(lKeys):
sEnumName += '%s=%d:' %(sKey, lIndex[i])
if iDefaultA == None:
iDefaultA = lIndex[0]
if iDefaultB == None:
iDefaultB = lIndex[0]
attributes.addDivider([sCtrl], 'space%s' %sType.upper())
cmds.addAttr(sCtrl, ln = 'spaceA%s' %sType.upper(), nn = 'Space A %s' %sType.upper(), at = 'enum', keyable = True, en = sEnumName[:-1], dv = iDefaultA)
cmds.addAttr(sCtrl, ln = 'spaceB%s' %sType.upper(), nn = 'Space B %s' %sType.upper(), at = 'enum', keyable = True, en = sEnumName[:-1], dv = iDefaultB)
cmds.addAttr(sCtrl, ln = 'spaceBlend%s' %sType.upper(), at = 'float', keyable = True, min = 0, max = 10)
sMultBlend = naming.oName(sType = 'multDoubleLinear', sSide = oCtrl.sSide, sPart = '%sSpaceBlendOutput%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
cmds.createNode('multDoubleLinear', name = sMultBlend)
cmds.connectAttr('%s.spaceBlend%s'%(sCtrl, sType.upper()), '%s.input1' %sMultBlend)
cmds.setAttr('%s.input2' %sMultBlend, 0.1, lock = True)
sRvsBlend = naming.oName(sType = 'reverse', sSide = oCtrl.sSide, sPart = '%sSpaceBlendOutput%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
cmds.createNode('reverse', name = sRvsBlend)
cmds.connectAttr('%s.output' %sMultBlend, '%s.inputX' %sRvsBlend)
## choice
sChoiceA = naming.oName(sType = 'choice', sSide = oCtrl.sSide, sPart = '%sSpaceA%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
sChoiceB = naming.oName(sType = 'choice', sSide = oCtrl.sSide, sPart = '%sSpaceB%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
sWtAddMatrix = naming.oName(sType = 'wtAddMatrix', sSide = oCtrl.sSide, sPart = '%sSpace%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
cmds.createNode('choice', name = sChoiceA)
cmds.createNode('choice', name = sChoiceB)
cmds.createNode('wtAddMatrix', name = sWtAddMatrix)
cmds.connectAttr('%s.spaceA%s' %(sCtrl, sType.upper()), '%s.selector' %sChoiceA)
cmds.connectAttr('%s.spaceB%s' %(sCtrl, sType.upper()), '%s.selector' %sChoiceB)
cmds.connectAttr('%s.output' %sChoiceA, '%s.wtMatrix[0].matrixIn' %sWtAddMatrix)
cmds.connectAttr('%s.output' %sChoiceB, '%s.wtMatrix[1].matrixIn' %sWtAddMatrix)
cmds.connectAttr('%s.outputX' %sRvsBlend, '%s.wtMatrix[0].weightIn' %sWtAddMatrix)
cmds.connectAttr('%s.output' %sMultBlend, '%s.wtMatrix[1].weightIn' %sWtAddMatrix)
sMultMatrix = naming.oName(sType = 'multMatrix', sSide = oCtrl.sSide, sPart = '%sSpace%s' %(oCtrl.sPart, sType.upper()), iIndex = oCtrl.iIndex).sName
cmds.createNode('multMatrix', name = sMultMatrix)
cmds.connectAttr('%s.matrixSum' %sWtAddMatrix, '%s.matrixIn[0]' %sMultMatrix)
cmds.connectAttr('%s.worldInverseMatrix[0]' %oCtrl.sPasser, '%s.matrixIn[1]' %sMultMatrix)
for i, sPlug in enumerate(lPlugs):
sPlug_space = self._spaceMatrix(sCtrl, sPlug, lKeys[i])
cmds.connectAttr(sPlug_space, '%s.input[%d]' %(sChoiceA, lIndex[i]), f = True)
cmds.connectAttr(sPlug_space, '%s.input[%d]' %(sChoiceB, lIndex[i]), f = True)
lSkipTranslate = ['x', 'y', 'z']
lSkipRotate = ['x', 'y', 'z']
lSkipScale = ['x', 'y', 'z']
if sType == 't':
lSkipTranslate = []
elif sType == 'r':
lSkipRotate = []
else:
lSkipScale = []
constraints.matrixConnect(sMultMatrix, [oCtrl.sSpace], 'matrixSum', lSkipTranslate = lSkipTranslate, lSkipRotate = lSkipRotate, lSkipScale = lSkipScale)
def labelBindJoint(sBindJnt):
oName = naming.oName(sBindJnt)
if 'left' in oName.sSideKey:
iSide = 1
sSuffix = oName.sSideKey.replace('left', '')
elif 'right' in oName.sSideKey:
iSide = 2
sSuffix = oName.sSideKey.replace('right', '')
else:
iSide = 0
sSuffix = oName.sSideKey.replace('middle', '')
sLabelName = sBindJnt.replace('%s_%s_' %(oName.sType, oName.sSide), '')
if sSuffix:
sLabelName = sLabelName.replace(oName.sPart, '%s%s' %(oName.sPart, sSuffix.title()))
## label
cmds.setAttr('%s.side' %sBindJnt, iSide)
cmds.setAttr('%s.type' %sBindJnt, 18)
cmds.setAttr('%s.otherType' %sBindJnt, sLabelName, type = 'string')
def __init__(self, *args, **kwargs):
super(spineRig, self).__init__(*args, **kwargs)
self._sSide = 'middle'
self._lBpJnts = cmds.ls('%s_*' %naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'spine').sName, type = 'joint')
self._lBpCtrls = [
naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'spineCtrl', iIndex = 1).sName,
naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'spineCtrl', iIndex = 2).sName,
naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'spineCtrl', iIndex = 3).sName,
naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'spineCtrl', iIndex = 4).sName,
naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'spineCtrl', iIndex = 5).sName,
]
self._lBpCtrlsPelvis = [
naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'pelvisCtrl').sName,
naming.oName(sType = 'bpJnt', sSide = self._sSide, sPart = 'pelvisEndCtrl').sName,
]
self._sName = 'Ribbon'
self._sPart = 'spine'
self._sNameRig = 'IkFkRibbon'
self._sPartPelvis = 'pelvis'
self._lCtrlOrient = ['z', 'y']
