def eyeCtlSet(self):
self.eyeLCtl = rigbase.Controler(n='EyeAim_L_CTL')
self.eyeRCtl = rigbase.Controler(n='EyeAim_R_CTL')
self.eyeCtl = rigbase.Controler(n='Eye_CTL')
self.eyeLCtl.setShape(normal=[0, 0, 1], radius=.2)
self.eyeRCtl.setShape(normal=[0, 0, 1], radius=.2)
self.eyeCtl.setShape(normal=[0, 0, 1], radius=1)
self.eyeLCtl.setParent(self.eyeCtl)
self.eyeRCtl.setParent(self.eyeCtl)
self.eyeCtl.setParent(self.headCtl)
self.eyeLCtl.setColor(13)
self.eyeRCtl.setColor(6)
self.eyeCtl.setColor(23)
attrEdit = rigbase.AttrEdit(self.eyeLCtl.name, self.eyeRCtl.name)
attrEdit.lockAndHideAttrs('rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v')
attrEdit = rigbase.AttrEdit(self.eyeCtl.name)
attrEdit.lockAndHideAttrs('sx', 'sy', 'sz', 'v')
rigbase.addHelpTx(self.eyeCtl.name, 'Follow')
attrEdit.addAttr(ln='chestFollow', min=0, max=10, k=1)
attrEdit.addAttr(ln='rootFollow', min=0, max=10, k=1)
attrEdit.addAttr(ln='flyFollow', min=0, max=10, k=1)
attrEdit.addAttr(ln='moveFollow', min=0, max=10)
def controlSet(self):
self.rootCtl, self.rootCtlGrp = rigbase.putControler( self.rootInit, n= self.rootInit.replace( 'Init', 'CTL' ), typ='box', size=[2.5,.1,2.2] )
self.flyCtl, self.flyCtlGrp = rigbase.putControler( self.rootCtl, n=self.rootCtl.replace( 'Root', 'Fly' ), typ='fly', size=[1.2,1,1.8], orient=[90,0,0], offset=[0,0.2,-2.6] )
self.hipCtl , self.hipCtlGrp = rigbase.putControler( self.rootCtl, n= self.rootCtl.replace( 'Root', 'Hip' ), typ='quadrangle', size=[1.5,1.5,1.5], orient=[0,45,0] )
self.torsoCtl , self.torsoCtlGrp = rigbase.putControler( self.rootCtl, n= self.rootCtl.replace( 'Root', 'TorsoRotate' ), typ='bar', size=[1.5,.7,.7], orient=[90,0,0] )
self.waistCtl, self.waistCtlGrp = rigbase.putControler( self.waistInit, n= self.waistInit.replace( 'Init', 'CTL' ), normal=[0,1,0], r=1.5 )
self.chestCtl, self.chestCtlGrp = rigbase.putControler( self.chestInit, n= self.chestInit.replace( 'Init', 'CTL' ), typ='box', size=[1.5,.3,1.5] )
self.chestMoveCtl, self.chestMoveCtlGrp = rigbase.putControler( self.chestInit, n= self.chestCtl.replace( 'Chest_CTL', 'ChestMove_CTL' ), normal=[0,0,1], center=[0,0,2.5], r=.5 )
self.collarLCtl, self.collarLCtlGrp = rigbase.putControler( self.collarLInit, n=self.collarLInit.replace( 'Init', 'CTL' ), normal=[1,0,0], r=1 )
self.collarRCtl, self.collarRCtlGrp = rigbase.putControler( self.collarRInit, n=self.collarRInit.replace( 'Init', 'CTL' ), normal=[1,0,0], r=1 )
self.shoulderLCtl, self.shoulderLCtlGrp = rigbase.putControler( self.shoulderLInit, n=self.shoulderLInit.replace( 'Init', 'CTL' ), typ='pin', orient=[0,0,-30], size=[.6,.6,.6] )
self.shoulderRCtl, self.shoulderRCtlGrp = rigbase.putControler( self.shoulderRInit, n=self.shoulderRInit.replace( 'Init', 'CTL' ), typ='pin', orient=[0,0,-30], size=[-.6,-.6,-.6] )
self.rootGrp = cmds.createNode( 'transform', n='Root_GRP' )
rigbase.constraint( self.rootCtl, self.rootGrp, s=1, sh=1 )
torsoGrp = cmds.createNode( 'transform', n= 'torso_GRP' )
#waistCtlPointObj = cmds.createNode( 'transform', n=self.waistInit.replace( 'Init', 'CtlPoint' ) )
rigbase.AttrEdit( torsoGrp, self.torsoCtl ).lockAndHideAttrs( 'tx', 'ty','tz', 'sx', 'sy','sz', 'v' )
rigbase.AttrEdit( self.flyCtl, self.rootCtl, self.hipCtl, self.waistCtl, self.chestCtl, self.chestMoveCtl, self.collarLCtl, self.collarRCtl ).lockAndHideAttrs( 'sx', 'sy','sz','v' )
rigbase.AttrEdit( self.shoulderLCtl, self.shoulderRCtl ).lockAndHideAttrs( 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' )
cmds.parent( self.shoulderLCtlGrp, self.collarLCtl )
cmds.parent( self.shoulderRCtlGrp, self.collarRCtl )
cmds.parent( self.collarLCtlGrp , self.collarRCtlGrp, self.chestMoveCtl )
cmds.parent( self.chestMoveCtlGrp, self.chestCtl )
cmds.parent( self.chestCtlGrp, self.torsoCtl )
cmds.parent( self.waistCtlGrp, torsoGrp )
cmds.parent( torsoGrp, self.torsoCtlGrp, self.hipCtlGrp, self.rootGrp )
cmds.setAttr( self.shoulderLCtlGrp+'.r', 0,0,0 )
cmds.setAttr( self.shoulderRCtlGrp+'.r', 0,0,0 )
rigbase.connectSameAttr( self.rootInit, self.flyCtlGrp ).doIt( 't', 'r' )
rigbase.connectSameAttr( self.torsoCtl, torsoGrp ).doIt( 'r' )
#rigbase.connectSameAttr( self.waistInit, waistCtlPointObj ).doIt( 't' )
#rigbase.connectSameAttr( self.waistInit, self.waistCtlGrp ).doIt( 't', 'r' )
#rigbase.connectSameAttr( self.chestInit, self.chestCtlGrp ).doIt( 't', 'r' )
rigbase.connectSameAttr( self.collarLInit, self.collarLCtlGrp ).doIt( 't', 'r' )
rigbase.connectSameAttr( self.collarRInit, self.collarRCtlGrp ).doIt( 't', 'r' )
rigbase.connectSameAttr( self.shoulderLInit, self.shoulderLCtlGrp ).doIt( 't' )
rigbase.connectSameAttr( self.shoulderRInit, self.shoulderRCtlGrp ).doIt( 't' )
#rigbase.constraint( self.waistCtl, waistCtlPointObj, t=0 )
rigbase.followAdd( self.flyCtl, self.rootCtlGrp )
cmds.parent( self.rootCtlGrp, self.flyCtlGrp, self.rigInstance.moveCtl )
cmds.parent( self.rootGrp, self.rigInstance.worldCtl )
self.rigInstance.collarLCtl = self.collarLCtl
self.rigInstance.collarRCtl = self.collarRCtl
self.rigInstance.chestCtl = self.chestCtl
self.rigInstance.chestMoveCtl = self.chestMoveCtl
self.rigInstance.waistCtl = self.waistCtl
self.rigInstance.torsoCtl = self.torsoCtl
self.rigInstance.hipCtl = self.hipCtl
self.rigInstance.flyCtl = self.flyCtl
self.rigInstance.rootCtl = self.rootCtl
self.rigInstance.rootGrp = self.rootGrp
def doIt(self):
self.torsoPart = TorsoInitCtlRig(initCtlNameList)
self.headPart = HeadInitCtlRig(initCtlNameList)
self.armPart = ArmInitCtlRig(initCtlNameList)
self.legPart = LegInitCtlRig(initCtlNameList)
self.fingerPart = FingerInitCtlRig(initCtlNameList)
self.torsoPart.rigAll()
self.headPart.rigAll()
self.armPart.rigAll()
self.legPart.rigAll()
self.fingerPart.rigAll()
self.initAllCtl = cmds.circle(normal=[0, 1, 0],
radius=7,
n='All_InitCTL')[0]
cmds.setAttr(self.initAllCtl + '.dh', 1)
rigbase.addParent(self.initAllCtl)
rigbase.connectSameAttr(self.initAllCtl,
self.initJntsGrp).doIt('t', 'r')
for initCtlName in initCtlNameList:
if not cmds.listRelatives(initCtlName, p=1):
cmds.parent(initCtlName, self.initAllCtl)
self.initJointSet()
cmds.parent(self.torsoInitJnts[0], self.initJntsGrp)
rigbase.transformSetColor(self.torsoInitJnts[0], 22)
cmds.select(self.torsoInitJnts[0], hi=1)
for sel in cmds.ls(sl=1):
cmds.setAttr(sel + '.radius', 0)
cmds.select(self.initAllCtl)
INIT = cmds.group(em=1, n='INIT')
cmds.parent('All_InitJnt', 'All_InitCTL_GRP', INIT)
self.rObj = cmds.createNode('multDoubleLinear',
n='RightClickObj_Inits')
attrEdit = rigbase.AttrEdit(self.rObj)
attrEdit.addAttr(ln='originalName', dt='string')
cmds.setAttr(self.rObj + '.originalName', self.rObj, type='string')
for initCtl in cmds.ls('*_InitCTL'):
attrEdit.addAttr(ln=initCtl, at='message')
cmds.connectAttr(initCtl + '.message', self.rObj + '.' + initCtl)
rigbase.AttrEdit('All_InitCTL').addAttr(ln=self.rObj, at='message')
cmds.connectAttr(self.rObj + '.message', 'All_InitCTL.' + self.rObj)
def connect( self, sels, *args ):
worldCtl = None
bjtWorld = None
for sel in sels:
if sel.find( 'BJT_World' ) != -1:
bjtWorld = sel
elif sel.find( 'World_CTL' ) != -1:
worldCtl = sel
if not bjtWorld or not worldCtl:
return None
bjtWorldGrp, bjtWorld, rootBjtGrp = self.getInputsGrp( bjtWorld )
worldCtlGrp, worldCtl, rootGrp = self.getOutputsGrp( worldCtl )
bjtNamespace = self.getNamespace( bjtWorld )
rjtNamespace = self.getNamespace( worldCtl )
rigbase.connectSameAttr( worldCtlGrp, bjtWorldGrp ).doIt( 't', 'r','s' )
rigbase.connectSameAttr( worldCtl, bjtWorld ).doIt( 't', 'r','s' )
#cmds.connectAttr( worldCtl+'.message', bjtWorld+'.World_CTL' )
rigbase.connectSameAttr( rootGrp, rootBjtGrp ).doIt( 't', 'r' )
bjts = self.getBjts( bjtWorld )
try:
attrEdit = rigbase.AttrEdit( worldCtl )
attrEdit.addAttr( ln=bjtNamespace.replace( ':', '' ), at='long', cb=1, min=0, max=1 )
except: pass
try:
bjtWorldShape = cmds.listRelatives( bjtWorld, s=1 )[0]
cmds.connectAttr( worldCtl+'.'+bjtNamespace.replace( ':', '' ), bjtWorldShape+'.v' )
except: pass
for bjt in bjts:
rjt = bjt.replace( '_BJT', '_RJT' )
if not bjtNamespace:
rjt = rjtNamespace + rjt
else:
rjt = rjt.replace( bjtNamespace, rjtNamespace )
if not cmds.objExists( rjt ):continue
cmds.connectAttr( rjt+'.t', bjt+'.t' )
cmds.connectAttr( rjt+'.r', bjt+'.r' )
cmds.connectAttr( rjt+'.s', bjt+'.s' )
if rjt.find( 'Leg_L_Lower4' ) != -1 or rjt.find( 'Leg_R_Lower4' ) != -1:
cmds.connectAttr( rjt+'.sh', bjt+'.sh' )
try:
cmds.connectAttr( rjt+'.jo', bjt+'.jo' )
except: pass
try:
cmds.setAttr( bjt+'.jo', 0,0,0 )
except: pass
if cmds.attributeQuery( 'parameter', node=bjt, ex=1 ):
cmds.connectAttr( bjt+'.parameter', rjt+'.parameter', f=1 )
def connectCurve(self, crvShape):
if cmds.nodeType(crvShape) == 'transform':
crvShape = cmds.listRelatives(crvShape, s=1)[0]
crv = cmds.listRelatives(crvShape, p=1)[0]
spci = cmds.createNode('splineCurveInfo', n='Neck_Spline_Crv_Spci')
cmds.connectAttr(crvShape + '.local', spci + '.inputCurve')
cmds.setAttr(spci + '.sua', 2)
cmds.setAttr(spci + '.eua', 2)
cmds.setAttr(spci + '.taa', 1)
cmds.setAttr(spci + '.tua', 2)
for rjt in self.rjts[0:-1]:
i = self.rjts.index(rjt)
paramValue = (i + .0001) / (len(self.rjts) - 1)
rigbase.AttrEdit(rjt).addAttr(ln='parameter',
min=0,
max=1,
k=1,
dv=paramValue)
cmds.connectAttr(rjt + '.parameter', spci + '.parameter[%d]' % i)
point = cmds.createNode('transform', n='NeckSpline_point%d' % i)
cmds.parent(point, crv)
cmds.connectAttr(spci + '.output[%d].position' % i, point + '.t')
cmds.connectAttr(spci + '.output[%d].rotate' % i, point + '.r')
rigbase.constraint(point, rjt)
self.spci = spci
def neckMiddleCtlSet(self):
self.neckMiddleCtl = rigbase.Controler(n='NeckMiddle_CTL')
self.neckMiddleCtl.setShape(normal=[0, 1, 0], radius=.5)
self.neckMiddleCtl.setColor(29)
self.middlePoint1 = rigbase.Transform(n='NeckMiddle_spline_Point1')
self.middlePoint2 = rigbase.Transform(n='NeckMiddle_spline_Point2')
self.middlePoint1.setParent(self.neckMiddleCtl)
self.middlePoint2.setParent(self.neckMiddleCtl)
rigbase.transformDefault(self.middlePoint1, self.middlePoint2)
midPnt1Dist = cmds.createNode('distanceBetween',
n='NeckMiddle_spPnt1_dist')
midPnt2Dist = cmds.createNode('distanceBetween',
n='NeckMiddle_spPnt2_dist')
midMult1Dist = cmds.createNode('multDoubleLinear', n='NeckMiddle_md1')
midMult2Dist = cmds.createNode('multDoubleLinear', n='NeckMiddle_md2')
cmds.setAttr(midMult1Dist + '.input2', -.4)
cmds.setAttr(midMult2Dist + '.input2', .4)
cmds.connectAttr(self.neckMiddleInit + '.m',
midPnt1Dist + '.inMatrix1')
cmds.connectAttr(self.headInit + '.m', midPnt2Dist + '.inMatrix2')
cmds.connectAttr(midPnt1Dist + '.distance', midMult1Dist + '.input1')
cmds.connectAttr(midPnt2Dist + '.distance', midMult2Dist + '.input1')
cmds.connectAttr(midMult1Dist + '.output', self.middlePoint1 + '.ty')
cmds.connectAttr(midMult2Dist + '.output', self.middlePoint2 + '.ty')
attrEdit = rigbase.AttrEdit(self.neckMiddleCtl.name)
attrEdit.lockAndHideAttrs('sx', 'sy', 'sz', 'v')
self.rigInstance.neckMiddleCtl = self.neckMiddleCtl.name
def rigAll(self):
neck, neckMiddle, head, eyeL, eyeR, eyeAimPiv = self.HeadInitCtlData.getSortList(
)
aimObject = rigbase.makeAimObject(head,
neck,
axis=1,
replaceTarget='InitCTL',
replace='InitCtl')[0]
aimObject = cmds.rename(aimObject,
aimObject.replace('AimObj', 'AimGrp'))
rigbase.betweenRigInAimObject(neckMiddle,
aimObject,
replaceTarget='InitCTL',
replace='InitCtl')
rigbase.AttrEdit(neckMiddle).lockAttrs('tx')
aimObjectNeck = rigbase.makeAimObject(neckMiddle,
neck,
axis=1,
replaceTarget='InitCTL',
replace='InitCtl')[0]
aimObjectNeckMiddle = rigbase.makeAimObject(head,
neckMiddle,
axis=1,
replaceTarget='InitCTL',
replace='InitCtl')[0]
cmds.parent(eyeL, eyeR, eyeAimPiv, head)
self.outputTransform = [neck, neckMiddle, head, eyeL, eyeR, eyeAimPiv]
def _splineJointUpObjectSet(self):
self.startUp = cmds.createNode( 'transform', n='Torso_Spline_startUp' )
self.endUp = cmds.createNode( 'transform', n='Torso_Spline_endUp' )
rigbase.AttrEdit( self.startUp, self.endUp ).lockAndHideAttrs( 'tx', 'ty','tz', 'sx', 'sy','sz', 'v' )
cmds.parent( self.endUp, self.chestMoveCtl )
cmds.parent( self.startUp, self.hipCtl )
chestDcmp = rigbase.getChildMtxDcmp( self.waistCtl, self.chestMoveCtl )
hipDcmp = rigbase.getChildMtxDcmp( self.waistCtl, self.hipCtl )
ffmChest = cmds.createNode( 'fourByFourMatrix', n= self.chestMoveCtl+'_childPosFFM' )
ffmHip = cmds.createNode( 'fourByFourMatrix', n= self.hipCtl +'_childPosFFM' )
smorChest = cmds.createNode( 'smartOrient', n=self.chestMoveCtl +'_childPosSmtOri' )
smorHip = cmds.createNode( 'smartOrient', n=self.hipCtl +'_childPosSmtOri' )
cmds.setAttr( chestDcmp +'.invt', 1 )
cmds.setAttr( smorChest+'.aimAxis', 1 )
cmds.setAttr( smorHip +'.aimAxis', 1 )
cmds.connectAttr( chestDcmp+'.otx', ffmChest+'.i10' )
cmds.connectAttr( chestDcmp+'.oty', ffmChest+'.i11' )
cmds.connectAttr( chestDcmp+'.otz', ffmChest+'.i12' )
cmds.connectAttr( hipDcmp+ '.otx', ffmHip+ '.i10' )
cmds.connectAttr( hipDcmp+ '.oty', ffmHip+ '.i11' )
cmds.connectAttr( hipDcmp+ '.otz', ffmHip+ '.i12' )
cmds.connectAttr( ffmChest+'.output', smorChest+'.inputMatrix' )
cmds.connectAttr( ffmHip +'.output', smorHip +'.inputMatrix' )
cmds.connectAttr( smorChest+'.oa', self.endUp +'.r' )
cmds.connectAttr( smorHip +'.oa', self.startUp +'.r' )
def twistAttrSet(self, side ):
if side == 'L':
targetCtl = self.shoulderLCtl
elif side == 'R':
targetCtl = self.shoulderRCtl
rigbase.addHelpTx( targetCtl, 'Twist' )
attrEdit = rigbase.AttrEdit( targetCtl )
attrEdit.addAttr( ln='twistCollar', k=1 )
attrEdit.addAttr( ln='twistShoulder', k=1 )
def create(self, inits, grp, colorIndex):
parentTarget = grp
self.ctls = []
for init in inits:
ctl = rigbase.Controler(n=init.replace('Init', 'CTL'))
rigbase.AttrEdit(ctl).lockAndHideAttrs('sx', 'sy', 'sz', 'v')
rigbase.connectSameAttr(init, ctl.transformGrp).doIt('t', 'r')
ctl.setShape(typ='box', size=[.1, .1, .1])
ctl.setColor(colorIndex)
ctl.setParent(parentTarget)
parentTarget = ctl
self.ctls.append(ctl)
def markingMenuSet(rigInstance):
ctls = cmds.ls('*_CTL')
rObj = cmds.createNode('multDoubleLinear', n='RightClickObj_Rigs')
attrEdit = rigbase.AttrEdit(rObj)
attrEdit.addAttr(ln='originalName', dt='string')
cmds.setAttr(rObj + '.originalName', rObj, type='string')
attrEdit = rigbase.AttrEdit(rObj)
for ctl in ctls:
attrEdit.addAttr(ln=ctl, at='message')
cmds.connectAttr(ctl + '.message', rObj + '.' + ctl)
rigbase.AttrEdit('World_CTL').addAttr(ln=rObj, at='message')
cmds.connectAttr(rObj + '.message', 'World_CTL.' + rObj)
bjts = cmds.ls('*_BJT')
bjts.append('BJT_World')
rObj = cmds.createNode('multDoubleLinear', n='RightClickObj_Bjts')
attrEdit = rigbase.AttrEdit(rObj)
attrEdit.addAttr(ln='originalName', dt='string')
cmds.setAttr(rObj + '.originalName', rObj, type='string')
attrEdit = rigbase.AttrEdit(rObj)
for bjt in bjts:
attrEdit.addAttr(ln=bjt, at='message')
cmds.connectAttr(bjt + '.message', rObj + '.' + bjt)
rigbase.AttrEdit('BJT_World').addAttr(ln=rObj, at='message')
cmds.connectAttr(rObj + '.message', 'BJT_World.' + rObj)
def headCtlSet(self):
self.headCtl = rigbase.Controler(n='Head_CTL')
self.headCtl.setShape(normal=[0, 0, 1], radius=1.2, center=[0, .8, 0])
self.headCtl.setColor(30)
attrEdit = rigbase.AttrEdit(self.headCtl.name)
rigbase.addHelpTx(self.headCtl.name, 'Follow')
attrEdit.lockAndHideAttrs('sx', 'sy', 'sz', 'v')
attrEdit.addAttr(ln='neckFollow', min=0, max=10, k=1)
attrEdit.addAttr(ln='chestFollow', min=0, max=10, k=1)
attrEdit.addAttr(ln='rootFollow', min=0, max=10)
attrEdit.addAttr(ln='flyFollow', min=0, max=10, k=1)
attrEdit.addAttr(ln='moveFollow', min=0, max=10)
rigbase.addHelpTx(self.headCtl.name, 'MiddleNeckVis')
attrEdit.addAttr(ln='middleNeckVis', min=0, max=1, at='long', cb=1)
def rigSelf(self):
root, waist, chest = self.torsoInitCtlData.getSortList()[:3]
aimObject = rigbase.makeAimObject(chest,
root,
axis=1,
replaceTarget='InitCTL',
replace='InitCtl')[0]
rigbase.betweenRigInAimObject(waist,
aimObject,
replaceTarget='InitCTL',
replace='InitCtl')
rigbase.AttrEdit(root, waist, chest).lockAttrs('r', 's', 'tx')
self.outputTransform = [root, waist, chest]
def rigOther(self):
collar_L, collar_R = self.torsoInitCtlData.getSortList()[-2:]
shoulder_L = self.armInitCtlData.getSortList('_L_')[0]
shoulder_R = self.armInitCtlData.getSortList('_R_')[0]
aimObjectL = rigbase.makeAimObject(shoulder_L,
collar_L,
replaceTarget='InitCTL',
replace='InitCtl')[0]
aimObjectR = rigbase.makeAimObject(shoulder_R,
collar_R,
replaceTarget='InitCTL',
replace='InitCtl',
inverseAim=1)[0]
rigbase.AttrEdit(aimObjectL, aimObjectR).lockAttrs('s')
self.outputTransform += [aimObjectL, aimObjectR]
def rigFootPart(self, side):
ankle = self.legInitCtlData.getSortList(side)[2]
footInitCtls = self.legInitCtlData.getSortList(side)[4:]
ball, toe, heel, ballPiv, bankIn, bankOut, toePiv = footInitCtls
rigbase.parentOrder(toePiv, bankOut, bankIn, ballPiv, heel)
rigbase.parentOrder(toe, ball)
cmds.parent(ball, heel, ankle)
for footInitCtl in footInitCtls:
rigbase.AttrEdit(footInitCtl).lockAttrs('r', 's', 'v')
if side.find('L') != -1:
self.outputTransformL += [
ball, toe, heel, ballPiv, bankIn, bankOut, toePiv
]
else:
self.outputTransformR += [
ball, toe, heel, ballPiv, bankIn, bankOut, toePiv
]
def splineSquashSet(self):
crvInfo = cmds.createNode( 'curveInfo', n=self.epBindNode_after+'_info' )
initCrvInfo = cmds.createNode( 'curveInfo', n=self.epBindNode_before+'_info' )
cmds.connectAttr( self.epBindNode_after+'.outputCurve', crvInfo+'.inputCurve' )
cmds.connectAttr( self.epBindNode_before+'.outputCurve', initCrvInfo+'.inputCurve' )
squashNode = cmds.createNode( 'squash', n='Torso_squash' )
cmds.connectAttr( initCrvInfo+'.arcLength', squashNode+'.lengthOriginal' )
cmds.connectAttr( crvInfo+'.arcLength', squashNode+'.lengthModify' )
rigbase.addHelpTx( self.chestCtl, 'Squash' )
attrEdit = rigbase.AttrEdit( self.chestCtl )
attrEdit.addAttr( ln='squash', min=-1, max=1, k=1 )
attrEdit.addAttr( ln='forceScale', k=1 )
cmds.connectAttr( self.chestCtl+'.squash', squashNode+'.squashRate' )
cmds.connectAttr( self.chestCtl+'.forceScale', squashNode+'.forceValue' )
for splineJnt in self.splineJnts[1:-1]:
cmds.connectAttr( squashNode+'.output', splineJnt+'.sx' )
cmds.connectAttr( squashNode+'.output', splineJnt+'.sy' )
cmds.connectAttr( squashNode+'.output', splineJnt+'.sz' )
def rigEachPart(self, index, side):
outputTransform = []
inverseAim = False
globalMult = 1
if side.find('R') != -1:
inverseAim = True
globalMult = -1
aimObjectOptions = {
'axis': 0,
'inverseAim': inverseAim,
'replaceTarget': 'InitCTL',
'replace': 'InitCtl'
}
fingerInitCtlNameList = self.fingerInitCtlData.getEachFingerList(
index, side)
firstFingerInitCtl = fingerInitCtlNameList[0]
secondFingerInitCtl = fingerInitCtlNameList[1]
betweenFingerInitCtls = fingerInitCtlNameList[2:-1]
endFingerInitCtl = fingerInitCtlNameList[-1]
aimObject0 = rigbase.makeAimObject(secondFingerInitCtl,
firstFingerInitCtl,
**aimObjectOptions)[0]
outputTransform.append(aimObject0)
aimObject1 = rigbase.makeAimObject(endFingerInitCtl,
secondFingerInitCtl,
**aimObjectOptions)[0]
aimObject1 = cmds.rename(aimObject1,
aimObject1.replace('AimObj', 'AimGrp'))
rigbase.betweenRigInAimObject(betweenFingerInitCtls,
aimObject1,
replaceTarget='InitCTL',
replace='InitCtl',
globalMult=globalMult)
for fingerInitCtl in betweenFingerInitCtls:
rigbase.AttrEdit(fingerInitCtl).lockAttrs('tz')
if side.find('L') != -1:
cmds.transformLimits(fingerInitCtl,
ty=[0.01, 1],
ety=[True, False])
else:
cmds.transformLimits(fingerInitCtl,
ty=[-1, 0.01],
ety=[False, True])
betweenFingerInitCtls.append(endFingerInitCtl)
aimObjectParent = secondFingerInitCtl
for fingerInitCtl in betweenFingerInitCtls:
aimObject = rigbase.makeAimObject(fingerInitCtl, aimObjectParent,
**aimObjectOptions)[0]
aimObjectParent = fingerInitCtl
outputTransform.append(aimObject)
outputTransform.append(endFingerInitCtl)
return outputTransform
def moveCtlSet(self):
self.moveCtl, self.moveCtlGrp = rigbase.putControler( self.worldCtl, n='Move_CTL', typ='move', size= [2,2,2] )
cmds.parent( self.moveCtlGrp, self.worldCtl )
self.rigInstance.moveCtl = self.moveCtl
rigbase.controlerSetColor( self.moveCtl , 20 )
rigbase.AttrEdit( self.moveCtl ).lockAndHideAttrs( 'sx', 'sy', 'sz', 'v' )
def collarConstSet(self, side ):
si = 0
if side == 'R':
si = 1
shoulderInitList = [self.shoulderLInit, self.shoulderRInit ]
shoulderCtlList = [self.shoulderLCtl,self.shoulderRCtl]
collarCtlList = [self.collarLCtl, self.collarRCtl]
const = cmds.createNode( 'transform', n='Shoulder_%s_Const' % side )
inCollar = cmds.createNode( 'transform', n='Shoulder_%s_Const_inCollar' % side )
inChest = cmds.createNode( 'transform', n='Shoulder_%s_Const_inChest' % side )
inRoot = cmds.createNode( 'transform', n='Shoulder_%s_Const_inRoot' % side )
inFly = cmds.createNode( 'transform', n='Shoulder_%s_Const_inFly' % side )
inMove = cmds.createNode( 'transform', n='Shoulder_%s_Const_inMove' % side )
cmds.parent( const , shoulderCtlList[si] )
cmds.parent( inCollar, collarCtlList[si] )
cmds.parent( inChest , self.chestCtl.replace( 'Chest', 'ChestMove' ) )
cmds.parent( inRoot , self.rootGrp )
cmds.parent( inFly , self.rootCtlGrp )
cmds.parent( inMove , self.rigInstance.moveCtl )
rigbase.transformDefault( const )#; cmds.setAttr( const+'.dla', 1 )
rigbase.connectSameAttr( shoulderInitList[si], inCollar ).doIt( 't', 'r' )
chestDcmp = rigbase.getChildMtxDcmp( shoulderInitList[si], self.chestInit )
cmds.connectAttr( chestDcmp+'.ot', inChest+'.t' )
cmds.connectAttr( chestDcmp+'.or', inChest+'.r' )
rootDcmp = rigbase.getChildMtxDcmp( shoulderInitList[si], self.rootInit )
cmds.connectAttr( rootDcmp+'.ot', inRoot+'.t' )
cmds.connectAttr( rootDcmp+'.or', inRoot+'.r' )
cmds.connectAttr( rootDcmp+'.ot', inFly+'.t' )
cmds.connectAttr( rootDcmp+'.or', inFly+'.r' )
cmds.connectAttr( rootDcmp+'.ot', inMove+'.t' )
cmds.connectAttr( rootDcmp+'.or', inMove+'.r' )
followMtx = cmds.createNode( 'followMatrix', n='Shoulder_%s_ConstFollow' % side )
mtxDcmp = cmds.createNode( 'multMatrixDecompose', n='Shoulder_%s_ConstMtxDcmp' % side )
cmds.connectAttr( inCollar+'.wm', followMtx+'.originalMatrix' )
cmds.connectAttr( inChest +'.wm', followMtx+'.inputMatrix[0]' )
cmds.connectAttr( inRoot +'.wm', followMtx+'.inputMatrix[1]' )
cmds.connectAttr( inFly +'.wm', followMtx+'.inputMatrix[2]' )
cmds.connectAttr( inMove +'.wm', followMtx+'.inputMatrix[3]' )
cmds.connectAttr( followMtx+'.outputMatrix', mtxDcmp+'.i[0]' )
cmds.connectAttr( const +'.pim', mtxDcmp+'.i[1]' )
cmds.connectAttr( mtxDcmp+'.or', const+'.r' )
rigbase.addHelpTx( collarCtlList[si], 'Follow' )
attrEdit = rigbase.AttrEdit( collarCtlList[si] )
attrEdit.addAttr( ln='chestFollow', min=0, max=10 )
attrEdit.addAttr( ln='rootFollow' , min=0, max=10 )
attrEdit.addAttr( ln='flyFollow' , min=0, max=10, k=1 )
attrEdit.addAttr( ln='moveFollow' , min=0, max=10 )
cmds.connectAttr( collarCtlList[si]+'.chestFollow', followMtx+'.inputWeight[0]' )
cmds.connectAttr( collarCtlList[si]+'.rootFollow' , followMtx+'.inputWeight[1]' )
cmds.connectAttr( collarCtlList[si]+'.flyFollow' , followMtx+'.inputWeight[2]' )
cmds.connectAttr( collarCtlList[si]+'.moveFollow' , followMtx+'.inputWeight[3]' )
if side == 'L':
self.shoulderLConst = const
self.rigInstance.ikGroupLConst = inChest
else:
self.shoulderRConst = const
self.rigInstance.ikGroupRConst = inChest
def hipConstSet(self):
hipLConst_inFly = cmds.createNode( 'transform', n='Hip_L_Const_inFly' )
hipRConst_inFly = cmds.createNode( 'transform', n='Hip_R_Const_inFly' )
hipLConst_inRoot = cmds.createNode( 'transform', n='Hip_L_Const_inRoot' )
hipRConst_inRoot = cmds.createNode( 'transform', n='Hip_R_Const_inRoot' )
hipLConst_inHip = cmds.createNode( 'transform', n='Hip_L_Const_inHip' )
hipRConst_inHip = cmds.createNode( 'transform', n='Hip_R_Const_inHip' )
hipLConst = cmds.createNode( 'transform', n='Hip_L_Const' )
hipRConst = cmds.createNode( 'transform', n='Hip_R_Const' )
cmds.parent( hipLConst_inFly, hipRConst_inFly, self.rootCtlGrp )
cmds.parent( hipLConst_inRoot, hipRConst_inRoot, self.rootGrp )
cmds.parent( hipLConst, hipRConst, hipLConst_inHip, hipRConst_inHip, self.hipCtl )
rigbase.connectSameAttr( self.hipLInit, hipLConst_inFly ).doIt( 't','r' )
rigbase.connectSameAttr( self.hipRInit, hipRConst_inFly ).doIt( 't','r' )
rigbase.connectSameAttr( self.hipLInit, hipLConst_inRoot ).doIt( 't' )
rigbase.connectSameAttr( self.hipRInit, hipRConst_inRoot ).doIt( 't' )
rigbase.constraint( hipLConst_inFly, hipLConst_inRoot, t=0 )
rigbase.constraint( hipRConst_inFly, hipRConst_inRoot, t=0 )
rigbase.connectSameAttr( self.hipLInit, hipLConst_inHip ).doIt( 't','r' )
rigbase.connectSameAttr( self.hipRInit, hipRConst_inHip ).doIt( 't','r' )
#cmds.setAttr( hipLConst_inHip+'.rz', -90 )
#cmds.setAttr( hipLConst_inRoot+'.rz', -90 )
#cmds.setAttr( hipRConst_inHip+'.rx', 180 )
#cmds.setAttr( hipRConst_inHip+'.rz', 90 )
#cmds.setAttr( hipRConst_inRoot+'.rx', 180 )
#cmds.setAttr( hipRConst_inRoot+'.rz', 90 )
blendMtxL = cmds.createNode( 'blendTwoMatrix', n='Hip_L_Const_blendMtx' )
blendMtxR = cmds.createNode( 'blendTwoMatrix', n='Hip_R_Const_blendMtx' )
multMtxDcmpL = cmds.createNode( 'multMatrixDecompose', n='Hip_L_Const_MtxDcmp' )
multMtxDcmpR = cmds.createNode( 'multMatrixDecompose', n='Hip_R_Const_MtxDcmp' )
cmds.connectAttr( hipLConst_inRoot+'.wm', blendMtxL+'.inMatrix1' )
cmds.connectAttr( hipRConst_inRoot+'.wm', blendMtxR+'.inMatrix1' )
cmds.connectAttr( hipLConst_inHip+'.wm', blendMtxL+'.inMatrix2' )
cmds.connectAttr( hipRConst_inHip+'.wm', blendMtxR+'.inMatrix2' )
cmds.connectAttr( blendMtxL+'.outMatrix', multMtxDcmpL+'.i[0]' )
cmds.connectAttr( blendMtxR+'.outMatrix', multMtxDcmpR+'.i[0]' )
cmds.connectAttr( hipLConst+'.pim', multMtxDcmpL+'.i[1]' )
cmds.connectAttr( hipRConst+'.pim', multMtxDcmpR+'.i[1]' )
cmds.connectAttr( hipLConst_inHip+'.t', hipLConst+'.t' )
cmds.connectAttr( hipRConst_inHip+'.t', hipRConst+'.t' )
cmds.connectAttr( multMtxDcmpL+'.or', hipLConst+'.r' )
cmds.connectAttr( multMtxDcmpR+'.or', hipRConst+'.r' )
rigbase.addHelpTx( self.hipCtl, 'Options' )
attrEdit = rigbase.AttrEdit( self.hipCtl )
attrEdit.addAttr( ln='legFollowL', min=0, max=1, k=1 )
attrEdit.addAttr( ln='legFollowR', min=0, max=1, k=1 )
cmds.connectAttr( self.hipCtl+'.legFollowL', blendMtxL+'.attributeBlender' )
cmds.connectAttr( self.hipCtl+'.legFollowR', blendMtxR+'.attributeBlender' )
self.rigInstance.hipLConst_inRoot = hipLConst_inRoot
self.rigInstance.hipRConst_inRoot = hipRConst_inRoot
self.rigInstance.hipLConst_inHip = hipLConst_inHip
self.rigInstance.hipRConst_inHip = hipRConst_inHip
self.rigInstance.hipLConstInFly = hipLConst_inFly
self.rigInstance.hipRConstInFly = hipRConst_inFly
self.hipLConst = hipLConst
self.hipRConst = hipRConst
def neckCtlSet(self):
self.neckCtl = rigbase.Controler(n='Neck_CTL')
self.neckCtl.setShape(normal=[0, 1, 0], radius=.6)
self.neckCtl.setColor(29)
attrEdit = rigbase.AttrEdit(self.neckCtl)
attrEdit.lockAndHideAttrs('sx', 'sy', 'sz', 'v')
def curveSet(self):
#self.crv = cmds.curve( n='Torso_Spline_CRV', d=3, p=[[0,0,0],[0,0,0],[0,0,0],[0,0,0]] )
self.initCrv = cmds.curve( n='Torso_SplineInit_CRV', d=3, p=[[0,0,0],[0,0,0],[0,0,0],[0,0,0]] )
#cmds.setAttr( self.crv+'.v', 0 )
cmds.setAttr( self.initCrv+'.v', 0 )
#self.crvShape = cmds.listRelatives( self.crv, s=1 )[0]
self.initCrvShape = cmds.listRelatives( self.initCrv, s=1 )[0]
self.crvPoint0Obj = self.hipCtl
self.crvPoint1Obj = cmds.createNode( 'transform', n= 'Torso_Spline_point1' )
self.crvPoint2Obj = cmds.createNode( 'transform', n= 'Torso_Spline_point2' )
self.crvPoint3Obj = self.chestCtl
self.crvOrigPoint0Obj = self.torsoCtl
self.crvOrigWaistObj = cmds.createNode( 'transform', n= 'Waist_CTL_SqPos' )
self.crvOrigPoint1Obj = cmds.createNode( 'transform', n= 'Torso_Spline_SquPoint1' )
self.crvOrigPoint2Obj = cmds.createNode( 'transform', n= 'Torso_Spline_SquPoint2' )
self.crvOrigPoint3Obj = cmds.createNode( 'transform', n= 'Chest_CTL_SquPos' )
rigbase.AttrEdit( self.crvPoint1Obj, self.crvPoint2Obj ).lockAndHideAttrs( 'tx', 'tz', 'rx', 'ry','rz', 'sx', 'sy','sz', 'v' )
cmds.parent( self.crvPoint1Obj, self.crvPoint2Obj, self.waistCtl )
cmds.parent( self.crvOrigWaistObj, self.crvOrigPoint3Obj, self.rootGrp )
cmds.parent( self.crvOrigPoint1Obj, self.crvOrigPoint2Obj, self.crvOrigWaistObj )
self.crvOrigSqPointGrp = cmds.group( self.crvOrigPoint1Obj, self.crvOrigPoint2Obj, n='Waist_CTL_SqSqPointGrp' )
cmds.xform( self.crvOrigSqPointGrp, piv=[0,0,0], os=1 )
rigbase.pInvRotConst( self.crvOrigSqPointGrp )
rigbase.connectSameAttr( self.waistInit, self.crvOrigWaistObj ).doIt( 't','r' )
chMtxDcmp = rigbase.getChildMtxDcmp( self.chestInit, self.rootInit )
cmds.connectAttr( chMtxDcmp+'.ot', self.crvOrigPoint3Obj+'.t' )
cmds.connectAttr( chMtxDcmp+'.or', self.crvOrigPoint3Obj+'.r' )
#rigbase.connectSameAttr( self.chestCtlGrp, self.crvOrigPoint3Obj ).doIt( 't', 'r' )
#rigbase.connectSameAttr( self.crvPoint1Obj, self.crvOrigPoint1Obj ).doIt( 't','r' )
#rigbase.connectSameAttr( self.crvPoint2Obj, self.crvOrigPoint2Obj ).doIt( 't','r' )
multPoint1Node = cmds.createNode( 'multDoubleLinear', n='Torso_Spline_point1_mult' )
multPoint2Node = cmds.createNode( 'multDoubleLinear', n='Torso_Spline_point2_mult' )
distPoint1Node = cmds.createNode( 'distanceBetween', n='Torso_spline_point1_dist' )
distPoint2Node = cmds.createNode( 'distanceBetween', n='Torso_spline_point2_dist' )
cmds.connectAttr( self.waistInit+'.t', distPoint1Node+'.point1' )
cmds.connectAttr( self.chestInit+'.t', distPoint2Node+'.point2' )
cmds.connectAttr( distPoint1Node+'.distance', multPoint1Node+'.input1' )
cmds.connectAttr( distPoint2Node+'.distance', multPoint2Node+'.input1' )
#cmds.connectAttr( multPoint1Node+'.output', self.crvPoint1Obj+'.ty' )
#cmds.connectAttr( multPoint2Node+'.output', self.crvPoint2Obj+'.ty' )
cmds.connectAttr( multPoint1Node+'.output', self.crvOrigPoint1Obj+'.ty' )
cmds.connectAttr( multPoint2Node+'.output', self.crvOrigPoint2Obj+'.ty' )
cmds.setAttr( multPoint1Node+'.input2', -.4 )
cmds.setAttr( multPoint2Node+'.input2', .4 )
'''
for i in range( 4 ):
dcmp = cmds.createNode( 'decomposeMatrix', n= self.crv+'_point%d_dcmp' % i )
exec( 'cmds.connectAttr( self.crvPoint%dObj+".wm", dcmp+".imat" )' % i )
cmds.connectAttr( dcmp+".ot", self.crvShape+'.controlPoints[%d]' %i )'''
for i in range( 4 ):
dcmp = cmds.createNode( 'multMatrixDecompose', n= self.initCrv+'_origPoint%d_dcmp' % i )
exec( 'cmds.connectAttr( self.crvOrigPoint%dObj+".wm", dcmp+".i[0]" )' % i )
cmds.connectAttr( self.initCrv+".wim", dcmp+".i[1]" )
cmds.connectAttr( dcmp+".ot", self.initCrvShape+'.controlPoints[%d]' %i )
rigbase.transformDefault( self.initCrv )
#rigbase.connectSameAttr( self.crv, self.initCrv ).doIt( 't', 'r', 's', 'sh' )
cmds.parent( self.initCrv, self.rootGrp )
def splineJointSet( self, splineNumber ):
self.splineJnts = []
cmds.select( d=1 )
self._splineJointUpObjectSet()
spci = cmds.createNode( 'splineCurveInfo', n= self.initCrv+'_Spci' )
cmds.connectAttr( self.initCrvShape+'.local', spci+'.inputCurve' )
#cmds.connectAttr( self.startUp+'.wm', spci+'.startTransform' )
#cmds.connectAttr( self.endUp +'.wm', spci+'.endTransform' )
cmds.setAttr( spci+'.startUpAxis', 2 )
cmds.setAttr( spci+'.endUpAxis', 2 )
cmds.setAttr( spci+'.targetAimAxis', 1 )
cmds.setAttr( spci+'.targetUpAxis', 2 )
for i in range( splineNumber ):
self.splineJnts.append( cmds.joint( n='Spline%d_RJT' % i, radius=1.5 ) )
pointObjs = []
for i in range( 0, splineNumber ):
pr = float(i)/(splineNumber-1)
pointObj = cmds.createNode( 'transform', n='Spline%d_SplinePoint' % i )
pointObjs.append( pointObj )
cmds.addAttr( self.splineJnts[i], ln='parameter', min=0, max=1, dv=pr )
cmds.setAttr( self.splineJnts[i]+'.parameter', e=1, k=1 )
cmds.connectAttr( self.splineJnts[i]+'.parameter', spci+'.pr[%d]' % i )
cmds.connectAttr( spci+'.o[%d].p' % i, pointObj+'.t' )
cmds.connectAttr( spci+'.o[%d].r' % i, pointObj+'.r' )
cmds.parent( pointObj, self.initCrv )
rigbase.constraint( pointObj, self.splineJnts[i] )
pointHObjs = []
cmds.select( self.torsoCtl )
for i in range( 0, splineNumber ):
pointHObjs.append( cmds.joint( n=pointObjs[i].replace( 'SplinePoint', 'SplineHJnt' ) ) )
mtxDcmp = rigbase.constraint( pointObjs[i], pointHObjs[i], r=0 )
cmds.connectAttr( mtxDcmp+'.or', pointHObjs[i]+'.jo' )
if i == 0:
cmds.connectAttr( self.rootGrp+'.wim', mtxDcmp+'.i[1]', f=1 )
else:
cmds.connectAttr( pointObjs[i-1]+'.wim', mtxDcmp+'.i[1]', f=1 )
cmds.select( pointHObjs[i] )
cmds.setAttr( pointHObjs[0]+'.v', 0 )
rigbase.constraint( pointHObjs[-1], self.chestCtlGrp, r=0 )
epBindNode = cmds.createNode( 'epBindNode', n='Torso_epBindNode' )
initEpBindNode = cmds.createNode( 'epBindNode', n='TorsoInit_epBindNode' )
chestOrPointer = cmds.createNode( 'transform', n='Chest_OrPointer' )
hipCuPointer = cmds.createNode( 'transform', n='Hip_CuPointer' )
cmds.parent( chestOrPointer, self.chestCtlGrp )
cmds.parent( hipCuPointer, self.hipCtlGrp )
rigbase.transformDefault( chestOrPointer )
cmds.connectAttr( self.chestCtl+'.r', chestOrPointer+'.r' )
cmds.connectAttr( self.hipCtl+'.t', hipCuPointer+'.t' )
cmds.connectAttr( self.hipCtlGrp+'.wm', epBindNode+'.om[0]' )
cmds.connectAttr( chestOrPointer+'.wm', epBindNode+'.om[1]')
cmds.connectAttr( hipCuPointer+'.wm', epBindNode+'.m[0]' )
cmds.connectAttr( self.chestCtl+'.wm', epBindNode+'.m[1]' )
for i in range( splineNumber ):
dcmp = cmds.createNode( 'decomposeMatrix' , n=pointHObjs[i]+'_dcmp' )
cmds.connectAttr( pointHObjs[i]+'.wm', dcmp+'.imat' )
cmds.connectAttr( dcmp+'.ot', epBindNode+'.ip[%d]' % i )
cmds.connectAttr( dcmp+'.ot', initEpBindNode+'.ip[%d]' % i )
smOri = cmds.createNode( 'smartOrient', n='Torso_Spline_SmOri' )
cmds.connectAttr( self.chestCtl+'.m', smOri+'.inputMatrix' )
cmds.setAttr( smOri+'.aimAxis', 1 )
for i in range( 1, splineNumber-1 ):
cmds.addAttr( self.chestCtl, ln='rotRate%d' % i, min=0, max=1, dv=.333 )
splineOrientMult = cmds.createNode( 'multiplyDivide', n='Torso_Spline_OrientMult%d' % i )
cmds.connectAttr( smOri+'.outAngle', splineOrientMult+'.input1' )
cmds.connectAttr( self.chestCtl+'.rotRate%d' % i, splineOrientMult+'.input2X' )
cmds.connectAttr( self.chestCtl+'.rotRate%d' % i, splineOrientMult+'.input2Y' )
cmds.connectAttr( self.chestCtl+'.rotRate%d' % i, splineOrientMult+'.input2Z' )
cmds.connectAttr( splineOrientMult+'.output', pointHObjs[i]+'.r' )
'''
firstCrv = cmds.circle( ch=0, n='Torso_FristCrv' )[0]
firstCrvShape = cmds.listRelatives( firstCrv, s=1 )[0]
cmds.connectAttr( epBindNode+'.outputCurve', firstCrvShape+'.create' )
cmds.parent( firstCrv, self.rootGrp )
firstCrv_dcmp = cmds.createNode( 'decomposeMatrix', n='Torso_firstCrv_invDcmp' )
cmds.connectAttr( firstCrv+'.pim', firstCrv_dcmp+'.imat' )
cmds.connectAttr( firstCrv_dcmp+'.ot', firstCrv+'.t' )
cmds.connectAttr( firstCrv_dcmp+'.or', firstCrv+'.r' )
cmds.connectAttr( firstCrv_dcmp+'.os', firstCrv+'.s' )
cmds.connectAttr( firstCrv_dcmp+'.osh', firstCrv+'.sh' )'''
def curveBasedCtlGrp( outputCurveAttr, ctlGrp, prRate=0.5 ):
posInfo = cmds.createNode( 'pointOnCurveInfo', n='Waist_Ct;PoseInfo' )
fbf = cmds.createNode( 'fourByFourMatrix', n='Waist_CtlFBF' )
smOri = cmds.createNode( 'smartOrient', n='Waist_CtlSmOri' )
compose = cmds.createNode( 'composeMatrix', n='Waist_CtlComp' )
mtxDcmp = cmds.createNode( 'multMatrixDecompose', n='Waist_CtlMtxDcmp' )
cmds.setAttr( posInfo+'.top', 1 )
cmds.setAttr( posInfo+'.parameter', prRate )
cmds.setAttr( smOri+'.aimAxis', 1 )
cmds.connectAttr( outputCurveAttr, posInfo+'.inputCurve' )
cmds.connectAttr( posInfo+'.tangentX', fbf+'.in10' )
cmds.connectAttr( posInfo+'.tangentY', fbf+'.in11' )
cmds.connectAttr( posInfo+'.tangentZ', fbf+'.in12' )
cmds.connectAttr( fbf+'.output', smOri+'.inputMatrix' )
cmds.connectAttr( posInfo+'.position', compose+'.it' )
cmds.connectAttr( smOri+'.outAngle', compose+'.ir')
cmds.connectAttr( compose+'.outputMatrix', mtxDcmp+'.i[0]' )
cmds.connectAttr( ctlGrp+'.pim', mtxDcmp+'.i[1]' )
cmds.connectAttr( mtxDcmp+'.ot', ctlGrp+'.t' )
cmds.connectAttr( mtxDcmp+'.or', ctlGrp+'.r' )
curveBasedCtlGrp( epBindNode+'.outputCurve', self.waistCtlGrp, prRate=0.5 )
chestCuPointer = cmds.createNode( 'transform', n='ChestCuPointer' )
cmds.parent( chestCuPointer, self.chestMoveCtlGrp )
cmds.connectAttr( self.chestMoveCtl+'.t', chestCuPointer+'.t' )
rigbase.transformDefault( chestCuPointer )
epBindNode2 = cmds.createNode( 'epBindNode', n='Torso_epBindNode2' )
for i in range( splineNumber ):
cmds.connectAttr( epBindNode+'.op[%d]' % i, epBindNode2+'.ip[%d]' % i )
waistOrientObj = cmds.createNode( 'transform', n='WaistOrient_OBJ' )
cmds.parent( waistOrientObj, self.waistCtlGrp )
rigbase.transformDefault( waistOrientObj )
waistSmOrient = cmds.createNode( 'smartOrient', n='WaistOrient_ObjSmOrient' )
cmds.connectAttr( self.waistCtl+'.m', waistSmOrient+'.inputMatrix' )
cmds.setAttr( waistSmOrient+'.aimAxis', 1 )
cmds.connectAttr( waistSmOrient+'.outAngle', waistOrientObj+'.r' )
cmds.connectAttr( self.waistCtl+'.t', waistOrientObj+'.t' )
cmds.connectAttr( hipCuPointer+'.wm', epBindNode2+'.m[0]' )
cmds.connectAttr( hipCuPointer+'.wm', epBindNode2+'.om[0]' )
cmds.connectAttr( waistOrientObj+'.wm', epBindNode2+'.m[1]' )
cmds.connectAttr( self.waistCtlGrp+'.wm', epBindNode2+'.om[1]' )
cmds.connectAttr( chestCuPointer+'.wm', epBindNode2+'.m[2]' )
cmds.connectAttr( self.chestMoveCtlGrp+'.wm', epBindNode2+'.om[2]' )
cuSpInfo = cmds.createNode( 'splineCurveInfo' , n='Torso_CurrentSplineInfo' )
cmds.setAttr( cuSpInfo+'.paramFromLength', 0 )
cmds.setAttr( cuSpInfo+'.startUpAxis', 2 )
cmds.setAttr( cuSpInfo+'.endUpAxis', 2 )
cmds.setAttr( cuSpInfo+'.targetAimAxis', 1 )
cmds.setAttr( cuSpInfo+'.targetUpAxis', 2 )
putCtls = []
rigbase.addHelpTx( self.waistCtl, 'Itp CTL Vis' )
rigbase.AttrEdit( self.waistCtl ).addAttr( ln='show', cb=1, min=0, max=1, at='long' )
for i in range( 1, splineNumber-1 ):
putCtl, putCtlGrp = rigbase.putControler( self.waistCtl, n='WaistItp%d_CTL' % i, normal=[0,1,0] )
rigbase.AttrEdit( putCtl ).lockAndHideAttrs( 'sx', 'sy', 'sz' ,'v' )
curveBasedCtlGrp( epBindNode2+'.outputCurve', putCtlGrp, i/( splineNumber-1.0 ) )
cmds.connectAttr( self.waistCtl+'.show', putCtlGrp+'.v' )
putCtls.append( [putCtl, putCtlGrp] )
cmds.parent( putCtlGrp, self.rootGrp )
epBindNode3 = cmds.createNode( 'epBindNode', n='Torso_epBindNode3' )
for i in range( splineNumber ):
cmds.connectAttr( epBindNode2+'.op[%d]' % i, epBindNode3+'.ip[%d]' % i )
cmds.connectAttr( hipCuPointer+'.wm', epBindNode3+'.m[0]' )
cmds.connectAttr( hipCuPointer+'.wm', epBindNode3+'.om[0]' )
for i in range( 1, splineNumber-1 ):
cmds.connectAttr( putCtls[i-1][0]+'.wm', epBindNode3+'.m[%d]' % i )
cmds.connectAttr( putCtls[i-1][1]+'.wm', epBindNode3+'.om[%d]' % i )
cmds.connectAttr( chestCuPointer+'.wm', epBindNode3+'.m[%d]' % (splineNumber-1) )
cmds.connectAttr( self.chestMoveCtlGrp+'.wm', epBindNode3+'.om[%d]' % (splineNumber-1) )
cuSpInfo = cmds.createNode( 'splineCurveInfo' , n='Torso_CurrentSplineInfo' )
cmds.setAttr( cuSpInfo+'.paramFromLength', 0 )
cmds.setAttr( cuSpInfo+'.startUpAxis', 2 )
cmds.setAttr( cuSpInfo+'.endUpAxis', 2 )
cmds.setAttr( cuSpInfo+'.targetAimAxis', 1 )
cmds.setAttr( cuSpInfo+'.targetUpAxis', 2 )
cmds.connectAttr( epBindNode3+'.outputCurve', cuSpInfo+'.inputCurve' )
cmds.connectAttr( self.startUp+'.wm', cuSpInfo+'.startTransform' )
cmds.connectAttr( self.endUp+'.wm', cuSpInfo+'.endTransform' )
cuSpGrp = cmds.createNode( 'transform', n='Torso_Spline_GRP' )
splinePtrs = []
for i in range( splineNumber ):
splineInfoPtr = cmds.createNode( 'transform', n='Torso%d_SplinePoint' % i )
splinePtrs.append( splineInfoPtr )
cmds.setAttr( cuSpInfo+'.parameter[%d]' % i, i/( splineNumber-1.0 )+0.001 )
cmds.connectAttr( cuSpInfo+'.output[%d].position' % i, splineInfoPtr+'.t' )
cmds.connectAttr( cuSpInfo+'.output[%d].rotate' % i, splineInfoPtr+'.r' )
cmds.parent( splinePtrs, cuSpGrp )
cmds.parent( cuSpGrp, self.rootCtlGrp )
splinePtrsInvDcmp = cmds.createNode( 'decomposeMatrix', n='Torso_SplinePtrsInvDcmp' )
cmds.connectAttr( self.rootCtlGrp+'.wim', splinePtrsInvDcmp+'.imat' )
cmds.connectAttr( splinePtrsInvDcmp+'.ot', cuSpGrp+'.t' )
cmds.connectAttr( splinePtrsInvDcmp+'.or', cuSpGrp+'.r' )
cmds.connectAttr( splinePtrsInvDcmp+'.os', cuSpGrp+'.s' )
cmds.connectAttr( splinePtrsInvDcmp+'.osh', cuSpGrp+'.sh' )
allWristAngle = cmds.createNode( 'wristAngle', n='Torso_TwistAllAngle' )
cmds.setAttr( allWristAngle+'.axis', 1 )
cmds.connectAttr( self.waistCtl+'.wm', allWristAngle+'.inputMatrix' )
for i in range( 1, splineNumber-1 ):
floatValue = i/(splineNumber-1.0)
weightValue = 1-math.fabs( 0.5-floatValue )/.5
cmds.addAttr( self.waistCtl, ln='multWeight%d' % i, min=0, max=1, dv=weightValue )
cuSplinePtr = cmds.createNode( 'transform', n='Torso_cuSplinePtr%d' % i )
cmds.parent( cuSplinePtr, splinePtrs[i] )
rigbase.transformDefault( cuSplinePtr )
rigbase.constraint( cuSplinePtr, self.splineJnts[i] )
twistMultNode = cmds.createNode( 'multDoubleLinear', n='Torso_TwistMult%d' % i )
addTwist = cmds.createNode( 'addDoubleLinear', n='Torso_TwistAdd%d' % i )
wristAngle = cmds.createNode( 'wristAngle', n='Torso_TwistAngle%d' % i )
cmds.setAttr( wristAngle+'.axis', 1 )
cmds.connectAttr( putCtls[i-1][0]+'.m', wristAngle+'.inputMatrix' )
cmds.connectAttr( wristAngle+'.outAngle', addTwist+'.input1' )
cmds.connectAttr( allWristAngle+'.outAngle', twistMultNode+'.input1' )
cmds.connectAttr( self.waistCtl+'.multWeight%d' % i, twistMultNode+'.input2' )
cmds.connectAttr( twistMultNode+'.output', addTwist+'.input2' )
cmds.connectAttr( addTwist+'.output', cuSplinePtr+'.ry' )
rigbase.constraint( self.hipCtl, self.splineJnts[0] )
rigbase.constraint( self.chestMoveCtl, self.splineJnts[-1] )
cmds.parent( self.splineJnts[0], self.rootGrp )
self.epBindNode_before = initEpBindNode
self.epBindNode_after = epBindNode3
def rigLegPart(self, side):
inverseAim = False
inverseUp = True
globalMult = 1
if side.find('R') != -1:
inverseAim = True
inverseUp = False
globalMult = -1
hip, knee, ankle, poleV = self.legInitCtlData.getSortList(side)[:4]
upperLeg, lowerLeg = self.legInitCtlAdd.getSortList(side)
aimObjectOptions = {
'axis': 0,
'upAxis': 2,
'inverseAim': inverseAim,
'inverseUp': inverseUp,
'upType': 'object',
'upObject': poleV,
'replaceTarget': 'InitCTL',
'replace': 'InitCtl'
}
aimObject, anklePoseMltDcmp = rigbase.makeAimObject(
ankle, hip, **aimObjectOptions)
aimObject = cmds.rename(aimObject,
aimObject.replace('AimObj', 'AimGrp'))
rigbase.betweenRigInAimObject(knee,
aimObject,
dcmp=anklePoseMltDcmp,
replaceTarget='InitCTL',
replace='InitCtl',
globalMult=globalMult)
rigbase.AttrEdit(knee).lockAttrs('ty')
aimObjectKnee = rigbase.makeAimObject(ankle, knee,
**aimObjectOptions)[0]
aimObjectHip = rigbase.makeAimObject(knee, hip, **aimObjectOptions)[0]
cmds.parent(upperLeg, aimObjectHip)
cmds.parent(lowerLeg, aimObjectKnee)
upperLegGrp = rigbase.addParent(upperLeg)
lowerLegGrp = rigbase.addParent(lowerLeg)
upperMtxDcmp = rigbase.getChildMtxDcmp(knee, aimObjectHip)
lowerMtxDcmp = rigbase.getChildMtxDcmp(ankle, aimObjectKnee)
upperMultMiddle = cmds.createNode('multiplyDivide',
n=upperLeg.replace(
'InitCTL', 'InitCtlMiddleMult'))
lowerMultMiddle = cmds.createNode('multiplyDivide',
n=lowerLeg.replace(
'InitCTL', 'InitCtlMiddleMult'))
cmds.connectAttr(upperMtxDcmp + '.ot', upperMultMiddle + '.input1')
cmds.connectAttr(lowerMtxDcmp + '.ot', lowerMultMiddle + '.input1')
cmds.setAttr(upperMultMiddle + '.input2', .5, .5, .5)
cmds.setAttr(lowerMultMiddle + '.input2', .5, .5, .5)
cmds.connectAttr(upperMultMiddle + '.output', upperLegGrp + '.t')
cmds.connectAttr(lowerMultMiddle + '.output', lowerLegGrp + '.t')
cmds.setAttr(upperLegGrp + '.r', 0, 0, 0)
cmds.setAttr(lowerLegGrp + '.r', 0, 0, 0)
if side.find('L') != -1:
self.outputTransformL = [aimObjectHip, aimObjectKnee, ankle, poleV]
self.outputAddTrL = [upperLeg, lowerLeg]
cmds.transformLimits(knee, tz=[0.01, 1], etz=[True, False])
else:
self.outputTransformR = [aimObjectHip, aimObjectKnee, ankle, poleV]
self.outputAddTrR = [upperLeg, lowerLeg]
cmds.transformLimits(knee, tz=[-1, 0.01], etz=[False, True])
def rigSide(self, side):
inverseAim = False
inverseUp = False
globalMult = 1
if side.find('R') != -1:
inverseAim = True
inverseUp = True
globalMult = -1
shoulder, elbow, wrist, poleV = self.armInitCtlData.getSortList(side)
upperArm, lowerArm = self.armInitCtlAdd.getSortList(side)
aimObjectOptions = {
'axis': 0,
'upAxis': 2,
'inverseAim': inverseAim,
'inverseUp': inverseUp,
'upType': 'object',
'upObject': poleV,
'replaceTarget': 'InitCTL',
'replace': 'InitCtl'
}
aimObject, wristPoseMltDcmp = rigbase.makeAimObject(
wrist, shoulder, **aimObjectOptions)
aimObject = cmds.rename(aimObject,
aimObject.replace('AimObj', 'AimGrp'))
rigbase.betweenRigInAimObject(elbow,
aimObject,
dcmp=wristPoseMltDcmp,
replaceTarget='InitCTL',
replace='InitCtl',
globalMult=globalMult)
rigbase.AttrEdit(elbow).lockAttrs('ty')
aimObjectElbow = rigbase.makeAimObject(wrist, elbow,
**aimObjectOptions)[0]
aimObjectShoulder = rigbase.makeAimObject(elbow, shoulder,
**aimObjectOptions)[0]
cmds.parent(upperArm, aimObjectShoulder)
cmds.parent(lowerArm, aimObjectElbow)
upperArmGrp = rigbase.addParent(upperArm)
lowerArmGrp = rigbase.addParent(lowerArm)
upperMtxDcmp = rigbase.getChildMtxDcmp(elbow, aimObjectShoulder)
lowerMtxDcmp = rigbase.getChildMtxDcmp(wrist, aimObjectElbow)
upperMultMiddle = cmds.createNode('multiplyDivide',
n=upperArm.replace(
'InitCTL', 'InitCtlMiddleMult'))
lowerMultMiddle = cmds.createNode('multiplyDivide',
n=lowerArm.replace(
'InitCTL', 'InitCtlMiddleMult'))
cmds.connectAttr(upperMtxDcmp + '.ot', upperMultMiddle + '.input1')
cmds.connectAttr(lowerMtxDcmp + '.ot', lowerMultMiddle + '.input1')
cmds.setAttr(upperMultMiddle + '.input2', .5, .5, .5)
cmds.setAttr(lowerMultMiddle + '.input2', .5, .5, .5)
cmds.connectAttr(upperMultMiddle + '.output', upperArmGrp + '.t')
cmds.connectAttr(lowerMultMiddle + '.output', lowerArmGrp + '.t')
cmds.setAttr(upperArmGrp + '.r', 0, 0, 0)
cmds.setAttr(lowerArmGrp + '.r', 0, 0, 0)
if side.find('L') != -1:
self.outputTransformL = [
aimObjectShoulder, aimObjectElbow, wrist, poleV
]
self.outputAddTrL = [upperArm, lowerArm]
cmds.transformLimits(elbow, tz=[-1, 0.01], etz=[False, True])
else:
self.outputTransformR = [
aimObjectShoulder, aimObjectElbow, wrist, poleV
]
self.outputAddTrR = [upperArm, lowerArm]
cmds.transformLimits(elbow, tz=[0.01, 1], etz=[True, False])
def createBjt(topRjt):
topBjt = rigbase.hierarchyCopyConnections(topRjt,
typ='joint',
replaceTarget='_RJT',
replace='_BJT',
t=0,
r=0)
bjts = cmds.listRelatives(topBjt, c=1, ad=1)
bjts.append(topBjt)
for bjt in bjts:
rjt = bjt.replace('_BJT', '_RJT')
#cmds.setAttr( bjt+'.r', 0,0,0 )
#cmds.setAttr( bjt+'.jox', e=1, k=1 )
#cmds.setAttr( bjt+'.joy', e=1, k=1 )
#cmds.setAttr( bjt+'.joz', e=1, k=1 )
#cmds.connectAttr( rjt+'.rx', bjt+'.rx' )
#cmds.connectAttr( rjt+'.ry', bjt+'.ry' )
#cmds.connectAttr( rjt+'.rz', bjt+'.rz' )
conSameAttr = rigbase.connectSameAttr(rjt, bjt)
conSameAttr.doIt('t', 'r', 's')
if rjt.find('Leg_L_Lower4') != -1 or rjt.find('Leg_R_Lower4') != -1:
conSameAttr.doIt('sh')
cmds.setAttr(bjt + '.ssc', cmds.getAttr(rjt + '.ssc'))
if cmds.attributeQuery('parameter', node=rjt, ex=1):
rigbase.AttrEdit(bjt).addAttr(ln='parameter',
min=-.001,
max=1.001,
dv=cmds.getAttr(rjt + '.parameter'),
cb=1)
cmds.connectAttr(bjt + '.parameter', rjt + '.parameter')
bjtP = cmds.listRelatives(bjt, p=1)
if not bjtP: continue
try:
cmds.connectAttr(bjtP[0] + '.scale', bjt + '.inverseScale')
except:
pass
topRjtGrp = cmds.listRelatives(topRjt, p=1)[0]
topBjtGrp = cmds.group(em=1, n='Root_BJT_GRP')
rigbase.transformSetColor(topRjtGrp, 11)
rigbase.transformSetColor(topBjtGrp, 29)
bjtWorld = cmds.group(n='BJT_World')
rigbase.addControlerShape(bjtWorld,
typ='circle',
normal=[0, 1, 0],
radius=5.5)
rigbase.controlerSetColor(bjtWorld, 29)
bjtWorldGrp = cmds.group(bjtWorld, n='BJT_World_GRP')
cmds.connectAttr(topRjtGrp + '.t', topBjtGrp + '.t')
cmds.connectAttr(topRjtGrp + '.r', topBjtGrp + '.r')
cmds.parent(topBjt, topBjtGrp)
rigbase.connectSameAttr('World_CTL_GRP',
'BJT_World_GRP').doIt('t', 'r', 's')
rigbase.connectSameAttr('World_CTL', 'BJT_World').doIt('t', 'r', 's')
#rigbase.AttrEdit( 'BJT_World' ).addAttr( ln='World_CTL', at='message' )
#cmds.connectAttr( 'World_CTL.message', 'BJT_World.World_CTL' )
RIG = cmds.group(em=1, n='RIG')
cmds.parent('World_CTL_GRP', 'All_Init', RIG)
SKIN = cmds.group(em=1, n='SKIN')
cmds.parent('BJT_World_GRP', SKIN)
cmds.setAttr(topRjt + '.v', 0)