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 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 annotation(self, side):
if side == 'L':
eyeCtl = self.rigInstance.eyeLCtl
eyeJnt = self.rigInstance.eyeLJnt
else:
eyeCtl = self.rigInstance.eyeRCtl
eyeJnt = self.rigInstance.eyeRJnt
loc = cmds.spaceLocator(n='Eye_%s_AnnotatLoc' % side)[0]
locShape = cmds.listRelatives(loc, s=1)[0]
annotateShape = cmds.createNode('annotationShape',
n='Eye_%s_AnnotateShape' % side)
annotate = cmds.listRelatives(annotateShape, p=1)[0]
cmds.rename(annotate, 'Eye_%s_Annotate' % side)
cmds.parent(annotate, eyeCtl)
rigbase.constraint(eyeJnt, annotate, r=0)
cmds.connectAttr(locShape + '.wm',
annotateShape + '.dagObjectMatrix[0]')
cmds.parent(loc, eyeCtl)
rigbase.transformDefault(loc)
cmds.setAttr(loc + '.v', 0)
cmds.setAttr(annotate + '.overrideEnabled', True)
cmds.setAttr(annotate + '.overrideDisplayType', 2)
def allSet(self):
colorLIndexList = [21, 20, 4, 15, 18]
colorRIndexList = [21, 20, 4, 15, 18]
def createScaleNode(switchCtl):
scaleNode = cmds.createNode('multiplyDivide',
n=switchCtl + '_handScale')
cmds.setAttr(scaleNode + '.op', 3)
cmds.connectAttr(switchCtl + '.handScale', scaleNode + '.input2X')
cmds.connectAttr(switchCtl + '.handScale', scaleNode + '.input2Y')
cmds.connectAttr(switchCtl + '.handScale', scaleNode + '.input2Z')
cmds.setAttr(scaleNode + '.input1X', 2)
cmds.setAttr(scaleNode + '.input1Y', 2)
cmds.setAttr(scaleNode + '.input1Z', 2)
return scaleNode
handLGrp = rigbase.Transform(n='Hand_L_CTL_GRP')
rigbase.constraint(self.handLConst, handLGrp)
cmds.connectAttr(self.switchLCtl + '.fingerCtl', handLGrp + '.v')
handRGrp = rigbase.Transform(n='Hand_R_CTL_GRP')
rigbase.constraint(self.handRConst, handRGrp)
cmds.connectAttr(self.switchRCtl + '.fingerCtl', handRGrp + '.v')
handLGrp.setParent(self.rootGrp)
handRGrp.setParent(self.rootGrp)
for inits in self.fingerLInits:
self.ctlSet.create(inits[:-1], handLGrp, colorLIndexList.pop(0))
self.aimObjSet.create(self.ctlSet.ctls)
self.jointSet.create(inits, self.ctlSet.ctls,
self.aimObjSet.aimObjs, self.handLRjt)
for inits in self.fingerRInits:
self.ctlSet.create(inits[:-1], handRGrp, colorRIndexList.pop(0))
self.aimObjSet.create(self.ctlSet.ctls)
self.jointSet.create(inits, self.ctlSet.ctls,
self.aimObjSet.aimObjs, self.handRRjt)
scaleNode = createScaleNode(self.switchLCtl)
cmds.connectAttr(scaleNode + '.output', handLGrp + '.s')
cmds.connectAttr(scaleNode + '.output', self.handLRjt + '.s', f=1)
children = cmds.listRelatives(self.handLRjt, c=1, type='joint')
for child in children:
cmds.setAttr(child + '.ssc', False)
scaleNode = createScaleNode(self.switchRCtl)
cmds.connectAttr(scaleNode + '.output', handRGrp + '.s')
cmds.connectAttr(scaleNode + '.output', self.handRRjt + '.s', f=1)
children = cmds.listRelatives(self.handRRjt, c=1, type='joint')
for child in children:
cmds.setAttr(child + '.ssc', False)
def allSet(self):
colorLIndexList = [ 21, 20, 4, 15, 18 ]
colorRIndexList = [ 21, 20, 4, 15, 18 ]
def createScaleNode( switchCtl ):
scaleNode = cmds.createNode( 'multiplyDivide', n=switchCtl+'_handScale' )
cmds.setAttr( scaleNode+'.op', 3 )
cmds.connectAttr( switchCtl+'.handScale', scaleNode+'.input2X' )
cmds.connectAttr( switchCtl+'.handScale', scaleNode+'.input2Y' )
cmds.connectAttr( switchCtl+'.handScale', scaleNode+'.input2Z' )
cmds.setAttr( scaleNode+'.input1X', 2 )
cmds.setAttr( scaleNode+'.input1Y', 2 )
cmds.setAttr( scaleNode+'.input1Z', 2 )
return scaleNode
handLGrp = rigbase.Transform( n='Hand_L_CTL_GRP' )
rigbase.constraint( self.handLConst, handLGrp )
cmds.connectAttr( self.switchLCtl+'.fingerCtl', handLGrp+'.v' )
handRGrp = rigbase.Transform( n='Hand_R_CTL_GRP' )
rigbase.constraint( self.handRConst, handRGrp )
cmds.connectAttr( self.switchRCtl+'.fingerCtl', handRGrp+'.v' )
handLGrp.setParent( self.rootGrp )
handRGrp.setParent( self.rootGrp )
for inits in self.fingerLInits:
self.ctlSet.create( inits[:-1], handLGrp, colorLIndexList.pop(0) )
self.aimObjSet.create( self.ctlSet.ctls )
self.jointSet.create( inits, self.ctlSet.ctls, self.aimObjSet.aimObjs, self.handLRjt )
for inits in self.fingerRInits:
self.ctlSet.create( inits[:-1], handRGrp, colorRIndexList.pop(0) )
self.aimObjSet.create( self.ctlSet.ctls )
self.jointSet.create( inits, self.ctlSet.ctls, self.aimObjSet.aimObjs, self.handRRjt )
scaleNode = createScaleNode( self.switchLCtl )
cmds.connectAttr( scaleNode+'.output', handLGrp+'.s' )
cmds.connectAttr( scaleNode+'.output', self.handLRjt+'.s', f=1 )
children = cmds.listRelatives( self.handLRjt, c=1, type='joint' )
for child in children:
cmds.setAttr( child+'.ssc', False )
scaleNode = createScaleNode( self.switchRCtl )
cmds.connectAttr( scaleNode+'.output', handRGrp+'.s' )
cmds.connectAttr( scaleNode+'.output', self.handRRjt+'.s', f=1 )
children = cmds.listRelatives( self.handRRjt, c=1, type='joint' )
for child in children:
cmds.setAttr( child+'.ssc', False )
def addControler( target, targetAttrList, **options ):
hik = rigbase.Controler( n=target.replace( 'MOC', 'HIK' ) )
hik.setShape( **options )
hik.setParent( allMoc )
rigbase.constraint( target, hik.transformGrp )
attrEdit = rigbase.AttrEdit( hik.name )
attrEdit.lockAndHideAttrs( 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' )
for targetAttr in targetAttrList:
index = targetAttrList.index( targetAttr )
if not targetAttr: continue
attrEdit.addAttr( ln=attrNameList[ index ], min=0, max=1, k=1 )
cmds.connectAttr( hik +'.'+ attrNameList[index], properties+'.'+targetAttr )
def create(self, inits, ctls, aimObjs, parentTarget ):
cmds.select( parentTarget )
jnts = []
for init in inits:
jnt = cmds.joint( n=init.replace( 'Init', 'RJT' ), radius=.5 )
jnts.append( jnt )
rigbase.connectSameAttr( inits[-1], jnt ).doIt( 't', 'r' )
for i in range( len( aimObjs ) ):
aimObj = aimObjs[i]
jnt = jnts[i]
rigbase.constraint( aimObj, jnt )
rigbase.constraint( ctls[-1], jnts[-2] )
def torsoPartJointSet(self ):
torsoTransforms = self.torsoPart.outputTransform
self.torsoInitJnts = []
self.torsoInits = []
cmds.select( d=1 )
for torsoTr in torsoTransforms:
if torsoTr.find( 'Collar' ) != -1:
cmds.select( self.torsoInitJnts[2] )
initJnt = cmds.joint( n='_'.join( torsoTr.split('_')[:-1] ) + '_InitJnt' )
rigbase.constraint( torsoTr, initJnt )
self.torsoInitJnts.append( initJnt )
self.torsoInits.append( initJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( initJnt )
def create(self, inits, ctls, aimObjs, parentTarget):
cmds.select(parentTarget)
jnts = []
for init in inits:
jnt = cmds.joint(n=init.replace('Init', 'RJT'), radius=.5)
jnts.append(jnt)
rigbase.connectSameAttr(inits[-1], jnt).doIt('t', 'r')
for i in range(len(aimObjs)):
aimObj = aimObjs[i]
jnt = jnts[i]
rigbase.constraint(aimObj, jnt)
rigbase.constraint(ctls[-1], jnts[-2])
def torsoPartJointSet(self):
torsoTransforms = self.torsoPart.outputTransform
self.torsoInitJnts = []
self.torsoInits = []
cmds.select(d=1)
for torsoTr in torsoTransforms:
if torsoTr.find('Collar') != -1:
cmds.select(self.torsoInitJnts[2])
initJnt = cmds.joint(n='_'.join(torsoTr.split('_')[:-1]) +
'_InitJnt')
rigbase.constraint(torsoTr, initJnt)
self.torsoInitJnts.append(initJnt)
self.torsoInits.append(initJnt.replace('InitJnt', 'Init'))
cmds.select(initJnt)
def fingerPartJointSet(self):
handLObjs = self.fingerPart.outputTransformL
handRObjs = self.fingerPart.outputTransformR
self.fingerLInitJnts = []
self.fingerRInitJnts = []
self.fingerLInits = []
self.fingerRInits = []
for fingerLObjs in handLObjs:
initJnts = []
inits = []
cmds.select(self.armLInitJnts[2])
for fingerObj in fingerLObjs:
splitName = fingerObj.split('_')[:-1]
jntName = '_'.join(splitName) + '_InitJnt'
fingerJnt = cmds.joint(n=jntName, radius=.5)
rigbase.constraint(fingerObj, fingerJnt)
initJnts.append(fingerJnt)
inits.append(fingerJnt.replace('InitJnt', 'Init'))
cmds.select(fingerJnt)
self.fingerLInitJnts.append(initJnts)
self.fingerLInits.append(inits)
for fingerRObjs in handRObjs:
initJnts = []
inits = []
cmds.select(self.armRInitJnts[2])
for fingerObj in fingerRObjs:
splitName = fingerObj.split('_')[:-1]
jntName = '_'.join(splitName) + '_InitJnt'
fingerJnt = cmds.joint(n=jntName, radius=.5)
rigbase.constraint(fingerObj, fingerJnt)
initJnts.append(fingerJnt)
inits.append(fingerJnt.replace('InitJnt', 'Init'))
cmds.select(fingerJnt)
self.fingerRInitJnts.append(initJnts)
self.fingerRInits.append(inits)
def fingerPartJointSet(self):
handLObjs = self.fingerPart.outputTransformL
handRObjs = self.fingerPart.outputTransformR
self.fingerLInitJnts = []
self.fingerRInitJnts = []
self.fingerLInits = []
self.fingerRInits = []
for fingerLObjs in handLObjs:
initJnts = []
inits = []
cmds.select( self.armLInitJnts[2] )
for fingerObj in fingerLObjs:
splitName = fingerObj.split( '_' )[:-1]
jntName = '_'.join( splitName )+'_InitJnt'
fingerJnt = cmds.joint( n=jntName, radius=.5 )
rigbase.constraint( fingerObj, fingerJnt )
initJnts.append( fingerJnt )
inits.append( fingerJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( fingerJnt )
self.fingerLInitJnts.append( initJnts )
self.fingerLInits.append( inits )
for fingerRObjs in handRObjs:
initJnts = []
inits = []
cmds.select( self.armRInitJnts[2] )
for fingerObj in fingerRObjs:
splitName = fingerObj.split( '_' )[:-1]
jntName = '_'.join( splitName )+'_InitJnt'
fingerJnt = cmds.joint( n=jntName, radius=.5 )
rigbase.constraint( fingerObj, fingerJnt )
initJnts.append( fingerJnt )
inits.append( fingerJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( fingerJnt )
self.fingerRInitJnts.append( initJnts )
self.fingerRInits.append( inits )
def collarJointSet( self, jntNum, side ):
if side == 'L':
inverse = False
si = 0
elif side == 'R':
inverse = True
si = 1
shoulderCtlList = [self.shoulderLCtl,self.shoulderRCtl]
collarCtlList = [self.collarLCtl, self.collarRCtl]
collarJntList = [self.collarLJnts, self.collarRJnts ]
aimObject = rigbase.makeAimObject( shoulderCtlList[si], collarCtlList[si], inverseAim = inverse )[0]
aimObject = cmds.rename( aimObject, "Shoulder_%s_CTL_AimObj" % side )
mtxDcmp = rigbase.getChildMtxDcmp( shoulderCtlList[si], aimObject )
cmds.setAttr( mtxDcmp+'.inverseDistance', inverse )
distSep = cmds.createNode( 'distanceSeparator', n='Collar_%s_DistSep' % side )
cmds.connectAttr( mtxDcmp+'.outputDistance', distSep+'.inputDistance' )
cmds.select( self.splineJnts[-1] )
collarJntList[si].append( cmds.joint( n='Collar0_%s_RJT' % side, radius=1.5 ) )
rigbase.constraint( aimObject, collarJntList[si][0] )
twistMult = cmds.createNode( 'multDoubleLinear', n='Collar_%s_twistMult' % side )
cmds.setAttr( twistMult+'.input2', 1.0/(len( collarJntList )-1) )
cmds.connectAttr( shoulderCtlList[si]+'.twistCollar', twistMult+'.input1' )
cmds.select( collarJntList[si][0] )
for i in range( jntNum-1 ):
prValue = float(i+1)/jntNum
jnt = cmds.joint( n='Collar%d_%s_RJT' %( i+1, side ), radius=1.5 )
collarJntList[si].append( jnt )
cmds.addAttr( jnt, ln='parameter', min=0, max=1, dv=prValue )
cmds.setAttr( jnt+'.parameter', e=1, k=1 )
cmds.connectAttr( jnt+'.parameter', distSep+'.pr[%d]' % (i+1) )
cmds.connectAttr( distSep+'.sd[%d]' % (i+1), jnt+'.tx', f=1 )
cmds.connectAttr( twistMult+'.output', jnt+'.rx' )
def annotation(self, side ):
if side == 'L':
eyeCtl = self.rigInstance.eyeLCtl
eyeJnt = self.rigInstance.eyeLJnt
else:
eyeCtl = self.rigInstance.eyeRCtl
eyeJnt = self.rigInstance.eyeRJnt
loc = cmds.spaceLocator( n='Eye_%s_AnnotatLoc' % side )[0]
locShape = cmds.listRelatives( loc, s=1 )[0]
annotateShape = cmds.createNode( 'annotationShape', n='Eye_%s_AnnotateShape' % side )
annotate = cmds.listRelatives( annotateShape, p=1 )[0]
cmds.rename( annotate, 'Eye_%s_Annotate' % side )
cmds.parent( annotate, eyeCtl )
rigbase.constraint( eyeJnt, annotate, r=0 )
cmds.connectAttr( locShape+'.wm', annotateShape+'.dagObjectMatrix[0]' )
cmds.parent( loc, eyeCtl )
rigbase.transformDefault( loc )
cmds.setAttr( loc+'.v', 0 )
cmds.setAttr( annotate+'.overrideEnabled', True )
cmds.setAttr( annotate+'.overrideDisplayType', 2 )
def headPartJointSet(self):
headObjs = self.headPart.outputTransform
self.headInitJnts = []
self.headInits = []
cmds.select( self.torsoInitJnts[2] )
for headObj in headObjs:
index = headObjs.index( headObj )
if index == 4:
cmds.select( self.headInitJnts[2] )
splitName = headObj.split( '_' )[:-1]
jntName = '_'.join( splitName )+'_InitJnt'
headJnt = cmds.joint( n=jntName )
rigbase.constraint( headObj, headJnt )
self.headInitJnts.append( headJnt )
self.headInits.append( headJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( headJnt )
if index == len( headObjs )-2:
cmds.select( self.headInitJnts[2] )
def headPartJointSet(self):
headObjs = self.headPart.outputTransform
self.headInitJnts = []
self.headInits = []
cmds.select(self.torsoInitJnts[2])
for headObj in headObjs:
index = headObjs.index(headObj)
if index == 4:
cmds.select(self.headInitJnts[2])
splitName = headObj.split('_')[:-1]
jntName = '_'.join(splitName) + '_InitJnt'
headJnt = cmds.joint(n=jntName)
rigbase.constraint(headObj, headJnt)
self.headInitJnts.append(headJnt)
self.headInits.append(headJnt.replace('InitJnt', 'Init'))
cmds.select(headJnt)
if index == len(headObjs) - 2:
cmds.select(self.headInitJnts[2])
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 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 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 armPartJointSet(self):
armLObjs = self.armPart.outputTransformL
armLObjs += self.armPart.outputAddTrL
self.armLInitJnts = []
self.armLInits = []
armRObjs = self.armPart.outputTransformR
armRObjs += self.armPart.outputAddTrR
self.armRInitJnts = []
self.armRInits = []
cmds.select( self.torsoInitJnts[-2] )
for armLObj in armLObjs:
index = armLObjs.index( armLObj )
if index in [3,4]:
cmds.select( self.armLInitJnts[0] )
if index == 5:
cmds.select( self.armLInitJnts[1] )
splitName = armLObj.split( '_' )[:-1]
jntName = '_'.join( splitName )+'_InitJnt'
armLJnt = cmds.joint( n=jntName )
if index == 3:
rigbase.transformDefault( armLJnt )
rigbase.constraint( armLObj, armLJnt, r=0 )
elif index in [4,5]:
armLObjP = cmds.listRelatives( armLObj, p=1 )[0]
cmds.setAttr( armLObjP+'.dh', 0 )
rigbase.constraint( armLObjP, armLJnt )
cmds.select( armLJnt )
cmds.rename( armLJnt, armLJnt.replace( '_InitJnt', '_InitJnt_GRP' ))
armLJnt = cmds.joint( n=armLJnt.replace( '_GRP', '' ) )
rigbase.constraint( armLObj, armLJnt )
else:
rigbase.constraint( armLObj, armLJnt )
self.armLInitJnts.append( armLJnt )
self.armLInits.append( armLJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( armLJnt )
cmds.select( self.torsoInitJnts[-1] )
for armRObj in armRObjs:
index = armRObjs.index( armRObj )
if index in [3,4]:
cmds.select( self.armRInitJnts[0] )
if index == 5:
cmds.select( self.armRInitJnts[1] )
splitName = armRObj.split( '_' )[:-1]
jntName = '_'.join( splitName )+'_InitJnt'
armRJnt = cmds.joint( n=jntName )
if index == 3:
rigbase.transformDefault( armRJnt )
rigbase.constraint( armRObj, armRJnt, r=0 )
elif index in [4,5]:
armRObjP = cmds.listRelatives( armRObj, p=1 )[0]
cmds.setAttr( armRObjP+'.dh', 0 )
rigbase.constraint( armRObjP, armRJnt )
cmds.select( armRJnt )
cmds.rename( armRJnt, armRJnt.replace( '_InitJnt', '_InitJnt_GRP' ))
armRJnt = cmds.joint( n=armRJnt.replace( '_GRP', '' ) )
rigbase.constraint( armRObj, armRJnt )
else:
rigbase.constraint( armRObj, armRJnt )
self.armRInitJnts.append( armRJnt )
self.armRInits.append( armRJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( armRJnt )
def legPartJointSet(self):
legLObjs = self.legPart.outputTransformL
legLObjs += self.legPart.outputAddTrL
self.legLInitJnts = []
self.legLInits = []
legRObjs = self.legPart.outputTransformR
legRObjs += self.legPart.outputAddTrR
self.legRInitJnts = []
self.legRInits = []
cmds.select( self.torsoInitJnts[0] )
for legLObj in legLObjs:
index = legLObjs.index( legLObj )
if index in [3,11]:
cmds.select( self.legLInitJnts[0] )
if index == 4:
cmds.select( self.legLInitJnts[2] )
if index == 6:
cmds.select( self.legLInitJnts[2] )
if index == 12:
cmds.select( self.legLInitJnts[1] )
splitName = legLObj.split( '_' )[:-1]
jntName = '_'.join( splitName )+'_InitJnt'
legLJnt = cmds.joint( n=jntName )
if index == 3:
rigbase.transformDefault( legLJnt )
rigbase.constraint( legLObj, legLJnt, r=0 )
elif index in [11,12]:
legLObjP = cmds.listRelatives( legLObj, p=1 )[0]
cmds.setAttr( legLObjP+'.dh', 0 )
rigbase.constraint( legLObjP, legLJnt )
cmds.select( legLJnt )
cmds.rename( legLJnt, legLJnt.replace( '_InitJnt', '_InitJnt_GRP' ))
legLJnt = cmds.joint( n=legLJnt.replace( '_GRP', '' ) )
rigbase.constraint( legLObj, legLJnt )
else:
rigbase.constraint( legLObj, legLJnt )
self.legLInitJnts.append( legLJnt )
self.legLInits.append( legLJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( legLJnt )
cmds.select( self.torsoInitJnts[0] )
for legRObj in legRObjs:
index = legRObjs.index( legRObj )
if index in [3,11]:
cmds.select( self.legRInitJnts[0] )
if index == 4:
cmds.select( self.legRInitJnts[2] )
if index == 6:
cmds.select( self.legRInitJnts[2] )
if index == 12:
cmds.select( self.legRInitJnts[1] )
splitName = legRObj.split( '_' )[:-1]
jntName = '_'.join( splitName )+'_InitJnt'
legRJnt = cmds.joint( n=jntName )
if index == 3:
rigbase.transformDefault( legRJnt )
rigbase.constraint( legRObj, legRJnt, r=0 )
elif index in [11,12]:
legRObjP = cmds.listRelatives( legRObj, p=1 )[0]
cmds.setAttr( legRObjP+'.dh', 0 )
rigbase.constraint( legRObjP, legRJnt )
cmds.select( legRJnt )
cmds.rename( legRJnt, legRJnt.replace( '_InitJnt', '_InitJnt_GRP' ))
legRJnt = cmds.joint( n=legRJnt.replace( '_GRP', '' ) )
rigbase.constraint( legRObj, legRJnt )
else:
rigbase.constraint( legRObj, legRJnt )
self.legRInitJnts.append( legRJnt )
self.legRInits.append( legRJnt.replace( 'InitJnt', 'Init' ) )
cmds.select( legRJnt )
def constrainEnd(self, endCtl ):
rigbase.constraint( endCtl, self.rjts[-1] )
def armPartJointSet(self):
armLObjs = self.armPart.outputTransformL
armLObjs += self.armPart.outputAddTrL
self.armLInitJnts = []
self.armLInits = []
armRObjs = self.armPart.outputTransformR
armRObjs += self.armPart.outputAddTrR
self.armRInitJnts = []
self.armRInits = []
cmds.select(self.torsoInitJnts[-2])
for armLObj in armLObjs:
index = armLObjs.index(armLObj)
if index in [3, 4]:
cmds.select(self.armLInitJnts[0])
if index == 5:
cmds.select(self.armLInitJnts[1])
splitName = armLObj.split('_')[:-1]
jntName = '_'.join(splitName) + '_InitJnt'
armLJnt = cmds.joint(n=jntName)
if index == 3:
rigbase.transformDefault(armLJnt)
rigbase.constraint(armLObj, armLJnt, r=0)
elif index in [4, 5]:
armLObjP = cmds.listRelatives(armLObj, p=1)[0]
cmds.setAttr(armLObjP + '.dh', 0)
rigbase.constraint(armLObjP, armLJnt)
cmds.select(armLJnt)
cmds.rename(armLJnt, armLJnt.replace('_InitJnt',
'_InitJnt_GRP'))
armLJnt = cmds.joint(n=armLJnt.replace('_GRP', ''))
rigbase.constraint(armLObj, armLJnt)
else:
rigbase.constraint(armLObj, armLJnt)
self.armLInitJnts.append(armLJnt)
self.armLInits.append(armLJnt.replace('InitJnt', 'Init'))
cmds.select(armLJnt)
cmds.select(self.torsoInitJnts[-1])
for armRObj in armRObjs:
index = armRObjs.index(armRObj)
if index in [3, 4]:
cmds.select(self.armRInitJnts[0])
if index == 5:
cmds.select(self.armRInitJnts[1])
splitName = armRObj.split('_')[:-1]
jntName = '_'.join(splitName) + '_InitJnt'
armRJnt = cmds.joint(n=jntName)
if index == 3:
rigbase.transformDefault(armRJnt)
rigbase.constraint(armRObj, armRJnt, r=0)
elif index in [4, 5]:
armRObjP = cmds.listRelatives(armRObj, p=1)[0]
cmds.setAttr(armRObjP + '.dh', 0)
rigbase.constraint(armRObjP, armRJnt)
cmds.select(armRJnt)
cmds.rename(armRJnt, armRJnt.replace('_InitJnt',
'_InitJnt_GRP'))
armRJnt = cmds.joint(n=armRJnt.replace('_GRP', ''))
rigbase.constraint(armRObj, armRJnt)
else:
rigbase.constraint(armRObj, armRJnt)
self.armRInitJnts.append(armRJnt)
self.armRInits.append(armRJnt.replace('InitJnt', 'Init'))
cmds.select(armRJnt)
def constrainEnd(self, endCtl):
rigbase.constraint(endCtl, self.rjts[-1])
def legPartJointSet(self):
legLObjs = self.legPart.outputTransformL
legLObjs += self.legPart.outputAddTrL
self.legLInitJnts = []
self.legLInits = []
legRObjs = self.legPart.outputTransformR
legRObjs += self.legPart.outputAddTrR
self.legRInitJnts = []
self.legRInits = []
cmds.select(self.torsoInitJnts[0])
for legLObj in legLObjs:
index = legLObjs.index(legLObj)
if index in [3, 11]:
cmds.select(self.legLInitJnts[0])
if index == 4:
cmds.select(self.legLInitJnts[2])
if index == 6:
cmds.select(self.legLInitJnts[2])
if index == 12:
cmds.select(self.legLInitJnts[1])
splitName = legLObj.split('_')[:-1]
jntName = '_'.join(splitName) + '_InitJnt'
legLJnt = cmds.joint(n=jntName)
if index == 3:
rigbase.transformDefault(legLJnt)
rigbase.constraint(legLObj, legLJnt, r=0)
elif index in [11, 12]:
legLObjP = cmds.listRelatives(legLObj, p=1)[0]
cmds.setAttr(legLObjP + '.dh', 0)
rigbase.constraint(legLObjP, legLJnt)
cmds.select(legLJnt)
cmds.rename(legLJnt, legLJnt.replace('_InitJnt',
'_InitJnt_GRP'))
legLJnt = cmds.joint(n=legLJnt.replace('_GRP', ''))
rigbase.constraint(legLObj, legLJnt)
else:
rigbase.constraint(legLObj, legLJnt)
self.legLInitJnts.append(legLJnt)
self.legLInits.append(legLJnt.replace('InitJnt', 'Init'))
cmds.select(legLJnt)
cmds.select(self.torsoInitJnts[0])
for legRObj in legRObjs:
index = legRObjs.index(legRObj)
if index in [3, 11]:
cmds.select(self.legRInitJnts[0])
if index == 4:
cmds.select(self.legRInitJnts[2])
if index == 6:
cmds.select(self.legRInitJnts[2])
if index == 12:
cmds.select(self.legRInitJnts[1])
splitName = legRObj.split('_')[:-1]
jntName = '_'.join(splitName) + '_InitJnt'
legRJnt = cmds.joint(n=jntName)
if index == 3:
rigbase.transformDefault(legRJnt)
rigbase.constraint(legRObj, legRJnt, r=0)
elif index in [11, 12]:
legRObjP = cmds.listRelatives(legRObj, p=1)[0]
cmds.setAttr(legRObjP + '.dh', 0)
rigbase.constraint(legRObjP, legRJnt)
cmds.select(legRJnt)
cmds.rename(legRJnt, legRJnt.replace('_InitJnt',
'_InitJnt_GRP'))
legRJnt = cmds.joint(n=legRJnt.replace('_GRP', ''))
rigbase.constraint(legRObj, legRJnt)
else:
rigbase.constraint(legRObj, legRJnt)
self.legRInitJnts.append(legRJnt)
self.legRInits.append(legRJnt.replace('InitJnt', 'Init'))
cmds.select(legRJnt)
