Beispiel #1
0
def cvBaseGuide(ctrlName, r=1):
    """Create a control to be used as a Base Guide control.
        Returns the main control (circle) and the radius control in a list.
    """
    # get radius by checking linear unit
    r = dpCheckLinearUnit(r)
    # create a simple circle curve:
    circle = cmds.circle(n=ctrlName, ch=True, o=True, nr=(0, 0, 1), d=3, s=8, radius=r)[0]
    radiusCtrl = cmds.circle(n=ctrlName+"_RadiusCtrl", ch=True, o=True, nr=(0, 1, 0), d=3, s=8, radius=(r/4.0))[0]
    # rename curveShape:
    renameShape([circle, radiusCtrl])
    # configure system of limits and radius:
    cmds.setAttr(radiusCtrl+".translateX", r)
    cmds.parent(radiusCtrl, circle, relative=True)
    cmds.transformLimits(radiusCtrl, tx=(0.01, 1), etx=(True, False))
    setLockHide([radiusCtrl], ['ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
    # find makeNurbCircle history of the circles:
    historyList = findHistory([circle, radiusCtrl], 'makeNurbCircle')
    circleHistory     = historyList[0]
    radiusCtrlHistory = historyList[1]
    # rename and make a connection for circle:
    circleHistory = cmds.rename(circleHistory, circle+"_makeNurbCircle")
    cmds.connectAttr(radiusCtrl+".tx", circleHistory+".radius", force=True)
    radiusCtrlHistory = cmds.rename(radiusCtrlHistory, radiusCtrl+"_makeNurbCircle")
    # create a mutiplyDivide in order to automatisation the radius of the radiusCtrl:
    radiusCtrlMD = cmds.createNode('multiplyDivide', name=radiusCtrl+'_MD')
    cmds.connectAttr(radiusCtrl+'.translateX', radiusCtrlMD+'.input1X', force=True)
    cmds.setAttr(radiusCtrlMD+'.input2X', 0.15)
    cmds.connectAttr(radiusCtrlMD+".outputX", radiusCtrlHistory+".radius", force=True)
    # colorize curveShapes:
    colorShape([circle, radiusCtrl], 'yellow')
    cmds.select(clear=True)
    return [circle, radiusCtrl]
Beispiel #2
0
 def createGuide(self, *args):
     Base.StartClass.createGuide(self)
     # Custom GUIDE:
     cmds.addAttr(self.moduleGrp, longName="flip", attributeType='bool')
     cmds.setAttr(self.moduleGrp+".flip", 0)
     
     cmds.addAttr(self.moduleGrp, longName="indirectSkin", attributeType='bool')
     cmds.setAttr(self.moduleGrp+".indirectSkin", 0)
     
     cmds.setAttr(self.moduleGrp+".moduleNamespace", self.moduleGrp[:self.moduleGrp.rfind(":")], type='string')
     
     self.cvJointLoc, shapeSizeCH = ctrls.cvJointLoc(ctrlName=self.guideName+"_JointLoc1", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.jGuide1 = cmds.joint(name=self.guideName+"_JGuide1", radius=0.001)
     cmds.setAttr(self.jGuide1+".template", 1)
     cmds.parent(self.jGuide1, self.moduleGrp, relative=True)
     
     self.cvEndJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName+"_JointEnd", r=0.1)
     self.connectShapeSize(shapeSizeCH)
     cmds.parent(self.cvEndJoint, self.cvJointLoc)
     cmds.setAttr(self.cvEndJoint+".tz", 1.3)
     self.jGuideEnd = cmds.joint(name=self.guideName+"_JGuideEnd", radius=0.001)
     cmds.setAttr(self.jGuideEnd+".template", 1)
     cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False))
     ctrls.setLockHide([self.cvEndJoint], ['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
     
     cmds.parent(self.cvJointLoc, self.moduleGrp)
     cmds.parent(self.jGuideEnd, self.jGuide1)
     cmds.parentConstraint(self.cvJointLoc, self.jGuide1, maintainOffset=False, name=self.jGuide1+"_ParentConstraint")
     cmds.parentConstraint(self.cvEndJoint, self.jGuideEnd, maintainOffset=False, name=self.jGuideEnd+"_ParentConstraint")
     cmds.scaleConstraint(self.cvJointLoc, self.jGuide1, maintainOffset=False, name=self.jGuide1+"_ScaleConstraint")
     cmds.scaleConstraint(self.cvEndJoint, self.jGuideEnd, maintainOffset=False, name=self.jGuideEnd+"_ScaleConstraint")
Beispiel #3
0
def sliderA(prefix):
    cmds.undoInfo(openChunk=True)
    
    #create nodes
    grp=cmds.group(empty=True,n=(prefix+'_grp'))
    cnt=cmds.circle(r=0.1,ch=False,n=(prefix+'_cnt'))
    shp=cmds.circle(o=True,r=1,ch=False,d=1,s=4,n=(prefix+'_shp'))
    
    #setup shp
    cmds.move(-1,0,0,'%s.cv[0]' % shp[0],r=True,os=True)
    cmds.move(-1,0,0,'%s.cv[4]' % shp[0],r=True,os=True)
    cmds.move(0,-1,0,'%s.cv[1]' % shp[0],r=True,os=True)
    cmds.move(1,0,0,'%s.cv[2]' % shp[0],r=True,os=True)
    cmds.move(0,1,0,'%s.cv[3]' % shp[0],r=True,os=True)
    
    cmds.parent(shp,grp)
    
    cmds.setAttr('%s.overrideEnabled' % shp[0],1)
    cmds.setAttr('%s.overrideDisplayType' % shp[0],2)
    
    #setup cnt
    cmds.parent(cnt,shp)
    
    cmds.setAttr('%s.overrideEnabled' % cnt[0],1)
    
    cmds.transformLimits(cnt,tx=(-1,1),etx=(1,1))
    cmds.transformLimits(cnt,ty=(-1,1),ety=(1,1))
    
    setupAttrs(prefix,cnt[0])
    
    return grp
    
    cmds.undoInfo(closeChunk=True)
Beispiel #4
0
    def createBrowCtl(self, jntNum, orderJnts):
        """
        create extra controllor for the panel
        """
        ctlP = "browDetailCtrl0"
        kids = cmds.listRelatives (ctlP, ad=True, type ='transform')   
        if kids:
            cmds.delete (kids)
            
        attTemp = ['scaleX','scaleY','scaleZ', 'rotateX','rotateY', 'tz', 'visibility' ]  
        index = 0

        for jnt in orderJnts:                            
            detailCtl = cmds.circle ( n = 'browDetail' + str(index+1).zfill(2), ch=False, o =True, nr = ( 0, 0, 1), r = 0.2 )
            detailPlane = cmds.nurbsPlane ( ax = ( 0, 0, 1 ), w = 0.1,  lengthRatio = 10, degree = 3, ch=False, n = 'browDetail'+ str(index+1).zfill(2) + 'P' )
            increment = 2.0/(jntNum-1)
            cmds.parent (detailCtl[0], detailPlane[0], relative=True )
            cmds.parent (detailPlane[0], ctlP, relative=True )
            cmds.setAttr (detailPlane[0] + '.tx', -2 + increment*index*2 )
            cmds.xform ( detailCtl[0], r =True, s = (0.2, 0.2, 0.2))  
            cmds.setAttr (detailCtl[0] +".overrideEnabled", 1)
            cmds.setAttr (detailCtl[0] +"Shape.overrideEnabled", 1)
            cmds.setAttr( detailCtl[0]+"Shape.overrideColor", 20)        
            
            cmds.transformLimits ( detailCtl[0] , tx = ( -.4, .4), etx=( True, True) )
            cmds.transformLimits ( detailCtl[0], ty = ( -.8, .8), ety=( True, True) )
            
            for att in attTemp:
                cmds.setAttr (detailCtl[0] +"."+ att, lock = True, keyable = False, channelBox =False)
                    
            index = index + 1
Beispiel #5
0
def setLimitsOnAttrs(limitsTbl, objs):
    for eachObj in objs:
        for attr, limits in limitsTbl.items():
            kw={}
            kw['e%s'%attr] = (1, 1)
            kw[attr] = limits
            mc.transformLimits(eachObj, **kw)
Beispiel #6
0
 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] )
Beispiel #7
0
 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] )
Beispiel #8
0
 def createDetailCtl(self, updn, i):
     """
     draw detail control
     """
     detailCtlP = cmds.group(em =True, n = updn  + 'LipDetailP'+ str(i))
     detailCtl = cmds.circle(n = updn  + 'LipDetail' + str(i), ch=False, o =True, nr =(0, 0, 1), r = 0.05 )
     cmds.parent(detailCtl[0], detailCtlP)
     cmds.setAttr(detailCtl[0]+"Shape.overrideEnabled", 1)
     cmds.setAttr(detailCtl[0]+"Shape.overrideColor", 20)
     cmds.setAttr(detailCtl[0]+'.translate', 0,0,0)
     cmds.transformLimits(detailCtl[0], tx =(-.5, .5), etx=(True, True))
     cmds.transformLimits(detailCtl[0], ty =(-.5, .5), ety=(True, True))
     attTemp = ['scaleX','scaleY','scaleZ', 'rotateX','rotateY','rotateZ', 'tz', 'visibility' ]  
     for y in attTemp:
         cmds.setAttr(detailCtl[0] +"."+ y, lock = True, keyable = False, channelBox =False) 
Beispiel #9
0
def createNodeUntwist(node, twistNodeName, boneAxis=1):
    '''
    createNodeUnTwist('joint1', 'joint1_untwist')
    '''    
    # Set Bone Vector
    boneVec = [0,0,0]
    boneVec[boneAxis] = 1;
    
    # Create untwist joint
    if not MC.objExists(twistNodeName):
        unTwistJnt = MC.duplicate(node)[0]
        unTwistJnt = MC.rename(unTwistJnt, twistNodeName)
        
        if MC.attributeQuery('radius', node=twistNodeName, exists=True):
            MC.setAttr('%s.radius' % twistNodeName, 2)
        MC.delete(MC.listRelatives(unTwistJnt, f=True, children=True))
        
    else:
        raise Exception,'%s node exists, please specify a unique untwist node name' % twistNodeName
        
    # Remove any transform limits on the twist joint   
    MC.transformLimits(twistNodeName, remove=True)
    
    # Set joint's rotateOrder to xyz because the angleBetween node only outputs in xyz order
    MC.setAttr('%s.rotateOrder' % twistNodeName, 0)
    
    # joint orient is included in matrix, so we need another xform to break it out
    rotMat = MC.createNode('transform', name='%s_xf' % twistNodeName, parent=twistNodeName)
    for attr in ['rotateX','rotateY','rotateZ', 'rotateOrder']:
        MC.connectAttr('%s.%s' % (node, attr), '%s.%s' % (rotMat, attr))
    
    rotPt = MC.createNode('pointMatrixMult', name='%s_pmm' % twistNodeName)
    MC.connectAttr('%s.matrix' % rotMat,  '%s.inMatrix' % rotPt)
    MC.setAttr('%s.inPoint' % rotPt, boneVec[0], boneVec[1], boneVec[2])
    MC.setAttr('%s.vectorMultiply' % rotPt, True)
    
    calcRot = MC.createNode('angleBetween', name='%s_angbt' % rotPt)
    MC.setAttr('%s.vector1' % calcRot, boneVec[0], boneVec[1], boneVec[2])
    MC.connectAttr('%s.output' % rotPt, '%s.vector2' % calcRot)
    
    # Get euler rotations and plug back into our untwist node
    for attr in ['X','Y','Z']:
        MC.connectAttr('%s.euler%s' % (calcRot, attr), '%s.rotate%s' % (twistNodeName, attr) )
        MC.connectAttr('%s.scale%s' % (node, attr), '%s.scale%s' % (twistNodeName, attr) )
    
    return twistNodeName
def ConnectControlToBlendshape(controller, blendAttr, clampValue, multiplyer):
	
	cmds.transformLimits(controller.split(".")[0], tx=(-1,1), etx=(True,True))
	
	clampNode = cmds.createNode("clamp", n=blendAttr.replace(".","_")+"_clm")
	if (clampValue>0):
		cmds.setAttr( clampNode+".maxR", clampValue );
	else:
		cmds.setAttr( clampNode+".minR", clampValue );	

	multNode = cmds.createNode("multiplyDivide", n=blendAttr.replace(".","_")+"_mdn")
	cmds.setAttr( multNode+".input2X", multiplyer );

	cmds.connectAttr(controller, clampNode+".inputR" )
	cmds.connectAttr(clampNode+".outputR", multNode+".input1X" )


	cmds.connectAttr(multNode+".outputX", blendAttr )
Beispiel #11
0
def connectIrisPupil():
    #连接 Iris Pupil连个属性并删除形状节点 使用方法选择两个眼睛控制器 然后执行命令
    sls = mc.ls(sl=True)
    size = len(sls)
    if size==0:
        print "No ctrl selected!"
        return
    for idx,tCtl in enumerate(sls):
        lr = "L" if re.search("L$",tCtl)!=None else "R"
        sCtl = lr+"_eyeBall_ctrl"
        sAtrs = ["iris","pupil"]
        tAtrs = ["IrisControl","PupilControl"]
        for n,atr in enumerate(sAtrs):
            sAtr = sCtl+"."+atr
            tAtr = tCtl+"."+tAtrs[n]
            sValue = mc.getAttr( sAtr )
            tValue = mc.getAttr( tAtr )
            pmaNode = mc.createNode("plusMinusAverage",name=tCtl+atr+"_pma")
            mc.connectAttr(sAtr,pmaNode+".input1D[0]")
            mc.setAttr(".input1D[1]",tValue-sValue)
            mc.connectAttr(".output1D",tAtr)
        sAtrs = ["sx","sy"]
        tAtrs = ["iris_scalX","iris_scalY"]
        for n,atr in enumerate(sAtrs):
            sAtr = sCtl+"."+atr
            tAtr = tCtl+"."+tAtrs[n]
            if mc.objExists(tAtr):
                attributesCls.setDrivenKey(tAtr,dv=[1,0],v=[0,-10],cd=sAtr,itt="linear",ott="linear",ift=["constant","constant"])
        mc.transformLimits(sCtl,sx=[-1,1],esx=[0,1])
        mc.transformLimits(sCtl,sy=[-1,1],esy=[0,1])
        #Delete shapes
        sps = mc.listRelatives(tCtl,s=True)
        if sps!=None and sps!=[]:
            for shp in sps:
                mc.setAttr("%s.intermediateObject"%shp,1)
            #mc.delete( sps )
        eyeballJnt = lr+"_eyeBall_jnt"
        mc.delete( mc.pointConstraint(eyeballJnt,tCtl) )
        #mc.parent(tCtl,eyeballJnt)
