def rig(self):
if super(Leg,self).rig():
return True
#create pelvis control
pelvisCtrl = \
control.create(name = self.pelvisJoint.replace('_%s' % common.JOINT, ''),
type = 'cube',
parent = self.controlsGrp,
color = common.SIDE_COLOR[self._getSide()])
#end loop
common.setColor(pelvisCtrl, color = common.SIDE_COLOR[self._getSide()])
pelvisCtrlZero = common.getParent(pelvisCtrl)
transform.matchXform(self.pelvisJoint, pelvisCtrlZero, type = 'pose')
cmds.parentConstraint(pelvisCtrl, self.pelvisJoint, mo = True)
#parent fkCtrls under the pelvis control
cmds.parent(common.getParent(self.controls['fk'][0]), pelvisCtrl)
#parent constraint ik/fk joints to the pelvis control
cmds.parentConstraint(self.pelvisJoint,self.joints['ik'][0], mo = True)
cmds.parentConstraint(self.pelvisJoint, self.joints['target'][0], mo = True)
#add joints to the joints dictionary
self.joints['fk'].insert(0, self.pelvisJoint)
#add controls to the control dictionary
self.controls['fk'].insert(0,pelvisCtrl)
self.hookRoot.pop(0)
self.hookRoot.insert(0, pelvisCtrlZero)
def _createAimLocator(self, position = [0,0,0], color = None):
#create aim locator and move into position
aimLocator = \
cmds.spaceLocator(n = '%s_aim_%s' % (self.name(), common.LOCATOR))[0]
aimZero = \
cmds.createNode('transform',
n = aimLocator.replace(common.LOCATOR, common.ZERO))
cmds.parent(aimLocator, aimZero)
cmds.xform(aimZero, ws = True, t = position)
#create display line between aim locator and start joint
displayLine = control.displayLine(self.startJoint, aimLocator)
cmds.parent(displayLine, self.guidesGrp)
#set color on aim control
common.setColor(aimLocator, color)
#parent locator to zero group
cmds.parent(aimZero, self.masterGuide)
return aimLocator
def setupRig(self):
if common.isValid(self.name()):
return True
self.setupConstraints = []
#makes component a puppet node
self.puppetNode = puppet.create(self.name())
#Create master guide control and
control.createSetup('{0}_master'.format(self.name()), type = 'square')
common.setColor(self.masterGuide, 'darkred')
#create hierarchy
cmds.createNode('transform', n = self.setupRigGrp)
cmds.createNode('transform', n = self.skeletonGrp)
cmds.createNode('transform', n = self.guidesGrp)
cmds.parent(self.skeletonGrp, self.setupRigGrp)
cmds.parent(self.guidesGrp, self.setupRigGrp)
cmds.parent(common.getParent(self.masterGuide),self.guidesGrp)
#add attributes to groups
attribute.addAttr(self.setupRigGrp, 'tag_guides', attrType = 'message')
masterGuideAttr = attribute.addAttr(self.setupRigGrp, 'master_guide', attrType = 'message')
attribute.connect(masterGuideAttr, '%s.tag_controls' % self.masterGuide)
def rig(self):
if super(Arm,self).rig():
return True
'''
if common.isValid(self.clavicleJoint.replace('_%s' % common.JOINT,common.CONTROL)):
return True
'''
#create pelvis control
clavicleCtrl = control.create(
name = self.clavicleJoint.replace('_%s' % common.JOINT,''),
type = 'cube',
parent = self.controlsGrp,
color = common.SIDE_COLOR[self._getSide()])
common.setColor(clavicleCtrl, color = common.SIDE_COLOR[self._getSide()])
clavicleCtrlZero = common.getParent(clavicleCtrl)
transform.matchXform(self.clavicleJoint, clavicleCtrlZero, type = 'pose')
cmds.parentConstraint(clavicleCtrl, self.clavicleJoint, mo = True)
#parent fkCtrls under the pelvis control
cmds.parent(common.getParent(self.controls['fk'][0]), clavicleCtrl)
#parent constraint ik/fk joints to the pelvis control
cmds.parentConstraint(self.clavicleJoint,self.joints['ik'][0], mo = True)
cmds.parentConstraint(self.clavicleJoint, self.joints['target'][0], mo = True)
#add joints to the joints dictionary
self.joints['fk'].insert(0, self.clavicleJoint)
#add controls to the control dictionary
self.controls['fk'].insert(0,clavicleCtrl)
self.hookRoot.pop(0)
self.hookRoot.insert(0, clavicleCtrlZero)
def setupCtrl(self, name, obj, color = None):
'''
:param name: The name of control created
:type name: *str*
:param obj: object to be controled
:type obj: str
:param color: object to be controled
:type color: str
:return: Guide control
:rtype: str
'''
#create hierarchy
guideZero = cmds.createNode('transform', n = '%s_%s' % (name, common.ZERO))
guideShape = cmds.createNode('implicitSphere',n = '%s_%sShape' % (name,common.GUIDES))
guide = common.getParent(guideShape)
guide = cmds.rename(guide, name + '_' + common.GUIDES)
#set color
if color:
common.setColor(guideShape, color)
else:
common.setColor(guideShape, common.SIDE_COLOR[self._getSide()])
#parent guide to zero group
cmds.parent(guide, guideZero)
cmds.delete(cmds.parentConstraint(obj, guideZero, mo = False))
constraint = cmds.pointConstraint(guide, obj)
cmds.parent([guideZero, constraint[0]],self.masterGuide)
#lock and hide attributes
attribute.lockAndHide(['r','s', 'v'], guide)
#tag the guide control with a tag_guides attribute
tagAttr = attribute.addAttr(guide, 'tag_guides', attrType = 'message')
#connect attribute to the setupRigGrp
attribute.connect('%s.tag_guides' % self.setupRigGrp, tagAttr)
return guide
def rig(self):
if not self._puppetNode:
self.runSetupRig()
if cmds.objExists('%s.master_guide' % self.setupRigGrp):
self.masterGuide = attribute.getConnections('master_guide', self.setupRigGrp)[0].split('.')[0]
if common.isValid(self.masterGuide):
#get orientations for controls
fkOrient = self.__fkOrient()
ikOrient = self.__ikOrient()
upVector = self.upVector
aimVector = self.aimVector
#call parent class rig function
if super(Limb, self).rig():
return True
#create ik fk switch
ikfkDict = ikfk.create(jointChain = [self.startJoint, self.midJoint, self.tipJoint], stretch = self.stretch)
ikfkDict['group'] = cmds.rename(ikfkDict['group'], '%s_%s' % (self.name(),ikfkDict['group']))
#set the visibility on the ik/fk/blend joints to off
cmds.setAttr('%s.v' % ikfkDict['fkJoints'][0], 0)
cmds.setAttr('%s.v' % ikfkDict['ikJoints'][0], 0)
cmds.setAttr('%s.v' % ikfkDict['blendJoints'][0], 0)
ikfkAttr = attribute.addAttr(self.rigGrp, attr = 'ikfk', attrType = 'enum', defValue = ['off','on'],value = 0)
cmds.connectAttr(ikfkAttr, '%s.ikfk' % ikfkDict['group'], l = True, f = True)
#parent ikfk group under joints group
cmds.parent(ikfkDict['group'], self.jointsGrp)
#rename all ik and blend joints
for i,jnt in enumerate(ikfkDict['ikJoints']):
jnt = cmds.rename(jnt, jnt.replace('%s_%s_%s' % (common.SKINCLUSTER,common.JOINT, common.IK), '%s_%s' % (common.IK, common.JOINT)))
ikfkDict['ikJoints'][i] = jnt
for i,jnt in enumerate(ikfkDict['blendJoints']):
jnt = cmds.rename(jnt, jnt.replace('%s_%s_%s' % (common.SKINCLUSTER,common.JOINT, common.BLEND), '%s_%s' % (common.BLEND, common.JOINT)))
ikfkDict['blendJoints'][i] = jnt
#create ik setup
ikCtrl = control.create(name = ikfkDict['ikJoints'][2].replace('_%s' % common.JOINT, ''),type = 'cube', parent = self.controlsGrp, color = common.SIDE_COLOR[self._getSide()])
ikCtrlZero = common.getParent(ikCtrl)
attribute.copy('stretch', ikfkDict['group'], destination = ikCtrl, connect = True,reverseConnect = False)
attribute.copy('stretchTop', ikfkDict['group'], destination = ikCtrl, connect = True,reverseConnect = False)
attribute.copy('stretchBottom', ikfkDict['group'], destination = ikCtrl, connect = True,reverseConnect = False)
if ikOrient == 'Local':
transform.matchXform(ikfkDict['ikJoints'][2], ikCtrlZero, type = 'pose')
else:
transform.matchXform(ikfkDict['ikJoints'][2], ikCtrlZero, type = 'position')
cmds.orientConstraint(ikCtrl, ikfkDict['ikJoints'][2], mo = True)
common.setColor(ikCtrl, common.SIDE_COLOR[self._getSide()])
#setup poleVector
pvCtrl = control.create(name = ikfkDict['ikJoints'][2].replace('_%s' % common.JOINT, '_%s' % common.POLEVECTOR),type = 'cube', parent = self.controlsGrp, color = common.SIDE_COLOR[self._getSide()])
#size polevector control
for i in range(len(common.getShapes(pvCtrl))):
control.scaleShape(pvCtrl, scale = [self.controlScale * .5, self.controlScale * .5, self.controlScale * .5], index = i)
pvCtrlZero = common.getParent(pvCtrl)
pvDisplayLineAttr = attribute.addAttr(pvCtrl, attr = 'pvLine', attrType = 'enum', defValue = 'off:on', value = 1)
transform.matchXform(ikfkDict['ikJoints'][1], pvCtrlZero, type = 'position')
#cmds.parent(ikfkDict['ikHandle'], w = True)
pvPos = ikfk.getPoleVectorPosition(ikfkDict['ikJoints'][1], ikfkDict['ikHandle'])
cmds.xform(pvCtrlZero, ws = True, t = pvPos)
common.setColor(pvCtrlZero, common.SIDE_COLOR[self._getSide()])
#create polevector constraint and parent under control
cmds.poleVectorConstraint(pvCtrl, ikfkDict['ikHandle'])
targetConstraint = cmds.pointConstraint(ikCtrl, ikfkDict['targetJnts'][1], mo = True) #ikhandle is under target joint
pvDisplayLine = control.displayLine(ikfkDict['ikJoints'][0], pvCtrl, name = pvCtrl.replace(common.CONTROL, common.DISPLAYLINE), parent = self.controlsGrp)
cmds.orientConstraint(ikCtrl,ikfkDict['ikJoints'][0], mo = True)
#adding attribute to ik ctrl
ikTwistAttr = attribute.addAttr(ikCtrl, attr = 'twist')
cmds.connectAttr(ikTwistAttr, '%s.twist' % ikfkDict['ikHandle'], f = True)
#connecting to shapes
ikfkReverse = cmds.createNode('reverse', n = ikCtrl.replace('%s_%s' % (common.IK, common.CONTROL), '%s_%s' % (common.REVERSE, common.UTILITY)))
attribute.connect('%s.ikfk' % ikfkDict['group'], '%s.inputX' % ikfkReverse)
for shape in common.getShapes(ikCtrl):
attribute.connect('%s.outputX' % ikfkReverse,'%s.v' % shape)
for shape in common.getShapes(pvCtrl):
attribute.connect('%s.outputX' % ikfkReverse,'%s.v' % shape)
#connect pvDisplayLineAttr in pvDisplayLine visibility
displayLineMultiply = cmds.createNode('multiplyDivide', n = pvDisplayLine.replace(common.DISPLAYLINE, common.MULTIPLYDIVIDE))
attribute.connect(pvDisplayLineAttr, '%s.input1X' % displayLineMultiply)
attribute.connect('%s.outputX' % ikfkReverse, '%s.input2X' % displayLineMultiply)
attribute.connect('%s.outputX' % displayLineMultiply, '%s.v' % common.getChildren(pvDisplayLine)[0])
#create fk setup
fkCtrls = list()
parent = self.controlsGrp
for i,jnt in enumerate(ikfkDict['fkJoints']):
cmds.select(cl = True)
#rename fk joint
jnt = cmds.rename(jnt,jnt.replace('%s_%s_%s' % (common.SKINCLUSTER,common.JOINT,common.FK), '%s_%s' % (common.FK,common.JOINT)))
ikfkDict['fkJoints'][i] = jnt #re-assign fk joint intop ikfkDict
#create controls, set color, and make connections
fkCtrl = control.create(name = jnt.replace('_%s' % common.JOINT, ''),type = 'circle', parent = parent, color = common.SIDE_COLOR[self._getSide()])
fkCtrlZero = common.getParent(fkCtrl)
if fkOrient == 'Local':
transform.matchXform(jnt, fkCtrlZero, type = 'pose')
#end if
else:
transform.matchXform(jnt, fkCtrlZero, type = 'position')
#end else
cmds.connectAttr('%s.ikfk' % ikfkDict['group'], '%s.v' % common.getShapes(fkCtrl)[0], f = True)
cmds.parentConstraint(fkCtrl, jnt, mo = True)
attribute.lockAndHide('t', fkCtrl)
attribute.lockAndHide('s', fkCtrl)
attribute.lockAndHide('v', fkCtrl)
#get joint rotate order and apply to control and parent group
rotateOrder = attribute.getValue('rotateOrder', jnt)
for node in [fkCtrl, fkCtrlZero]:
cmds.setAttr('%s.rotateOrder' % node, rotateOrder)
fkCtrls.append(fkCtrl)
parent = fkCtrl
#end loop
#end loop
aimAxis = transform.getAimAxis(ikfkDict['blendJoints'][0], allowNegative = False)
#Up Twist Joint Setup
if self.upTwistJnts:
noTwistJnt = common.duplicate(self.startJoint, name = self.startJoint.replace('%s' % common.SKINCLUSTER, 'NoTwist_%s' % common.SKINCLUSTER), parent = self.startJoint)
inverseMultNode = cmds.createNode('multiplyDivide', n = noTwistJnt.replace('%s_%s' % (common.SKINCLUSTER,common.JOINT), '%s_%s' % (common.UTILITY, common.MULTIPLYDIVIDE)))
cmds.connectAttr('%s.r%s' % (ikfkDict['blendJoints'][0], aimAxis), '%s.input1X' % inverseMultNode, f = True)
cmds.setAttr('%s.input2X' % inverseMultNode, -1)
cmds.connectAttr('%s.outputX' % inverseMultNode, '%s.r%s' % (noTwistJnt, aimAxis), f = True)
step = 1.0 / (len(self.upTwistJnts) +1)
for i in range( 1, (len(self.upTwistJnts)+1) ):
twsitMultNode = cmds.createNode('multiplyDivide', n = self.upTwistJnts[i - 1].replace('%s_%s' % (common.SKINCLUSTER,common.JOINT), '%s_%s' % (common.UTILITY, common.MULTIPLYDIVIDE)))
cmds.connectAttr('%s.r%s' % (ikfkDict['blendJoints'][0], aimAxis), '%s.input1X' % twsitMultNode, f = True)
cmds.setAttr('%s.input2X' % twsitMultNode, -(1-(step*i)) )
cmds.connectAttr('%s.outputX' % twsitMultNode, '%s.r%s' % (self.upTwistJnts[i -1], aimAxis),f = True)
#end loop
self.upTwistJnts.insert(0, noTwistJnt)
#end if
if self.loTwistJnts:
twistJnt = common.duplicate(self.midJoint,name = self.midJoint.replace('%s' % common.SKINCLUSTER, 'loTwist_%s' % common.SKINCLUSTER), parent = self.midJoint)
constraint = cmds.aimConstraint(ikfkDict['blendJoints'][2],twistJnt,aimVector = aimVector, upVector = upVector, worldUpType ="objectrotation", worldUpVector = upVector, worldUpObject = self.tipJoint)
cmds.setAttr('%s.v' % twistJnt, 0)
#end if
step = 1.0 / (len(self.loTwistJnts) +1)
for i in range( 1, (len(self.loTwistJnts)+1) ):
twsitMultNode = cmds.createNode('multiplyDivide', n = self.loTwistJnts[i - 1].replace('%s_%s' % (common.SKINCLUSTER,common.JOINT), '%s_%s' % (common.UTILITY, common.MULTIPLYDIVIDE)))
cmds.connectAttr('%s.r%s' % (ikfkDict['blendJoints'][2], aimAxis), '%s.input1X' % twsitMultNode, f = True)
cmds.setAttr('%s.input2X' % twsitMultNode, 1-(step*i) )
cmds.connectAttr('%s.outputX' % twsitMultNode, '%s.r%s' % (self.loTwistJnts[i -1], aimAxis),f = True)
#end loop
#------------------------
#Add to class variables
#------------------------
#assign joints to the joints list
self.joints = {'ik' : ikfkDict['ikJoints'], 'fk' : ikfkDict['fkJoints'], 'blend' : ikfkDict['blendJoints'], 'target' : ikfkDict['targetJnts']}
#assign controls to the controls list
#assign fkCtrls into the controls dictionary
self.controls = {'ik' : [ikCtrl, pvCtrl],'fk' : fkCtrls }
self.ikfkGroup = ikfkDict['group']
#assign hooks
self.hookRoot = [ikfkDict['ikJoints'][0], common.getParent(fkCtrls[0]), ikCtrl, ikfkDict['targetJnts'][-1]]
self.hookPoint = [ikfkDict['blendJoints'][-1]]
#add no twist joint to the skincluster list
self.skinClusterJnts.append(noTwistJnt)
