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']