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 createRibbonFromNodes(sName, lNodes, bAuto = False, sDirection = 'x', fWidth = 1, bNormalize = True, sParent = None):
sCrvA = curves.createCurveOnNodes('RIBBON_TEMP_001', lNodes, iDegree = 3)
sCrvB = curves.createCurveOnNodes('RIBBON_TEMP_002', lNodes, iDegree = 3)
if bAuto:
sJntA = joints.createJntOnExistingNode(lNodes[0], lNodes[0], 'RIBBON_TEMP_AIM_001')
sJntB = joints.createJntOnExistingNode(lNodes[-1], lNodes[-1], 'RIBBON_TEMP_AIM_002')
cmds.parent(sJntB, sJntA)
cmds.joint(sJntA, edit = True, oj = 'xyz', secondaryAxisOrient = 'yup', ch = True, zso = True)
sOffsetA = transforms.createTransformNode('RIBBON_TEMP_OFFSET_001', sParent = sJntA, sPos = sJntA)
sOffsetB = transforms.createTransformNode('RIBBON_TEMP_OFFSET_002', sParent = sJntA, sPos = sJntA)
cmds.parent(sCrvA, sOffsetA)
cmds.parent(sCrvB, sOffsetB)
cmds.setAttr('%s.tz' %sOffsetA, fWidth * 0.5)
cmds.setAttr('%s.tz' %sOffsetB, -fWidth * 0.5)
cmds.parent(sCrvA, world = True)
cmds.parent(sCrvB, world = True)
cmds.makeIdentity(sCrvA, t = 1, r = 1, s = 1, apply = True)
cmds.makeIdentity(sCrvB, t = 1, r = 1, s = 1, apply = True)
cmds.delete(sJntA)
else:
cmds.setAttr('%s.t%s' %(sCrvA, sDirection), fWidth * 0.5)
cmds.setAttr('%s.t%s' %(sCrvB, sDirection), -fWidth * 0.5)
cmds.loft(sCrvA, sCrvB, ch=False, u = True, c = False, rn=False, ar=True, d = 3, ss = 1, rsn = True,name = sName)
if bNormalize:
cmds.rebuildSurface(sName, ch = False, su = len(lNodes) - 1, sv = 1, dv = 3, du = 3)
cmds.delete(sCrvA, sCrvB)
if sParent and cmds.objExists(sParent):
cmds.parent(sName, sParent)
return sName
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 __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):
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 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)
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=sGrp)
lJnts.append(sJnt)
## create ribbon surface
## if no control bpjnt, create controls, cluster ribbon
lCtrls = []
if not self._lBpCtrls:
sRibbon = surfaces.createRibbonFromNodes(naming.oName(
sType='surface',
sSide=self._sSide,
sPart='%s%s' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
lJnts,
bAuto=True,
fWidth=2,
bNormalize=False,
sParent=sGrpNode)
cmds.setAttr('%s.v' % sRibbon, 0)
lCls = surfaces.clusterSurface(sRibbon, sUV='u')
cmds.rebuildSurface(sRibbon,
ch=True,
su=len(lJnts) - 1,
sv=1,
dv=3,
du=3)
for i, sCls in enumerate(lCls):
oCtrl = controls.create('%s%s' % (self._sPart, self._sName),
sSide=self._sSide,
iIndex=i,
iStacks=self._iStacks,
bSub=self._bSub,
sParent=sGrpCtrl,
sPos=sCls,
sShape='cube',
fSize=4,
lLockHideAttrs=self._lLockHideAttrs)
cmds.parent(sCls, oCtrl.sOutput)
lCtrls.append(oCtrl.sName)
else:
sRibbon = surfaces.createRibbonFromNodes(naming.oName(
sType='surface',
sSide=self._sSide,
sPart='%s%s' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
self._lBpCtrls,
bAuto=True,
fWidth=2,
bNormalize=False,
sParent=sGrpNode)
cmds.setAttr('%s.v' % sRibbon, 0)
lCls = surfaces.clusterSurface(sRibbon, sUV='u')
cmds.rebuildSurface(sRibbon,
ch=True,
su=len(lJnts) - 1,
sv=1,
dv=3,
du=3)
for i, sCls in enumerate(lCls):
oJntName = naming.oName(self._lBpCtrls[i])
iRotateOrder = cmds.getAttr('%s.ro' % self._lBpCtrls[i])
oCtrl = controls.create('%s%s' % (oJntName.sPart, self._sName),
sSide=oJntName.sSide,
iIndex=oJntName.iIndex,
iStacks=self._iStacks,
bSub=self._bSub,
sParent=sGrpCtrl,
iRotateOrder=iRotateOrder,
sPos=self._lBpCtrls[i],
sShape='cube',
fSize=4,
lLockHideAttrs=self._lLockHideAttrs)
cmds.parent(sCls, oCtrl.sOutput)
lCtrls.append(oCtrl.sName)
### attach joints
sGrpFollicle, lFollicles = constraints.follicleConstraint(
sRibbon, lJnts, bMaintainOffset=True)
cmds.parent(sGrpFollicle, sGrpNode)
#### 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 = [
'ribbonRig', self._sConnectInJnt, self._sConnectInCtrl, lJnts[-1],
sConnectOutCtrl, sConnectOutRootCtrl, sString_lJnts,
sString_lCtrls, sRibbon, sGrpCtrl, sGrp
]
lAttrs = [
'sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt',
'sConnectOutCtrl', 'sConnectOutRootCtrl', 'lJnts', 'lCtrls',
'sRibbon', 'sGrpCtrl', 'sModuleNode'
]
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
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)
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
## ik handle
sIkHnd = naming.oName(sType='ikHandle',
sSide=self._sSide,
sPart=self._sPart,
iIndex=self._iIndex).sName
cmds.ikHandle(sj=lJnts[0], ee=lJnts[-1], sol='ikSCsolver', name=sIkHnd)
## control
if self._bCtrl:
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)
iRotateOrder = cmds.getAttr('%s.ro' % lJnts[0])
oJntName = naming.oName(lJnts[0])
oCtrl_root = controls.create(oJntName.sPart,
sSide=oJntName.sSide,
iIndex=oJntName.iIndex,
iStacks=self._iStacks,
bSub=self._bSub,
sParent=sGrpCtrl,
sPos=lJnts[0],
iRotateOrder=iRotateOrder,
sShape='cube',
fSize=4,
lLockHideAttrs=self._lLockHideAttrs)
oJntName = naming.oName(lJnts[-1])
oCtrl_aim = controls.create(oJntName.sPart,
sSide=oJntName.sSide,
iIndex=oJntName.iIndex,
iStacks=self._iStacks,
bSub=self._bSub,
sParent=sGrpCtrl,
sPos=lJnts[-1],
iRotateOrder=iRotateOrder,
sShape='cube',
fSize=4,
lLockHideAttrs=self._lLockHideAttrs)
cmds.pointConstraint(oCtrl_root.sOutput, lJnts[0], mo=False)
#### 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=oCtrl.sOutput,
bVis=True)
constraints.constraint([lJnts[-1], sConnectOutCtrl],
sType='parent',
bForce=True,
bMaintainOffset=False)
sParentIk = oCtrl_aim.sOutput
lCtrls = [oCtrl_root.sName, oCtrl_aim.sName]
else:
sParentIk = self._sConnectInCtrl
lCtrls = ''
sGrpIkHndle = transforms.createTransformNode(
naming.oName(sType='grp',
sSide=self._sSide,
sPart='%s%sRigIkHndle' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=sParentIk,
bVis=False)
cmds.parent(sIkHnd, sGrpIkHndle)
## write rig info
sString_lJnts = self._convertListToString(lJnts)
sString_lCtrls = self._convertListToString(lCtrls)
lRigInfo = [
'ikSCsolverRig', self._sConnectInJnt, self._sConnectInCtrl,
lJnts[-1], sConnectOutCtrl, sString_lJnts, sString_lCtrls, sIkHnd,
sGrpCtrl, sGrp
]
lAttrs = [
'sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt',
'sConnectOutCtrl', 'lJnts', 'lCtrls', 'sIkHnd', 'sGrpCtrl',
'sModuleNode'
]
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
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 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 createComponent(self):
super(baseIkRPsolverLimb, self).createComponent()
sParent_ctrl = self._sComponentControls
## put ik joint chain locally
sGrp_ikJnts = transforms.createTransformNode(naming.oName(sType = 'group', sSide = self._sSide, sPart = '%sRPJointsLocal' %self._sName, iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sComponentRigNodesWorld)
sParent_jntLocal = sGrp_ikJnts
lJntsLocal = []
lJntsLocal, lBindJnts = createDriveJoints.createDriveJoints(self._lBpJnts, sParent = sGrp_ikJnts, sSuffix = 'IkRPLocal', bBind = False)
lJnts, lBindJnts = createDriveJoints.createDriveJoints(self._lBpJnts, sParent = self._sComponentJoints, sSuffix = 'IkRP', bBind = self._bBind)
for i, sJntLocal in enumerate(lJntsLocal):
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr('%s.translate%s' %(sJntLocal, sAxis), '%s.translate%s' %(lJnts[i], sAxis))
cmds.connectAttr('%s.rotate%s' %(sJntLocal, sAxis), '%s.rotate%s' %(lJnts[i], sAxis))
cmds.connectAttr('%s.scale%s' %(sJntLocal, sAxis), '%s.scale%s' %(lJnts[i], sAxis))
## ctrls
lCtrls = []
for i, sBpCtrl in enumerate(self._lBpCtrls):
oJntName = naming.oName(sBpCtrl)
iRotateOrder = cmds.getAttr('%s.ro' %sBpCtrl)
if i != 2:
lLockHideAttrs = ['rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']
else:
lLockHideAttrs = self._lLockHideAttrs
oCtrl = controls.create(oJntName.sPart, sSide = oJntName.sSide, iIndex = oJntName.iIndex, iStacks = self._iStacks, bSub = True, sParent = self._sComponentControls, sPos = sBpCtrl, iRotateOrder = iRotateOrder, sShape = 'cube', fSize = 8, lLockHideAttrs = lLockHideAttrs)
lCtrls.append(oCtrl.sName)
## ik handle
sIkHnd = naming.oName(sType = 'ikHandle', sSide = self._sSide, sPart = '%sRPsolver' %self._sName, iIndex = self._iIndex).sName
cmds.ikHandle(sj = lJntsLocal[0], ee = lJntsLocal[-1], sol = 'ikRPsolver', name = sIkHnd)
#### offset group
sGrpIk = transforms.createTransformNode(naming.oName(sType = 'group', sSide = self._sSide, sPart = '%sRPsolver' %self._sName, iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sComponentRigNodesWorld, sPos = lCtrls[-1])
sGrpPv = transforms.createTransformNode(naming.oName(sType = 'group', sSide = self._sSide, sPart = '%sPV' %self._sName, iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sComponentRigNodesWorld, sPos = lCtrls[1])
cmds.parent(sIkHnd, sGrpIk)
#### pole vector constraint
cmds.poleVectorConstraint(sGrpPv, sIkHnd)
#### pole vector line
sCrv, lClsHnds = curves.createCurveLine(naming.oName(sType = 'curve', sSide = self._sSide, sPart = '%sPvLineIk' %self._sName, iIndex = self._iIndex).sName, [lJnts[1], lCtrls[1]], bConstraint = False)
cmds.parent(lClsHnds, sCrv, self._sComponentControls)
## pass info to class
self._lJnts = lJnts
self._lCtrls = lCtrls
self._lBindJnts = lBindJnts
self._sGrpIk = sGrpIk
self._sIkHnd = sIkHnd
self._lJntsLocal = lJntsLocal
if lBindJnts:
self._lBindRootJnts = [lBindJnts[0]]
else:
self._lBindRootJnts = None
## matrix connect
constraints.matrixConnect(lCtrls[0], [lJntsLocal[0]], 'matrixOutputWorld',lSkipRotate = ['X', 'Y', 'Z'], lSkipScale = ['X', 'Y', 'Z'], bForce = True)
constraints.matrixConnect(lCtrls[1], [sGrpPv, lClsHnds[1]], 'matrixOutputWorld',lSkipRotate = ['X', 'Y', 'Z'], lSkipScale = ['X', 'Y', 'Z'], bForce = True)
constraints.matrixConnect(lCtrls[2], [sGrpIk], 'matrixOutputWorld', lSkipScale = ['X', 'Y', 'Z'], bForce = True)
sMultMatrixPv = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = self._sSide, sPart = '%sPvMatrix' %self._sName, iIndex = self._iIndex).sName)
cmds.connectAttr('%s.matrix' %lJnts[1], '%s.matrixIn[0]' %sMultMatrixPv)
cmds.connectAttr('%s.matrix' %lJnts[0], '%s.matrixIn[1]' %sMultMatrixPv)
constraints.matrixConnect(sMultMatrixPv, [lClsHnds[0]], 'matrixSum', lSkipRotate = ['X', 'Y', 'Z'], lSkipScale = ['X', 'Y', 'Z'], bForce = True)
## write component info
self._writeGeneralComponentInfo('baseIkRPsolverLimb', lJnts, lCtrls, lBindJnts, self._lBindRootJnts)
## 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(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 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 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
lJnts = []
for i, sBpJnt in enumerate(self._lBpJnts):
oJntName = naming.oName(sBpJnt)
oJntName.sType = 'jnt'
sJnt = joints.createJntOnExistingNode(sBpJnt, sBpJnt, oJntName.sName, sParent = sParent_jnt)
lJnts.append(sJnt)
sParent_jnt = sJnt
## rig each limb
iJnts_min = len(lJnts)
dRigLimbs = {}
lCtrls = []
for sMode in self._dRigLimbs.keys():
dRigLimbs_each = {sMode: {
'iIndex': 0,
'class': None,
'lJnts': None,
}}
oLimb = self._dRigLimbs[sMode]['class'](sSide = self._sSide, iIndex = self._iIndex)
oLimb._lBpJnts = self._lBpJnts
oLimb._sConnectInJnt = sGrp
oLimb._sConnectInCtrl = sGrpCtrl
oLimb.create()
if self._dRigLimbs[sMode].has_key('iIndex'):
dRigLimbs_each[sMode]['iIndex'] = self._dRigLimbs[sMode]['iIndex']
else:
dRigLimbs_each[sMode]['iIndex'] = namingDict.spaceDict[sMode]
dRigLimbs_each[sMode]['class'] = oLimb
if hasattr(oLimb, 'lJntsOutput'):
dRigLimbs_each[sMode]['lJnts'] = oLimb.lJntsOutput
if len(oLimb.lJntsOutput) < iJnts_min:
iJnts_min = len(oLimb.lJntsOutput)
else:
dRigLimbs_each[sMode]['lJnts'] = oLimb.lJnts
if len(oLimb.lJnts) < iJnts_min:
iJnts_min = len(oLimb.lJnts)
lCtrls += oLimb.lCtrls
dRigLimbs.update(dRigLimbs_each)
## add shape node
sCtrlShape = naming.oName(sType = 'ctrl', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex).sName
controls.addCtrlShape(lCtrls, sCtrlShape, bVis = False)
## blend constraint joints
for i in range(0, iJnts_min):
lDrivers = []
#dDrivers = {'cog': {'iIndex': 0, 'sOutput': 'ctrl_m_cog'}}
dDrivers = {}
for sMode in dRigLimbs.keys():
dDriver_each = {sMode: {'iIndex': dRigLimbs[sMode]['iIndex'], 'sOutput': dRigLimbs[sMode]['lJnts'][i]}}
dDrivers.update(dDriver_each)
constraints.spaceConstraint(dDrivers, lJnts[i], sType = self._sConstraintType, sCtrl = sCtrlShape, bMaintainOffset = False, sName = self._sName, lDefaultVal = None)
## vis switch
sCondition = naming.oName(sType = 'condition', sSide = self._sSide, sPart = '%s%s%sSelector' %(self._sPart, self._sName[0].upper(), self._sName[1:]), iIndex = self._iIndex).sName
cmds.createNode('condition', name = sCondition)
cmds.connectAttr('%s.%sModeA' %(sCtrlShape, self._sName), '%s.colorIfTrueR' %sCondition)
cmds.connectAttr('%s.%sModeB' %(sCtrlShape, self._sName), '%s.colorIfFalseR' %sCondition)
cmds.connectAttr('%s.%sModeBlend' %(sCtrlShape, self._sName), '%s.firstTerm' %sCondition)
cmds.setAttr('%s.secondTerm' %sCondition, 0.5)
cmds.setAttr('%s.operation' %sCondition, 4)
lAttrs = []
lEnumIndex = []
for sMode in dRigLimbs.keys():
lAttrs.append('%s.v' %dRigLimbs[sMode]['class'].sGrpCtrl)
lEnumIndex.append(dRigLimbs[sMode]['iIndex'])
attributes.enumToMultiAttrs('outColorR', lAttrs, iEnumRange = len(lEnumIndex), lEnumIndex = lEnumIndex, sEnumObj = sCondition)
#enumToMultiAttrs(sEnumAttr, lAttrs, iEnumRange = 2, lEnumIndex = None, lValRange = [[0,1]], sEnumObj = None)
#### control connect out node
sConnectOutCtrl = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sConnectOutCtrl' %(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)
lCtrls = sCtrlShape
## write rig info
sModuleNodes = ''
sModuleIndex = ''
for sMode in dRigLimbs.keys():
sModuleNodes += '%s,' %dRigLimbs[sMode]['class'].sModuleNode
sModuleIndex += '%d,' %dRigLimbs[sMode]['iIndex']
sString_lJnts = self._convertListToString(lJnts)
sString_lCtrls = self._convertListToString(lCtrls)
lRigInfo = ['blendModeRig', sGrp, self._sConnectInJnt, self._sConnectInCtrl, lJnts[-1], sConnectOutCtrl, sString_lJnts, sString_lCtrls, sGrpCtrl, sModuleNodes[:-1], sModuleIndex[:-1]]
lAttrs = ['sModuleType', 'sModuleNode', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt', 'sConnectOutCtrl', 'lJnts', 'lCtrls', 'sGrpCtrl', 'lModuleNodes', 'lModuleIndex']
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
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 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
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
lCtrls = []
for i, sBpJnt in enumerate([self._sBpRoot, self._sBpPv,
self._sBpCtrl]):
oJntName = naming.oName(sBpJnt)
iRotateOrder = cmds.getAttr('%s.ro' % sBpJnt)
if i == 2:
lLockHideAttrs = self._lLockHideAttrs
else:
lLockHideAttrs = ['rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']
oCtrl = controls.create(oJntName.sPart,
sSide=oJntName.sSide,
iIndex=oJntName.iIndex,
iStacks=self._iStacks,
bSub=self._bSub,
sParent=sGrpCtrl,
sPos=sBpJnt,
iRotateOrder=iRotateOrder,
sShape='cube',
fSize=8,
lLockHideAttrs=lLockHideAttrs)
lCtrls.append(oCtrl.sName)
## ik handle
if self._bOrient:
sJntEnd_rp = lJnts[-2]
sIkHnd_sc = naming.oName(sType='ikHandle',
sSide=self._sSide,
sPart='%sSCsolver' % self._sPart,
iIndex=self._iIndex).sName
cmds.ikHandle(sj=lJnts[-2],
ee=lJnts[-1],
sol='ikSCsolver',
name=sIkHnd_sc)
else:
sJntEnd_rp = lJnts[-1]
sIkHnd_sc = None
sIkHnd_rp = naming.oName(sType='ikHandle',
sSide=self._sSide,
sPart='%sRPsolver' % self._sPart,
iIndex=self._iIndex).sName
cmds.ikHandle(sj=lJnts[0],
ee=sJntEnd_rp,
sol='ikRPsolver',
name=sIkHnd_rp)
#### parent ik handle
oCtrl = controls.oControl(lCtrls[2])
sGrpIkHndle = transforms.createTransformNode(
naming.oName(sType='grp',
sSide=self._sSide,
sPart='%s%sRigIkHndle' % (self._sPart, self._sName),
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=oCtrl.sOutput,
bVis=False)
cmds.parent(sIkHnd_rp, sGrpIkHndle)
if sIkHnd_sc:
cmds.parent(sIkHnd_sc, sGrpIkHndle)
#### pole vector
oCtrl = controls.oControl(lCtrls[1])
cmds.poleVectorConstraint(oCtrl.sOutput, sIkHnd_rp)
## pole vector line
curves.createCurveLine(naming.oName(sType='curve',
sSide=self._sSide,
sPart='%sPvLineIk' % self._sPart,
iIndex=self._iIndex).sName,
[lJnts[1], oCtrl.sOutput],
sParent=sGrpCtrl)
#### root control
oCtrl = controls.oControl(lCtrls[0])
cmds.pointConstraint(oCtrl.sOutput, lJnts[0], mo=False)
#### 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=oCtrl.sOutput,
bVis=True)
constraints.constraint([lJnts[-1], sConnectOutCtrl],
sType='parent',
bForce=True,
bMaintainOffset=True)
## write rig info
sString_lJnts = self._convertListToString(lJnts)
sString_lCtrls = self._convertListToString(lCtrls)
lRigInfo = [
'ikRPsolverRig', self._sConnectInJnt, self._sConnectInCtrl,
lJnts[-1], sConnectOutCtrl, sString_lJnts, sString_lCtrls,
sIkHnd_rp, sGrpCtrl, sGrp
]
lAttrs = [
'sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt',
'sConnectOutCtrl', 'lJnts', 'lCtrls', 'sIkHnd', 'sGrpCtrl',
'sModuleNode'
]
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
def spaceConstraint(dDrivers,
sDriven,
sType='parent',
sCtrl=None,
bMaintainOffset=True,
sName='space',
lDefaultVal=None):
## dDrivers = {'cog': {'iIndex': 0, 'sOutput': 'ctrl_m_cog'}}
sEnum = ''
for sSpace in dDrivers.keys():
sEnum += '%s=%d:' % (sSpace, dDrivers[sSpace]['iIndex'])
if sType == 'parent':
sConstraint = cmds.createNode('parentConstraint',
name='%s_parentConstraint1' % sDriven)
cmds.parent(sConstraint, sDriven)
for sAttr in ['translate', 'rotate']:
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr(
'%s.constraint%s%s' % (sConstraint, sAttr.title(), sAxis),
'%s.%s%s' % (sDriven, sAttr, sAxis))
for sAttr in ['rotateOrder', 'rotatePivot']:
cmds.connectAttr(
'%s.%s' % (sDriven, sAttr), '%s.constraint%s%s' %
(sConstraint, sAttr[0].upper(), sAttr[1:]))
cmds.connectAttr('%s.rotatePivotTranslate' % sDriven,
'%s.constraintRotateTranslate' % sConstraint)
cmds.connectAttr('%s.parentInverseMatrix[0]' % sDriven,
'%s.constraintParentInverseMatrix' % sConstraint)
lAttrs_s = [
'translate', 'rotate', 'scale', 'parentMatrix[0]', 'rotateOrder',
'rotatePivot', 'rotatePivotTranslate'
]
lAttrs_d = [
'targetTranslate', 'targetRotate', 'targetScale',
'targetParentMatrix', 'targetRotateOrder', 'targetRotatePivot',
'targetRotateTranslate'
]
elif sType == 'point':
sConstraint = cmds.createNode('pointConstraint',
name='%s_pointConstraint1' % sDriven)
cmds.parent(sConstraint, sDriven)
for sAttr in ['translate']:
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr(
'%s.constraint%s%s' % (sConstraint, sAttr.title(), sAxis),
'%s.%s%s' % (sDriven, sAttr, sAxis))
for sAttr in ['rotatePivot']:
cmds.connectAttr(
'%s.%s' % (sDriven, sAttr), '%s.constraint%s%s' %
(sConstraint, sAttr[0].upper(), sAttr[1:]))
cmds.connectAttr('%s.rotatePivotTranslate' % sDriven,
'%s.constraintRotateTranslate' % sConstraint)
cmds.connectAttr('%s.parentInverseMatrix[0]' % sDriven,
'%s.constraintParentInverseMatrix' % sConstraint)
lAttrs_s = [
'translate', 'parentMatrix[0]', 'rotatePivot',
'rotatePivotTranslate'
]
lAttrs_d = [
'targetTranslate', 'targetParentMatrix', 'targetRotatePivot',
'targetRotateTranslate'
]
elif sType == 'orient':
sConstraint = cmds.createNode('orientConstraint',
name='%s_orientConstraint1' % sDriven)
cmds.parent(sConstraint, sDriven)
for sAttr in ['rotate']:
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr(
'%s.constraint%s%s' % (sConstraint, sAttr.title(), sAxis),
'%s.%s%s' % (sDriven, sAttr, sAxis))
for sAttr in ['rotateOrder']:
cmds.connectAttr(
'%s.%s' % (sDriven, sAttr), '%s.constraint%s%s' %
(sConstraint, sAttr[0].upper(), sAttr[1:]))
cmds.connectAttr('%s.parentInverseMatrix[0]' % sDriven,
'%s.constraintParentInverseMatrix' % sConstraint)
lAttrs_s = ['rotate', 'parentMatrix[0]', 'rotateOrder']
lAttrs_d = ['targetRotate', 'targetParentMatrix', 'targetRotateOrder']
elif sType == 'scale':
sConstraint = cmds.createNode('scaleConstraint',
name='%s_scaleConstraint1' % sDriven)
cmds.parent(sConstraint, sDriven)
for sAttr in ['scale']:
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr(
'%s.constraint%s%s' % (sConstraint, sAttr.title(), sAxis),
'%s.%s%s' % (sDriven, sAttr, sAxis))
cmds.connectAttr('%s.parentInverseMatrix[0]' % sDriven,
'%s.constraintParentInverseMatrix' % sConstraint)
lAttrs_s = ['scale', 'parentMatrix[0]']
lAttrs_d = ['targetScale', 'targetParentMatrix']
## add attr to ctrl
if not sCtrl:
sCtrl = sDriven
oNameCtrl = naming.oName(sCtrl)
sRvs = naming.oName(sType='reverse',
sSide=oNameCtrl.sSide,
sPart='%s%s%sBlend' %
(oNameCtrl.sPart, sName[0].upper(), sName[1:]),
iIndex=oNameCtrl.iIndex,
iSuffix=oNameCtrl.iSuffix).sName
if not cmds.attributeQuery('%sDivider' % sName, node=sCtrl, exists=True):
attributes.addDivider([sCtrl], sName)
cmds.addAttr(sCtrl,
ln='%sModeA' % sName,
nn='Mode A',
at='enum',
en=sEnum[:-1],
keyable=True)
cmds.addAttr(sCtrl,
ln='%sModeB' % sName,
nn='Mode B',
at='enum',
en=sEnum[:-1],
keyable=True)
cmds.addAttr(sCtrl,
ln='%sModeBlend' % sName,
nn='Mode A---B',
at='float',
min=0,
max=1,
keyable=True)
sRvs = cmds.createNode('reverse', name=sRvs)
cmds.connectAttr('%s.%sModeBlend' % (sCtrl, sName), '%s.inputX' % sRvs)
cmds.connectAttr('%s.%sModeBlend' % (sCtrl, sName),
'%s.target[1].targetWeight' % sConstraint)
cmds.connectAttr('%s.outputX' % sRvs,
'%s.target[0].targetWeight' % sConstraint)
oNameDriven = naming.oName(sDriven)
for i, sAttr_s in enumerate(lAttrs_s):
sChoiceA = naming.oName(
sType='choice',
sSide=oNameDriven.sSide,
sPart='%s%s%s%s%sA' %
(oNameDriven.sPart, sName[0].upper(), sName[1:],
lAttrs_d[i][0].upper(), lAttrs_d[i][1:]),
iIndex=oNameDriven.iIndex,
iSuffix=oNameDriven.iSuffix).sName
sChoiceB = naming.oName(
sType='choice',
sSide=oNameDriven.sSide,
sPart='%s%s%s%s%sB' %
(oNameDriven.sPart, sName[0].upper(), sName[1:],
lAttrs_d[i][0].upper(), lAttrs_d[i][1:]),
iIndex=oNameDriven.iIndex,
iSuffix=oNameDriven.iSuffix).sName
sChoiceA = cmds.createNode('choice', name=sChoiceA)
sChoiceB = cmds.createNode('choice', name=sChoiceB)
cmds.connectAttr('%s.output' % sChoiceA,
'%s.target[0].%s' % (sConstraint, lAttrs_d[i]))
cmds.connectAttr('%s.output' % sChoiceB,
'%s.target[1].%s' % (sConstraint, lAttrs_d[i]))
cmds.connectAttr('%s.%sModeA' % (sCtrl, sName),
'%s.selector' % sChoiceA)
cmds.connectAttr('%s.%sModeB' % (sCtrl, sName),
'%s.selector' % sChoiceB)
for sSpace in dDrivers.keys():
sDriver = dDrivers[sSpace]['sOutput']
iIndex = dDrivers[sSpace]['iIndex']
if bMaintainOffset:
oNameDriver = naming.oName(sDriver)
oNameDriver.sType = 'grp'
oNameDriver.sPart = '%s%sConstraint' % (oNameDriver.sPart,
sType.title())
sConstraintGrp = oNameDriver.sName
if not cmds.objExists(sConstraintGrp):
sConstraintGrp = transforms.createTransformNode(
sConstraintGrp, sParent=sDriver)
transforms.transformSnap([sDriver, sConstraintGrp],
sType='all')
cmds.setAttr('%s.v' % sConstraintGrp, 0)
attributes.lockHideAttrs([
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz',
'v'
],
sNode=sConstraintGrp)
sNullOffset = naming.oName(sType='null',
sSide=oNameDriven.sSide,
sPart='%s%sConstraintOffset' %
(oNameDriven.sPart, sType.title()),
iIndex=oNameDriven.iIndex,
iSuffix=oNameDriven.iSuffix).sName
sNull = naming.oName(sType='null',
sSide=oNameDriven.sSide,
sPart='%s%sConstraint' %
(oNameDriven.sPart, sType.title()),
iIndex=oNameDriven.iIndex,
iSuffix=oNameDriven.iSuffix).sName
iRotateOrder = cmds.getAttr('%s.ro' % sDriven)
sNullOffset = transforms.createTransformNode(
sNullOffset,
sParent=sConstraintGrp,
iRotateOrder=iRotateOrder)
sNull = transforms.createTransformNode(
sNull, sParent=sNullOffset, iRotateOrder=iRotateOrder)
transforms.transformSnap([sDriven, sNullOffset], sType='all')
attributes.lockHideAttrs([
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sNode=sNullOffset)
attributes.lockHideAttrs([
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sNode=sNull)
sDriver = sNull
cmds.connectAttr('%s.%s' % (sDriver, sAttr_s),
'%s.input[%d]' % (sChoiceA, iIndex))
cmds.connectAttr('%s.%s' % (sDriver, sAttr_s),
'%s.input[%d]' % (sChoiceB, iIndex))
if lDefaultVal:
cmds.setAttr('%s.%sModeA' % (sCtrl, sName), lDefaultVal[0])
cmds.setAttr('%s.%sModeB' % (sCtrl, sName), lDefaultVal[1])
def follicleConstraint(sGeo,
lNodes,
sType='parent',
bMaintainOffset=True,
lSkipTranslate=None,
lSkipRotate=None,
bForce=False):
oName = naming.oName(sGeo)
sGrpFollicle = naming.oName(sType='grp',
sSide=oName.sSide,
sPart='%sFollicle' % oName.sPart,
iIndex=oName.iIndex).sName
if not cmds.objExists(sGrpFollicle):
transforms.createTransformNode(sGrpFollicle,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz',
'sx', 'sy', 'sz', 'v'
])
cmds.addAttr(sGrpFollicle, ln='follicleCount', at='long', dv=0)
cmds.setAttr('%s.follicleCount' % sGrpFollicle, lock=True)
sGeoShape = meshes.getShape(sGeo)
lFollicles = []
iFollicle = cmds.getAttr('%s.follicleCount' % sGrpFollicle)
for i, sNode in enumerate(lNodes):
lPos_node = cmds.xform(sNode, q=True, t=True, ws=True)
if cmds.objectType(sGeoShape) == 'mesh':
lPosClst, lPosUv = meshes.getClosestPointOnMesh(lPos_node, sGeo)
lShapeConnectAttr = ['outMesh', 'inputMesh']
elif cmds.objectType(sGeoShape) == 'nurbsSurface':
lPosClst, lPosUv = surfaces.getClosestPointOnSurface(
lPos_node, sGeo)
lShapeConnectAttr = ['local', 'inputSurface']
else:
raise RuntimeError('%s is not a mesh or nurbs surface' % sGeo)
## create follicle
sFollicleShape = cmds.createNode('follicle')
sFollicleTrans = cmds.listRelatives(sFollicleShape, p=True)[0]
sFollicle = naming.oName(sType='follicle',
sSide=oName.sSide,
sPart='%sFollicle' % oName.sPart,
iIndex=oName.iIndex,
iSuffix=iFollicle + i + 1).sName
cmds.rename(sFollicleTrans, sFollicle)
sFollicleShape = cmds.listRelatives(sFollicle, s=True)[0]
lFollicles.append(sFollicle)
## connect
cmds.connectAttr('%s.%s' % (sGeoShape, lShapeConnectAttr[0]),
'%s.%s' % (sFollicleShape, lShapeConnectAttr[1]))
cmds.connectAttr('%s.worldMatrix[0]' % sGeoShape,
'%s.inputWorldMatrix' % sFollicleShape)
for sAttr in ['X', 'Y', 'Z']:
cmds.connectAttr('%s.outRotate%s' % (sFollicleShape, sAttr),
'%s.rotate%s' % (sFollicle, sAttr))
cmds.connectAttr('%s.outTranslate%s' % (sFollicleShape, sAttr),
'%s.translate%s' % (sFollicle, sAttr))
cmds.setAttr('%s.parameterU' % sFollicleShape, lPosUv[0])
cmds.setAttr('%s.parameterV' % sFollicleShape, lPosUv[1])
cmds.parent(sFollicle, sGrpFollicle)
## constraint
constraint([sFollicle, sNode],
sType=sType,
bMaintainOffset=bMaintainOffset,
lSkipTranslate=lSkipTranslate,
lSkipRotate=lSkipRotate,
bForce=bForce)
## update follicle count
cmds.setAttr('%s.follicleCount' % sGrpFollicle, lock=False)
cmds.setAttr('%s.follicleCount' % sGrpFollicle,
iFollicle + len(lNodes),
lock=True)
return sGrpFollicle, lFollicles
def __constraint(lDrivers,
sDriven,
bMaintainOffset=False,
lSkipTranslate=None,
lSkipRotate=None,
lSkipScale=None,
bForce=False,
sType='parent'):
lConnections = []
lLocks = []
lReturn = []
if sType == 'parent':
lAttrConnect = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 't', 'r']
elif sType == 'point':
lAttrConnect = ['tx', 'ty', 'tz', 't']
elif sType == 'orient':
lAttrConnect = ['rx', 'ry', 'rz', 'r']
elif sType == 'scale':
lAttrConnect = ['sx', 'sy', 'sz', 's']
elif sType == 'all':
lAttrConnect = [
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 't', 'r', 's'
]
for sAttr in lAttrConnect:
lConnectionsAttr = cmds.listConnections('%s.%s' % (sDriven, sAttr),
s=True,
scn=True,
p=True)
if lConnectionsAttr:
for sConnection in lConnectionsAttr:
lConnections.append([sConnection, sAttr])
bLock = cmds.getAttr('%s.%s' % (sDriven, sAttr), lock=True)
if bLock:
lLocks.append(sAttr)
bConstraint = True
if not bForce:
if lConnections or lLocks:
cmds.warning('%s already has input connections, skipped' % sDriven)
bConstraint = False
lReturn = None
if bConstraint:
for lConnectionAttr in lConnections:
cmds.disconnectAttr('%s.%s' % (sDriven, lConnectionAttr[1]),
lConnectionAttr[0])
for sLockAttr in lLocks:
cmds.setAttr('%s.%s' % (sDriven, sLockAttr), lock=False)
if bMaintainOffset:
oNameDriven = naming.oName(sDriven)
lNulls = []
for i, sDriver in enumerate(lDrivers):
oNameDriver = naming.oName(sDriver)
oNameDriver.sType = 'grp'
oNameDriver.sPart = '%s%sConstraint' % (oNameDriver.sPart,
sType.title())
sConstraintGrp = oNameDriver.sName
if not cmds.objExists(sConstraintGrp):
sConstraintGrp = transforms.createTransformNode(
sConstraintGrp, sParent=sDriver)
transforms.transformSnap([sDriver, sConstraintGrp],
sType='all')
cmds.setAttr('%s.v' % sConstraintGrp, 0)
attributes.lockHideAttrs([
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz',
'v'
],
sNode=sConstraintGrp)
sNullOffset = naming.oName(
sType='null',
sSide=oNameDriven.sSide,
sPart='%s%sConstraintOffsetW%d' %
(oNameDriven.sPart, sType.title(), i),
iIndex=oNameDriven.iIndex,
iSuffix=oNameDriven.iSuffix).sName
sNull = naming.oName(sType='null',
sSide=oNameDriven.sSide,
sPart='%s%sConstraintW%d' %
(oNameDriven.sPart, sType.title(), i),
iIndex=oNameDriven.iIndex,
iSuffix=oNameDriven.iSuffix).sName
iRotateOrder = cmds.getAttr('%s.ro' % sDriven)
sNullOffset = transforms.createTransformNode(
sNullOffset,
sParent=sConstraintGrp,
iRotateOrder=iRotateOrder)
sNull = transforms.createTransformNode(
sNull, sParent=sNullOffset, iRotateOrder=iRotateOrder)
transforms.transformSnap([sDriven, sNullOffset], sType='all')
attributes.lockHideAttrs([
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sNode=sNullOffset)
attributes.lockHideAttrs([
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sNode=sNull)
lNulls.append(sNull)
lConstraints = lNulls
else:
lConstraints = lDrivers
if sType == 'parent':
sConstraint = cmds.parentConstraint(lConstraints,
sDriven,
mo=False,
st=lSkipTranslate,
sr=lSkipRotate)[0]
cmds.setAttr('%s.interpType' % sConstraint, 2)
lReturn.append(sConstraint)
elif sType == 'point':
sConstraint = cmds.pointConstraint(lConstraints,
sDriven,
mo=False,
sk=lSkipTranslate)[0]
lReturn.append(sConstraint)
elif sType == 'orient':
sConstraint = cmds.orientConstraint(lConstraints,
sDriven,
mo=False,
sk=lSkipRotate)[0]
cmds.setAttr('%s.interpType' % sConstraint, 2)
lReturn.append(sConstraint)
elif sType == 'scale':
sConstraint = cmds.scaleConstraint(lConstraints,
sDriven,
mo=False,
sk=lSkipScale)[0]
lReturn.append(sConstraint)
elif sType == 'all':
sConstraint = cmds.parentConstraint(lConstraints,
sDriven,
mo=False,
st=lSkipTranslate,
sr=lSkipRotate)[0]
cmds.setAttr('%s.interpType' % sConstraint, 2)
lReturn.append(sConstraint)
sConstraint = cmds.scaleConstraint(lConstraints,
sDriven,
mo=False,
sk=lSkipScale)[0]
lReturn.append(sConstraint)
bConstraintInfo = cmds.attributeQuery('%sConstraints' % sType,
node=sDriven,
exists=True)
if not bConstraintInfo:
cmds.addAttr(sDriven, ln='%sConstraints' % sType, dt='string')
sConstraintInfo = ''
for sDriver in lDrivers:
sConstraintInfo += '%s,' % sDriver
cmds.setAttr('%s.%sConstraints' % (sDriven, sType), lock=False)
cmds.setAttr('%s.%sConstraints' % (sDriven, sType),
sConstraintInfo,
type='string',
lock=True)
for sLockAttr in lLocks:
cmds.setAttr('%s.%s' % (sDriven, sLockAttr), lock=True)
return lReturn
def createComponent(self):
super(baseFkOnIkSplineLimb, self).createComponent()
iRotateOrder = self._iRotateOrder
## get reverse rotateOrder
lRotateOrderRvs = [5, 3, 4, 1, 2, 0]
iRotateOrderRvs = lRotateOrderRvs[iRotateOrder]
## top and bot ik control
lCtrlBend = []
lCtrlBendName = []
lGrpRvs = []
lGrpRvsZero = []
lCtrlOffset = []
lCtrlCls = []
lCtrlClsEnd = []
sGrp_topRvsZero = transforms.createTransformNode(naming.oName(sType = 'zero', sSide = self._sSide, sPart = '%sTopBendRvs' %self._sName, iIndex = self._iIndex).sName, iRotateOrder = iRotateOrder, sParent = self._sComponentControls, sPos = self._lCtrls[-2])
sGrp_topRvs = transforms.createTransformNode(naming.oName(sType = 'null', sSide = self._sSide, sPart = '%sTopBendRvs' %self._sName, iIndex = self._iIndex).sName, iRotateOrder = iRotateOrderRvs, sParent = sGrp_topRvsZero, sPos = sGrp_topRvsZero)
oCtrlTop = controls.create('%sTopIk' %self._sName, sSide = self._sSide, iIndex = self._iIndex, iStacks = self._iStacks, bSub = True, iRotateOrder = iRotateOrder, sParent = sGrp_topRvs, sPos = sGrp_topRvs, sShape = 'cube', fSize = 6, lLockHideAttrs = ['sx', 'sy', 'sz', 'v'])
oCtrlOffset_top = controls.create('%sTopIkOffset' %self._sName, sSide = self._sSide, iIndex = self._iIndex, iStacks = self._iStacks, bSub = True, iRotateOrder = iRotateOrder, sParent = oCtrlTop.sOutput, sPos = oCtrlTop.sOutput, sShape = 'cube', fSize = 3, lLockHideAttrs = ['sx', 'sy', 'sz', 'v'])
if self._bTop:
lCtrlBend.append(oCtrlTop)
lCtrlBendName.append('Top')
lGrpRvs.append(sGrp_topRvs)
lGrpRvsZero.append(sGrp_topRvsZero)
lCtrlOffset.append(oCtrlOffset_top)
lCtrlCls.append(self._lCtrls[-2])
lCtrlClsEnd.append(self._lCtrls[-1])
else:
cmds.setAttr('%s.v' %oCtrlTop.sZero, 0)
sGrp_botRvsZero = transforms.createTransformNode(naming.oName(sType = 'zero', sSide = self._sSide, sPart = '%sBotBendRvs' %self._sName, iIndex = self._iIndex).sName, iRotateOrder = iRotateOrder, sParent = self._sComponentControls, sPos = self._lCtrls[1])
sGrp_botRvs = transforms.createTransformNode(naming.oName(sType = 'null', sSide = self._sSide, sPart = '%sBotBendRvs' %self._sName, iIndex = self._iIndex).sName, iRotateOrder = iRotateOrderRvs, sParent = sGrp_botRvsZero, sPos = sGrp_botRvsZero)
oCtrlBot = controls.create('%sBotIk' %self._sName, sSide = self._sSide, iIndex = self._iIndex, iStacks = self._iStacks, bSub = True, iRotateOrder = iRotateOrder, sParent = sGrp_botRvs, sPos = sGrp_botRvs, sShape = 'cube', fSize = 6, lLockHideAttrs = ['sx', 'sy', 'sz', 'v'])
oCtrlOffset_bot = controls.create('%sBotIkOffset' %self._sName, sSide = self._sSide, iIndex = self._iIndex, iStacks = self._iStacks, bSub = True, iRotateOrder = iRotateOrder, sParent = oCtrlBot.sOutput, sPos = oCtrlBot.sOutput, sShape = 'cube', fSize = 3, lLockHideAttrs = ['sx', 'sy', 'sz', 'v'])
if self._bBot:
lCtrlBend.append(oCtrlBot)
lCtrlBendName.append('Bot')
lGrpRvs.append(sGrp_botRvs)
lGrpRvsZero.append(sGrp_botRvsZero)
lCtrlOffset.append(oCtrlOffset_bot)
lCtrlCls.append(self._lCtrls[1])
lCtrlClsEnd.append(self._lCtrls[0])
else:
cmds.setAttr('%s.v' %oCtrlBot.sZero, 0)
###### matrix connect, add multiply attrs
lRotatePlug = []
for i, oCtrl in enumerate(lCtrlBend):
attributes.addDivider([oCtrl.sName], 'RotMult')
for j in range(1, len(self._lCtrls) - 1):
cmds.addAttr(oCtrl.sName, ln = 'rotMult%02d' %j, at = 'float', min = 0, max = 1, dv = 1, keyable = True)
sDecomposeMatrix = cmds.createNode('decomposeMatrix', name = naming.oName(sType = 'decomposeMatrix', sSide = self._sSide, sPart = '%s%sBend' %(self._sName, lCtrlBendName[i])).sName)
sQuatToEuler = cmds.createNode('quatToEuler', name = naming.oName(sType = 'quatToEuler', sSide = self._sSide, sPart = '%s%sBend' %(self._sName, lCtrlBendName[i])).sName)
cmds.connectAttr('%s.matrixOutputLocal' %oCtrl.sName, '%s.inputMatrix' %sDecomposeMatrix)
cmds.connectAttr('%s.outputQuat' %sDecomposeMatrix, '%s.inputQuat' %sQuatToEuler)
cmds.connectAttr('%s.ro' %oCtrl.sName, '%s.inputRotateOrder' %sQuatToEuler)
sMult = cmds.createNode('multiplyDivide', name = naming.oName(sType = 'multiplyDivide', sSide = self._sSide, sPart = '%s%sBend' %(self._sName, lCtrlBendName[i])).sName)
cmds.setAttr('%s.operation' %sMult, 2)
sMultRvs = cmds.createNode('multiplyDivide', name = naming.oName(sType = 'multiplyDivide', sSide = self._sSide, sPart = '%s%sBendRvs' %(self._sName, lCtrlBendName[i])).sName)
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr('%s.outputRotate%s' %(sQuatToEuler, sAxis), '%s.input1%s' %(sMult, sAxis))
cmds.setAttr('%s.input2%s' %(sMult, sAxis), len(self._lCtrls) - 2)
cmds.connectAttr('%s.outputRotate%s' %(sQuatToEuler, sAxis), '%s.input1%s' %(sMultRvs, sAxis))
cmds.setAttr('%s.input2%s' %(sMultRvs, sAxis), -1)
cmds.connectAttr('%s.output%s' %(sMultRvs, sAxis), '%s.rotate%s' %(lGrpRvs[i], sAxis))
lRotatePlug.append(sMult)
###### create individual bend control for each cluster (no top nor bot end cluster)
sParent_ctrl = self._sComponentControls
lGrpBend_top = []
lGrpBend_bot = []
for i, sCtrl in enumerate(self._lCtrls[1:len(self._lCtrls)-1]):
lMultRot = []
lCtrlBendIndiv = []
if self._bTop:
oCtrl_top = controls.create('%sTopBend' %self._sName, sSide = self._sSide, iIndex = i + 1, iStacks = self._iStacks, bSub = True, iRotateOrder = iRotateOrder, sPos = sCtrl, sParent = sParent_ctrl, sShape = 'cube', fSize = 4, lLockHideAttrs = ['sx', 'sy', 'sz', 'v'] )
lGrpBend_top.append(oCtrl_top)
sMultRot_top = cmds.createNode('multiplyDivide', name = naming.oName(sType = 'multiplyDivide', sSide = self._sSide, sPart = '%sTopBendMult' %self._sName, iIndex = i + 1).sName)
lMultRot.append(sMultRot_top)
lCtrlBendIndiv.append(oCtrl_top)
if self._bBot:
oCtrl_bot = controls.create('%sBotBend' %self._sName, sSide = self._sSide, iIndex = len(self._lCtrls) - i - 2, iStacks = self._iStacks, bSub = True, iRotateOrder = iRotateOrder, sPos = sCtrl, sParent = sParent_ctrl, sShape = 'cube', fSize = 4, lLockHideAttrs = ['sx', 'sy', 'sz', 'v'] )
lGrpBend_bot.append(oCtrl_bot)
sMultRot_bot = cmds.createNode('multiplyDivide', name = naming.oName(sType = 'multiplyDivide', sSide = self._sSide, sPart = '%sBotBendMult' %self._sName, iIndex = len(self._lCtrls) - i - 2).sName)
lMultRot.append(sMultRot_bot)
lCtrlBendIndiv.append(oCtrl_bot)
for sAxis in ['X', 'Y', 'Z']:
for j, sMultRot in enumerate(lMultRot):
cmds.connectAttr('%s.output%s' %(lRotatePlug[j], sAxis), '%s.input1%s' %(sMultRot, sAxis))
cmds.connectAttr('%s.rotMult%02d' %(lCtrlBend[j].sName, i + 1), '%s.input2%s' %(sMultRot, sAxis))
cmds.connectAttr('%s.output%s' %(sMultRot, sAxis), '%s.rotate%s' %(lCtrlBendIndiv[j].lStacks[0], sAxis))
lGrpBend_bot.reverse()
lGrpBend = []
for lCtrls in [lGrpBend_top, lGrpBend_bot]:
if lCtrls:
lGrpBend.append(lCtrls)
for i, oCtrl in enumerate(lCtrls[1:]):
oParent = lCtrls[i]
cmds.parent(oCtrl.sZero, oParent.sOutput)
## add world matrix
cmds.addAttr(oCtrl.sName, ln = 'matrixOutputBend', at = 'matrix')
sMultMatrix = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = oCtrl.sSide, sPart = '%sMatrixOutputBend' %oCtrl.sPart, iIndex = oCtrl.iIndex).sName)
cmds.connectAttr('%s.matrixOutputWorld' %oCtrl.sName, '%s.matrixIn[0]' %sMultMatrix)
if i > 0:
cmds.connectAttr('%s.matrixOutputBend' %oParent.sName, '%s.matrixIn[1]' %sMultMatrix)
else:
cmds.connectAttr('%s.matrixOutputWorld' %oParent.sName, '%s.matrixIn[1]' %sMultMatrix)
cmds.connectAttr('%s.matrixSum' %sMultMatrix, '%s.matrixOutputBend' %oCtrl.sName)
## connect bend matrix to top and bot ik bend ctrl
for i, lGrp in enumerate(lGrpBend):
constraints.matrixConnect(lGrpBend[i][-1].sName, [lGrpRvsZero[i]], 'matrixOutputBend', lSkipScale = ['X', 'Y', 'Z'])
## get top bot ik bend ctrl translate matrix
lMultMatrix = []
for i, oCtrl in enumerate(lCtrlBend):
sGrpRvs = lGrpRvs[i]
sMultMatrix = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = self._sSide, sPart = '%s%sMatrix' %(self._sName, lCtrlBendName[i]), iIndex = self._iIndex).sName)
lMultMatrix.append(sMultMatrix)
sGrpRvsZero = lGrpRvsZero[i]
sGrpBend = lGrpBend[i][-1].sName
oCtrlOffset = lCtrlOffset[i]
sCtrlCls = lCtrlCls[i]
oCtrlCls = controls.oControl(sCtrlCls)
cmds.connectAttr('%s.matrixOutputWorld' %oCtrlOffset.sName, '%s.matrixIn[0]' %sMultMatrix)
cmds.connectAttr('%s.matrixOutputWorld' %oCtrl.sName, '%s.matrixIn[1]' %sMultMatrix)
cmds.connectAttr('%s.matrix' %sGrpRvs, '%s.matrixIn[2]' %sMultMatrix)
cmds.connectAttr('%s.matrix' %sGrpRvsZero, '%s.matrixIn[3]' %sMultMatrix)
sMultMatrixCls = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = oCtrlCls.sSide, sPart = '%sMatrixOutput' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
lMatrix = apiUtils.getLocalMatrixInNode(oCtrlCls.sPasser, oCtrlOffset.sName, sNodeAttr = 'worldMatrix[0]', sParentAttr = 'worldMatrix[0]')
lInverseMatrix = cmds.getAttr('%s.inverseMatrix' %oCtrlCls.sZero)
cmds.setAttr('%s.matrixIn[0]' %sMultMatrixCls, lMatrix, type = 'matrix')
cmds.connectAttr('%s.matrixSum' %sMultMatrix, '%s.matrixIn[1]' %sMultMatrixCls)
cmds.setAttr('%s.matrixIn[2]' %sMultMatrixCls, lInverseMatrix, type = 'matrix')
constraints.matrixConnect(sMultMatrixCls, [oCtrlCls.sPasser], 'matrixSum', lSkipTranslate = [], lSkipRotate = [], lSkipScale = ['x', 'y', 'z'], bForce = True)
sCtrlClsEnd = lCtrlClsEnd[i]
oCtrlClsEnd = controls.oControl(sCtrlClsEnd)
sMultMatrixClsEnd = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = oCtrlClsEnd.sSide, sPart = '%sMatrixOutput' %oCtrlClsEnd.sPart, iIndex = oCtrlClsEnd.iIndex).sName)
lMatrix = apiUtils.getLocalMatrixInNode(oCtrlClsEnd.sPasser, oCtrlOffset.sName, sNodeAttr = 'worldMatrix[0]', sParentAttr = 'worldMatrix[0]')
lInverseMatrix = cmds.getAttr('%s.inverseMatrix' %oCtrlClsEnd.sZero)
cmds.setAttr('%s.matrixIn[0]' %sMultMatrixClsEnd, lMatrix, type = 'matrix')
cmds.connectAttr('%s.matrixSum' %sMultMatrix, '%s.matrixIn[1]' %sMultMatrixClsEnd)
cmds.setAttr('%s.matrixIn[2]' %sMultMatrixClsEnd, lInverseMatrix, type = 'matrix')
constraints.matrixConnect(sMultMatrixClsEnd, [oCtrlClsEnd.sPasser], 'matrixSum', lSkipTranslate = [], lSkipRotate = [], lSkipScale = ['x', 'y', 'z'], bForce = True)
##### mid cls connect
iNum = len(self._lCtrls[2:]) - 1
#### get top bot local translate
lMinusTranslate = []
for i, sMatrix in enumerate(lMultMatrix):
oNameMatrix = naming.oName(sMatrix)
sGrpBend = lGrpBend[i][-1].sName
oNameGrp = naming.oName(sGrpBend)
oNameMatrix.sType = 'decomposeMatrix'
oNameGrp.sType = 'decomposeMatrix'
sDecomposeMatrix_ctrl = cmds.createNode('decomposeMatrix', name = oNameMatrix.sName)
sDecomposeMatrix_grp = cmds.createNode('decomposeMatrix', name = oNameGrp.sName)
cmds.connectAttr('%s.matrixSum' %sMatrix, '%s.inputMatrix' %sDecomposeMatrix_ctrl)
cmds.connectAttr('%s.matrixOutputBend' %sGrpBend, '%s.inputMatrix' %sDecomposeMatrix_grp)
oNameMatrix.sType = 'plusMinusAverage'
oNameMatrix.sPart = '%sLocalTranslate' %oNameMatrix.sPart
sMinus = cmds.createNode('plusMinusAverage', name = oNameMatrix.sName)
cmds.setAttr('%s.operation' %sMinus, 2)
cmds.connectAttr('%s.outputTranslate' %sDecomposeMatrix_ctrl, '%s.input3D[0]' %sMinus)
cmds.connectAttr('%s.outputTranslate' %sDecomposeMatrix_grp, '%s.input3D[1]' %sMinus)
lMinusTranslate.append(sMinus)
for i, sCtrlCls in enumerate(self._lCtrls[2:iNum + 1]):
oCtrlCls = controls.oControl(sCtrlCls)
sAddMatrix = cmds.createNode('addMatrix', name = naming.oName(sType = 'addMatrix', sSide = oCtrlCls.sSide, sPart = '%sMatrixBend' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
sMultMatrixRotCls = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = oCtrlCls.sSide, sPart = '%sMatrixBendRot' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
sMultMatrixCls = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = oCtrlCls.sSide, sPart = '%sMatrixBend' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
cmds.connectAttr('%s.matrixSum' %sAddMatrix, '%s.matrixIn[0]' %sMultMatrixCls)
lInverseMatrix = cmds.getAttr('%s.inverseMatrix' %oCtrlCls.sZero)
cmds.setAttr('%s.matrixIn[1]' %sMultMatrixCls, lInverseMatrix, type = 'matrix')
fWeight = (i + 1) / float(iNum)
sPlus = cmds.createNode('plusMinusAverage', name = naming.oName(sType = 'plusMinusAverage', sSide = oCtrlCls.sSide, sPart = '%sTranslateOutput' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
for j, sPos in enumerate(lCtrlBendName):
sMult = cmds.createNode('multiplyDivide', name = naming.oName(sType = 'multiplyDivide', sSide = oCtrlCls.sSide, sPart = '%s%sTranslate' %(oCtrlCls.sPart, sPos), iIndex = oCtrlCls.iIndex).sName)
if sPos == 'Top':
sGrpBend = lGrpBend[j][i + 1].sName
for sAxis in ['X', 'Y', 'Z']:
cmds.setAttr('%s.input2%s' %(sMult, sAxis), fWeight)
else:
sGrpBend = lGrpBend[j][-i - 2].sName
for sAxis in ['X', 'Y', 'Z']:
cmds.setAttr('%s.input2%s' %(sMult, sAxis), 1-fWeight)
cmds.connectAttr('%s.matrixOutputBend' %sGrpBend, '%s.matrixIn[%d]' %(sAddMatrix, j))
cmds.connectAttr('%s.matrixOutputBend' %sGrpBend, '%s.matrixIn[%d]' %(sMultMatrixRotCls, j))
cmds.connectAttr('%s.output3D' %lMinusTranslate[j], '%s.input1' %sMult)
cmds.connectAttr('%s.output' %sMult, '%s.input3D[%d]' %(sPlus, j))
sDecomposeMatrix = cmds.createNode('decomposeMatrix', name = naming.oName(sType = 'decomposeMatrix', sSide = oCtrlCls.sSide, sPart = '%sMatrixBend' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
cmds.connectAttr('%s.matrixSum' %sMultMatrixCls, '%s.inputMatrix' %sDecomposeMatrix)
cmds.connectAttr('%s.outputTranslate' %sDecomposeMatrix, '%s.input3D[2]' %sPlus)
sDecomposeMatrixRot = cmds.createNode('decomposeMatrix', name = naming.oName(sType = 'decomposeMatrix', sSide = oCtrlCls.sSide, sPart = '%sMatrixBendRot' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
cmds.connectAttr('%s.matrixSum' %sMultMatrixRotCls, '%s.inputMatrix' %sDecomposeMatrixRot)
sQuatToEuler = cmds.createNode('quatToEuler', name = naming.oName(sType = 'quatToEuler', sSide = oCtrlCls.sSide, sPart = '%sMatrixBend' %oCtrlCls.sPart, iIndex = oCtrlCls.iIndex).sName)
cmds.connectAttr('%s.outputQuat' %sDecomposeMatrixRot, '%s.inputQuat' %sQuatToEuler)
cmds.connectAttr('%s.ro' %oCtrlCls.sPasser, '%s.inputRotateOrder' %sQuatToEuler)
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr('%s.output3D%s' %(sPlus, sAxis.lower()), '%s.translate%s' %(oCtrlCls.sPasser, sAxis))
cmds.connectAttr('%s.outputRotate%s' %(sQuatToEuler, sAxis), '%s.rotate%s' %(oCtrlCls.sPasser, sAxis))
#### twist matrix connect
lMultMatrixTwist = []
for i, sPos in enumerate(['Top', 'Bot']):
sMultMatrixTwist = cmds.createNode('multMatrix', name = naming.oName(sType = 'multMatrix', sSide = self._sSide, sPart = '%sMatrixTwist%s' %(self._sName, sPos), iIndex = self._iIndex).sName)
lMatrix = apiUtils.getLocalMatrixInNode([self._lJnts[-1], self._lJnts[0]][i], [oCtrlTop, oCtrlBot][i].sName)
cmds.setAttr('%s.matrixIn[0]' %sMultMatrixTwist, lMatrix, type = 'matrix')
cmds.connectAttr('%s.matrixOutputWorld' %[oCtrlOffset_top, oCtrlOffset_bot][i].sName, '%s.matrixIn[1]' %sMultMatrixTwist)
cmds.connectAttr('%s.matrixOutputWorld' %[oCtrlTop, oCtrlBot][i].sName, '%s.matrixIn[2]' %sMultMatrixTwist)
cmds.connectAttr('%s.matrix' %[sGrp_topRvs, sGrp_botRvs][i], '%s.matrixIn[3]' %sMultMatrixTwist)
cmds.connectAttr('%s.matrix' %[sGrp_topRvsZero, sGrp_botRvsZero][i], '%s.matrixIn[4]' %sMultMatrixTwist)
lMultMatrixTwist.append(sMultMatrixTwist)
cmds.setAttr('%s.dTwistControlEnable' %self._sIkHnd, 1)
cmds.setAttr('%s.dWorldUpType' %self._sIkHnd, 4)
for i, sMultMatrixTwist in enumerate(lMultMatrixTwist):
cmds.connectAttr('%s.matrixSum' %sMultMatrixTwist, '%s.%s' %(self._sIkHnd, ['dWorldUpMatrixEnd', 'dWorldUpMatrix'][i]))
## hide controls
for sCtrl in [self._lCtrls[0], self._lCtrls[1], self._lCtrls[-2], self._lCtrls[-1]]:
oCtrl = controls.oControl(sCtrl)
cmds.setAttr('%s.v' %oCtrl.sZero, 0, lock = True)
sCtrlShape = naming.oName(sType = 'ctrl', sSide = self._sSide, sPart = self._sName, iIndex = self._iIndex).sName
lCtrls = [oCtrlTop, oCtrlBot, oCtrlOffset_top, oCtrlOffset_bot] + lGrpBend_top + lGrpBend_bot
lCtrlsName = []
for oCtrl in lCtrls:
lCtrlsName.append(oCtrl.sName)
lCtrlsName += self._lCtrls[2: len(self._lCtrls) - 2]
controls.addCtrlShape(lCtrlsName, sCtrlShape, bVis = False)
for i, sPos in enumerate(lCtrlBendName):
cmds.addAttr(sCtrlShape, ln = '%sBendCtrlVis' %sPos.lower(), at = 'long', min = 0, max = 1, keyable = False)
cmds.setAttr('%s.%sBendCtrlVis' %(sCtrlShape, sPos.lower()), channelBox = True)
for oCtrl in lGrpBend[i]:
cmds.connectAttr('%s.%sBendCtrlVis' %(sCtrlShape, sPos.lower()), '%s.v' %oCtrl.sZero)
cmds.addAttr(sCtrlShape, ln = 'tweakCtrlVis', at = 'long', min = 0, max = 1, keyable = False)
cmds.setAttr('%s.tweakCtrlVis' %sCtrlShape, channelBox = True)
for sCtrl in self._lCtrls[2: len(self._lCtrls) - 2]:
oCtrl = controls.oControl(sCtrl)
cmds.connectAttr('%s.tweakCtrlVis' %sCtrlShape, '%s.v' %oCtrl.sZero)
for i, sCtrl in enumerate([oCtrlTop.sName, oCtrlBot.sName]):
oCtrlOffset = [oCtrlOffset_top, oCtrlOffset_bot][i]
cmds.addAttr(sCtrl, ln = 'offsetCtrlVis', at = 'long', min = 0, max = 1, keyable = False)
cmds.setAttr('%s.offsetCtrlVis' %sCtrl, channelBox = True)
cmds.connectAttr('%s.offsetCtrlVis' %sCtrl, '%s.v' %oCtrlOffset.sZero)
## write component info
self._writeGeneralComponentInfo('baseFkOnIkSplineLimb', self._lJnts, lCtrlsName, self._lBindJnts, self._lBindRootJnts)
self._getComponentInfo(self._sComponentMaster)
def createComponent(self):
super(baseIkSCsolverLimb, self).createComponent()
sParent_jnt = self._sComponentJoints
sParent_ctrl = self._sComponentControls
lJnts = []
lCtrls = []
lBindJnts = []
## controls
oCtrlRoot = controls.create(
'%sRoot' % self._sName,
sSide=self._sSide,
iIndex=self._iIndex,
iStacks=self._iStacks,
bSub=True,
sParent=self._sComponentControls,
sPos=self._lBpJnts[0],
sShape='cube',
fSize=8,
lLockHideAttrs=['rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'])
lCtrls.append(oCtrlRoot.sName)
oCtrlAim = controls.create('%sAim' % self._sName,
sSide=self._sSide,
iIndex=self._iIndex,
iStacks=self._iStacks,
bSub=True,
sParent=self._sComponentControls,
sPos=self._lBpJnts[-1],
sShape='cube',
fSize=8,
lLockHideAttrs=['sx', 'sy', 'sz', 'v'])
lCtrls.append(oCtrlAim.sName)
## put ik joint chain locally
sGrp_ikJnts = transforms.createTransformNode(
naming.oName(sType='group',
sSide=self._sSide,
sPart='%sSCJointsLocal' % self._sName,
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=self._sComponentRigNodesWorld)
sParent_jntLocal = sGrp_ikJnts
lJntsLocal = []
lJntsLocal, lBindJnts = createDriveJoints.createDriveJoints(
self._lBpJnts,
sParent=sGrp_ikJnts,
sSuffix='IkSCLocal',
bBind=False)
## stretch
if self._bStretch:
## add stretch attr
attributes.addDivider([oCtrlAim.sName], 'stretch')
cmds.addAttr(oCtrlAim.sName,
ln='limitFactorPos',
at='float',
min=1,
dv=self._lLimitFactor[1],
keyable=True)
cmds.addAttr(oCtrlAim.sName,
ln='limitFactorNeg',
at='float',
min=0,
max=1,
dv=self._lLimitFactor[0],
keyable=True)
cmds.addAttr(oCtrlAim.sName,
ln='factorYPos',
at='float',
min=0,
dv=self._lFactorY[1],
keyable=True)
cmds.addAttr(oCtrlAim.sName,
ln='factorZPos',
at='float',
min=0,
dv=self._lFactorZ[1],
keyable=True)
cmds.addAttr(oCtrlAim.sName,
ln='factorYNeg',
at='float',
min=0,
dv=self._lFactorY[0],
keyable=True)
cmds.addAttr(oCtrlAim.sName,
ln='factorZNeg',
at='float',
min=0,
dv=self._lFactorZ[0],
keyable=True)
cmds.addAttr(oCtrlAim.sName, ln='stretchLengthOrig', at='float')
sGrp_stretch = transforms.createTransformNode(
naming.oName(sType='group',
sSide=self._sSide,
sPart='%sSCJointStretch' % self._sName,
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=self._sComponentRigNodesWorld)
## distance measure
sDistance = cmds.createNode('distanceBetween',
name=naming.oName(
sType='distanceBetween',
sSide=self._sSide,
sPart='%sStretch' % self._sName,
iIndex=self._iIndex).sName)
sNullRoot = transforms.createTransformNode(naming.oName(
sType='null',
sSide=self._sSide,
sPart='%sRootStretch' % self._sName,
iIndex=self._iIndex).sName,
sPos=oCtrlRoot.sName,
sParent=sGrp_stretch)
sNullAim = transforms.createTransformNode(naming.oName(
sType='null',
sSide=self._sSide,
sPart='%sAimStretch' % self._sName,
iIndex=self._iIndex).sName,
sPos=oCtrlAim.sName,
sParent=sGrp_stretch)
constraints.matrixConnect(oCtrlRoot.sName, [sNullRoot],
'matrixOutputWorld',
lSkipRotate=['X', 'Y', 'Z'],
lSkipScale=['X', 'Y', 'Z'])
constraints.matrixConnect(oCtrlAim.sName, [sNullAim],
'matrixOutputWorld',
lSkipRotate=['X', 'Y', 'Z'],
lSkipScale=['X', 'Y', 'Z'])
cmds.connectAttr('%s.t' % sNullRoot, '%s.point1' % sDistance)
cmds.connectAttr('%s.t' % sNullAim, '%s.point2' % sDistance)
fDis = cmds.getAttr('%s.distance' % sDistance)
cmds.setAttr('%s.stretchLengthOrig' % oCtrlAim.sName,
fDis,
lock=True)
sDivide = cmds.createNode(
'multiplyDivide',
name=naming.oName(sType='multiplyDivide',
sSide=self._sSide,
sPart='%sStretchFactor' % self._sName,
iIndex=self._iIndex).sName)
cmds.setAttr('%s.operation' % sDivide, 2)
cmds.connectAttr('%s.distance' % sDistance, '%s.input1X' % sDivide)
cmds.connectAttr('%s.stretchLengthOrig' % oCtrlAim.sName,
'%s.input2X' % sDivide)
sConditionStretchOutput = cmds.createNode(
'condition',
name=naming.oName(sType='condition',
sSide=self._sSide,
sPart='%sStretchOutput' % self._sName,
iIndex=self._iIndex).sName)
cmds.connectAttr('%s.outputX' % sDivide,
'%s.firstTerm' % sConditionStretchOutput)
cmds.setAttr('%s.secondTerm' % sConditionStretchOutput, 1)
cmds.setAttr('%s.operation' % sConditionStretchOutput, 2)
sConditionStretchPos = cmds.createNode(
'condition',
name=naming.oName(sType='condition',
sSide=self._sSide,
sPart='%sStretchPos' % self._sName,
iIndex=self._iIndex).sName)
cmds.connectAttr('%s.outputX' % sDivide,
'%s.firstTerm' % sConditionStretchPos)
cmds.connectAttr('%s.limitFactorPos' % oCtrlAim.sName,
'%s.secondTerm' % sConditionStretchPos)
cmds.setAttr('%s.operation' % sConditionStretchPos, 4)
cmds.connectAttr('%s.outputX' % sDivide,
'%s.colorIfTrueR' % sConditionStretchPos)
cmds.connectAttr('%s.limitFactorPos' % oCtrlAim.sName,
'%s.colorIfFalseR' % sConditionStretchPos)
cmds.connectAttr('%s.outColorR' % sConditionStretchPos,
'%s.colorIfTrueR' % sConditionStretchOutput)
sConditionStretchNeg = cmds.createNode(
'condition',
name=naming.oName(sType='condition',
sSide=self._sSide,
sPart='%sStretchNeg' % self._sName,
iIndex=self._iIndex).sName)
cmds.connectAttr('%s.outputX' % sDivide,
'%s.firstTerm' % sConditionStretchNeg)
cmds.connectAttr('%s.limitFactorNeg' % oCtrlAim.sName,
'%s.secondTerm' % sConditionStretchNeg)
cmds.setAttr('%s.operation' % sConditionStretchNeg, 2)
cmds.connectAttr('%s.outputX' % sDivide,
'%s.colorIfTrueR' % sConditionStretchNeg)
cmds.connectAttr('%s.limitFactorNeg' % oCtrlAim.sName,
'%s.colorIfFalseR' % sConditionStretchNeg)
cmds.connectAttr('%s.outColorR' % sConditionStretchNeg,
'%s.colorIfFalseR' % sConditionStretchOutput)
for i, lFactors in enumerate([self._lFactorY, self._lFactorZ]):
sAxis = ['Y', 'Z'][i]
sRemapPos = cmds.createNode(
'remapValue',
name=naming.oName(sType='remapValue',
sSide=self._sSide,
sPart='%sStretch%sPos' %
(self._sName, sAxis),
iIndex=self._iIndex).sName)
sRemapNeg = cmds.createNode(
'remapValue',
name=naming.oName(sType='remapValue',
sSide=self._sSide,
sPart='%sStretch%sNeg' %
(self._sName, sAxis),
iIndex=self._iIndex).sName)
cmds.connectAttr('%s.outputX' % sDivide,
'%s.inputValue' % sRemapPos)
cmds.connectAttr('%s.outputX' % sDivide,
'%s.inputValue' % sRemapNeg)
cmds.setAttr('%s.inputMin' % sRemapPos, 1)
cmds.connectAttr('%s.limitFactorPos' % oCtrlAim.sName,
'%s.inputMax' % sRemapPos)
cmds.connectAttr('%s.limitFactorNeg' % oCtrlAim.sName,
'%s.inputMin' % sRemapNeg)
cmds.setAttr('%s.inputMax' % sRemapNeg, 1)
cmds.setAttr('%s.outputMin' % sRemapPos, 1)
cmds.setAttr('%s.outputMax' % sRemapNeg, 1)
cmds.connectAttr('%s.factor%sPos' % (oCtrlAim.sName, sAxis),
'%s.outputMax' % sRemapPos)
cmds.connectAttr('%s.factor%sNeg' % (oCtrlAim.sName, sAxis),
'%s.outputMin' % sRemapNeg)
cmds.connectAttr(
'%s.outValue' % sRemapPos, '%s.colorIfTrue%s' %
(sConditionStretchOutput, ['G', 'B'][i]))
cmds.connectAttr(
'%s.outValue' % sRemapNeg, '%s.colorIfFalse%s' %
(sConditionStretchOutput, ['G', 'B'][i]))
sMultStretchX = cmds.createNode(
'multDoubleLinear',
name=naming.oName(sType='multDoubleLinear',
sSide=self._sSide,
sPart='%sStretchX' % self._sName,
iIndex=self._iIndex).sName)
cmds.connectAttr('%s.stretchLengthOrig' % oCtrlAim.sName,
'%s.input1' % sMultStretchX)
cmds.connectAttr('%s.outColorR' % sConditionStretchOutput,
'%s.input2' % sMultStretchX)
cmds.connectAttr('%s.output' % sMultStretchX,
'%s.tx' % lJntsLocal[-1])
cmds.connectAttr('%s.outColorG' % sConditionStretchOutput,
'%s.sy' % lJntsLocal[0])
cmds.connectAttr('%s.outColorB' % sConditionStretchOutput,
'%s.sz' % lJntsLocal[0])
lJnts, lBindJnts = createDriveJoints.createDriveJoints(
self._lBpJnts,
sParent=self._sComponentJoints,
sSuffix='IkSC',
bBind=self._bBind)
for i, sJntLocal in enumerate(lJntsLocal):
for sAxis in ['X', 'Y', 'Z']:
cmds.connectAttr('%s.translate%s' % (sJntLocal, sAxis),
'%s.translate%s' % (lJnts[i], sAxis))
cmds.connectAttr('%s.rotate%s' % (sJntLocal, sAxis),
'%s.rotate%s' % (lJnts[i], sAxis))
cmds.connectAttr('%s.scale%s' % (sJntLocal, sAxis),
'%s.scale%s' % (lJnts[i], sAxis))
## ik handles
sIkHnd = naming.oName(sType='ikHandle',
sSide=self._sSide,
sPart='%sSCsolver' % self._sName,
iIndex=self._iIndex).sName
cmds.ikHandle(sj=lJntsLocal[0],
ee=lJntsLocal[-1],
sol='ikSCsolver',
name=sIkHnd)
#### offset group
sGrpIk = transforms.createTransformNode(
naming.oName(sType='group',
sSide=self._sSide,
sPart='%sSCsolverOffset' % self._sName,
iIndex=self._iIndex).sName,
lLockHideAttrs=[
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
],
sParent=self._sComponentRigNodesWorld,
sPos=oCtrlAim.sName)
cmds.parent(sIkHnd, sGrpIk)
#### matrix connect
constraints.matrixConnect(oCtrlAim.sName, [sGrpIk],
'matrixOutputWorld',
lSkipScale=['X', 'Y', 'Z'],
bForce=True)
constraints.matrixConnect(oCtrlRoot.sName, [lJnts[0]],
'matrixOutputWorld',
lSkipRotate=['X', 'Y', 'Z'],
lSkipScale=['X', 'Y', 'Z'],
bForce=True)
## pass info to class
self._lJnts = lJnts
self._lCtrls = lCtrls
self._lBindJnts = lBindJnts
self._sGrpIk = sGrpIk
self._sIkHnd = sIkHnd
self._lJntslocal = lJntsLocal
if lBindJnts:
self._lBindRootJnts = [lBindJnts[0]]
else:
self._lBindRootJnts = None
## write component info
self._writeGeneralComponentInfo('baseIkSCsolverLimb', lJnts, lCtrls,
lBindJnts, self._lBindRootJnts)
## 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)