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 __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 _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 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 createComponent(self):
# create groups
### master group
sComponentMaster = naming.oName(sType = 'rigComponent', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentMaster, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sParent)
### rig nodes world group
sComponentRigNodesWorld = naming.oName(sType = 'rigNodesWorld', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentRigNodesWorld, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentMaster)
### sub components group
sComponentSubComponents = naming.oName(sType = 'subComponents', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentSubComponents, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentMaster)
### inherits group
sComponentInherits = naming.oName(sType = 'inherits', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentInherits, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentMaster)
### xform group
sComponentXform = naming.oName(sType = 'xform', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentXform, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentInherits)
### passer group
sComponentPasser = naming.oName(sType = 'passer', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentPasser, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentXform)
### space group
sComponentSpace = naming.oName(sType = 'space', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentSpace, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentPasser)
## controls group
sComponentControls = naming.oName(sType = 'controls', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentControls, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentSpace)
### rig nodes local group
sComponentRigNodesLocal = naming.oName(sType = 'rigNodesLocal', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
transforms.createTransformNode(sComponentRigNodesLocal, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sComponentSpace)
# visibility switch
### controls
cmds.addAttr(sComponentMaster, ln = 'controls', at = 'long', min = 0, max = 1, keyable = False, dv = 1)
cmds.setAttr('%s.controls' %sComponentMaster, channelBox = True)
### rig nodes
cmds.addAttr(sComponentMaster, ln = 'rigNodes', at = 'long', min = 0, max = 1, keyable = False, dv = 0)
cmds.setAttr('%s.rigNodes' %sComponentMaster, channelBox = True)
### sub components
cmds.addAttr(sComponentMaster, ln = 'subComponents', at = 'long', min = 0, max = 1, keyable = False, dv = 0)
cmds.setAttr('%s.subComponents' %sComponentMaster, channelBox = True)
### connect attrs
attributes.connectAttrs(['%s.controls' %sComponentMaster], ['%s.v' %sComponentControls], bForce = True)
attributes.connectAttrs(['%s.rigNodes' %sComponentMaster, '%s.rigNodes' %sComponentMaster], ['%s.v' %sComponentRigNodesLocal, '%s.v' %sComponentRigNodesWorld], bForce = True)
attributes.connectAttrs(['%s.subComponents' %sComponentMaster], ['%s.v' %sComponentSubComponents], bForce = True)
# input attrs
### input matrix
cmds.addAttr(sComponentMaster, ln = 'inputMatrix', at = 'matrix')
cmds.addAttr(sComponentMaster, ln = 'inputMatrixInverse', at = 'matrix')
sMultMatrix = naming.oName(sType = 'multMatrix', sSide = self._sSide, sPart = '%sInputMatrix' %self._sName, iIndex = self._iIndex).sName
sDecomposeMatrix = naming.oName(sType = 'decomposeMatrix', sSide = self._sSide, sPart = '%sInputMatrix' %self._sName, iIndex = self._iIndex).sName
cmds.createNode('multMatrix', name = sMultMatrix)
cmds.createNode('decomposeMatrix', name = sDecomposeMatrix)
cmds.connectAttr('%s.inputMatrixInverse' %sComponentMaster, '%s.matrixIn[0]' %sMultMatrix)
cmds.connectAttr('%s.inputMatrix' %sComponentMaster, '%s.matrixIn[1]' %sMultMatrix)
cmds.connectAttr('%s.matrixSum' %sMultMatrix, '%s.inputMatrix' %sDecomposeMatrix)
for sAxis in ['X', 'Y', 'Z']:
attributes.connectAttrs(['%s.outputTranslate%s' %(sDecomposeMatrix, sAxis), '%s.outputRotate%s' %(sDecomposeMatrix, sAxis), '%s.outputScale%s' %(sDecomposeMatrix, sAxis)], ['%s.translate%s' %(sComponentXform, sAxis), '%s.rotate%s' %(sComponentXform, sAxis), '%s.scale%s' %(sComponentXform, sAxis)], bForce = True)
attributes.connectAttrs(['%s.outputShear' %sDecomposeMatrix], ['%s.shear' %sComponentXform], bForce = True)
self._sComponentMaster = sComponentMaster
self._sComponentXform = sComponentXform
self._sComponentPasser = sComponentPasser
self._sComponentSpace = sComponentSpace
self._sComponentRigNodesWorld = sComponentRigNodesWorld
self._sComponentSubComponents = sComponentSubComponents
self._sComponentControls = sComponentControls
self._sComponentRigNodesLocal = sComponentRigNodesLocal
## add component info
cmds.addAttr(sComponentMaster, ln = 'sComponentType', dt = 'string')
cmds.setAttr('%s.sComponentType' %sComponentMaster, 'baseComponent', type = 'string')
cmds.addAttr(sComponentMaster, ln = 'sComponentSpace', dt = 'string')
cmds.setAttr('%s.sComponentSpace' %sComponentMaster, sComponentSpace, type = 'string', lock = True)
cmds.addAttr(sComponentMaster, ln = 'sComponentPasser', dt = 'string')
cmds.setAttr('%s.sComponentPasser' %sComponentMaster, sComponentPasser, type = 'string', lock = True)
cmds.addAttr(sComponentMaster, ln = 'lWorldMatrix', dt = 'matrix')
cmds.addAttr(sComponentMaster, ln = 'lWorldMatrixRvs', dt = 'matrix')
if self._sWorldMatrixInput:
cmds.connectAttr(self._sWorldMatrixInput, '%s.lWorldMatrix' %sComponentMaster, f = True)
if self._sWorldMatrixRvsInput:
cmds.connectAttr(self._sWorldMatrixRvsInput, '%s.lWorldMatrixRvs' %sComponentMaster, f = True)
self._sWorldMatrixPlug = '%s.lWorldMatrix' %sComponentMaster
self._sWorldMatrixRvsPlug = '%s.lWorldMatrixRvs' %sComponentMaster
def __baseNode(self):
sMaster = transforms.createTransformNode('master',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
])
## add attr
### resolution
sEnumRes = ''
for sRes in self.lRes:
sEnumRes += '%s:' % sRes
sEnumRes = sEnumRes[:-1]
cmds.addAttr(sMaster,
ln='resolution',
at='enum',
enumName=sEnumRes,
keyable=False,
dv=0)
cmds.setAttr('%s.resolution' % sMaster, channelBox=True)
### geometry
cmds.addAttr(sMaster,
ln='geometries',
at='enum',
enumName='on:off:tempelate:reference',
keyable=False,
dv=3)
cmds.setAttr('%s.geometries' % sMaster, channelBox=True)
### joints
cmds.addAttr(sMaster,
ln='joints',
at='enum',
enumName='on:off:tempelate:reference',
keyable=False,
dv=1)
cmds.setAttr('%s.joints' % sMaster, channelBox=True)
### controls
cmds.addAttr(sMaster,
ln='controls',
at='long',
min=0,
max=1,
keyable=False,
dv=1)
cmds.setAttr('%s.controls' % sMaster, channelBox=True)
### rigs
cmds.addAttr(sMaster,
ln='rigs',
at='long',
min=0,
max=1,
keyable=False,
dv=0)
cmds.setAttr('%s.rigs' % sMaster, channelBox=True)
## add groups
sDoNotTouch = transforms.createTransformNode('doNotTouch',
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sMaster)
sControls = transforms.createTransformNode('controls',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sMaster)
sGeometry = transforms.createTransformNode('geometries',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sDoNotTouch)
sRigGeometry = transforms.createTransformNode('rigGeometries',
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sDoNotTouch)
sJoints = transforms.createTransformNode('joints',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sDoNotTouch)
sRigs = transforms.createTransformNode('rigs',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sDoNotTouch)
sRigsShow = transforms.createTransformNode('rigsShow',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sRigs)
sRigsHide = transforms.createTransformNode('rigsHide',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sRigs)
## connect attrs
lGrps = [sGeometry, sJoints]
for i, sAttr in enumerate(['geometries', 'joints']):
sConditionVis = naming.oName(sType='condition',
sSide='middle',
sPart='%sVis' % sAttr).sName
cmds.createNode('condition', name=sConditionVis)
cmds.connectAttr('%s.%s' % (sMaster, sAttr),
'%s.firstTerm' % sConditionVis)
cmds.setAttr('%s.secondTerm' % sConditionVis, 1)
cmds.setAttr('%s.colorIfTrueR' % sConditionVis, 0)
cmds.setAttr('%s.colorIfFalseR' % sConditionVis, 1)
attributes.connectAttrs(['%s.outColorR' % sConditionVis],
['%s.v' % lGrps[i]],
bForce=True)
cmds.setAttr('%s.overrideEnabled' % lGrps[i], 1)
attributes.enumToSingleAttrs(sAttr,
['%s.overrideDisplayType' % lGrps[i]],
iEnumRange=4,
lValRange=[[0, 0], [0, 0], [0, 1],
[0, 2]],
sEnumObj=sMaster)
attributes.connectAttrs(['%s.controls' % sMaster],
['%s.v' % sControls],
bForce=True)
attributes.connectAttrs(['%s.rigs' % sMaster], ['%s.v' % sRigsHide],
bForce=True)
## create res grp for geometry and rig geometry
lVisAttrs = []
lValRange = []
for sRes in self.lRes:
sGrpGeo = transforms.createTransformNode(
naming.oName(sType='grp',
sSide='m',
sRes=sRes,
sPart='geometries').sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent='geometries')
sGrpXtrs = transforms.createTransformNode(
naming.oName(sType='grp', sSide='m', sRes=sRes,
sPart='xtrs').sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=sGrpGeo)
sGrpDef = transforms.createTransformNode(
naming.oName(sType='grp', sSide='m', sRes=sRes,
sPart='def').sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=sGrpGeo)
sGrpRigGeo = transforms.createTransformNode(
naming.oName(sType='grp',
sSide='m',
sRes=sRes,
sPart='rigGeometries').sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent='rigGeometries')
attributes.connectAttrs(['%s.v' % sGrpGeo], ['%s.v' % sGrpRigGeo],
bForce=True)
lVisAttrs.append('%s.v' % sGrpGeo)
lValRange.append([0, 1])
attributes.enumToMultiAttrs('resolution',
lVisAttrs,
iEnumRange=len(self.lRes),
lValRange=lValRange,
sEnumObj=sMaster)
## create def joints grp and rig joints grp
sDefJoints = transforms.createTransformNode('defJoints',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sJoints)
sRigJoints = transforms.createTransformNode('rigJoints',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz'
],
sParent=sJoints)
cmds.addAttr(sMaster, ln='rigJointsVis', at='bool')
cmds.connectAttr('%s.rigJointsVis' % sMaster, '%s.v' % sRigJoints)
cmds.setAttr('%s.v' % sRigJoints,
keyable=False,
lock=True,
channelBox=False)
def createComponent(self):
super(baseJointsLimb, self).createComponent()
### inherits local group
sComponentInheritsLocal = naming.oName(sType='inherits',
sSide=self._sSide,
sPart='%sLocal' % self._sName,
iIndex=self._iIndex).sName
transforms.createTransformNode(sComponentInheritsLocal,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=self._sComponentMaster,
bInheritsTransform=False)
### xform local group
sComponentXformLocal = naming.oName(sType='xform',
sSide=self._sSide,
sPart='%sLocal' % self._sName,
iIndex=self._iIndex).sName
transforms.createTransformNode(sComponentXformLocal,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sComponentInheritsLocal)
attributes.connectAttrs(
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
sDriver=self._sComponentXform,
sDriven=sComponentXformLocal,
bForce=True)
### passer local group
sComponentPasserLocal = naming.oName(sType='passer',
sSide=self._sSide,
sPart='%sLocal' % self._sName,
iIndex=self._iIndex).sName
transforms.createTransformNode(sComponentPasserLocal,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sComponentXformLocal)
attributes.connectAttrs(
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
sDriver=self._sComponentPasser,
sDriven=sComponentPasserLocal,
bForce=True)
### space local group
sComponentSpaceLocal = naming.oName(sType='space',
sSide=self._sSide,
sPart='%sLocal' % self._sName,
iIndex=self._iIndex).sName
transforms.createTransformNode(sComponentSpaceLocal,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sComponentPasserLocal)
attributes.connectAttrs(
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
sDriver=self._sComponentSpace,
sDriven=sComponentSpaceLocal,
bForce=True)
## joints group
sComponentJoints = naming.oName(sType='joints',
sSide=self._sSide,
sPart=self._sName,
iIndex=self._iIndex).sName
transforms.createTransformNode(sComponentJoints,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sComponentSpaceLocal)
# visibility switch
### joints
cmds.addAttr(self._sComponentMaster,
ln='joints',
at='enum',
enumName='on:off:tempelate:reference',
keyable=False,
dv=1)
cmds.setAttr('%s.joints' % self._sComponentMaster, channelBox=True)
cmds.addAttr(self._sComponentMaster, ln='iJointCount', at='long')
cmds.addAttr(self._sComponentMaster, ln='sControls', dt='string')
cmds.addAttr(self._sComponentMaster, ln='sBindJoints', dt='string')
cmds.addAttr(self._sComponentMaster, ln='sBindRootJoints', dt='string')
cmds.addAttr(self._sComponentMaster, ln='sTwistSections', dt='string')
cmds.addAttr(self._sComponentMaster, ln='iTwistJointCount', at='long')
cmds.addAttr(self._sComponentMaster,
ln='sTwistBindJoints',
dt='string')
### connect attrs
sConditionJointsVis = cmds.createNode(
'condition',
name=naming.oName(sType='condition',
sSide=self._sSide,
sPart='%sJointVis' % self._sName,
iIndex=self._iIndex).sName)
cmds.createNode('condition', name=sConditionJointsVis)
cmds.connectAttr('%s.joints' % self._sComponentMaster,
'%s.firstTerm' % sConditionJointsVis)
cmds.setAttr('%s.secondTerm' % sConditionJointsVis, 1)
cmds.setAttr('%s.colorIfTrueR' % sConditionJointsVis, 0)
cmds.setAttr('%s.colorIfFalseR' % sConditionJointsVis, 1)
attributes.connectAttrs(['%s.outColorR' % sConditionJointsVis],
['%s.v' % sComponentJoints],
bForce=True)
cmds.setAttr('%s.overrideEnabled' % sComponentJoints, 1)
attributes.enumToSingleAttrs(
'joints', ['%s.overrideDisplayType' % sComponentJoints],
iEnumRange=4,
lValRange=[[0, 0], [0, 0], [0, 1], [0, 2]],
sEnumObj=self._sComponentMaster)
self._sComponentJoints = sComponentJoints
def createComponent(self):
super(baseComponentsBlendLimb, self).createComponent()
cmds.setAttr('%s.subComponents' % self._sComponentMaster, 1)
lJnts, lBindJnts = createDriveJoints.createDriveJoints(
self._lBpJnts,
sParent=self._sComponentJoints,
sSuffix='',
bBind=self._bBind)
## create temp controller
sCrv = cmds.curve(p=[[0, 0, 0], [1, 0, 0]],
k=[0, 1],
d=1,
per=False,
name='TEMP_CRV')
sCtrlShape = naming.oName(sType='ctrl',
sSide=self._sSide,
sPart=self._sName,
iIndex=self._iIndex).sName
controls.addCtrlShape([sCrv],
sCtrlShape,
bVis=False,
dCtrlShapeInfo=None,
bTop=False)
sEnumName = ''
iIndexCustom = 90
lKey = self._dComponents.keys()
lIndex = []
iDefaultA = None
iDefaultB = None
for sKey in lKey:
if namingDict.dSpaceDict.has_key(sKey):
iIndexKey = namingDict.dSpaceDict[sKey]
else:
iIndexKey = iIndexCustom
iIndexCustom += 1
lIndex.append(iIndexKey)
sEnumName += '%s=%d:' % (sKey, iIndexKey)
if sKey == self._sDefaultA:
iDefaultA = iIndexKey
if sKey == self._sDefaultB:
iDefaultB = iIndexKey
if iDefaultA == None:
iDefaultA = lIndex[0]
if iDefaultB == None:
iDefaultB = lIndex[0]
## add attrs
cmds.addAttr(sCtrlShape,
ln='moduleA',
at='enum',
keyable=True,
en=sEnumName[:-1],
dv=iDefaultA)
cmds.addAttr(sCtrlShape,
ln='moduleB',
at='enum',
keyable=True,
en=sEnumName[:-1],
dv=iDefaultB)
cmds.addAttr(sCtrlShape,
ln='moduleBlend',
at='float',
keyable=True,
min=0,
max=10)
sMultBlend = naming.oName(sType='multDoubleLinear',
sSide=self._sSide,
sPart='%sModuleBlendOutput' % self._sName,
iIndex=self._iIndex).sName
cmds.createNode('multDoubleLinear', name=sMultBlend)
cmds.connectAttr('%s.moduleBlend' % sCtrlShape,
'%s.input1' % sMultBlend)
cmds.setAttr('%s.input2' % sMultBlend, 0.1, lock=True)
sRvsBlend = naming.oName(sType='reverse',
sSide=self._sSide,
sPart='%sModuleBlendOutput' % self._sName,
iIndex=self._iIndex).sName
cmds.createNode('reverse', name=sRvsBlend)
cmds.connectAttr('%s.output' % sMultBlend, '%s.inputX' % sRvsBlend)
sCondBlend = naming.oName(sType='condition',
sSide=self._sSide,
sPart='%sModuleBlendIndex' % self._sName,
iIndex=self._iIndex).sName
cmds.createNode('condition', name=sCondBlend)
cmds.connectAttr('%s.output' % sMultBlend, '%s.firstTerm' % sCondBlend)
cmds.setAttr('%s.secondTerm' % sCondBlend, 0.5, lock=True)
cmds.setAttr('%s.operation' % sCondBlend, 4)
cmds.connectAttr('%s.moduleA' % sCtrlShape,
'%s.colorIfTrueR' % sCondBlend)
cmds.connectAttr('%s.moduleB' % sCtrlShape,
'%s.colorIfFalseR' % sCondBlend)
## choice node
lNodes = []
for sJnt in lJnts:
oJntName = naming.oName(sJnt)
sChoiceA = naming.oName(sType='choice',
sSide=oJntName.sSide,
sPart='%sA' % oJntName.sPart,
iIndex=oJntName.iIndex).sName
sChoiceB = naming.oName(sType='choice',
sSide=oJntName.sSide,
sPart='%sB' % oJntName.sPart,
iIndex=oJntName.iIndex).sName
sWtAddMatrix = naming.oName(sType='wtAddMatrix',
sSide=oJntName.sSide,
sPart=oJntName.sPart,
iIndex=oJntName.iIndex).sName
cmds.createNode('choice', name=sChoiceA)
cmds.createNode('choice', name=sChoiceB)
cmds.createNode('wtAddMatrix', name=sWtAddMatrix)
cmds.connectAttr('%s.moduleA' % sCtrlShape,
'%s.selector' % sChoiceA)
cmds.connectAttr('%s.moduleB' % sCtrlShape,
'%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)
constraints.matrixConnectJnt(sWtAddMatrix, sJnt, 'matrixSum')
lNodes.append([sChoiceA, sChoiceB])
dModuleInfo = {}
for sKey in self._dComponents.keys():
sModulePath = self._dComponents[sKey]['sModulePath']
sModuleName = self._dComponents[sKey]['sModuleName']
dKwargs = self._dComponents[sKey]['dKwargs']
dKwargs.update({
'bInfo':
False,
'lBpJnts':
self._lBpJnts,
'sParent':
self._sComponentSubComponents,
'sName':
'%s%s%s' % (self._sName, sKey[0].upper(), sKey[1:]),
'sSide':
self._sSide,
'iIndex':
self._iIndex,
'iTwistJntNum':
0
})
oModule = importer.importModule(sModulePath)
oLimb = getattr(oModule, sModuleName)(**dKwargs)
oLimb.createComponent()
## connect attrs
attributes.connectAttrs(
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
sDriver=self._sComponentPasser,
sDriven=oLimb._sComponentPasser,
bForce=True)
attributes.connectAttrs(
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'],
sDriver=self._sComponentSpace,
sDriven=oLimb._sComponentSpace,
bForce=True)
cmds.connectAttr('%s.inputMatrix' % self._sComponentMaster,
'%s.inputMatrix' % oLimb._sComponentMaster)
cmds.connectAttr('%s.lWorldMatrix' % self._sComponentMaster,
'%s.lWorldMatrix' % oLimb._sComponentMaster)
controls.addCtrlShape(oLimb._lCtrls,
sCtrlShape,
bVis=False,
dCtrlShapeInfo=None,
bTop=False)
iNum = lKey.index(sKey)
iIndex = lIndex[iNum]
for i, sJnt in enumerate(lJnts):
cmds.connectAttr('%s.matrix' % oLimb._lJnts[i],
'%s.input[%d]' % (lNodes[i][0], iIndex))
cmds.connectAttr('%s.matrix' % oLimb._lJnts[i],
'%s.input[%d]' % (lNodes[i][1], iIndex))
## control vis
sCondCtrlVis = naming.oName(sType='condition',
sSide=self._sSide,
sPart='%s%sCtrlVis' %
(self._sName, sKey),
iIndex=self._iIndex).sName
cmds.createNode('condition', name=sCondCtrlVis)
cmds.connectAttr('%s.outColorR' % sCondBlend,
'%s.firstTerm' % sCondCtrlVis)
cmds.setAttr('%s.secondTerm' % sCondCtrlVis, iIndex, lock=True)
cmds.setAttr('%s.colorIfTrueR' % sCondCtrlVis, 1, lock=True)
cmds.setAttr('%s.colorIfFalseR' % sCondCtrlVis, 0, lock=True)
sMultVis = naming.oName(sType='multDoubleLinear',
sSide=self._sSide,
sPart='%s%sCtrlVis' % (self._sName, sKey),
iIndex=self._iIndex).sName
cmds.createNode('multDoubleLinear', name=sMultVis)
cmds.connectAttr('%s.outColorR' % sCondCtrlVis,
'%s.input1' % sMultVis)
cmds.connectAttr('%s.controls' % self._sComponentMaster,
'%s.input2' % sMultVis)
cmds.connectAttr('%s.output' % sMultVis,
'%s.controls' % oLimb._sComponentMaster)
dModuleInfo.update({
sKey: {
'sModulePath': sModulePath,
'sModuleName': sModuleName,
'sComponentNode': oLimb._sComponentMaster
}
})
cmds.delete(sCrv)
if lBindJnts:
self._lBindRootJnts = [lBindJnts[0]]
else:
self._lBindRootJnts = None
## write component info
self._writeGeneralComponentInfo('baseComponentsBlendLimb', lJnts,
[sCtrlShape], lBindJnts,
self._lBindRootJnts)
cmds.addAttr(self._sComponentMaster, ln='dModuleInfo', dt='string')
cmds.setAttr('%s.dModuleInfo' % self._sComponentMaster,
str(dModuleInfo),
type='string',
lock=True)
## output matrix
if self._bInfo:
self._writeOutputMatrixInfo(lJnts)
## add twist joints
addTwistJoints.twistJointsForLimb(self._iTwistJntNum,
self._lSkipTwist,
lJnts,
self._lBpJnts,
bBind=self._bBind,
sNode=self._sComponentMaster,
bInfo=self._bInfo)
self._getComponentInfo(self._sComponentMaster)
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)
sGrpNode = transforms.createTransformNode(
naming.oName(sType='grp',
sSide=self._sSide,
sPart='%s%sNode' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=self._sGrpNode)
## twist locs
sMatcherBot, sOffsetBot = transforms.createTransformMatcherNode(
self._lBpJnts[0], sParent=None)
sMatcherTop, sOffsetTop = transforms.createTransformMatcherNode(
self._lBpJnts[-1], sParent=None)
## create curve
lBot = []
lTop = []
if self._bOrientTop:
lTop.append(sMatcherTop)
if self._bOrientBot:
lBot.append(sMatcherBot)
sCrv = curves.createCurveOnNodes(naming.oName(
sType='curve',
sSide=self._sSide,
sPart='%s%s' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
lBot + self._lBpCtrls + lTop,
iDegree=3,
sParent=sGrpNode)
cmds.setAttr('%s.v' % sCrv, 0)
## create joints
sParent_jnt = sGrp
lJnts = []
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)
sParent_jnt = sJnt
## create cluster
lClsHnds = curves.clusterCurve(sCrv)
## create contorls
lCtrls = []
if not self._lBpCtrls:
self._lBpCtrls = self._lBpJnts
for i, sJnt in enumerate(self._lBpCtrls):
oJntName = naming.oName(sJnt)
iRotateOrder = cmds.getAttr('%s.ro' % sJnt)
oCtrl = controls.create('%s%s' % (oJntName.sPart, self._sName),
sSide=oJntName.sSide,
iIndex=oJntName.iIndex,
iStacks=self._iStacks,
bSub=self._bSub,
sParent=sGrpCtrl,
sPos=sJnt,
iRotateOrder=iRotateOrder,
sShape='cube',
fSize=8,
lLockHideAttrs=self._lLockHideAttrs)
if self._lCtrlOrient:
transforms.worldOrientTransform(oCtrl.sPasser,
sFoward=self._lCtrlOrient[0],
sUp=self._lCtrlOrient[1])
if self._bOrientBot:
cmds.parent(lClsHnds[i + 1], oCtrl.sOutput)
if i == 0:
cmds.parent(lClsHnds[0], oCtrl.sOutput)
else:
cmds.parent(lClsHnds[i], oCtrl.sOutput)
if self._bOrientTop:
if i == len(self._lBpCtrls) - 1:
cmds.parent(lClsHnds[-1], oCtrl.sOutput)
lCtrls.append(oCtrl.sName)
## rebuild curve
curves.rebuildCurveWithSameCvNum(sCrv)
## spline ik handle
sIkHnd = naming.oName(sType='ikHandle',
sSide=self._sSide,
sPart='%s%s' % (self._sPart, self._sName),
iindex=self._iIndex).sName
cmds.ikHandle(sj=lJnts[0],
ee=lJnts[-1],
sol='ikSplineSolver',
c=sCrv,
ccv=False,
pcv=False,
name=sIkHnd)
cmds.makeIdentity(lJnts, apply=True, t=1, r=1, s=1)
cmds.parent(sIkHnd, sGrpCtrl)
cmds.setAttr('%s.v' % sIkHnd, 0)
## advanced twist
for i, sCtrl in enumerate([lCtrls[0], lCtrls[-1]]):
oCtrl = controls.oControl(sCtrl)
cmds.parent([sOffsetBot, sOffsetTop][i], oCtrl.sOutput)
cmds.setAttr('%s.dTwistControlEnable' % sIkHnd, 1)
cmds.setAttr('%s.dWorldUpType' % sIkHnd, 4)
attributes.connectAttrs([
'%s.worldMatrix[0]' % sMatcherBot,
'%s.worldMatrix[0]' % sMatcherTop
], ['%s.dWorldUpMatrix' % sIkHnd,
'%s.dWorldUpMatrixEnd' % sIkHnd],
bForce=True)
#### control connect out node
sConnectOutCtrl = transforms.createTransformNode(naming.oName(
sType='grp',
sSide=self._sSide,
sPart='%s%sRigConnectOutCtrl' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz',
'v'
],
sParent=sGrpCtrl,
bVis=True)
constraints.constraint([lJnts[-1], sConnectOutCtrl],
sType='parent',
bForce=True,
bMaintainOffset=True)
#### control root connect out node
sConnectOutRootCtrl = transforms.createTransformNode(naming.oName(
sType='grp',
sSide=self._sSide,
sPart='%s%sRigConnectOutRootCtrl' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty',
'tz', 'rx',
'ry', 'rz',
'sx', 'sy',
'sz', 'v'
],
sParent=sGrpCtrl,
bVis=True)
constraints.constraint([lJnts[0], sConnectOutRootCtrl],
sType='parent',
bForce=True,
bMaintainOffset=True)
## write rig info
sString_lJnts = self._convertListToString(lJnts)
sString_lCtrls = self._convertListToString(lCtrls)
lRigInfo = [
'ikSplineRig', self._sConnectInJnt, self._sConnectInCtrl,
lJnts[-1], sConnectOutCtrl, sConnectOutRootCtrl, sString_lJnts,
sString_lCtrls, sIkHnd, sGrpCtrl, sGrp
]
lAttrs = [
'sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt',
'sConnectOutCtrl', 'sConnectOutRootCtrl', 'lJnts', 'lCtrls',
'sIkHnd', 'sGrpCtrl', 'sModuleNode'
]
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
def create(sPart, sSide = 'middle', iIndex = None, bSub = False, iStacks = 1, sParent = None, sPos = None, iRotateOrder = 0, sShape = 'cube', fSize = 1, sColor = None, lLockHideAttrs = []):
'''
create control function
return control wrapper
sPart: control's part name
sSide: control's side name
iIndex: control's index
bSub: whether the control will have sub control or not
iStacks: how many stack groups the control will have
sParent: where the control should be parented
sPos: where the control would be snapped to
iRotateOrder: set the control's rotateOrder
sShape: control's shape
fSize: control's shape's size
sColor: control's shape color string/index
lLockHideAttrs: list of attributes should be locked and hidden
'''
## zero grp
sZero = naming.oName(sType = 'zero', sSide = sSide, sPart = sPart, iIndex = iIndex).sName
sZero = transforms.createTransformNode(sZero, sParent = sParent, iRotateOrder = iRotateOrder)
## passer grp
sPasser = naming.oName(sType = 'passer', sSide = sSide, sPart = sPart, iIndex = iIndex).sName
sPasser = transforms.createTransformNode(sPasser, sParent = sZero, iRotateOrder = iRotateOrder)
## passer grp
sSpace = naming.oName(sType = 'space', sSide = sSide, sPart = sPart, iIndex = iIndex).sName
sSpace = transforms.createTransformNode(sSpace, sParent = sPasser, iRotateOrder = iRotateOrder)
## stacks grp
sParentStack = sSpace
for i in range(iStacks):
sStack = naming.oName(sType = 'stack', sSide = sSide, sPart = sPart, iIndex = iIndex, iSuffix = i + 1).sName
sStack = transforms.createTransformNode(sStack, sParent = sParentStack, iRotateOrder = iRotateOrder)
sParentStack = sStack
## ctrl
oCtrl = naming.oName(sType = 'ctrl', sSide = sSide, sPart = sPart, iIndex = iIndex)
sCtrl = oCtrl.sName
sCtrl = transforms.createTransformNode(sCtrl, lLockHideAttrs = lLockHideAttrs, sParent = sParentStack, iRotateOrder = iRotateOrder)
## output
sOutput = naming.oName(sType = 'grp', sSide = sSide, sPart = '%sOutput' %sPart, iIndex = iIndex).sName
sOutput = transforms.createTransformNode(sOutput, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sCtrl, iRotateOrder = iRotateOrder)
## sub Ctrl
if bSub:
cmds.addAttr(sCtrl, ln = 'subCtrlVis', at = 'long', keyable = False, min = 0, max = 1, dv = 0)
cmds.setAttr('%s.subCtrlVis' %sCtrl, channelBox = True)
sSub = naming.oName(sType = 'ctrl', sSide = sSide, sPart = '%sSub' %sPart, iIndex = iIndex).sName
sSub = transforms.createTransformNode(sSub, lLockHideAttrs = lLockHideAttrs, sParent = sCtrl, iRotateOrder = iRotateOrder)
attributes.connectAttrs(['%s.subCtrlVis' %sCtrl], ['%s.v' %sSub], bForce = True)
attributes.connectAttrs(['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'], ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'], sDriver = sSub, sDriven = sOutput, bForce = True)
## add shape
if sColor:
if isinstance(sColor, basestring):
iColor = controlShapeDict.dColors[sColor]
else:
iColor = sColor
else:
if 'm' in oCtrl.sSide:
iColor = controlShapeDict.dColors['yellow']
elif 'l' in oCtrl.sSide:
iColor = controlShapeDict.dColors['blue']
else:
iColor = controlShapeDict.dColors['red']
dCtrlShapeInfo = {
'lCtrlPnts': controlShapeDict.dCtrlShapes[sShape]['lCtrlPnts'],
'lKnots': controlShapeDict.dCtrlShapes[sShape]['lKnots'],
'bPeriodic': controlShapeDict.dCtrlShapes[sShape]['bPeriodic'],
'iDegree': controlShapeDict.dCtrlShapes[sShape]['iDegree'],
'bOverride': True,
'iOverrideType': 0,
'iColor': iColor
}
addCtrlShape([sCtrl], '%sShape' %sCtrl, bVis = True, dCtrlShapeInfo = dCtrlShapeInfo)
scaleCtrlShape(sCtrl, fScale = fSize)
if bSub:
addCtrlShape([sSub], '%sShape' %sSub, bVis = True, dCtrlShapeInfo = dCtrlShapeInfo)
scaleCtrlShape(sSub, fScale = fSize * 0.9)
if sPos:
transforms.transformSnap([sPos, sZero])
## write control info
cmds.addAttr(sCtrl, ln = 'sOutput', dt = 'string')
cmds.addAttr(sCtrl, ln = 'iStacks', at = 'long', dv = iStacks)
cmds.addAttr(sCtrl, ln = 'sSub', dt = 'string')
cmds.setAttr('%s.sOutput' %sCtrl, sOutput, type = 'string', lock = True)
cmds.setAttr('%s.iStacks' %sCtrl, lock = True)
if bSub:
cmds.setAttr('%s.sSub' %sCtrl, sSub, type = 'string', lock = True)
else:
cmds.setAttr('%s.sSub' %sCtrl, '', type = 'string', lock = True)
##### matrix
cmds.addAttr(sCtrl, ln = 'matrixOutputLocal', at = 'matrix')
cmds.addAttr(sCtrl, ln = 'inverseMatrixOutputLocal', at = 'matrix')
cmds.addAttr(sCtrl, ln = 'matrixOutputWorld', at = 'matrix')
cmds.addAttr(sCtrl, ln = 'inverseMatrixOutputWorld', at = 'matrix')
sInverseMatrixOutputLocal = cmds.createNode('inverseMatrix', name = naming.oName(sType = 'inverseMatrix', sSide = sSide, sPart = '%sInverseMatrixOutputLocal' %sPart, iIndex = iIndex).sName)
cmds.connectAttr('%s.matrixOutputLocal' %sCtrl, '%s.inputMatrix' %sInverseMatrixOutputLocal)
cmds.connectAttr('%s.outputMatrix' %sInverseMatrixOutputLocal, '%s.inverseMatrixOutputLocal' %sCtrl)
sInverseMatrixOutputWorld = cmds.createNode('inverseMatrix', name = naming.oName(sType = 'inverseMatrix', sSide = sSide, sPart = '%sInverseMatrixOutputWorld' %sPart, iIndex = iIndex).sName)
cmds.connectAttr('%s.matrixOutputWorld' %sCtrl, '%s.inputMatrix' %sInverseMatrixOutputWorld)
cmds.connectAttr('%s.outputMatrix' %sInverseMatrixOutputWorld, '%s.inverseMatrixOutputWorld' %sCtrl)
sMultMatrixLocal = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = sSide, sPart = '%sMatrixOutputLocal' %sPart, iIndex = iIndex).sName)
sMultMatrixWorld = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = sSide, sPart = '%sMatrixOutputWorld' %sPart, iIndex = iIndex).sName)
sMultMatrixStacks = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = sSide, sPart = '%sStacksMatrixOutput' %sPart, iIndex = iIndex).sName)
cmds.connectAttr('%s.matrix' %sOutput, '%s.matrixIn[0]' %sMultMatrixLocal)
cmds.connectAttr('%s.matrix' %sCtrl, '%s.matrixIn[1]' %sMultMatrixLocal)
cmds.connectAttr('%s.matrixSum' %sMultMatrixStacks, '%s.matrixIn[2]' %sMultMatrixLocal)
cmds.connectAttr('%s.matrix' %sSpace, '%s.matrixIn[3]' %sMultMatrixLocal)
cmds.connectAttr('%s.matrix' %sPasser, '%s.matrixIn[4]' %sMultMatrixLocal)
cmds.connectAttr('%s.matrixSum' %sMultMatrixLocal, '%s.matrixOutputLocal' %sCtrl)
for i in range(iStacks):
iNum = iStacks - i
sStack = naming.oName(sType = 'stack', sSide = sSide, sPart = sPart, iIndex = iIndex, iSuffix = iNum).sName
cmds.connectAttr('%s.matrix' %sStack, '%s.matrixIn[%d]' %(sMultMatrixStacks, i))
cmds.connectAttr('%s.matrixSum' %sMultMatrixLocal, '%s.matrixIn[0]' %sMultMatrixWorld)
cmds.connectAttr('%s.matrix' %sZero, '%s.matrixIn[1]' %sMultMatrixWorld)
cmds.connectAttr('%s.matrixSum' %sMultMatrixWorld, '%s.matrixOutputWorld' %sCtrl)
oCtrl = oControl(sCtrl)
return oCtrl
def create(self):
self._lBpCtrlsSpine = self._lBpCtrls
self._lBpCtrls = [self._lBpCtrlsPelvis[1]] + self._lBpCtrls
sGrp = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sRig' %(self._sPart, self._sNameRig), 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._sNameRig), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInCtrl)
sGrpNode = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sNode' %(self._sPart, self._sNameRig), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sGrpNode)
self._sConnectInJnt = sGrp
self._sConnectInCtrl = sGrpCtrl
self._sGrpNode = sGrpNode
super(spineRig, self).create()
## fk rig
oSpineFk = fkJointChainRig.fkJointChainRig(
sName = 'Fk',
sSide = self._sSide,
sPart = self._sPart,
iIndex = self._iIndex,
lBpJnts = self._lBpCtrlsSpine,
sConnectInCtrl = self._sConnectInCtrl,
sConnectInJnt = self._sConnectInJnt,
bSub = self._bSub,
iStacks = self._iStacks,
lLockHideAttrs = self._lLockHideAttrs)
oSpineFk.create()
## pelvis rig
oPelvisFk = fkJointChainRig.fkJointChainRig(
sName = 'Fk',
sSide = self._sSide,
sPart = self._sPartPelvis,
iIndex = self._iIndex,
lBpJnts = self._lBpCtrlsPelvis,
sConnectInCtrl = self._sConnectInCtrl,
sConnectInJnt = self._sConnectInJnt,
bSub = self._bSub,
iStacks = self._iStacks,
lLockHideAttrs = self._lLockHideAttrs
)
oPelvisFk.create()
## ik spline
oSpineIk = ikSplineRig.ikSplineRig(
sName = 'ikSpline',
sSide = self._sSide,
sPart = self._sPart,
iIndex = self._iIndex,
lBpJnts = self._lBpCtrls,
sConnectInCtrl = self._sConnectInCtrl,
sConnectInJnt = self._sConnectInJnt,
sGrpNode = self._sGrpNode,
bSub = self._bSub,
iStacks = self._iStacks,
lLockHideAttrs = self._lLockHideAttrs,
lBpCtrls = self._lBpCtrlsSpine[:-1],
bOrientTop = True,
bOrientBot = True,
lCtrlOrient = self._lCtrlOrient,
)
oSpineIk.create()
## constraint and hidde ribbon controls
for i, sCtrl in enumerate(self._lCtrls):
oCtrl = controls.oControl(sCtrl)
cmds.parentConstraint(oSpineIk.lJnts[i], oCtrl.sPasser, mo = False)
cmds.setAttr('%s.v' %oCtrl.sPasser, 0)
## constraint ik controls
## pelvis
oCtrl = controls.oControl(oSpineIk.lCtrls[0])
constraints.constraint([oPelvisFk.lJnts[0], oCtrl.sPasser], sType = 'parent', bMaintainOffset = True)
## spine
for i, sCtrl in enumerate(oSpineIk.lCtrls[1:]):
oCtrl = controls.oControl(sCtrl)
if i == 0:
constraints.constraint([oSpineFk.lJnts[i], oCtrl.sPasser], sType = 'parent', bMaintainOffset = True)
else:
constraints.constraint([oSpineFk.lJnts[i + 1], oCtrl.sPasser], sType = 'parent', bMaintainOffset = True)
## add ctrl shape
sCtrlShape = naming.oName(sType = 'ctrl', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex).sName
controls.addCtrlShape(oSpineIk.lCtrls + oSpineFk.lCtrls + oPelvisFk.lCtrls, sCtrlShape, bVis = False)
cmds.addAttr(sCtrlShape, ln = 'ikCtrlVis', at = 'long', min = 0, max = 1)
cmds.setAttr('%s.ikCtrlVis' %sCtrlShape, channelBox = True)
attributes.connectAttrs(['%s.ikCtrlVis' %sCtrlShape], ['%s.v' %oSpineIk.sGrpCtrl], bForce = True)
## write rig info
sModuleNodes = '%s,%s,%s' %(oSpineFk.sModuleNode, oPelvisFk.sModuleNode, oSpineIk.sModuleNode)
sString_lJnts = self._convertListToString(self._lJnts)
sString_lCtrls = self._convertListToString(oSpineFk.lCtrls + oPelvisFk.lCtrls + oSpineIk.lCtrls)
lRigInfo = ['spineRig', self._sConnectInJnt, self._sConnectInCtrl, self._sConnectOutJnt, self._sConnectOutCtrl, self._sConnectOutRootCtrl,sString_lJnts, sString_lCtrls, sGrpCtrl, sModuleNodes, sGrp]
lAttrs = ['sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt', 'sConnectOutCtrl', 'sConnectOutRootCtrl', 'lJnts', 'lCtrls', 'sGrpCtrl', 'lModuleNodes', 'sModuleNode']
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
def buildBaseRigNodes(self):
## create master node
sMaster = transforms.createTransformNode('master',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
])
####### add attrs
sEnumName = ''
for sRes in self.lRes:
sEnumName += '%s:' % sRes
sEnumName = sEnumName[:-1]
cmds.addAttr(sMaster,
ln='resolution',
at='enum',
enumName=sEnumName,
keyable=False,
dv=0)
cmds.setAttr('%s.resolution' % sMaster, channelBox=True)
for sAttr in [
'geometry', 'joints', 'controls', 'rigNodes', 'rigGeometry'
]:
if sAttr == 'geometry':
iVal = 3
elif sAttr == 'controls':
iVal = 0
else:
iVal = 1
cmds.addAttr(sMaster,
ln=sAttr,
at='enum',
enumName='on:off:template:reference',
keyable=False,
dv=iVal)
cmds.setAttr('%s.%s' % (sMaster, sAttr), channelBox=True)
cmds.addAttr(sMaster,
ln='geoDeformMove',
nn='Geo Deform/Move',
at='long',
min=0,
max=1,
dv=0,
keyable=False)
cmds.setAttr('%s.geoDeformMove' % sMaster, channelBox=True)
## create control, do not touch group
sControl = transforms.createTransformNode('controls',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sMaster)
sDoNotTouch = transforms.createTransformNode('doNotTouch',
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sMaster)
## create geometry groups
sGeometry = transforms.createTransformNode('geometry',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sDoNotTouch)
for sRes in self.lRes:
sResGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart='geo').sName
sResGrp = transforms.createTransformNode(sResGrp,
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sGeometry)
for sPart in ['xtrs', 'def']:
sGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart=sPart).sName
sGrp = transforms.createTransformNode(sGrp,
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sResGrp)
## create joint group
sJoint = transforms.createTransformNode('joints',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sDoNotTouch)
for sGrp in ['defJoints', 'rigJoints']:
transforms.createTransformNode(sGrp,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry',
'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=sJoint)
## create rigNode groups
sRigNode = transforms.createTransformNode('rigNodes',
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sDoNotTouch)
for sPart in ['transform', 'origin']:
sGrp = naming.oName(sType='group',
sSide='middle',
sPart='rigNodes%s' % sPart.title()).sName
sGrp = transforms.createTransformNode(sGrp,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz', 'v'
],
sParent=sRigNode)
## create rigGeometry groups
sRigGeometry = transforms.createTransformNode('rigGeometry',
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sDoNotTouch)
for sRes in self.lRes:
sResGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart='rigGeometry').sName
sResGrp = transforms.createTransformNode(sResGrp,
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
],
sParent=sRigGeometry)
for sPart in ['transform', 'origin']:
sGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart='rigGeometry%s' %
sPart.title()).sName
sGrp = transforms.createTransformNode(sGrp,
lLockHideAttrs=[
'tx', 'ty', 'tz',
'rx', 'ry', 'rz',
'sx', 'sy', 'sz'
],
sParent=sResGrp)
cmds.setAttr('%s.v' % sGrp, 0)
## Vis connections
### resolution
lAttr = []
for sRes in self.lRes:
sResGeoGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart='geo').sName
sResRigGeoGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart='rigGeometry').sName
lAttr.append('%s.v' % sResGeoGrp)
attributes.connectAttrs(['%s.v' % sResGeoGrp],
['%s.v' % sResRigGeoGrp],
bForce=True)
attributes.enumToMultiAttrs('resolution',
lAttr,
iEnumRange=len(self.lRes),
lValRange=[[0, 1]],
sEnumObj=sMaster)
### geometry joints controls rigNodes
lGrps = [sGeometry, sJoint, sControl, sRigNode, sRigGeometry]
for i, sAttr in enumerate(
['geometry', 'joints', 'controls', 'rigNodes', 'rigGeometry']):
sConditionVis = naming.oName(sType='condition',
sSide='middle',
sPart='%sVis' % sAttr).sName
cmds.createNode('condition', name=sConditionVis)
cmds.connectAttr('%s.%s' % (sMaster, sAttr),
'%s.firstTerm' % sConditionVis)
cmds.setAttr('%s.secondTerm' % sConditionVis, 1)
cmds.setAttr('%s.colorIfTrueR' % sConditionVis, 0)
cmds.setAttr('%s.colorIfFalseR' % sConditionVis, 1)
attributes.connectAttrs(['%s.outColor' % sConditionVis],
['%s.v' % lGrps[i]],
bForce=True)
cmds.setAttr('%s.overrideEnabled' % lGrps[i], 1)
attributes.enumToSingleAttrs(sAttr,
['%s.overrideDisplayType' % lGrps[i]],
iEnumRange=4,
lValRange=[[0, 0], [0, 0], [0, 1],
[0, 2]],
sEnumObj=sMaster)
## create ctrls
fWidth, fHeight, fDepth = transforms.getBoundingBoxInfo(self.sAsset)
fCtrlSize = fWidth * fDepth * 1.2
### world ctrl
sParentCtrl = sControl
lCtrlShape = [['circle', 'yellow'], ['triangle', 'royal heath'],
['triangle', 'royal purple']]
for i, sCtrlName in enumerate(['world', 'layout', 'local']):
oCtrl = controls.create(sCtrlName,
sSide='middle',
iIndex=None,
bSub=False,
iStacks=1,
sParent=sParentCtrl,
sPos=None,
sShape=lCtrlShape[i][0],
fSize=fCtrlSize,
sColor=lCtrlShape[i][1],
lLockHideAttrs=['sx', 'sy', 'sz', 'v'])
cmds.addAttr(oCtrl.sName,
ln='rigScale',
at='float',
dv=1,
keyable=True)
attributes.connectAttrs([
'%s.rigScale' % oCtrl.sName,
'%s.rigScale' % oCtrl.sName,
'%s.rigScale' % oCtrl.sName,
], [
'%s.sx' % oCtrl.sName,
'%s.sy' % oCtrl.sName,
'%s.sz' % oCtrl.sName
],
bForce=True)
sParentCtrl = oCtrl.sName
fCtrlSize *= 0.85
sCtrlLocal = sParentCtrl
## connect ctrl with grps
### geo grp
for sRes in self.lRes:
for sPart in ['xtrs', 'def']:
sGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart=sPart).sName
lConstraints = constraints.constraint([sCtrlLocal, sGrp],
sType='all',
bForce=True)
if sPart == 'def':
for sConstraint in lConstraints:
sWeightAttr = constraints.getWeightAliasList(
sConstraint)[0]
attributes.connectAttrs(
['%s.geoDeformMove' % sMaster],
['%s.%s' % (sConstraint, sWeightAttr)],
bForce=True)
### joints
lConstraints = constraints.constraint([sCtrlLocal, sJoint],
sType='all',
bForce=True)
for sConstraint in lConstraints:
sWeightAttr = constraints.getWeightAliasList(sConstraint)[0]
attributes.connectAttrs(['%s.geoDeformMove' % sMaster],
['%s.%s' % (sConstraint, sWeightAttr)],
bForce=True)
### rigNodes
sGrp = naming.oName(sType='group',
sSide='middle',
sPart='rigNodesTransform').sName
lConstraints = constraints.constraint([sCtrlLocal, sGrp],
sType='all',
bForce=True)
### rig geometry
for sRes in self.lRes:
sGrp = naming.oName(sType='group',
sSide='middle',
sRes=sRes,
sPart='rigGeometryTransform').sName
lConstraints = constraints.constraint([sCtrlLocal, sGrp],
sType='all',
bForce=True)
def matrixConnectJnt(sDrvNode,
sDrivenJnt,
sDrvAttr,
lSkipTranslate=[],
lSkipRotate=[],
lSkipScale=[],
bForce=True):
oName = naming.oName(sDrvNode)
oName.sType = 'decomposeMatrix'
sDecomposeMatrix = oName.sName
sDecomposeMatrixRotScale = None
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 or len(lSkipScale) < 3:
oNameDriven = naming.oName(sDrivenJnt)
sMultMatrix = naming.oName(sType='multMatrix',
sSide=oNameDriven.sSide,
sPart='%sMatrixRotScale' %
oNameDriven.sPart,
iIndex=oNameDriven.iIndex).sName
cmds.createNode('multMatrix', name=sMultMatrix)
cmds.connectAttr('%s.%s' % (sDrvNode, sDrvAttr),
'%s.matrixIn[0]' % sMultMatrix)
fOrientX = cmds.getAttr('%s.jointOrientX' % sDrivenJnt)
fOrientY = cmds.getAttr('%s.jointOrientY' % sDrivenJnt)
fOrientZ = cmds.getAttr('%s.jointOrientZ' % sDrivenJnt)
mMatrix = apiUtils.createMMatrixFromTransformInfo(
lRotate=[fOrientX, fOrientY, fOrientZ])
lMatrixInverse = apiUtils.convertMMatrixToList(mMatrix.inverse())
cmds.setAttr('%s.matrixIn[1]' % sMultMatrix,
lMatrixInverse,
type='matrix')
sDecomposeMatrixRotScale = naming.oName(
sType='decomposeMatrix',
sSide=oNameDriven.sSide,
sPart='%sRotScale' % oNameDriven.sPart,
iIndex=oNameDriven.iIndex).sName
cmds.createNode('decomposeMatrix', name=sDecomposeMatrixRotScale)
cmds.connectAttr('%s.matrixSum' % sMultMatrix,
'%s.inputMatrix' % sDecomposeMatrixRotScale)
if len(lSkipRotate) < 3:
sQuatToEuler = naming.oName(sType='quatToEuler',
sSide=oNameDriven.sSide,
sPart='%sRot' % oNameDriven.sPart,
iIndex=oNameDriven.iIndex).sName
cmds.createNode('quatToEuler', name=sQuatToEuler)
cmds.connectAttr('%s.outputQuat' % sDecomposeMatrixRotScale,
'%s.inputQuat' % sQuatToEuler)
cmds.connectAttr('%s.ro' % sDrivenJnt,
'%s.inputRotateOrder' % sQuatToEuler)
## connect matrix
for sAxis in ['X', 'Y', 'Z']:
if sAxis not in lSkipTranslate:
attributes.connectAttrs(
['%s.outputTranslate%s' % (sDecomposeMatrix, sAxis)],
['%s.translate%s' % (sDrivenJnt, sAxis)],
bForce=bForce)
if sAxis not in lSkipRotate:
attributes.connectAttrs(
['%s.outputRotate%s' % (sQuatToEuler, sAxis)],
['%s.rotate%s' % (sDrivenJnt, sAxis)],
bForce=bForce)
if sAxis not in lSkipScale:
attributes.connectAttrs(
['%s.outputScale%s' % (sDecomposeMatrixRotScale, sAxis)],
['%s.scale%s' % (sDrivenJnt, sAxis)],
bForce=bForce)
if sDecomposeMatrixRotScale:
attributes.connectAttrs(['%s.outputShear' % sDecomposeMatrixRotScale],
['%s.shear' % sDrivenJnt],
bForce=bForce)
else:
attributes.connectAttrs(['%s.outputShear' % sDecomposeMatrix],
['%s.shear' % sDrivenJnt],
bForce=bForce)