#import rig_ch.facialSystem.replaceEyeball as rpe
#reload(rpe)
#rpe.eyebalRder("Anim")
#rpe.eyebalRder("Render")
#rpe.connectIrisPupil()
 def createGuide(self, *args):
     Base.StartClass.createGuide(self)
     # Custom GUIDE:
     cmds.setAttr(self.moduleGrp + ".moduleNamespace", self.moduleGrp[:self.moduleGrp.rfind(":")], type='string')
     cmds.addAttr(self.moduleGrp, longName="nJoints", attributeType='long')
     cmds.setAttr(self.moduleGrp + ".nJoints", 1)
     self.cvJointLoc, shapeSizeCH = ctrls.cvJointLoc(ctrlName=self.guideName + "_JointLoc1", r=0.5)
     self.connectShapeSize(shapeSizeCH)
     self.cvEndJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_JointEnd", r=0.1)
     self.connectShapeSize(shapeSizeCH)
     cmds.parent(self.cvEndJoint, self.cvJointLoc)
     cmds.setAttr(self.cvEndJoint + ".tz", 1.3)
     cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False))
     ctrls.setLockHide([self.cvEndJoint], ['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
     cmds.parent(self.cvJointLoc, self.moduleGrp)
     # Edit GUIDE:
     cmds.setAttr(self.moduleGrp + ".rx", -90)
     cmds.setAttr(self.moduleGrp + ".ry", -90)
     cmds.setAttr(self.moduleGrp + "_RadiusCtrl.tx", 4)
Beispiel #13
0
 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
Beispiel #14
0
 def createGuide(self, *args):
     Base.StartClass.createGuide(self)
     # Custom GUIDE:
     cmds.addAttr(self.moduleGrp, longName="nJoints", attributeType='long')
     cmds.setAttr(self.moduleGrp+".nJoints", 1)
     
     cmds.setAttr(self.moduleGrp+".moduleNamespace", self.moduleGrp[:self.moduleGrp.rfind(":")], type='string')
     
     self.cvJointLoc, shapeSizeCH = ctrls.cvJointLoc(ctrlName=self.guideName+"_JointLoc1", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.jGuide1 = cmds.joint(name=self.guideName+"_JGuide1", radius=0.001)
     cmds.setAttr(self.jGuide1+".template", 1)
     cmds.parent(self.jGuide1, self.moduleGrp, relative=True)
     
     self.cvEndJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName+"_JointEnd", r=0.2)
     self.connectShapeSize(shapeSizeCH)
     cmds.parent(self.cvEndJoint, self.cvJointLoc)
     cmds.setAttr(self.cvEndJoint+".tz", 1.3)
     self.jGuideEnd = cmds.joint(name=self.guideName+"_JGuideEnd", radius=0.001)
     cmds.setAttr(self.jGuideEnd+".template", 1)
     cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False))
     ctrls.setLockHide([self.cvEndJoint], ['rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
     
     cmds.parent(self.cvJointLoc, self.moduleGrp)
     cmds.parent(self.jGuideEnd, self.jGuide1)
     ctrls.directConnect(self.cvJointLoc, self.jGuide1, ['tx', 'ty', 'tz', 'rx', 'ry', 'rz'])
     ctrls.directConnect(self.cvEndJoint, self.jGuideEnd, ['tx', 'ty', 'tz', 'rx', 'ry', 'rz'])
     
     # change the number of falanges to 3:
     self.changeJointNumber(3)
     
     # create a base cvLoc to start the finger joints:
     self.cvBaseJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName+"_JointLoc0", r=0.2)
     self.connectShapeSize(shapeSizeCH)
     cmds.setAttr(self.cvBaseJoint+".translateZ", -1)
     cmds.parent(self.cvBaseJoint, self.moduleGrp)
     
     # transform cvLocs in order to put as a good finger guide:
     cmds.setAttr(self.moduleGrp+".rotateX", 90)
     cmds.setAttr(self.moduleGrp+".rotateZ", 90)
Beispiel #15
0
 def __setup_main_control(self):
     #--- this method setups the main control
     if not cmds.objExists(self.main_ctl + '.globalScale'):
         attr = attribute.Attribute()
         attr.addAttr(node= self.main_ctl, 
                      attrName = 'globalScale', 
                      attrType = 'double', 
                      min = 0, 
                      default = 1)
         #--- connect the scale attributes of the main control with the gs
         for axis in 'xyz':
             attr.connectAttr(node = [self.main_ctl, self.main_ctl], 
                              attribute = ['globalScale', 's' + axis])
         #--- limit the scale minimum to 0.01
         cmds.transformLimits(self.main_ctl, 
                              scaleX = (0.01,1),
                              scaleY = (0.01,1),
                              scaleZ = (0.01,1),
                              enableScaleX = (1,0),
                              enableScaleY = (1,0),
                              enableScaleZ = (1,0))
         #--- lock the scale attributes of the main control
         attr.lockAttr(node = self.main_ctl, 
                       attribute = ['s'])
     if not cmds.objExists(self.main_ctl + '.displayType'):
         attr = attribute.Attribute()
         attr.addAttr(node= self.main_ctl, 
                      attrName = 'displayType',
                      attrType = 'enum', 
                      enum = ['normal', 'template', 'reference'])
         #--- connect the meshes
         for i in cmds.ls(type='mesh'):
             if cmds.objExists(i):
                 attr.setAttr(node=i, attribute=['overrideEnabled'], value=1, lock=True)
                 attr.connectAttr(node=[self.main_ctl, i], 
                                  attribute=['displayType',
                                            'drawOverride.overrideDisplayType'])
         attr.setAttr(node=self.main_ctl, attribute=['displayType'], value=2)
Beispiel #16
0
def setTranslateLimits(ctrl, tx=True, ty=True, tz=True):
    """
	"""
    if tx:
        mc.transformLimits(ctrl, tx=(-1.0, 1.0), etx=(1, 1))
    if ty:
        mc.transformLimits(ctrl, ty=(-1.0, 1.0), ety=(1, 1))
    if tz:
        mc.transformLimits(ctrl, tz=(-1.0, 1.0), etz=(1, 1))
Beispiel #17
0
 def locadCtl(self, *args):
     """
     """
     ctls = cmds.ls(sl=True, fl =1, type = 'transform')
     
     tx = cmds.transformLimits(ctls[-1], tx = True, q = True)
     ty = cmds.transformLimits(ctls[-1], ty = True, q = True)
     tz = cmds.transformLimits(ctls[-1], tz = True, q = True)
     rx = cmds.transformLimits(ctls[-1], rx = True, q = True)
     ry = cmds.transformLimits(ctls[-1], ry = True, q = True)
     rz = cmds.transformLimits(ctls[-1], rz = True, q = True)
     
     cmds.floatField(self.txMinFloatField, e = True, v = tx[0])
     cmds.floatField(self.txMaxFloatField, e = True, v = tx[1])
     cmds.floatField(self.tyMinFloatField, e = True, v = ty[0])
     cmds.floatField(self.tyMaxFloatField, e = True, v = ty[1])
     cmds.floatField(self.tzMinFloatField, e = True, v = tz[0])
     cmds.floatField(self.tzMaxFloatField, e = True, v = tz[1])
     cmds.floatField(self.rxMinFloatField, e = True, v = rx[0])
     cmds.floatField(self.rxMaxFloatField, e = True, v = rx[1])
     cmds.floatField(self.ryMinFloatField, e = True, v = ry[0])
     cmds.floatField(self.ryMaxFloatField, e = True, v = ry[1])
     cmds.floatField(self.rzMinFloatField, e = True, v = rz[0])
     cmds.floatField(self.rzMaxFloatField, e = True, v = rz[1])
Beispiel #18
0
def mirrorControlShape(typ, source, targent, flipAxis):
    if len(typ) == 0:return
    if source not in 'LR':return
    if source == targent:return

    #- get source side controls
    all_controls     = ' '.join(mc.listRelatives(mc.ls(type='nurbsCurve'), p=True, path=True))
    matched_controls = re.findall('\S*%s_\w+_%s_\d+'%(source, typ), all_controls)

    for ctl in matched_controls:
        #- get targent control
        targentControl = re.sub('%s_'%source, '%s_'%targent, ctl)
        if not mc.objExists(targentControl):continue

        #- duplicate shape
        tempx = mc.duplicate(ctl, po=True)
        mc.parent(mc.listRelatives(ctl, s=True, path=True), tempx, s=True, add=True)

        #- make Temp
        Temp = pymel.core.PyNode(mc.duplicate(tempx, rc=True)[0])
        for a in 'trs':
            for b in 'xyz':
                attr = a + b
                mc.setAttr('%s.%s'%(Temp, attr), l=False, k=True, cb=False)

        #- close max min value controler
        mc.transformLimits(Temp.name(), etx=(0, 0),ety=(0, 0),etz=(0, 0),erx=(0, 0),ery=(0, 0),erz=(0, 0))
        mc.parent(Temp.name(), w=True)

        #- filp
        grp = mc.createNode('transform')

        sourcePosi = mc.xform(ctl, q=True, ws=True, rp=True)
        targenPosi = mc.xform(targentControl, q=True, ws=True, rp=True)

        midPoint = [(sourcePosi[0] + targenPosi[0]) / 2,
                    (sourcePosi[0] + targenPosi[0]) / 2,
                    (sourcePosi[0] + targenPosi[0]) / 2]
        mc.move(midPoint[0], midPoint[1], midPoint[2], grp, a=True)


        mc.parent(Temp.name(), grp)
        mc.setAttr('%s.s%s'%(grp, flipAxis.lower()), -1)

        #- freeze transformations
        mc.parent(Temp.name(), targentControl)
        mc.makeIdentity(Temp.name(), apply=True, t=True, r=True, s=True)

        #- get original shapes
        originalShapes = mc.listRelatives(targentControl, s=True, path=True, type='nurbsCurve')

        #- parent new shapes
        shapes = mc.listRelatives(Temp.name(), s=True, path=True, type='nurbsCurve')
        for shp in shapes:
            mc.setAttr('%s.ovc'%shp, mc.getAttr('%s.ovc'%originalShapes[0]))
        mc.delete(originalShapes)
        mc.parent(shapes, targentControl, s=True, r=True)

        for shp in shapes:
            mc.rename(shp, '%sShape'%targentControl)

        #- delete temp
        mc.delete(tempx, Temp.name(), grp)
    def build(self):
        
        FKIKCtl       = '%s_legFrontFkIk_ctl_%s' % (self.locus,self.count)
        IKCtl         = '%s_legFrontIk_ctl_%s' % (self.locus,self.count)
        footBallPivot = '%s_footPivotBallLegFrontIk_org_%s' % (self.locus,self.count)
        footRoll      = '%s_footRollLegFrontIk_org_%s' % (self.locus,self.count)
        ballIkCtl     = '%s_legFrontBallIk_ctl_%s' % (self.locus,self.count)
        
        # add attrs
        cmds.addAttr(FKIKCtl,ln='feetControls',at='double',min=0,max=1,dv=1)
        cmds.setAttr('%s.feetControls' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='swivel',at='double',dv=0)
        cmds.setAttr('%s.swivel' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='toeRoll',at='double',dv=0)
        cmds.setAttr('%s.toeRoll' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='toeSwivel',at='double',dv=0)
        cmds.setAttr('%s.toeSwivel' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='toeTwist',at='double',dv=0)
        cmds.setAttr('%s.toeTwist' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='heelBank',at='double',dv=0)
        cmds.setAttr('%s.heelBank' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='heelSwivel',at='double',dv=0)
        cmds.setAttr('%s.heelSwivel' % FKIKCtl,e=True,k=True)
        
        negate = 1
        if self.locus == 'L':
            negate = -1
        elif self.locus == 'C':
            # fix the outer and inner foot bind joints if the foot is centered
            cmds.rename('L_%sInnerfoot_bnd_%s' % (self.namespace,self.count),'C_%sInnerfoot_bnd_%s' % (self.namespace,self.count))
            cmds.rename('R_%sOuterfoot_bnd_%s' % (self.namespace,self.count),'C_%sOuterfoot_bnd_%s' % (self.namespace,self.count))
        
        # constrain to the rig
        cmds.connectAttr('C_main_loc_0Shape.worldPosition','%s_%s_mod_%s.translate' % (self.locus,self.namespace,self.count))
        cmds.orientConstraint('C_main_loc_0','%s_%s_mod_%s' % (self.locus,self.namespace,self.count),mo=True)
        cmds.parentConstraint('%s_%sFoot_bnd_%s' % (self.locus,self.namespace,self.count),'%s_%sFKIK_org_%s' % (self.locus,self.namespace,self.count),mo=True)
        cmds.parentConstraint('C_chest_bnd_0','%s_%sCtl_org_%s' % (self.locus,self.namespace,self.count),mo=True)
        
        # connect fkikctl attrs to ik foot ctl attrs
        cmds.connectAttr('%s.swivel' % FKIKCtl,'%s.swivel' % IKCtl)
        cmds.setAttr('%s.swivel' % IKCtl,l=True,k=False)
        cmds.setAttr('%s.toe' % IKCtl,l=True,k=False)
        cmds.setAttr('%s.rollAngle' % IKCtl,l=True,k=False)
        
        # add control to IK feet controls to hide other controls
        cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s_legFrontToeIk_ctl_%sShape.v' % (self.locus,self.count))
        cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s_legFrontHeelIk_ctl_%sShape.v' % (self.locus,self.count))
        
        # add follow to ik feet controls
        cmds.addAttr(IKCtl,ln='follow',at='double',min=0,max=1,dv=0)
        cmds.setAttr('%s.follow' % IKCtl,e=True,k=True)
        
        pConst = cmds.parentConstraint('%s_%sIK_org_%s' % (self.locus,self.namespace,self.count),'C_root_bnd_0','%s_legFrontIk_org_%s' % (self.locus,self.count),mo=True)[0]
        rev    = cmds.createNode('reverse')
        
        cmds.connectAttr('%s.follow' % IKCtl,'%s.C_root_bnd_0W1' % pConst)
        cmds.connectAttr('%s.follow' % IKCtl,'%s.inputX' % rev)
        cmds.connectAttr('%s.outputX' % rev,'%s.%s_%sIK_org_%sW0' % (pConst,self.locus,self.namespace,self.count))
        cmds.setAttr('%s.interpType' % pConst, 2)
        
        # reconnect foot roll
        cmds.parent(footBallPivot, '%s_legFrontBallIk_cth_%s' % (self.locus,self.count))
        cmds.setAttr('%s.roll' % IKCtl,l=True,cb=False,k=False)
        cmds.connectAttr('%s.swivel' % IKCtl,'%s_legFrontToeIk_cth_%s.ry' % (self.locus,self.count))
    
        # add foot bank
        off = cmds.group(em=True,n='%s_%sFootBankInIk_off_%s' % (self.locus,self.namespace,self.count))
        inn = cmds.group(em=True,n='%s_%sFootBankInIk_org_%s' % (self.locus,self.namespace,self.count))
        cmds.delete(cmds.parentConstraint('%s_%sInnerfoot_bnd_%s' % (self.locus,self.namespace,self.count),inn,mo=False))
        cmds.delete(cmds.parentConstraint('%s_%sInnerfoot_bnd_%s' % (self.locus,self.namespace,self.count),off,mo=False))
        
        out = cmds.group(em=True,n='%s_%sFootBankOutIk_org_%s' % (self.locus,self.namespace,self.count))
        cmds.delete(cmds.parentConstraint('%s_%sOuterfoot_bnd_%s' % (self.locus,self.namespace,self.count),out,mo=False))
        
        cmds.parent(off,IKCtl)
        cmds.parent(inn,off)
        cmds.parent(out,inn)
        cmds.parent(footRoll,out)
        
        cmds.setAttr('%s.rz' % ballIkCtl,l=False,k=True)
        cmds.transformLimits(ballIkCtl,erz=[0,0])
        
        cond = cmds.createNode('condition')
        mult = cmds.createNode('multiplyDivide')
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.firstTerm' % cond)
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.colorIfTrueR' % cond)
        if self.locus == 'R': cmds.setAttr('%s.operation' % cond,2)
        else: cmds.setAttr('%s.operation' % cond,4)
        cmds.setAttr('%s.colorIfFalseR' % cond,0)
        cmds.setAttr('%s.input2X' % mult,negate)
        cmds.connectAttr('%s.outColorR' % cond,'%s.input1X' % mult)
        cmds.connectAttr('%s.outputX' % mult,'%s.rx' % out)
        
        cond = cmds.createNode('condition')
        mult = cmds.createNode('multiplyDivide')
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.firstTerm' % cond)
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.colorIfTrueR' % cond)
        if self.locus == 'R': cmds.setAttr('%s.operation' % cond,4)
        else: cmds.setAttr('%s.operation' % cond,2)
        cmds.setAttr('%s.colorIfFalseR' % cond,0)
        cmds.setAttr('%s.input2X' % mult,negate)
        cmds.connectAttr('%s.outColorR' % cond,'%s.input1X' % mult)
        cmds.connectAttr('%s.outputX' % mult,'%s.rx' % inn)
        
#         dup = cmds.duplicate(ballIkCtl,po=True,n='%s_legBallIk_dmy_%s' % (self.locus,self.count))[0]
#         cmds.parent(footBallPivot,dup)
#         cmds.connectAttr('%s.rx' % ballIkCtl,'%s.rx' % dup)
        
        # reorient the toes and midfoot controls
#         toe     = cmds.circle(ch=False)[0]
#         midfoot = cmds.circle(ch=False)[0]
#         new     = [toe,midfoot]
#         old     = ['%s_%sToesFk_ctl_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfootFk_ctl_%s' % (self.locus,self.namespace,self.count)]
#          
#         i = 0
#         while True:
#             if i == len(new): break
#              
#             a   = new[i]
#             b   = old[i]
#             p   = cmds.listRelatives(b,p=True)[0]
#             gp  = cmds.listRelatives(p,p=True)[0]
#             pos = cmds.xform(b,q=True,ws=True,t=True)
#             cmds.move(pos[0],pos[1],pos[2],a,ws=True)
#             cmds.parent(b,a)
#             cmds.parent(p,w=True)
#             cmds.setAttr('%s.rotate' % p,0,0,0)
#             cmds.parent(p,gp)
#             cmds.parent(a,p)
#             shpA = cmds.listRelatives(a,s=True)[0]
#             cmds.setAttr('%s.overrideEnabled' % shpA,1)
#             shpB = cmds.listRelatives(b,s=True)[0]
#             plg = cmds.listConnections('%s.v' % shpB,s=True,d=False,p=True)
#             if plg:
#                 cmds.disconnectAttr(plg[0],'%s.v' % shpB)
#                 cmds.connectAttr(plg[0],'%s.v' % shpA)
#             cmds.setAttr('%s.v' % shpB,0)
#             cmds.setAttr('%s.v' % a,l=True,k=False)
#             cmds.connectAttr('%s.sx' % a, '%s.sz' % b)
#             cmds.connectAttr('%s.sy' % a, '%s.sy' % b)
#             cmds.connectAttr('%s.sz' % a, '%s.sx' % b)
#             cmds.rename(b,string.replace(b,'_ctl_','_dmy_'))
#             cmds.rename(shpA,'%sShape' % b)
#             cmds.rename(a,b)
#             i = i + 1
        
        # rerig foot roll to incorporate the toe joint
        cmds.delete('%s_%sToesEnd_bnd_%s' % (self.locus,self.namespace,self.count))
        cmds.parent('%s_%sToe_bnd_%s' % (self.locus,self.namespace,self.count),'%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count))
        # create toes IK joint
        toesIKJoint = cmds.joint(n='%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count))
        pos         = cmds.xform('%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count),q=True,ws=True,t=True)
        cmds.move(pos[0],pos[1],pos[2],toesIKJoint,ws=True)
        cmds.parent(toesIKJoint,'%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count))
        cmds.makeIdentity(toesIKJoint,a=True,r=True,jo=True)
        cmds.parent('%s_%sToeIk_jnt_%s' % (self.locus,self.namespace,self.count),toesIKJoint)
        # new rotational groups
        org = cmds.group(em=True,n='%s_%sToesPivotBallLegIK_org_%s' % (self.locus,self.namespace,self.count))
        cmds.parent(org,'%s_legFrontBallIk_cth_%s' % (self.locus,self.count),r=True)
        cmds.move(pos[0],pos[1],pos[2],org,ws=True)
        cmds.parent(footBallPivot,org)
        # toe ik handles
        cmds.delete('%s_liftToeLegFrontToeIk_org_%s' % (self.locus,self.count))
        midfootIK = cmds.ikHandle(n='%s_legFrontMidfootIk_hdl_%s' % (self.locus,self.count),sj='%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),ee=toesIKJoint)[0]
        toeIK     = cmds.ikHandle(n='%s_legFrontToeIk_hdl_%s' % (self.locus,self.count),sj=toesIKJoint,ee='%s_%sToeIk_jnt_%s' % (self.locus,self.namespace,self.count))[0]
        cmds.setAttr('%s.v' % midfootIK,0)
        cmds.setAttr('%s.v' % toeIK,0)
        
        # connect roll
        clamp = cmds.createNode('clamp')
        mult  = cmds.createNode('multiplyDivide')
        cmds.setAttr('%s.maxR' % clamp,99999)
        cmds.setAttr('%s.input2X' % mult,0.25)
        #cmds.connectAttr('%s.rx' % ballIkCtl,'%s.input1X' % mult)
        #cmds.connectAttr('%s.outputX' % mult,'%s.inputR' % clamp)
        #cmds.connectAttr('%s.outputR' % clamp,'%s.rx' % footBallPivot)
        cmds.connectAttr('%s.rx' % ballIkCtl,'%s.inputR' % clamp)
        cmds.connectAttr('%s.outputR' % clamp,'%s.input1X' % mult)
        cmds.connectAttr('%s.outputX' % mult,'%s.rx' % footBallPivot)
        cmds.connectAttr('%s.outputR' % clamp,'%s.rx' % org)
        clamp = cmds.createNode('clamp')
        #avg   = cmds.createNode('plusMinusAverage')
        plug  = cmds.listConnections('%s_rollLegFrontHeelIk_org_%s.rx' % (self.locus,self.count),s=True,d=False,p=True)[0]
        cmds.setAttr('%s.minR' % clamp,-99999)
        cmds.connectAttr('%s.rx' % ballIkCtl,'%s.inputR' % clamp)
        cmds.disconnectAttr(plug,'%s_rollLegFrontHeelIk_org_%s.rx' % (self.locus,self.count))
        cmds.connectAttr('%s.outputR' % clamp,'%s_rollLegFrontHeelIk_org_%s.rx' % (self.locus,self.count))
        cmds.connectAttr('%s.heelBank' % FKIKCtl,'%s.rz' % footBallPivot)
        cmds.connectAttr('%s.heelBank' % FKIKCtl,'%s.rz' % org)
        #cmds.setAttr('%s.input1D[0]' % avg,cmds.getAttr('%s.ry' % footBallPivot))
        #cmds.connectAttr('%s.heelSwivel' % FKIKCtl,'%s.input1D[1]' % avg)
        #cmds.connectAttr('%s.output1D' % avg, '%s.ry' % footBallPivot)
        children = cmds.listRelatives(footBallPivot,c=True)
        cmds.parent(children,w=True)
        cmds.connectAttr('%s.heelSwivel' % FKIKCtl,'%s.ry' % footBallPivot)
        cmds.parent(children,footBallPivot)
        cmds.connectAttr('%s.heelSwivel' % FKIKCtl,'%s.ry' % org)
        # create 'fk' controls
        toesctl = cmds.circle(ch=False,n='%s_%sToesIk_ctl_%s' % (self.locus,self.namespace,self.count))[0]
        toescth = cmds.group(n='%s_%sToesIk_cth_%s' % (self.locus,self.namespace,self.count))
        toesctg = cmds.group(n='%s_%sToesIk_ctg_%s' % (self.locus,self.namespace,self.count))
        toesdummyoff = cmds.group(n='%s_%sToesIkDummy_off_%s' % (self.locus,self.namespace,self.count),em=True)
        toesdummyorg = cmds.group(n='%s_%sToesIkDummy_org_%s' % (self.locus,self.namespace,self.count))
        #cmds.move(pos[0],pos[1],pos[2],toesctg,ws=True)
        #cmds.move(pos[0],pos[1],pos[2],toesdummyorg,ws=True)
        cmds.delete(cmds.parentConstraint('%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count),toesctg,mo=False))
        cmds.delete(cmds.parentConstraint('%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count),toesdummyorg,mo=False))
        
        pos = cmds.xform('%s_%sMidfoot_bnd_%s' % (self.locus,self.namespace,self.count),q=True,ws=True,t=True)
        footctl = cmds.circle(ch=False,n='%s_%sMidfootIk_ctl_%s' % (self.locus,self.namespace,self.count))[0]
        footcth = cmds.group(n='%s_%sMidfootIk_cth_%s' % (self.locus,self.namespace,self.count))
        footctg = cmds.group(n='%s_%sMidfootIk_ctg_%s' % (self.locus,self.namespace,self.count))
        footdummyoff  = cmds.group(n='%s_%sMidfootIkDummy_off_%s' % (self.locus,self.namespace,self.count),em=True)
        footdummyorg  = cmds.group(n='%s_%sMidfootIkDummy_org_%s' % (self.locus,self.namespace,self.count))
        footdummymain = cmds.group(n='%s_%sFootIkDummy_org_%s' % (self.locus,self.namespace,self.count))
        #cmds.move(pos[0],pos[1],pos[2],footctg,ws=True)
        #cmds.move(pos[0],pos[1],pos[2],footdummyorg,ws=True)
        cmds.delete(cmds.parentConstraint('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),footctg,mo=False))
        #cmds.delete(cmds.parentConstraint('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),footdummyorg,mo=False))
        cmds.delete(cmds.parentConstraint('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),footdummymain,mo=False))
        
        cmds.setAttr('%s.tx' % toesctl,l=True,k=False)
        cmds.setAttr('%s.ty' % toesctl,l=True,k=False)
        cmds.setAttr('%s.tz' % toesctl,l=True,k=False)
        cmds.setAttr('%s.sx' % toesctl,l=True,k=False)
        cmds.setAttr('%s.sy' % toesctl,l=True,k=False)
        cmds.setAttr('%s.sz' % toesctl,l=True,k=False)
        cmds.setAttr('%s.v' % toesctl,l=True,k=False)
        cmds.setAttr('%s.tx' % footctl,l=True,k=False)
        cmds.setAttr('%s.ty' % footctl,l=True,k=False)
        cmds.setAttr('%s.tz' % footctl,l=True,k=False)
        cmds.setAttr('%s.sx' % footctl,l=True,k=False)
        cmds.setAttr('%s.sy' % footctl,l=True,k=False)
        cmds.setAttr('%s.sz' % footctl,l=True,k=False)
        cmds.setAttr('%s.v' % footctl,l=True,k=False)
        
        cmds.parent(toesctg,footctl)
        cmds.parent(toesdummyorg,footdummyoff)
        #cmds.parent(footdummyorg,footdummymain)
        cmds.parent(footctg,'%s_legFrontToeIk_ctl_%s' % (self.locus,self.count))
        cmds.parent(footdummymain,'%s_legFrontToeIk_ctl_%s' % (self.locus,self.count))
        cmds.parent(toeIK,toesdummyoff)
        cmds.parent(midfootIK,footdummyoff)
        
        #####################################
        #####################################
        #####################################
        #####################################
        cmds.connectAttr('%s.rotate' % toesctl,'%s.rotate' % toesdummyoff)
        cmds.connectAttr('%s.rotate' % footctl,'%s.rotate' % footdummyoff)
        #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % toescth)
        #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % footcth)
        #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % toesdummyorg)
        #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % footdummyorg)
        cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % toescth)
        cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % footcth)
        cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % toesdummyorg)
        cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % footdummyorg)
        cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % toescth)
        cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % footcth)
        cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % toesdummyorg)
        cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % footdummyorg)
        #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % toescth)
        #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % footcth)
        #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % toesdummyorg)
        #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % footdummyorg)
        cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % toescth)
        cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % footcth)
        cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % toesdummyorg)
        cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % footdummyorg)
        
        cmds.parentConstraint('%s_%sFootIk_jnt_%s' % (self.locus,self.namespace,self.count),footctg,mo=True)
        cmds.parentConstraint('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),toesctg,mo=True)
        # connect shape visibility
        shp = cmds.listRelatives(toesctl,s=True)[0]
        cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s.v' % shp)
        shp = cmds.listRelatives(footctl,s=True)[0]
        cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s.v' % shp)
        # move original fk controls
        cmds.parent('%s_%sMidfootFk_ctj_%s' % (self.locus,self.namespace,self.count),'%s_%sFootFk_jnt_%s' % (self.locus,self.namespace,self.count))
        cmds.parent('%s_%sToesFk_ctj_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfootFk_jnt_%s' % (self.locus,self.namespace,self.count))
        cmds.delete('%s_to%sMidfootFk_jth_%s' % (self.locus,self.namespace,self.count),'%s_to%sFootFk_jth_%s' % (self.locus,self.namespace,self.count))
        # constrain bind joints
        for constraint in cmds.listConnections('%s_%sMidfoot_bnd_%s' % (self.locus,self.namespace,self.count),s=True,d=False):
            if cmds.objectType(constraint,isAType='constraint'):
                cmds.delete(constraint)
                break
        pConst = cmds.parentConstraint('%s_%sMidfootFk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfoot_bnd_%s' % (self.locus,self.namespace,self.count))[0]
        rev    = cmds.createNode('reverse')
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.inputX' % rev)
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_%sMidfootIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
        cmds.connectAttr('%s.outputX' % rev,'%s.%s_%sMidfootFk_jnt_%sW0' % (pConst,self.locus,self.namespace,self.count))
        
        for constraint in cmds.listConnections('%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count),s=True,d=False):
            if cmds.objectType(constraint,isAType='constraint'):
                cmds.delete(constraint)
                break
        pConst = cmds.parentConstraint('%s_%sToesFk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count))[0]
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_%sToesIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
        cmds.connectAttr('%s.outputX' % rev,'%s.%s_%sToesFk_jnt_%sW0' % (pConst,self.locus,self.namespace,self.count))
        
        ### ^
        ### ^
        ### ^
        ###
        # replace the ik control with split translational/rotational controls
#         cmds.delete('%s_%sFootIk_orc_%s' % (self.locus,self.namespace,self.count))
#         ctg = cmds.duplicate('%s_%sFootFk_cth_%s' % (self.locus,self.namespace,self.count),n='%s_%sFootIk_ctg_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         cth = cmds.duplicate('%s_%sFootFk_cth_%s' % (self.locus,self.namespace,self.count),n='%s_%sFootIk_cth_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         ctl = cmds.duplicate('%s_%sFootFk_ctl_%s' % (self.locus,self.namespace,self.count),n='%s_%sFootIk_ctl_%s' % (self.locus,self.namespace,self.count))[0]
#         cmds.delete(cmds.listRelatives(ctl,type='joint',f=True))
#         cmds.parent(ctl,cth)
#         cmds.parent(cth,ctg)
#         cmds.parent(ctg,IKCtl)
#         cmds.makeIdentity(ctg,a=True,r=True)
#         cmds.parent('%s_%sFootBankInIk_org_%s' % (self.locus,self.namespace,self.count),ctl)
        
        # create dummy ik leg to constrain the foot rotation controls
#         shoulder = cmds.duplicate('%s_%sShoulderIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sShoulderIk_dmy_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         elbow    = cmds.duplicate('%s_%sElbowIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sElbowIk_dmy_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         foot     = cmds.duplicate('%s_%sFootIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sFootIk_dmy_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         cmds.parent(foot,elbow)
#         cmds.parent(elbow,shoulder)
#         handle = cmds.ikHandle(sj=shoulder,ee=foot,sol='ikRPsolver')[0]
#         cmds.parent(handle,IKCtl)
#         cmds.setAttr('%s.v' % handle,0)
#         cmds.poleVectorConstraint('%s_poleLegFront_ctl_%s' % (self.locus,self.count),handle)
        
        # setup the global orientation blending of the ik foot rotational control
#         pConst = cmds.parentConstraint(foot,IKCtl,ctg,st=['x','y','z'],mo=True)[0]
#         rev    = cmds.createNode('reverse')
#         cmds.connectAttr('%s.Global' % ctl,'%s.%sW1' % (pConst,IKCtl))
#         cmds.connectAttr('%s.Global' % ctl,'%s.inputX' % rev)
#         cmds.connectAttr('%s.outputX' % rev,'%s.%sW0' % (pConst,foot))
#         cmds.setAttr('%s.interpType' % pConst,2)
#         cmds.setAttr('%s.Global' % ctl,1)
        
        # lower the foot roll controls to the ground plane
        cmds.setAttr('%s_rollLegFrontBallIk_org_%s.tx' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegFrontBallIk_org_%s.ty' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegFrontBallIk_org_%s.tz' % (self.locus,self.count),l=False,k=True)
        cmds.parent('%s_rollLegFrontBallIk_org_%s' % (self.locus,self.count),w=True)
        cmds.parent('%s_%sMidfootIk_ctg_%s' % (self.locus,self.namespace,self.count),w=True)
        cmds.parent('%s_%sFootIkDummy_org_%s' % (self.locus,self.namespace,self.count),w=True)
        #cmds.parent('%s_liftToeLegFrontToeIk_org_%s' % (self.locus,self.count),w=True)
        cmds.setAttr('%s_rollLegFrontHeelIk_org_%s.tx' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegFrontHeelIk_org_%s.ty' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegFrontHeelIk_org_%s.tz' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegFrontToeIk_org_%s.tx' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegFrontToeIk_org_%s.ty' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegFrontToeIk_org_%s.tz' % (self.locus,self.count),l=False,k=True)
        cmds.parent(toeIK,w=True)
        cmds.move(0,0,0,'%s_rollLegFrontHeelIk_org_%s' % (self.locus,self.count),ws=True,x=False,y=True,z=False)
        cmds.move(0,0,0,'%s_rollLegFrontToeIk_org_%s' % (self.locus,self.count),ws=True,x=False,y=True,z=False)
        cmds.parent('%s_rollLegFrontBallIk_org_%s' % (self.locus,self.count),'%s_legFrontToeIk_ctl_%s' % (self.locus,self.count))
        cmds.parent('%s_%sMidfootIk_ctg_%s' % (self.locus,self.namespace,self.count),'%s_legFrontToeIk_ctl_%s' % (self.locus,self.count))
        cmds.parent('%s_%sFootIkDummy_org_%s' % (self.locus,self.namespace,self.count),'%s_legFrontToeIk_ctl_%s' % (self.locus,self.count))
        cmds.parent(toeIK,toesdummyoff)
        #cmds.parent('%s_liftToeLegFrontToeIk_org_%s' % (self.locus,self.count),'%s_legFrontToeIk_ctl_%s' % (self.locus,self.count))
        
        # lock attributes
        for attr in ['sx','sy','sz']:
            cmds.setAttr('%s_%sShoulderFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sElbowFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sFootFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            #cmds.setAttr('%s_%sFootIk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sMidfootFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sToesFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
        
        # reconstrain pole vector
        cmds.delete('%s_legFrontFkIk_prc_%s' % (self.locus,self.count))
        cmds.delete('%s_poleLegFront_prc_%s' % (self.locus,self.count))
        pConst = cmds.parentConstraint(IKCtl,'%s_poleLegFrontStatic_tgt_%s' % (self.locus,self.count),'%s_poleLegFront_org_%s' % (self.locus,self.count),mo=True)[0]
        rev    = cmds.createNode('reverse')
        cmds.connectAttr('%s_poleLegFront_ctl_%s.follow' % (self.locus,self.count),'%s.%sW0' % (pConst,IKCtl))
        cmds.connectAttr('%s_poleLegFront_ctl_%s.follow' % (self.locus,self.count),'%s.inputX' % rev)
        cmds.connectAttr('%s.outputX' % rev,'%s.%s_poleLegFrontStatic_tgt_%sW1' % (pConst,self.locus,self.count))
        cmds.setAttr('%s.interpType' % pConst,2)
        
        # add extra wrist IK control
        ctl = cmds.circle(ch=False,n='%s_%sWristIk_ctl_%s' % (self.locus,self.namespace,self.count))[0]
        cth = cmds.group(n='%s_%sWristIk_cth_%s' % (self.locus,self.namespace,self.count))
        ctg = cmds.group(n='%s_%sWristIk_ctg_%s' % (self.locus,self.namespace,self.count))
        cmds.parent(ctg,footBallPivot,r=True)
        cmds.parent('%s_legFrontIk_hdl_%s' % (self.locus,self.count),ctl)
         
        cmds.setAttr('%s.tx' % ctl,l=True,k=False)
        cmds.setAttr('%s.ty' % ctl,l=True,k=False)
        cmds.setAttr('%s.tz' % ctl,l=True,k=False)
        cmds.setAttr('%s.sx' % ctl,l=True,k=False)
        cmds.setAttr('%s.sy' % ctl,l=True,k=False)
        cmds.setAttr('%s.sz' % ctl,l=True,k=False)
        cmds.setAttr('%s.v' % ctl,l=True,k=False)
        
        cmds.setAttr('%s.legAim' % IKCtl,0)
        
Beispiel #20
0
def setTranslateLimits(ctrl,tx=[],ty=[],tz=[]):
	'''
	'''
	if(tx): mc.transformLimits(ctrl,tx=(tx[0],tx[1]),etx=(1,1))
	if(ty): mc.transformLimits(ctrl,ty=(ty[0],ty[1]),ety=(1,1))
	if(tz): mc.transformLimits(ctrl,tz=(tz[0],tz[1]),etz=(1,1))
Beispiel #21
0
    def ctlSetLimits(self, *args):
        """
        """
        ctls = cmds.ls(sl=1, fl =1, type = 'transform')

        posTx = cmds.floatField(self.txMaxFloatField, q = True, v = True)
        negTx = cmds.floatField(self.txMinFloatField, q = True, v = True) 
        posTy = cmds.floatField(self.tyMaxFloatField, q = True, v = True) 
        negTy = cmds.floatField(self.tyMinFloatField, q = True, v = True) 
        posTz = cmds.floatField(self.tzMaxFloatField, q = True, v = True) 
        negTz = cmds.floatField(self.tzMinFloatField, q = True, v = True)
        posRx = cmds.floatField(self.rxMaxFloatField, q = True, v = True) 
        negRx = cmds.floatField(self.rxMinFloatField, q = True, v = True) 
        posRy = cmds.floatField(self.ryMaxFloatField, q = True, v = True) 
        negRy = cmds.floatField(self.ryMinFloatField, q = True, v = True) 
        posRz = cmds.floatField(self.rzMaxFloatField, q = True, v = True) 
        negRz = cmds.floatField(self.rzMinFloatField, q = True, v = True)
        
        for c in ctls:
            #set translate limits 
            if cmds.getAttr(c +'.translateX', lock =1) == False:
                cmds.transformLimits(c, translationX = (negTx, posTx), etx = (1,1)) 
            if cmds.getAttr(c +'.translateY', lock =1) == False:
                cmds.transformLimits(c, translationY = (negTy, posTy), ety =(1,1))
            if cmds.getAttr(c +'.translateZ', lock =1) == False:
                cmds.transformLimits(c, translationZ = (negTz, posTz), etz =(1,1))
            
            #set rotate limits
            if cmds.getAttr(c +'.rotateX', lock =1) == False:
                cmds.transformLimits(c, rotationX = (negRx, posRx), erx =(1,1))
            if cmds.getAttr(c +'.rotateX', lock =1) == False:
                cmds.transformLimits(c, rotationY = (negRy, posRy), ery =(1,1))        
            if cmds.getAttr(c +'.rotateX', lock =1) == False:
                cmds.transformLimits(c, rotationZ = (negRz, posRz), erz =(1,1))
Beispiel #22
0
 def createGuide(self, *args):
     Base.StartClass.createGuide(self)
     # Custom GUIDE:
     cmds.setAttr(self.moduleGrp + ".moduleNamespace", self.moduleGrp[:self.moduleGrp.rfind(":")], type='string')
     # create cvJointLoc and cvLocators:
     self.cvFootLoc, shapeSizeCH = ctrls.cvJointLoc(ctrlName=self.guideName + "_foot", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.cvRFALoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_RfA", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.cvRFBLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_RfB", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.cvRFCLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_RfC", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.cvRFDLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_RfD", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.cvRFELoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_RfE", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     # create jointGuides:
     self.jGuideFoot = cmds.joint(name=self.guideName + "_JGuideFoot", radius=0.001)
     self.jGuideRFE = cmds.joint(name=self.guideName + "_JGuideRfE", radius=0.001)
     cmds.select(clear=True)
     self.jGuideRFA = cmds.joint(name=self.guideName + "_JGuideRfA", radius=0.001)
     self.jGuideRFD = cmds.joint(name=self.guideName + "_JGuideRfD", radius=0.001)
     self.jGuideRFB = cmds.joint(name=self.guideName + "_JGuideRfB", radius=0.001)
     self.jGuideRFC = cmds.joint(name=self.guideName + "_JGuideRfC", radius=0.001)
     self.jGuideRFAC = cmds.joint(name=self.guideName + "_JGuideRfAC", radius=0.001)
     # set jointGuides as templates:
     cmds.setAttr(self.jGuideFoot + ".template", 1)
     cmds.setAttr(self.jGuideRFA + ".template", 1)
     cmds.setAttr(self.jGuideRFB + ".template", 1)
     cmds.setAttr(self.jGuideRFC + ".template", 1)
     cmds.setAttr(self.jGuideRFD + ".template", 1)
     cmds.setAttr(self.jGuideRFE + ".template", 1)
     cmds.parent(self.jGuideFoot, self.jGuideRFA, self.moduleGrp, relative=True)
     # create cvEnd:
     self.cvEndJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_JointEnd", r=0.1)
     self.connectShapeSize(shapeSizeCH)
     cmds.parent(self.cvEndJoint, self.cvRFELoc)
     cmds.setAttr(self.cvEndJoint + ".tz", 1.3)
     self.jGuideEnd = cmds.joint(name=self.guideName + "_JGuideEnd", radius=0.001)
     cmds.setAttr(self.jGuideEnd + ".template", 1)
     cmds.parent(self.jGuideEnd, self.jGuideRFE)
     # make parents between cvLocs:
     cmds.parent(self.cvFootLoc, self.cvRFALoc, self.cvRFBLoc, self.cvRFCLoc, self.cvRFDLoc, self.moduleGrp)
     cmds.parent(self.cvRFELoc, self.cvFootLoc)
     # connect cvLocs in jointGuides:
     ctrls.directConnect(self.cvFootLoc, self.jGuideFoot, ['tx', 'ty', 'tz', 'rx', 'ry', 'rz'])
     cmds.parentConstraint(self.cvRFALoc, self.jGuideRFA, maintainOffset=False,
                           name=self.jGuideRFA + "_ParentConstraint")
     cmds.parentConstraint(self.cvRFBLoc, self.jGuideRFB, maintainOffset=False,
                           name=self.jGuideRFB + "_ParentConstraint")
     cmds.parentConstraint(self.cvRFCLoc, self.jGuideRFC, maintainOffset=False,
                           name=self.jGuideRFC + "_ParentConstraint")
     cmds.parentConstraint(self.cvRFDLoc, self.jGuideRFD, maintainOffset=False,
                           name=self.jGuideRFD + "_ParentConstraint")
     cmds.parentConstraint(self.cvRFELoc, self.jGuideRFE, maintainOffset=False,
                           name=self.jGuideRFE + "_ParentConstraint")
     cmds.parentConstraint(self.cvRFALoc, self.jGuideRFAC, maintainOffset=False,
                           name=self.jGuideRFAC + "_ParentConstraint")
     ctrls.directConnect(self.cvEndJoint, self.jGuideEnd, ['tx', 'ty', 'tz', 'rx', 'ry', 'rz'])
     # limit, lock and hide cvEnd:
     cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False))
     ctrls.setLockHide([self.cvEndJoint], ['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
     # transform cvLocs in order to put as a good foot guide:
     cmds.setAttr(self.cvFootLoc + ".translateZ", 2)
     cmds.setAttr(self.cvFootLoc + ".rotateY", -90)
     cmds.setAttr(self.cvRFELoc + ".translateX", -1)
     cmds.setAttr(self.cvRFELoc + ".translateZ", 2.5)
     cmds.setAttr(self.cvRFCLoc + ".translateX", 1)
     cmds.setAttr(self.cvRFALoc + ".translateX", -0.6)
     cmds.setAttr(self.cvRFALoc + ".translateY", -1)
     cmds.setAttr(self.cvRFBLoc + ".translateX", -0.6)
     cmds.setAttr(self.cvRFBLoc + ".translateY", 1)
     cmds.setAttr(self.cvRFDLoc + ".translateX", -3.5)
     cmds.setAttr(self.moduleGrp + ".rotateX", -90)
     cmds.setAttr(self.moduleGrp + ".rotateY", 90)
Beispiel #23
0
 def createGuide(self, *args):
     Base.StartClass.createGuide(self)
     # Custom GUIDE:
     cmds.setAttr(self.moduleGrp + ".moduleNamespace", self.moduleGrp[: self.moduleGrp.rfind(":")], type="string")
     # create cvJointLoc and cvLocators:
     self.cvNeckLoc, shapeSizeCH = ctrls.cvJointLoc(ctrlName=self.guideName + "_neck", r=0.5)
     self.connectShapeSize(shapeSizeCH)
     self.cvHeadLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_head", r=0.4)
     self.connectShapeSize(shapeSizeCH)
     self.cvJawLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_jaw", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.cvChinLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_chin", r=0.3)
     self.connectShapeSize(shapeSizeCH)
     self.cvLLipLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_lLip", r=0.1)
     self.connectShapeSize(shapeSizeCH)
     self.cvRLipLoc, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_rLip", r=0.1)
     self.connectShapeSize(shapeSizeCH)
     # create jointGuides:
     self.jGuideNeck = cmds.joint(name=self.guideName + "_JGuideNeck", radius=0.001)
     self.jGuideHead = cmds.joint(name=self.guideName + "_JGuideHead", radius=0.001)
     self.jGuideJaw = cmds.joint(name=self.guideName + "_JGuideJaw", radius=0.001)
     self.jGuideChin = cmds.joint(name=self.guideName + "_JGuideChin", radius=0.001)
     # set jointGuides as templates:
     cmds.setAttr(self.jGuideNeck + ".template", 1)
     cmds.setAttr(self.jGuideHead + ".template", 1)
     cmds.setAttr(self.jGuideJaw + ".template", 1)
     cmds.setAttr(self.jGuideChin + ".template", 1)
     cmds.parent(self.jGuideNeck, self.moduleGrp, relative=True)
     # create cvEnd:
     self.cvEndJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName + "_JointEnd", r=0.1)
     self.connectShapeSize(shapeSizeCH)
     cmds.parent(self.cvEndJoint, self.cvChinLoc)
     cmds.setAttr(self.cvEndJoint + ".tz", 1.3)
     self.jGuideEnd = cmds.joint(name=self.guideName + "_JGuideEnd", radius=0.001)
     cmds.setAttr(self.jGuideEnd + ".template", 1)
     cmds.parent(self.jGuideEnd, self.jGuideChin)
     # make parents between cvLocs:
     cmds.parent(self.cvNeckLoc, self.moduleGrp)
     cmds.parent(self.cvHeadLoc, self.cvNeckLoc)
     cmds.parent(self.cvJawLoc, self.cvHeadLoc)
     cmds.parent(self.cvChinLoc, self.cvJawLoc)
     cmds.parent(self.cvLLipLoc, self.cvJawLoc)
     cmds.parent(self.cvRLipLoc, self.cvJawLoc)
     # connect cvLocs in jointGuides:
     ctrls.directConnect(self.cvNeckLoc, self.jGuideNeck, ["tx", "ty", "tz", "rx", "ry", "rz"])
     ctrls.directConnect(self.cvHeadLoc, self.jGuideHead, ["tx", "ty", "tz", "rx", "ry", "rz"])
     ctrls.directConnect(self.cvJawLoc, self.jGuideJaw, ["tx", "ty", "tz", "rx", "ry", "rz"])
     ctrls.directConnect(self.cvChinLoc, self.jGuideChin, ["tx", "ty", "tz", "rx", "ry", "rz"])
     ctrls.directConnect(self.cvEndJoint, self.jGuideEnd, ["tx", "ty", "tz", "rx", "ry", "rz"])
     # limit, lock and hide cvEnd:
     cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False))
     ctrls.setLockHide([self.cvEndJoint], ["tx", "ty", "rx", "ry", "rz", "sx", "sy", "sz"])
     # transform cvLocs in order to put as a good head guide:
     cmds.setAttr(self.cvNeckLoc + ".rotateY", -10)
     cmds.setAttr(self.cvHeadLoc + ".translateZ", 2)
     cmds.setAttr(self.cvHeadLoc + ".rotateY", 5)
     cmds.setAttr(self.cvJawLoc + ".translateX", -0.5)
     cmds.setAttr(self.cvJawLoc + ".translateZ", 1.25)
     cmds.setAttr(self.cvJawLoc + ".rotateY", -95)
     cmds.setAttr(self.cvChinLoc + ".translateZ", 0.25)
     cmds.setAttr(self.moduleGrp + ".rotateX", -90)
     cmds.setAttr(self.moduleGrp + ".rotateY", 90)
     # lip cvLocs:
     cmds.setAttr(self.cvLLipLoc + ".translateY", -0.5)
     cmds.setAttr(self.cvLLipLoc + ".translateZ", 1)
     self.lipMD = cmds.createNode("multiplyDivide", name=self.guideName + "_lip_MD")
     cmds.connectAttr(self.cvLLipLoc + ".translateX", self.lipMD + ".input1X", force=True)
     cmds.connectAttr(self.cvLLipLoc + ".translateY", self.lipMD + ".input1Y", force=True)
     cmds.connectAttr(self.cvLLipLoc + ".translateZ", self.lipMD + ".input1Z", force=True)
     cmds.connectAttr(self.lipMD + ".outputX", self.cvRLipLoc + ".translateX", force=True)
     cmds.connectAttr(self.lipMD + ".outputY", self.cvRLipLoc + ".translateY", force=True)
     cmds.connectAttr(self.lipMD + ".outputZ", self.cvRLipLoc + ".translateZ", force=True)
     cmds.setAttr(self.lipMD + ".input2Y", -1)
from sgMaya import sgCmds, sgModel
import pymel.core
from maya import cmds

slider     = sgCmds.makeController( sgModel.Controller.move2Points, 0.5 )
sliderBase = sgCmds.createSliderBase('x')
slider.setParent( sliderBase )

cmds.transformLimits( slider.name(), tx=[0,1], etx=[1,0] )
cmds.transformLimits( slider.name(), ty=[0,1], ety=[1,0] )

keyAttrs =  cmds.listAttr( slider.name(), k=1, sn=1 )
keyAttrs += cmds.listAttr( slider.name(), cb=1, sn=1 )

for keyAttr in keyAttrs:
    if keyAttr in ['tx','ty'] : continue
    cmds.setAttr( slider.attr( keyAttr ).name(), e=1, lock=1, k=0 )
    cmds.setAttr( slider.attr( keyAttr ).name(), e=1, cb=0 )

sliderBaseParent = sgCmds.makeParent( sliderBase )
pymel.core.select( sliderBaseParent )
def makeRotateInfoForOneJoint(joint):
    #- create sets
    TempCircle = mc.circle(r=1, ch=False)
    TempLine = mc.curve(d=1, p=((-1, 1, 0), (-1, -1, 0), (1, -1, 0), (1, 1, 0), (-1, 1, 0)))

    BaseLoc = mc.spaceLocator(p=(0,0,0), name='%s_RIF_Baseloc'%joint.rsplit('_', 2)[0])[0]
    AimLoc = mc.spaceLocator(p=(0,0,0), name='%s_RIF_aimLoc'%joint.rsplit('_', 2)[0])[0]

    grp = mc.group(TempCircle, TempLine, BaseLoc, AimLoc, name='%s_RIF_G'%joint.rsplit('_', 2)[0])

    #- set Temp Curve Template
    for temp in (TempCircle, TempLine):
        shape = mc.listRelatives(temp, s=True, path=True)
        mc.setAttr('%s.ove'%shape[0], 1)
        mc.setAttr('%s.ovdt'%shape[0], 1)

    #- lock attributes
    for attr in mc.listAttr(BaseLoc, k=True):
        if attr in ('translateX', 'translateY'):
            continue
        mc.setAttr('%s.%s'%(BaseLoc, attr), l=True, k=False)

    #- limit Translate
    mc.transformLimits(BaseLoc, tx=(-1, 1), ty=(-1, 1), etx=(True, True), ety=(True, True))
    mc.pointConstraint(AimLoc, BaseLoc, skip='z')


    #- add Atributes
    for attr in ('x', 'y', 'ypxp', 'ypxn', 'ynxp', 'ynxn', 'up', 'down', 'left', 'right'):
        mc.addAttr(grp, sn=attr, k=True)

    #- comp connections
    #- 1
    mc.connectAttr('%s.tx'%BaseLoc, '%s.x'%grp)
    mc.connectAttr('%s.ty'%BaseLoc, '%s.y'%grp)

    #- 2
    Values = ('ypxp', 0.707,0.707), ('ypxn', -0.707,0.707), ('ynxp', 0.707,-0.707), ('ynxn', -0.707,-0.707)
    for Attr, x, y in Values:
        node = mc.createNode('multDoubleLinear')
        mc.setDrivenKeyframe('%s.i1'%node, cd='%s.tx'%BaseLoc, dv=0, v=0, itt='linear', ott='linear')
        mc.setDrivenKeyframe('%s.i1'%node, cd='%s.tx'%BaseLoc, dv=x, v=1, itt='linear', ott='linear')
        mc.setDrivenKeyframe('%s.i2'%node, cd='%s.ty'%BaseLoc, dv=0, v=0, itt='linear', ott='linear')
        mc.setDrivenKeyframe('%s.i2'%node, cd='%s.ty'%BaseLoc, dv=y, v=1, itt='linear', ott='linear')
        mc.connectAttr('%s.o'%node, '%s.%s'%(grp, Attr))

    #- 3
    # to line 71

    #- match Position
    mc.delete(mc.parentConstraint(joint, grp))
    JntChildren = mc.listRelatives(joint, c=True, path=True, type='joint')
    if not JntChildren:return
    mc.delete(mc.aimConstraint(JntChildren, grp, aim=(0,0,1), u=(0,1,0)))
    mc.delete(mc.pointConstraint(JntChildren, AimLoc))
    mc.parentConstraint(joint, AimLoc, mo=True)

    #- match Scale
    startPosi = mc.xform(grp, q=True, ws=True, rp=True)
    endPosi = mc.xform(AimLoc , q=True, ws=True, rp=True)
    Dis = math.sqrt((startPosi[0] - endPosi[0]) ** 2 + (startPosi[1] - endPosi[1]) ** 2 + (startPosi[2] - endPosi[2]) ** 2)
    mc.setAttr(grp + '.sx', Dis)
    mc.setAttr(grp + '.sy', Dis)
    mc.setAttr(grp + '.sz', Dis)


    #- connect line 52
    Expstrings = '\
    $Ah = %s.ty;\n\
    $Aw = %s.tx;\n\
    $C = %s;\n\
    %s.%s = clamp(0, 180,  90 - acos($Ah / $C) * 180 / 3.14159265359);\n\
    %s.%s = clamp(-180, 0, 90 - acos($Ah / $C) * 180 / 3.14159265359);\n\
    %s.%s = clamp(0, 180,  90 - acos($Aw / $C) * 180 / 3.14159265359);\n\
    %s.%s = clamp(-180, 0, 90 - acos($Aw / $C) * 180 / 3.14159265359);\n\
    '%(BaseLoc, BaseLoc, mc.getAttr('%s.tz'%AimLoc),  grp, 'up', grp, 'down', grp, 'left', grp, 'right')
    mc.expression(s=Expstrings)
    #---------------------------------------------------------------------------------------



    # connect attbutes to prefs_grp
    if not mc.objExists('prefs_grp'):return
    typ = joint.rsplit('_', 2)[0]
    mc.addAttr('prefs_grp', sn=typ, k=True)
    mc.setAttr('prefs_grp.' + typ, l=True)
    for Attr in mc.listAttr(grp, ud=True):
        mc.addAttr('prefs_grp', sn=typ + Attr, k=True)
        mc.connectAttr('%s.%s'%(grp, Attr), 'prefs_grp.%s%s'%(typ , Attr))

    return grp, AimLoc
Beispiel #26
0
def limit(limitTransforms=[{'node': None, 'attr': None, 'min': None, 'max': None}]):
    """
    @type  limitTransforms: dictionary in a list
    @param limitTransforms: specify a dictionary in a list which includes
                            the object name, one attribute, the min and the
                            max keys storing the defined limitation values.
                            (ie: [{'node': 'C_bla_CTL',
                                   'attr': 'tx',
                                   'min': -2,
                                   'max': 2}])
    """
    assert limitTransforms, "limit: Please specify valid keys and values!"

    for d in limitTransforms:
        assert isinstance(limitTransforms, list), ("limit: Please specify a list!")
        node = None
        attr = None
        mini = None
        maxi = None
        for i in d.items():
            if i[0] == 'node':
                node = i[1]
            elif i[0] == 'attr':
                attr = i[1]
            elif i[0] == 'min':
                mini = i[1]
            elif i[0] == 'max':
                maxi = i[1]
            else:
                raise Exception("limit: Please define 'node','attr',"
                                "'min','max' as keys!")

        if not node[1]:
            if attr[1]:
                raise Exception("limit: Please specify a node!")
        else:
            if not attr[1]:
                raise Exception("limit: Please specify attribute!")
            if not isinstance(attr[1], str):
                raise Exception("limit: Please specify only one"
                                " valid attribute per dictionary!")

        if node:
            #--- enable the transforms
            enableMin = False
            enableMax = False

            if mini is not None:
                enableMin = True
            if maxi is not None:
                enableMax = True

            #--- specify default limitation values
            if attr.startswith('t'):
                if mini is None:
                    mini = -1
                if maxi is None:
                    maxi = 1
            elif attr.startswith('r'):
                if mini is None:
                    mini = -45
                if maxi is None:
                    maxi = 45
            if attr.startswith('s'):
                if mini is None:
                    mini = -1
                if maxi is None:
                    maxi = 1

            #--- set translation
            if attr == 'tx':
                cmds.transformLimits(node, etx=(enableMin, enableMax), tx=(mini, maxi))
            elif attr == 'ty':
                cmds.transformLimits(node, ety=(enableMin, enableMax), ty=(mini, maxi))
            elif attr == 'tz':
                cmds.transformLimits(node, etz=(enableMin, enableMax), tz=(mini, maxi))

            #--- set rotation
            if attr == 'rx':
                cmds.transformLimits(node, erx=(enableMin, enableMax), rx=(mini, maxi))
            elif attr == 'ry':
                cmds.transformLimits(node, ery=(enableMin, enableMax), ry=(mini, maxi))
            elif attr == 'rz':
                cmds.transformLimits(node, erz=(enableMin, enableMax), rz=(mini, maxi))

            #--- set scale
            if attr == 'sx':
                cmds.transformLimits(node, esx=(enableMin, enableMax), sx=(mini, maxi))
            elif attr == 'sy':
                cmds.transformLimits(node, esy=(enableMin, enableMax), sy=(mini, maxi))
            elif attr == 'sz':
                cmds.transformLimits(node, esz=(enableMin, enableMax), sz=(mini, maxi))
    def build(self):
        
        FKIKCtl       = '%s_legFkIk_ctl_%s' % (self.locus,self.count)
        IKCtl         = '%s_legIk_ctl_%s' % (self.locus,self.count)
        footBallPivot = '%s_footPivotBallLegBackIk_org_%s' % (self.locus,self.count)
        footRoll      = '%s_footRollLegBackIk_org_%s' % (self.locus,self.count)
        ballIkCtl     = '%s_legBallIk_ctl_%s' % (self.locus,self.count)
        legikhandle   = '%s_legIk_hdl_%s' % (self.locus,self.count)
        
        cmds.rename('%s_footPivotBallLegIk_org_%s' % (self.locus,self.count),footBallPivot)
        cmds.rename('%s_footRollLegIk_org_%s' % (self.locus,self.count),footRoll)
        
        cmds.ikHandle(legikhandle,e=True,sol='ikSpringSolver')
        
        # add attrs
        cmds.addAttr(FKIKCtl,ln='feetControls',at='double',min=0,max=1,dv=1)
        cmds.setAttr('%s.feetControls' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='swivel',at='double',dv=0)
        cmds.setAttr('%s.swivel' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='toeRoll',at='double',dv=0)
        cmds.setAttr('%s.toeRoll' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='toeSwivel',at='double',dv=0)
        cmds.setAttr('%s.toeSwivel' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='toeTwist',at='double',dv=0)
        cmds.setAttr('%s.toeTwist' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='heelBank',at='double',dv=0)
        cmds.setAttr('%s.heelBank' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='heelSwivel',at='double',dv=0)
        cmds.setAttr('%s.heelSwivel' % FKIKCtl,e=True,k=True)
        cmds.addAttr(FKIKCtl,ln='kneeWeighting',at='double',min=0,max=1,dv=0.5)
        cmds.setAttr('%s.kneeWeighting' % FKIKCtl,e=True,k=True)
        
        negate = 1
        if self.locus == 'L': 
            negate = -1
        elif self.locus == 'C':
            # fix the outer and inner foot bind joints if the foot is centered
            cmds.rename('L_%sInnerfoot_bnd_%s' % (self.namespace,self.count),'C_%sInnerfoot_bnd_%s' % (self.namespace,self.count))
            cmds.rename('R_%sOuterfoot_bnd_%s' % (self.namespace,self.count),'C_%sOuterfoot_bnd_%s' % (self.namespace,self.count))
        
        # constrain to the rig
        cmds.connectAttr('C_main_loc_0Shape.worldPosition','%s_%s_mod_%s.translate' % (self.locus,self.namespace,self.count))
        cmds.orientConstraint('C_main_loc_0','%s_%s_mod_%s' % (self.locus,self.namespace,self.count),mo=True)
        cmds.parentConstraint('%s_%sAnkle_bnd_%s' % (self.locus,self.namespace,self.count),'%s_%sFKIK_org_%s' % (self.locus,self.namespace,self.count),mo=True)
        cmds.parentConstraint('C_root_bnd_0','%s_%sCtl_org_%s' % (self.locus,self.namespace,self.count),mo=True)
        hiprootloc = cmds.spaceLocator(n='%s_hipRootFollow_loc_%s' % (self.locus,self.count))[0]
        cmds.parent(hiprootloc,'%s_%sHip_bnd_%s' % (self.locus,self.namespace,self.count),r=True)
        cmds.parent(hiprootloc,'C_root_bnd_0')
        cmds.setAttr('%s.v' % hiprootloc,0)
        
        cmds.orientConstraint(hiprootloc,'%s_%sAim_org_%s' % (self.locus,self.namespace,self.count),mo=True)
        cmds.pointConstraint(hiprootloc,'%s_%sHipIk_jth_%s' % (self.locus,self.namespace,self.count),mo=True)
        cmds.setAttr('%s_%sHipIk_org_%s.inheritsTransform' % (self.locus,self.namespace,self.count),0)
                              
        ankle = cmds.duplicate('%s_%sAnkleIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sAnkleIk_tmp_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        cmds.parent(ankle,w=True)
        
        posA = cmds.xform('%s_%sKnee_bnd_%s' % (self.locus,self.namespace,self.count),q=True,ws=True,t=True)
        posB = cmds.xform('comp_%s%s:R_knee_ctl_0' % (self.namespace,self.count),q=True,ws=True,t=True)
        
        if round(posA[0]) != round(posB[0]*negate) or round(posA[1]) != round(posB[1]) or round(posA[2]) != round(posB[2]): 
        
            # reposition the pole vector control - this messes up the joint orientations
            cmds.delete('%s_poleLeg_prc_%s' % (self.locus,self.count))
            pos    = cmds.xform('comp_%s%s:R_poleVector_loc_0' % (self.namespace,self.count),q=True,ws=True,t=True)
            cmds.move(pos[0]*negate,pos[1],pos[2],'%s_poleLegStatic_tgt_%s' % (self.locus,self.count),ws=True)
            cmds.move(pos[0]*negate,pos[1],pos[2],'%s_poleLeg_org_%s' % (self.locus,self.count),ws=True)
            pConst = cmds.parentConstraint(IKCtl,'%s_poleLegStatic_tgt_%s' % (self.locus,self.count),'%s_poleLeg_org_%s' % (self.locus,self.count),mo=True)[0]
            rev    = cmds.createNode('reverse')
            cmds.connectAttr('%s_poleLeg_ctl_%s.follow' % (self.locus,self.count),'%s.%sW0' % (pConst,IKCtl))
            cmds.connectAttr('%s_poleLeg_ctl_%s.follow' % (self.locus,self.count),'%s.inputX' % rev)
            cmds.connectAttr('%s.outputX' % rev,'%s.%s_poleLegStatic_tgt_%sW1' % (pConst,self.locus,self.count))
            cmds.setAttr('%s.interpType' % pConst,2)
        
        # re create IK chain to set correct the messed up orientations
        cmds.select(cl=True)
        hock  = cmds.joint(n='%s_%sHockIk_tmp_%s' % (self.locus,self.namespace,self.count))
        knee  = cmds.joint(n='%s_%sKneeIk_tmp_%s' % (self.locus,self.namespace,self.count))
        
        cmds.parent(knee,'%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),r=True)
        cmds.setAttr('%s.rx' % knee,180)
        cmds.parent(knee,'%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count))
        cmds.parent(hock,'%s_%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count),r=True)
        cmds.setAttr('%s.rx' % hock,180)
        cmds.parent(hock,knee)
        cmds.parent(ankle,hock)
        
        plug = cmds.listConnections('%s_%sKneeIk_jnt_%s.tx' % (self.locus,self.namespace,self.count),s=True,d=False,p=True)[0]
        cmds.connectAttr(plug,'%s.tx' % knee)
        plug = cmds.listConnections('%s_%sHockIk_jnt_%s.tx' % (self.locus,self.namespace,self.count),s=True,d=False,p=True)[0]
        cmds.connectAttr(plug,'%s.tx' % hock)
        
        cmds.delete(legikhandle)
        cmds.parent('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),w=True)
        cmds.parent('%s_fKAlignedLegIk_org_%s' % (self.locus,self.count),w=True)
        cmds.parent('%s_poleLeg_ann_%s' % (self.locus,self.count),w=True,r=True)
        cmds.delete('%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count))
        
        cmds.makeIdentity('%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),a=True,r=True)
        cmds.joint('%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),e=True,spa=True,ch=True)
        legikhandle = cmds.ikHandle(sj='%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),ee=ankle,sol='ikSpringSolver')[0]
        cmds.poleVectorConstraint('%s_poleLeg_ctl_%s' % (self.locus,self.count),legikhandle)
        
        cmds.parent('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),ankle)
        cmds.parent('%s_fKAlignedLegIk_org_%s' % (self.locus,self.count),ankle)
        cmds.parent(legikhandle,footBallPivot)
        
        handle = cmds.ikHandle(sj=ankle,ee='%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),sol='ikSCsolver')[0]
        cmds.parent(handle,footBallPivot)
        cmds.setAttr('%s.v' % handle,0)
        
        # rename tmp joints and reconstrain bind joints
        cmds.rename(knee,'%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count))
        cmds.rename(hock,'%s_%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count))
        cmds.rename(ankle,'%s_%sAnkleIk_jnt_%s' % (self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint('%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sKnee_bnd_%s' % (self.locus,self.namespace,self.count),mo=False)[0]
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_%sKneeIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint('%s_%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sHock_bnd_%s' % (self.locus,self.namespace,self.count),mo=False)[0]
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_%sHockIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint('%s_%sAnkleIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sAnkle_bnd_%s' % (self.locus,self.namespace,self.count),mo=False)[0]
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_%sAnkleIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
        
        # fix the fk chain orientations
        knee  = '%s_%sKneeFk_ctj_%s' % (self.locus,self.namespace,self.count)
        hock  = '%s_%sHockFk_ctj_%s' % (self.locus,self.namespace,self.count)
        ankle = '%s_%sAnkleFk_ctj_%s' % (self.locus,self.namespace,self.count)
        cmds.parent(knee,w=True)
        cmds.parent(hock,w=True)
        cmds.parent(ankle,w=True)
        
        cmds.delete(cmds.aimConstraint(hock,knee,wut='object',wuo='comp_%s%s:%s_poleVector_loc_0' % (self.namespace,self.count,self.locus),aim=[negate,0,0],u=[0,negate,0]))
        cmds.delete(cmds.aimConstraint(ankle,hock,wut='object',wuo='comp_%s%s:%s_poleVector_loc_0' % (self.namespace,self.count,self.locus),aim=[negate,0,0],u=[0,negate,0]))
        
        cmds.parent(ankle,'%s_%sHockFk_ctl_%s' % (self.locus,self.namespace,self.count))
        cmds.parent(hock,'%s_%sKneeFk_ctl_%s' % (self.locus,self.namespace,self.count))
        cmds.parent(knee,'%s_%sHipFk_jnt_%s' % (self.locus,self.namespace,self.count))
        
        # connect fkikctl attrs to ik foot ctl attrs
        cmds.connectAttr('%s.swivel' % FKIKCtl,'%s.swivel' % IKCtl)
        cmds.setAttr('%s.swivel' % IKCtl,l=True,k=False)
        cmds.setAttr('%s.toe' % IKCtl,l=True,k=False)
        cmds.setAttr('%s.rollAngle' % IKCtl,l=True,k=False)
        
        # add control to IK feet controls to hide other controls
        cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s_legToeIk_ctl_%sShape.v' % (self.locus,self.count))
        cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s_legHeelIk_ctl_%sShape.v' % (self.locus,self.count))
        
        # add follow to ik feet controls
        cmds.addAttr(IKCtl,ln='follow',at='double',min=0,max=1,dv=0)
        cmds.setAttr('%s.follow' % IKCtl,e=True,k=True)
        
        pConst = cmds.parentConstraint('%s_%sIK_org_%s' % (self.locus,self.namespace,self.count),'C_root_bnd_0','%s_legIk_org_%s' % (self.locus,self.count),mo=True)[0]
        rev    = cmds.createNode('reverse')
        
        cmds.connectAttr('%s.follow' % IKCtl,'%s.C_root_bnd_0W1' % pConst)
        cmds.connectAttr('%s.follow' % IKCtl,'%s.inputX' % rev)
        cmds.connectAttr('%s.outputX' % rev,'%s.%s_%sIK_org_%sW0' % (pConst,self.locus,self.namespace,self.count))
        cmds.setAttr('%s.interpType' % pConst, 2)
        
        # reconnect foot roll
#         cmds.parent(footBallPivot, '%s_legBallIk_cth_%s' % (self.locus,self.count))
#         cmds.setAttr('%s.roll' % IKCtl,l=True,cb=False,k=False)
#         cmds.connectAttr('%s.swivel' % IKCtl,'%s_legToeIk_cth_%s.ry' % (self.locus,self.count))
#         cmds.disconnectAttr('%s.swivel' % IKCtl,'%s_poleAimLeg_amc_%s.offsetX' % (self.locus,self.count))
        
        # add foot bank
        off = cmds.group(em=True,n='%s_%sFootBankInIk_off_%s' % (self.locus,self.namespace,self.count))
        inn = cmds.group(em=True,n='%s_%sFootBankInIk_org_%s' % (self.locus,self.namespace,self.count))
        cmds.delete(cmds.parentConstraint('%s_%sInnerfoot_bnd_%s' % (self.locus,self.namespace,self.count),inn,mo=False))
        cmds.delete(cmds.parentConstraint('%s_%sInnerfoot_bnd_%s' % (self.locus,self.namespace,self.count),off,mo=False))
        
        out = cmds.group(em=True,n='%s_%sFootBankOutIk_org_%s' % (self.locus,self.namespace,self.count))
        cmds.delete(cmds.parentConstraint('%s_%sOuterfoot_bnd_%s' % (self.locus,self.namespace,self.count),out,mo=False))
        
        cmds.parent(off,IKCtl)
        cmds.parent(inn,off)
        cmds.parent(out,inn)
        cmds.parent(footRoll,out)
        
        cmds.setAttr('%s.rz' % ballIkCtl,l=False,k=True)
        cmds.transformLimits(ballIkCtl,erz=[0,0])
        
        cond = cmds.createNode('condition')
        mult = cmds.createNode('multiplyDivide')
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.firstTerm' % cond)
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.colorIfTrueR' % cond)
        if self.locus == 'R': cmds.setAttr('%s.operation' % cond,2)
        else: cmds.setAttr('%s.operation' % cond,4)
        cmds.setAttr('%s.colorIfFalseR' % cond,0)
        cmds.setAttr('%s.input2X' % mult,negate)
        cmds.connectAttr('%s.outColorR' % cond,'%s.input1X' % mult)
        cmds.connectAttr('%s.outputX' % mult,'%s.rx' % out)
        
        cond = cmds.createNode('condition')
        mult = cmds.createNode('multiplyDivide')
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.firstTerm' % cond)
        cmds.connectAttr('%s.rz' % ballIkCtl,'%s.colorIfTrueR' % cond)
        if self.locus == 'R': cmds.setAttr('%s.operation' % cond,4)
        else: cmds.setAttr('%s.operation' % cond,2)
        cmds.setAttr('%s.colorIfFalseR' % cond,0)
        cmds.setAttr('%s.input2X' % mult,negate)
        cmds.connectAttr('%s.outColorR' % cond,'%s.input1X' % mult)
        cmds.connectAttr('%s.outputX' % mult,'%s.rx' % inn)
        
        dup = cmds.duplicate(ballIkCtl,po=True,n='%s_legBallIk_dmy_%s' % (self.locus,self.count))[0]
        cmds.parent(footBallPivot,dup)
        cmds.connectAttr('%s.rx' % ballIkCtl,'%s.rx' % dup)
        
        # reorient the toes and midfoot controls
#         toe    = cmds.circle(ch=False)[0]
#         midfoot = cmds.circle(ch=False)[0]
#         new     = [toe,midfoot]
#         old     = ['%s_%sToesFk_ctl_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfootFk_ctl_%s' % (self.locus,self.namespace,self.count)]
#          
#         i = 0
#         while True:
#             if i == len(new): break
#              
#             a   = new[i]
#             b   = old[i]
#             p   = cmds.listRelatives(b,p=True)[0]
#             gp  = cmds.listRelatives(p,p=True)[0]
#             pos = cmds.xform(b,q=True,ws=True,t=True)
#             cmds.move(pos[0],pos[1],pos[2],a,ws=True)
#             cmds.parent(b,a)
#             cmds.parent(p,w=True)
#             cmds.setAttr('%s.rotate' % p,0,0,0)
#             cmds.parent(p,gp)
#             cmds.parent(a,p)
#             shpA = cmds.listRelatives(a,s=True)[0]
#             cmds.setAttr('%s.overrideEnabled' % shpA,1)
#             shpB = cmds.listRelatives(b,s=True)[0]
#             plg = cmds.listConnections('%s.v' % shpB,s=True,d=False,p=True)
#             if plg:
#                 cmds.disconnectAttr(plg[0],'%s.v' % shpB)
#                 cmds.connectAttr(plg[0],'%s.v' % shpA)
#             cmds.setAttr('%s.v' % shpB,0)
#             cmds.setAttr('%s.v' % a,l=True,k=False)
#             cmds.connectAttr('%s.sx' % a, '%s.sz' % b)
#             cmds.connectAttr('%s.sy' % a, '%s.sy' % b)
#             cmds.connectAttr('%s.sz' % a, '%s.sx' % b)
#             cmds.rename(b,string.replace(b,'_ctl_','_dmy_'))
#             cmds.rename(shpA,'%sShape' % b)
#             cmds.rename(a,b)
#             i = i + 1
            
        # rerig foot roll to incorporate the toe joint
#         cmds.delete('%s_%sToesEnd_bnd_%s' % (self.locus,self.namespace,self.count))
#         cmds.parent('%s_legToe_bnd_%s' % (self.locus,self.count),'%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count))
#         # create toes IK joint
#         toesIKJoint = cmds.joint(n='%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count))
#         pos         = cmds.xform('%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count),q=True,ws=True,t=True)
#         cmds.move(pos[0],pos[1],pos[2],toesIKJoint,ws=True)
#         cmds.parent(toesIKJoint,'%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count))
#         cmds.makeIdentity(toesIKJoint,a=True,r=True,jo=True)
#         cmds.parent('%s_legToeIk_jnt_%s' % (self.locus,self.count),toesIKJoint)
#         # new rotational groups
#         org = cmds.group(em=True,n='%s_%sToesPivotBallLegIK_org_%s' % (self.locus,self.namespace,self.count))
#         cmds.parent(org,'%s_legBallIk_cth_%s' % (self.locus,self.count),r=True)
#         cmds.move(pos[0],pos[1],pos[2],org,ws=True)
#         cmds.parent(footBallPivot,org)
#         # toe ik handles
#         #cmds.delete('%s_liftToeLegToeIk_org_%s' % (self.locus,self.count))
#         toesIK = cmds.ikHandle(sj='%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),ee=toesIKJoint)[0]
#         toeIK  = cmds.ikHandle(sj=toesIKJoint,ee='%s_legToeIk_jnt_%s' % (self.locus,self.count))[0]
#         cmds.setAttr('%s.v' % toesIK,0)
#         cmds.setAttr('%s.v' % toeIK,0)
        
        # connect roll
#         clamp = cmds.createNode('clamp')
#         mult  = cmds.createNode('multiplyDivide')
#         cmds.setAttr('%s.maxR' % clamp,99999)
#         cmds.setAttr('%s.input2X' % mult,0.25)
#         cmds.connectAttr('%s.rx' % ballIkCtl,'%s.inputR' % clamp)
#         cmds.connectAttr('%s.outputR' % clamp,'%s.input1X' % mult)
#         cmds.connectAttr('%s.outputX' % mult,'%s_%sToesPivotBallLegIK_org_%s.rx' % (self.locus,self.namespace,self.count))
#         cmds.connectAttr('%s.outputR' % clamp,'%s.rx' % footBallPivot)
#         clamp = cmds.createNode('clamp')
#         #avg   = cmds.createNode('plusMinusAverage')
#         plug  = cmds.listConnections('%s_rollLegHeelIk_org_%s.rx' % (self.locus,self.count),s=True,d=False,p=True)[0]
#         cmds.setAttr('%s.minR' % clamp,-99999)
#         cmds.connectAttr('%s.rx' % ballIkCtl,'%s.inputR' % clamp)
#         cmds.disconnectAttr(plug,'%s_rollLegHeelIk_org_%s.rx' % (self.locus,self.count))
#         cmds.connectAttr('%s.outputR' % clamp,'%s_rollLegHeelIk_org_%s.rx' % (self.locus,self.count))
#         cmds.connectAttr('%s.heelBank' % FKIKCtl,'%s.rz' % footBallPivot)
#         cmds.connectAttr('%s.heelBank' % FKIKCtl,'%s_%sToesPivotBallLegIK_org_%s.rz' % (self.locus,self.namespace,self.count))
#         #cmds.setAttr('%s.input1D[0]' % avg,cmds.getAttr('%s.ry' % footBallPivot))
#         #cmds.connectAttr('%s.heelSwivel' % FKIKCtl,'%s.input1D[1]' % avg)
#         #cmds.connectAttr('%s.output1D' % avg, '%s.ry' % footBallPivot)
#         children = cmds.listRelatives(footBallPivot,c=True)
#         cmds.parent(children,w=True)
#         cmds.connectAttr('%s.heelSwivel' % FKIKCtl,'%s.ry' % footBallPivot)
#         cmds.parent(children,footBallPivot)
#         cmds.connectAttr('%s.heelSwivel' % FKIKCtl,'%s_%sToesPivotBallLegIK_org_%s.ry' % (self.locus,self.namespace,self.count))
#         # create 'fk' controls
#         toesctl = cmds.circle(ch=False,n='%s_%sToesIk_ctl_%s' % (self.locus,self.namespace,self.count))[0]
#         toescth = cmds.group(n='%s_%sToesIk_cth_%s' % (self.locus,self.namespace,self.count))
#         toesctg = cmds.group(n='%s_%sToesIk_ctg_%s' % (self.locus,self.namespace,self.count))
#         toesdummyoff = cmds.group(n='%s_%sToesIkDummy_off_%s' % (self.locus,self.namespace,self.count),em=True)
#         toesdummyorg = cmds.group(n='%s_%sToesIkDummy_org_%s' % (self.locus,self.namespace,self.count))
#         #cmds.move(pos[0],pos[1],pos[2],toesctg,ws=True)
#         #cmds.move(pos[0],pos[1],pos[2],toesdummyorg,ws=True)
#         cmds.delete(cmds.parentConstraint('%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count),toesctg,mo=False))
#         cmds.delete(cmds.parentConstraint('%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count),toesdummyorg,mo=False))
#         
#         pos = cmds.xform('%s_%sMidfoot_bnd_%s' % (self.locus,self.namespace,self.count),q=True,ws=True,t=True)
#         footctl = cmds.circle(ch=False,n='%s_%sMidfootIk_ctl_%s' % (self.locus,self.namespace,self.count))[0]
#         footcth = cmds.group(n='%s_%sMidfootIk_cth_%s' % (self.locus,self.namespace,self.count))
#         footctg = cmds.group(n='%s_%sMidfootIk_ctg_%s' % (self.locus,self.namespace,self.count))
#         footdummyoff  = cmds.group(n='%s_%sMidfootIkDummy_off_%s' % (self.locus,self.namespace,self.count),em=True)
#         footdummyorg  = cmds.group(n='%s_%sMidfootIkDummy_org_%s' % (self.locus,self.namespace,self.count))
#         footdummymain = cmds.group(n='%s_%sFootIkDummy_org_%s' % (self.locus,self.namespace,self.count))
#         #cmds.move(pos[0],pos[1],pos[2],footctg,ws=True)
#         #cmds.move(pos[0],pos[1],pos[2],footdummyorg,ws=True)
#         cmds.delete(cmds.parentConstraint('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),footctg,mo=False))
#         cmds.delete(cmds.parentConstraint('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),footdummymain,mo=False))
#         
#         cmds.setAttr('%s.tx' % toesctl,l=True,k=False)
#         cmds.setAttr('%s.ty' % toesctl,l=True,k=False)
#         cmds.setAttr('%s.tz' % toesctl,l=True,k=False)
#         cmds.setAttr('%s.sx' % toesctl,l=True,k=False)
#         cmds.setAttr('%s.sy' % toesctl,l=True,k=False)
#         cmds.setAttr('%s.sz' % toesctl,l=True,k=False)
#         cmds.setAttr('%s.v' % toesctl,l=True,k=False)
#         cmds.setAttr('%s.tx' % footctl,l=True,k=False)
#         cmds.setAttr('%s.ty' % footctl,l=True,k=False)
#         cmds.setAttr('%s.tz' % footctl,l=True,k=False)
#         cmds.setAttr('%s.sx' % footctl,l=True,k=False)
#         cmds.setAttr('%s.sy' % footctl,l=True,k=False)
#         cmds.setAttr('%s.sz' % footctl,l=True,k=False)
#         cmds.setAttr('%s.v' % footctl,l=True,k=False)
#         
#         cmds.parent(toesctg,footctl)
#         cmds.parent(toesdummyorg,footdummyoff)
#         #cmds.parent(footdummyorg,footdummymain)
#         cmds.parent(footctg,'%s_legToeIk_ctl_%s' % (self.locus,self.count))
#         cmds.parent(footdummymain,'%s_legToeIk_ctl_%s' % (self.locus,self.count))
#         cmds.parent(toeIK,toesdummyoff)
#         cmds.parent(toesIK,footdummyoff)
#         
#         #####################################
#         #####################################
#         #####################################
#         #####################################
#         cmds.connectAttr('%s.rotate' % toesctl,'%s.rotate' % toesdummyoff)
#         cmds.connectAttr('%s.rotate' % footctl,'%s.rotate' % footdummyoff)
#         #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % toescth)
#         #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % footcth)
#         #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % toesdummyorg)
#         #cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % footdummyorg)
#         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % toescth)
#         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % footcth)
#         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % toesdummyorg)
#         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rz' % footdummyorg)
#         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % toescth)
#         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % footcth)
#         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % toesdummyorg)
#         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % footdummyorg)
#         #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % toescth)
#         #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % footcth)
#         #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % toesdummyorg)
#         #cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % footdummyorg)
#         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % toescth)
#         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % footcth)
#         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % toesdummyorg)
#         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rx' % footdummyorg)
# #         cmds.parent(toesctg,footctl)
# #         cmds.parent(toesdummyorg,footdummyoff)
# #         cmds.parent(footctg,'%s_legToeIk_ctl_%s' % (self.locus,self.count))
# #         cmds.parent(footdummyorg,'%s_legToeIk_ctl_%s' % (self.locus,self.count))
# #         cmds.parent(toeIK,toesdummyoff)
# #         cmds.parent(toesIK,footdummyoff)
# #         cmds.connectAttr('%s.rotate' % toesctl,'%s.rotate' % toesdummyoff)
# #         cmds.connectAttr('%s.rotate' % footctl,'%s.rotate' % footdummyoff)
# #         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % toescth)
# #         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % footcth)
# #         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % toesdummyorg)
# #         cmds.connectAttr('%s.toeRoll' % FKIKCtl,'%s.rx' % footdummyorg)
# #         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % toescth)
# #         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % footcth)
# #         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % toesdummyorg)
# #         cmds.connectAttr('%s.toeSwivel' % FKIKCtl,'%s.ry' % footdummyorg)
# #         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % toescth)
# #         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % footcth)
# #         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % toesdummyorg)
# #         cmds.connectAttr('%s.toeTwist' % FKIKCtl,'%s.rz' % footdummyorg)
#         
#         cmds.parentConstraint('%s_%sAnkleIk_jnt_%s' % (self.locus,self.namespace,self.count),footctg,mo=True)
#         cmds.parentConstraint('%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),toesctg,mo=True)
#         # connect shape visibility
#         shp = cmds.listRelatives(toesctl,s=True)[0]
#         cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s.v' % shp)
#         shp = cmds.listRelatives(footctl,s=True)[0]
#         cmds.connectAttr('%s.feetControls' % FKIKCtl,'%s.v' % shp)
#         # move original fk controls
#         cmds.parent('%s_%sMidfootFk_ctj_%s' % (self.locus,self.namespace,self.count),'%s_%sAnkleFk_jnt_%s' % (self.locus,self.namespace,self.count))
#         cmds.parent('%s_%sToesFk_ctj_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfootFk_jnt_%s' % (self.locus,self.namespace,self.count))
#         cmds.delete('%s_to%sMidfootFk_jth_%s' % (self.locus,self.namespace,self.count),'%s_to%sAnkleFk_jth_%s' % (self.locus,self.namespace,self.count))
#         # constrain bind joints
#         for constraint in cmds.listConnections('%s_%sMidfoot_bnd_%s' % (self.locus,self.namespace,self.count),s=True,d=False):
#             if cmds.objectType(constraint,isAType='constraint'):
#                 cmds.delete(constraint)
#                 break
#         pConst = cmds.parentConstraint('%s_%sMidfootFk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfootIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sMidfoot_bnd_%s' % (self.locus,self.namespace,self.count))[0]
#         rev    = cmds.createNode('reverse')
#         cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.inputX' % rev)
#         cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_%sMidfootIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
#         cmds.connectAttr('%s.outputX' % rev,'%s.%s_%sMidfootFk_jnt_%sW0' % (pConst,self.locus,self.namespace,self.count))
#         
#         for constraint in cmds.listConnections('%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count),s=True,d=False):
#             if cmds.objectType(constraint,isAType='constraint'):
#                 cmds.delete(constraint)
#                 break
#         pConst = cmds.parentConstraint('%s_%sToesFk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sToesIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sToes_bnd_%s' % (self.locus,self.namespace,self.count))[0]
#         cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_%sToesIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
#         cmds.connectAttr('%s.outputX' % rev,'%s.%s_%sToesFk_jnt_%sW0' % (pConst,self.locus,self.namespace,self.count))
        
        # replace the ik control with split translational/rotational controls
#         ctg = cmds.duplicate('%s_%sAnkleFk_cth_%s' % (self.locus,self.namespace,self.count),n='%s_%sAnkleIk_ctg_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         cth = cmds.duplicate('%s_%sAnkleFk_cth_%s' % (self.locus,self.namespace,self.count),n='%s_%sAnkleIk_cth_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         ctl = cmds.duplicate('%s_%sAnkleFk_ctl_%s' % (self.locus,self.namespace,self.count),n='%s_%sAnkleIk_ctl_%s' % (self.locus,self.namespace,self.count))[0]
#         cmds.delete(cmds.listRelatives(ctl,type='joint',f=True))
#         cmds.parent(ctl,cth)
#         cmds.parent(cth,ctg)
#         cmds.parent(ctg,IKCtl)
#         cmds.makeIdentity(ctg,a=True,r=True)
#         cmds.parent('%s_%sFootBankInIk_org_%s' % (self.locus,self.namespace,self.count),ctl)
        
        # create dummy ik leg to constrain the ankle rotation controls
#         hip   = cmds.duplicate('%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sHipIk_dmy_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         knee  = cmds.duplicate('%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sKneeIk_dmy_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         hock  = cmds.duplicate('%s_%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sHockIk_dmy_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         ankle = cmds.duplicate('%s_%sAnkleIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_%sAnkleIk_dmy_%s' % (self.locus,self.namespace,self.count),po=True)[0]
#         cmds.parent(ankle,hock)
#         cmds.parent(hock,knee)
#         cmds.parent(knee,hip)
#         dummyikhandle = cmds.ikHandle(sj=hip,ee=ankle,sol='ikSpringSolver')[0]
#         cmds.parent(dummyikhandle,IKCtl)
#         cmds.poleVectorConstraint('%s_poleLeg_ctl_%s' % (self.locus,self.count),dummyikhandle)
        
        # setup the global orientation blending of the ik ankle rotational control
#         pConst = cmds.parentConstraint(ankle,IKCtl,ctg,st=['x','y','z'],mo=True)[0]
#         rev    = cmds.createNode('reverse')
#         cmds.connectAttr('%s.Global' % ctl,'%s.%sW1' % (pConst,IKCtl))
#         cmds.connectAttr('%s.Global' % ctl,'%s.inputX' % rev)
#         cmds.connectAttr('%s.outputX' % rev,'%s.%sW0' % (pConst,ankle))
#         cmds.setAttr('%s.interpType' % pConst,2)
#         cmds.setAttr('%s.Global' % ctl,1)
        
        # lower the foot roll controls to the ground plane
        cmds.setAttr('%s_rollLegBallIk_org_%s.tx' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegBallIk_org_%s.ty' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegBallIk_org_%s.tz' % (self.locus,self.count),l=False,k=True)
        cmds.parent('%s_rollLegBallIk_org_%s' % (self.locus,self.count),w=True)
        #cmds.parent('%s_%sMidfootIk_ctg_%s' % (self.locus,self.namespace,self.count),w=True)
        #cmds.parent('%s_%sFootIkDummy_org_%s' % (self.locus,self.namespace,self.count),w=True)
        cmds.setAttr('%s_rollLegHeelIk_org_%s.tx' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegHeelIk_org_%s.ty' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegHeelIk_org_%s.tz' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegToeIk_org_%s.tx' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegToeIk_org_%s.ty' % (self.locus,self.count),l=False,k=True)
        cmds.setAttr('%s_rollLegToeIk_org_%s.tz' % (self.locus,self.count),l=False,k=True)
        cmds.parent('%s_legToeIk_hdl_%s' % (self.locus,self.count),w=True)
        cmds.move(0,0,0,'%s_rollLegHeelIk_org_%s' % (self.locus,self.count),ws=True,x=False,y=True,z=False)
        cmds.move(0,0,0,'%s_rollLegToeIk_org_%s' % (self.locus,self.count),ws=True,x=False,y=True,z=False)
        cmds.parent('%s_rollLegBallIk_org_%s' % (self.locus,self.count),'%s_legToeIk_ctl_%s' % (self.locus,self.count))
        cmds.parent('%s_legToeIk_hdl_%s' % (self.locus,self.count),'%s_liftToeLegToeIk_org_%s' % (self.locus,self.count))
        #cmds.parent('%s_%sMidfootIk_ctg_%s' % (self.locus,self.namespace,self.count),'%s_legToeIk_ctl_%s' % (self.locus,self.count))
        #cmds.parent('%s_%sFootIkDummy_org_%s' % (self.locus,self.namespace,self.count),'%s_legToeIk_ctl_%s' % (self.locus,self.count))
        
        # fix the IK partial stretching
        if not cmds.listConnections('%s_%sAnkleIk_jnt_%s.tx' % (self.locus,self.namespace,self.count),s=True,d=False):
            mult = cmds.createNode('multiplyDivide')
            x    = cmds.getAttr('%s_%sAnkleIk_jnt_%s.tx' % (self.locus,self.namespace,self.count))
            cmds.setAttr('%s.input1X' % mult,x)
            cmds.connectAttr('%s_messureDivLegIk_mdn_%s.outputX' % (self.locus,self.count),'%s.input2X' % mult)
            cmds.connectAttr('%s.outputX' % mult,'%s_%sAnkleIk_jnt_%s.tx' % (self.locus,self.namespace,self.count))
        
        # create the secondary IK structure
        ctl = cmds.circle(n='%s_%sHipIk_ctl_%s' % (self.locus,self.namespace,self.count),d=3,s=8,ch=False,nr=[1,0,0])[0]
        cth = cmds.group(n='%s_%sHipIk_cth_%s' % (self.locus,self.namespace,self.count))
        ctg = cmds.group(n='%s_%sHipIk_ctg_%s' % (self.locus,self.namespace,self.count))
        org = cmds.group(n='%s_secondaryIk_org_%s' % (self.locus,self.count))
        loc = cmds.spaceLocator(n='%s_%sKneeIk_loc_%s' % (self.locus,self.namespace,self.count))[0]
        
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.v' % org)
        
        cmds.setAttr('%s.tx' % ctl,l=True,k=False)
        cmds.setAttr('%s.ty' % ctl,l=True,k=False)
        cmds.setAttr('%s.tz' % ctl,l=True,k=False)
        cmds.setAttr('%s.rx' % ctl,l=True,k=False)
        cmds.setAttr('%s.sx' % ctl,l=True,k=False)
        cmds.setAttr('%s.sy' % ctl,l=True,k=False)
        cmds.setAttr('%s.sz' % ctl,l=True,k=False)
        cmds.setAttr('%s.v' % ctl,l=True,k=False)
        
        # position hip control
        cmds.parent(org,'%s_%sIK_org_%s' % (self.locus,self.namespace,self.count))
        cmds.parentConstraint('%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),ctg,mo=False)
        
        # position knee locator
        cmds.parent(loc,ctl,r=True)
        cmds.connectAttr('%s_%sKneeIk_jnt_%s.tx' % (self.locus,self.namespace,self.count),'%s.tx' % loc)
        cmds.setAttr('%s.v' % loc,0)
        
        # duplicate knee
        knee  = cmds.duplicate('%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_secondary%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        hock  = cmds.duplicate('%s_%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_secondary%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        ankle = cmds.duplicate('%s_%sAnkleIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_secondary%sAnkleIk_jnt_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        
        if not cmds.listConnections('%s.drawOverride' % knee,s=True,d=False):
            cmds.connectAttr('controlJointLayer.drawInfo','%s.drawOverride' % knee)
            cmds.connectAttr('controlJointLayer.drawInfo','%s.drawOverride' % hock)
        cmds.connectAttr('%s_%sHockIk_jnt_%s.tx' % (self.locus,self.namespace,self.count),'%s.tx' % hock)
        
        cmds.parent(ankle,hock)
        cmds.parent(hock,knee)
        cmds.parent('%s_poleLeg_ann_%s' % (self.locus,self.count),knee,r=True)
        cmds.parent(knee,org)
        
        # create IK
        handle = cmds.ikHandle(sj=knee,ee=ankle,sol='ikRPsolver')[0]
        cmds.parent(handle,footBallPivot)
        cmds.poleVectorConstraint('%s_poleLeg_ctl_%s' % (self.locus,self.count),handle)[0]
        cmds.pointConstraint(loc,knee)
        cmds.setAttr('%s.v' % handle,0)
        posA = cmds.xform('%s_%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count),q=True,ws=True,t=True)
        posB = cmds.xform(hock,q=True,ws=True,t=True)
        
        if round(posA[0]) != round(posB[0]) or round(posA[1]) != round(posB[1]) or round(posA[2]) != round(posB[2]):
            cmds.setAttr('%s.twist' % handle,180)
        
        # setup the IK hip twist
        hipTwistIK  = cmds.duplicate('%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_twist%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        kneeTwistIK = cmds.duplicate('%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_twist%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        
        cmds.parent(kneeTwistIK,hipTwistIK)
        cmds.parent(hipTwistIK,'%s_%sAim_org_%s' % (self.locus,self.namespace,self.count))
        
        handle  = cmds.ikHandle(sj=hipTwistIK,ee=kneeTwistIK,sol='ikRPsolver')[0]
        cmds.parent(handle,ctl)
        cmds.poleVectorConstraint(hiprootloc,handle)[0]
        cmds.pointConstraint(hiprootloc,hipTwistIK)
        cmds.setAttr('%s.v' % handle,0)
        
#         mult = cmds.createNode('multiplyDivide')
#         cmds.connectAttr('C_root_bnd_0.rx','%s.input1X' % mult)
#         cmds.connectAttr('%s.outputX' % mult,'%s.twist' % handle)
#         cmds.setAttr('%s.input2X' % mult,-1)
        
        twistLocAIK = cmds.spaceLocator(n='%s_%sHipIkTwistA_loc_%s' % (self.locus,self.namespace,self.count))[0]
        twistLocBIK = cmds.spaceLocator(n='%s_%sHipIkTwistB_loc_%s' % (self.locus,self.namespace,self.count))[0]
        cmds.parent(twistLocAIK,twistLocBIK,hipTwistIK,r=True)
        pConst = cmds.pointConstraint(hipTwistIK,kneeTwistIK,twistLocAIK,mo=False)[0]
        oConst = cmds.orientConstraint(ctl,hipTwistIK,twistLocAIK,mo=False)[0]
        cmds.setAttr('%s.interpType' % oConst,2)
        cmds.setAttr('%s.%sW0' % (pConst,hipTwistIK),0.65)
        cmds.setAttr('%s.%sW1' % (pConst,kneeTwistIK),0.35)
        cmds.setAttr('%s.%sW0' % (oConst,ctl),0.35)
        cmds.setAttr('%s.%sW1' % (oConst,hipTwistIK),0.65)
        pConst = cmds.pointConstraint(hipTwistIK,kneeTwistIK,twistLocBIK,mo=False)[0]
        oConst = cmds.orientConstraint(ctl,hipTwistIK,twistLocBIK,mo=False)[0]
        cmds.setAttr('%s.interpType' % oConst,2)
        cmds.setAttr('%s.%sW0' % (pConst,hipTwistIK),0.35)
        cmds.setAttr('%s.%sW1' % (pConst,kneeTwistIK),0.65)
        cmds.setAttr('%s.%sW0' % (oConst,ctl),0.65)
        cmds.setAttr('%s.%sW1' % (oConst,hipTwistIK),0.35)
        
        # setup the FK hip twist
        hipTwistFK  = cmds.duplicate('%s_%sHipIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_twist%sHipFk_jnt_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        kneeTwistFK = cmds.duplicate('%s_%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),n='%s_twist%sKneeFk_jnt_%s' % (self.locus,self.namespace,self.count),po=True)[0]
        
        cmds.parent(kneeTwistFK,hipTwistFK)
        cmds.parent(hipTwistFK,'%s_%sAim_org_%s' % (self.locus,self.namespace,self.count))
        
        handle = cmds.ikHandle(sj=hipTwistFK,ee=kneeTwistFK,sol='ikRPsolver')[0]
        cmds.parent(handle,'%s_%sHipFk_ctl_%s' % (self.locus,self.namespace,self.count))
        cmds.poleVectorConstraint('%s_%sHipFk_ctl_%s' % (self.locus,self.namespace,self.count),handle)[0]
        cmds.pointConstraint('%s_%sHipFk_ctl_%s' % (self.locus,self.namespace,self.count),hipTwistFK)
        cmds.setAttr('%s.v' % handle,0)
        
        mult = cmds.createNode('multiplyDivide')
        cmds.connectAttr('C_root_bnd_0.rx','%s.input1X' % mult)
        cmds.connectAttr('%s.outputX' % mult,'%s.twist' % handle)
        cmds.setAttr('%s.input2X' % mult,-1)
        
        twistLocAFK = cmds.spaceLocator(n='%s_%sHipFkTwistA_loc_%s' % (self.locus,self.namespace,self.count))[0]
        twistLocBFK = cmds.spaceLocator(n='%s_%sHipFkTwistB_loc_%s' % (self.locus,self.namespace,self.count))[0]
        cmds.parent(twistLocAFK,twistLocBFK,hipTwistFK,r=True)
        pConst = cmds.pointConstraint(hipTwistFK,kneeTwistFK,twistLocAFK,mo=False)[0]
        oConst = cmds.orientConstraint('%s_%sHipFk_ctl_%s' % (self.locus,self.namespace,self.count),hipTwistFK,twistLocAFK,mo=False)[0]
        cmds.setAttr('%s.interpType' % oConst,2)
        cmds.setAttr('%s.%sW0' % (pConst,hipTwistFK),0.65)
        cmds.setAttr('%s.%sW1' % (pConst,kneeTwistFK),0.35)
        cmds.setAttr('%s.%s_%sHipFk_ctl_%sW0' % (oConst,self.locus,self.namespace,self.count),0.35)
        cmds.setAttr('%s.%sW1' % (oConst,hipTwistFK),0.65)
        pConst = cmds.pointConstraint(hipTwistFK,kneeTwistFK,twistLocBFK,mo=False)[0]
        oConst = cmds.orientConstraint('%s_%sHipFk_ctl_%s' % (self.locus,self.namespace,self.count),hipTwistFK,twistLocBFK,mo=False)[0]
        cmds.setAttr('%s.interpType' % oConst,2)
        cmds.setAttr('%s.%sW0' % (pConst,hipTwistFK),0.35)
        cmds.setAttr('%s.%sW1' % (pConst,kneeTwistFK),0.65)
        cmds.setAttr('%s.%s_%sHipFk_ctl_%sW0' % (oConst,self.locus,self.namespace,self.count),0.65)
        cmds.setAttr('%s.%sW1' % (oConst,hipTwistFK),0.35)
        
        # re-constrain the bind joints
        cmds.delete('%s_%sHip_prc_%s' % (self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint(hipTwistFK,hipTwistIK,'%s_%sHip_bnd_%s' % (self.locus,self.namespace,self.count),mo=True)[0]
        cmds.setAttr('%s.interpType' % pConst,2)
        cmds.connectAttr('%s_blendLegFkIk_rev_%s.outputX' % (self.locus,self.count),'%s.%sW0' % (pConst,hipTwistFK))
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%sW1' % (pConst,hipTwistIK))
        
        cmds.delete('%s_%sKnee_prc_%s' % (self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint('%s_%sKneeFk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_secondary%sKneeIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sKnee_bnd_%s' % (self.locus,self.namespace,self.count))[0]
        cmds.setAttr('%s.interpType' % pConst,2)
        cmds.connectAttr('%s_blendLegFkIk_rev_%s.outputX' % (self.locus,self.count),'%s.%s_%sKneeFk_jnt_%sW0' % (pConst,self.locus,self.namespace,self.count))
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_secondary%sKneeIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
        
        cmds.delete('%s_%sHock_prc_%s' % (self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint('%s_%sHockFk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_secondary%sHockIk_jnt_%s' % (self.locus,self.namespace,self.count),'%s_%sHock_bnd_%s' % (self.locus,self.namespace,self.count))[0]
        cmds.setAttr('%s.interpType' % pConst,2)
        cmds.connectAttr('%s_blendLegFkIk_rev_%s.outputX' % (self.locus,self.count),'%s.%s_%sHockFk_jnt_%sW0' % (pConst,self.locus,self.namespace,self.count))
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%s_secondary%sHockIk_jnt_%sW1' % (pConst,self.locus,self.namespace,self.count))
        
        # create the hip twist bind joints
        cmds.select(cl=True)
        jnt = cmds.joint(n='%s_%sHipA_bnd_%s' % (self.locus,self.namespace,self.count))
        cmds.parent(jnt,'%s_%sHip_bnd_%s' % (self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint(twistLocAFK,twistLocAIK,jnt,mo=False)[0]
        cmds.setAttr('%s.interpType' % pConst,2)
        cmds.connectAttr('%s_blendLegFkIk_rev_%s.outputX' % (self.locus,self.count),'%s.%sW0' % (pConst,twistLocAFK))
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%sW1' % (pConst,twistLocAIK))
        
        cmds.select(cl=True)
        jnt = cmds.joint(n='%s_%sHipB_bnd_%s' % (self.locus,self.namespace,self.count))
        cmds.parent(jnt,'%s_%sHipA_bnd_%s' % (self.locus,self.namespace,self.count))
        pConst = cmds.parentConstraint(twistLocBFK,twistLocBIK,jnt,mo=False)[0]
        cmds.setAttr('%s.interpType' % pConst,2)
        cmds.connectAttr('%s_blendLegFkIk_rev_%s.outputX' % (self.locus,self.count),'%s.%sW0' % (pConst,twistLocBFK))
        cmds.connectAttr('%s.FKIKBlend' % FKIKCtl,'%s.%sW1' % (pConst,twistLocBIK))
        
        cmds.parent('%s_%sKnee_bnd_%s' % (self.locus,self.namespace,self.count),jnt)
        
        # lock attributes
        for attr in ['sx','sy','sz']:
            cmds.setAttr('%s_%sHipFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sKneeFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sHockFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sAnkleFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            #cmds.setAttr('%s_%sAnkleIk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            cmds.setAttr('%s_%sMidfootFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
            #cmds.setAttr('%s_%sToesFk_ctl_%s.%s' % (self.locus,self.namespace,self.count,attr),l=True,k=False)
        
        # create toe locator
        loc = cmds.spaceLocator(n='%s_toe_loc_%s' % (self.locus,self.count))[0]
        cmds.parent(loc,'%s_legToe_bnd_%s' % (self.locus,self.count),r=True)
        cmds.setAttr('%s.v' % loc,0)
        
        avg = cmds.createNode('plusMinusAverage')
        cmds.connectAttr('%s.kneeWeighting' % FKIKCtl,'%s.springAngleBias[0].springAngleBias_FloatValue' % legikhandle)
        cmds.connectAttr('%s.kneeWeighting' % FKIKCtl,'%s.input1D[1]' % avg)
        cmds.setAttr('%s.input1D[0]' % avg,1)
        cmds.setAttr('%s.operation' % avg,2)
        cmds.connectAttr('%s.output1D' % avg,'%s.springAngleBias[1].springAngleBias_FloatValue' % legikhandle)
        if cmds.getAttr('%s.v' % legikhandle):
            cmds.setAttr('%s.v' % legikhandle,0)
        
#         cmds.connectAttr('%s.kneeWeighting' % FKIKCtl,'%s.springAngleBias[0].springAngleBias_FloatValue' % dummyikhandle)
#         cmds.setAttr('%s.input1D[0]' % avg,1)
#         cmds.setAttr('%s.operation' % avg,2)
#         cmds.connectAttr('%s.output1D' % avg,'%s.springAngleBias[1].springAngleBias_FloatValue' % dummyikhandle)
#         cmds.setAttr('%s.v' % dummyikhandle,0)
def setTranslateLimits(ctrl, tx=True, ty=True, tz=True):
    """
    """
    if (tx): cmds.transformLimits(ctrl, tx=(-1.0, 1.0), etx=(1, 1))
    if (ty): cmds.transformLimits(ctrl, ty=(-1.0, 1.0), ety=(1, 1))
    if (tz):   cmds.transformLimits(ctrl, tz=(-1.0, 1.0), etz=(1, 1))
Beispiel #29
0
 def sqCreateStickyLipsCtrlAttr(self, *args):
     if not cmds.objExists(self.optionCtrl):
         cmds.circle(name=self.optionCtrl, constructionHistory=False)
     cmds.addAttr(self.optionCtrl, longName='stickyLips', attributeType='bool')
     cmds.setAttr(self.optionCtrl+'.stickyLips', edit=True, keyable=True)
     
     for i in range(0, self.maxIter):
         cmds.addAttr(self.optionCtrl, longName="stickyLipsWireLocator"+str(i), attributeType='float', keyable=False)
     
     for i in range(0, self.maxIter):
         for wireNode in self.wireNodeList:
             cmds.connectAttr(self.optionCtrl+".stickyLipsWireLocator"+str(i), wireNode+".wireLocatorEnvelope["+str(i)+"]")
     
     slTextCurve = cmds.textCurves(ch=False, font="Arial|w400|h-08", text="StickyLips", name="StickyLips_Label_Txt")[0]
     if "Shape" in slTextCurve:
         slTextCurve = cmds.rename(slTextCurve, slTextCurve[:slTextCurve.find("Shape")])
     t = 0
     slCharTransformList = cmds.listRelatives(slTextCurve, children=True, type="transform")
     for charTransform in slCharTransformList:
         txValue = cmds.getAttr(charTransform+".tx")
         sLTextShapeList = cmds.listRelatives(charTransform, allDescendents=True, type="nurbsCurve")
         for i, textShape in enumerate(sLTextShapeList):
             textShape = cmds.rename(textShape, "StickyLips_Txt_"+str(t)+"Shape")
             cmds.parent(textShape, slTextCurve, shape=True, relative=True)
             cmds.move(txValue, 0, 0, textShape+".cv[:]", relative=True)
             t = t+1
         cmds.delete(charTransform)
     cmds.setAttr(slTextCurve+".translateX", -0.1)
     cmds.setAttr(slTextCurve+".translateY", 0.25)
     cmds.setAttr(slTextCurve+".scaleX", 0.1)
     cmds.setAttr(slTextCurve+".scaleY", 0.1)
     cmds.setAttr(slTextCurve+".scaleZ", 0.1)
     cmds.setAttr(slTextCurve+".template", 1)
     cmds.makeIdentity(slTextCurve, apply=True)
     
     sideNameList = ["L", "R"]
     for side in sideNameList:
         bg = cmds.circle(name=side+"_StickyLips_Bg", normal=(0,0,1), radius=1, degree=1, sections=4, constructionHistory=False)[0]
         cmds.setAttr(bg+".rotateZ", 45)
         cmds.setAttr(bg+".translateX", 0.5)
         cmds.makeIdentity(bg, apply=True)
         cmds.setAttr(bg+".scaleX", 0.85)
         cmds.setAttr(bg+".scaleY", 0.15)
         cmds.makeIdentity(bg, apply=True)
         cmds.setAttr(bg+".template", 1)
         
         self.sliderCtrl = cmds.circle(name=side+"_StickyLips_Ctrl", normal=(0,0,1), radius=0.1, degree=3, constructionHistory=False)[0]
         attrToHideList = ['ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']
         for attr in attrToHideList:
             cmds.setAttr(self.sliderCtrl+"."+attr, edit=True, lock=True, keyable=False)
         cmds.transformLimits(self.sliderCtrl, translationX=(0,1), enableTranslationX=(1,1))
         
     distPos = 1.0 / self.maxIter
     for i in range(0, self.maxIter):
         lPosA = (i * distPos)
         lPosB = (lPosA + distPos)
         rPosB = 1 - (i * distPos)
         rPosA = (rPosB - distPos)
         if i > 0:
             lPosA = lPosA - (distPos*0.33)
             rPosA = rPosA - (distPos*0.33)
         cmds.setDrivenKeyframe(self.optionCtrl, attribute="stickyLipsWireLocator"+str(i), currentDriver=sideNameList[0]+"_StickyLips_Ctrl.translateX", driverValue=lPosA, value=0, inTangentType="linear", outTangentType="linear")
         cmds.setDrivenKeyframe(self.optionCtrl, attribute="stickyLipsWireLocator"+str(i), currentDriver=sideNameList[0]+"_StickyLips_Ctrl.translateX", driverValue=lPosB, value=1, inTangentType="linear", outTangentType="linear")
         cmds.setDrivenKeyframe(self.optionCtrl, attribute="stickyLipsWireLocator"+str(i), currentDriver=sideNameList[1]+"_StickyLips_Ctrl.translateX", driverValue=rPosA, value=0, inTangentType="linear", outTangentType="linear")
         cmds.setDrivenKeyframe(self.optionCtrl, attribute="stickyLipsWireLocator"+str(i), currentDriver=sideNameList[1]+"_StickyLips_Ctrl.translateX", driverValue=rPosB, value=1, inTangentType="linear", outTangentType="linear")
     
     lSliderGrp = cmds.group(sideNameList[0]+"_StickyLips_Ctrl", sideNameList[0]+"_StickyLips_Bg", name=sideNameList[0]+"_StickyLips_Ctrl_Grp")
     rSliderGrp = cmds.group(sideNameList[1]+"_StickyLips_Ctrl", sideNameList[1]+"_StickyLips_Bg", name=sideNameList[1]+"_StickyLips_Ctrl_Grp")
     cmds.setAttr(rSliderGrp+".rotateZ", 180)
     cmds.setAttr(rSliderGrp+".translateY", -0.25)
     sliderGrp = cmds.group(lSliderGrp, rSliderGrp, slTextCurve, name="StickyLips_Ctrl_Grp")
Beispiel #30
0
 def createLidCtl(self, miNum):
     """
     create sub controller for the control panel
     """
        
     for updn in self.lrUplow:
         ctlP = updn + "Ctrl0"
         kids = cmds.listRelatives(ctlP, ad=True, type ='transform')   
         if kids:
             cmds.delete(kids)
                 
         cntCtlP = cmds.duplicate(ctlP, po =True, n = updn + 'CntCtlP')
         cmds.parent(cntCtlP[0],ctlP)
         cntCtl = cmds.circle(n = updn + "Center", ch=False, o =True, nr =(0, 0, 1), r = 0.1)
         cntCtl[0]
         cmds.parent(cntCtl[0], cntCtlP[0])
         cmds.setAttr(cntCtl[0] + ".overrideEnabled", 1)
         cmds.setAttr(cntCtl[0] + "Shape.overrideEnabled", 1)
         cmds.setAttr(cntCtl[0] + "Shape.overrideColor", 9)
         cmds.setAttr(cntCtl[0] + '.translate', 0,0,0)
         cmds.transformLimits(cntCtl, tx =(-1, 1), etx=(True, True))
         cmds.transformLimits(cntCtl, ty =(-1, 1), ety=(True, True))
     
         inCornerP = cmds.duplicate(cntCtlP , n = updn + 'InCornerP', rc =True)
         cmds.setAttr(inCornerP[0] +'.tx', -1)
         inTemp = cmds.listRelatives(inCornerP[0], c=True, type ='transform') 
         inCorner = cmds.rename(inTemp[0], updn + 'InCorner')
         cmds.setAttr(inCorner +'.scale', .8, .8, .8)
         cmds.transformLimits(inCorner, tx =(-.25, .25), etx=(True, True))
         cmds.transformLimits(inCorner, ty =(-1,  1), ety=(True, True))
                 
         outCornerP = cmds.duplicate(cntCtlP , n = updn + 'OutCornerP', rc=True)
         cmds.setAttr(outCornerP[0] +'.tx', 1)
         outTemp = cmds.listRelatives(outCornerP[0], c=True, type ='transform') 
         outCorner = cmds.rename(outTemp[0], updn + 'OutCorner') 
         cmds.setAttr(outCorner +'.scale', .8, .8, .8) 
         cmds.transformLimits(outCorner, tx =(-.25, .25), etx=(True, True))
         cmds.transformLimits(outCorner, ty =(-1, 1), ety=(True, True))
         
         attTemp = ['scaleX','scaleY','scaleZ', 'rotateX','rotateY','rotateZ', 'tz', 'visibility' ]  
         for x in attTemp:
             cmds.setAttr(cntCtl[0] +"."+ x, lock = True, keyable = False, channelBox =False)
             cmds.setAttr(inCorner +"."+ x, lock = True, keyable = False, channelBox =False) 
             cmds.setAttr(outCorner+"."+ x, lock = True, keyable = False, channelBox =False) 
     
         for i in range(0, miNum):
             detailCtl = cmds.spaceLocator(n = updn  + 'Detail' + str(i+1).zfill(2))
             detailCtlP = cmds.group(em =True, n = updn  + 'Detail'+ str(i+1).zfill(2) + 'P')
             cmds.parent(detailCtl[0], detailCtlP)
             cmds.parent(detailCtlP, ctlP)
             cmds.setAttr(detailCtl[0] +".overrideEnabled", 1)
             cmds.setAttr(detailCtl[0] +"Shape.overrideEnabled", 1)
             cmds.setAttr(detailCtl[0]+"Shape.overrideColor", 20)
             increment = 2.0 /(miNum-1)
             cmds.setAttr(detailCtlP + ".tx", increment*i - 1.0)
             cmds.setAttr(detailCtlP + ".ty", 0)
             cmds.setAttr(detailCtlP + ".tz", 0)
             cmds.xform(detailCtl, r =True, s =(0.1, 0.1, 0.1))
             cmds.transformLimits(detailCtl , tx =(-.25, .25), etx=(True, True))
             cmds.transformLimits(detailCtl , ty =(-.5, .5), ety=(True, True))
             for y in attTemp:
                 cmds.setAttr(detailCtl[0] +"."+ y, lock = True, keyable = False, channelBox =False)