def connect_ikfk(self): for fk_key, fk_ctl in self.fk.controls.items(): con = fk_ctl.constraint rev = cmds.createNode("reverse") cmds.connectAttr("%s.fkik" % self.settings_node, "%s.inputX" % rev) aliases = cmds.parentConstraint(con, wal=True, q=True) cmds.connectAttr("%s.fkik" % self.settings_node, "%s.%s" % (con, aliases[0])) cmds.connectAttr("%s.outputX" % rev, "%s.%s" % (con, aliases[1])) # Control visibility cmds.setAttr("%s.visibility" % fk_ctl.ctl, l=False) cmds.connectAttr("%s.outputX" % rev, "%s.visibility" % fk_ctl.ctl) for ik_key, ik_ctl in self.ik.controls.items(): cmds.setAttr("%s.visibility" % ik_ctl.ctl, l=False) cmds.connectAttr("%s.fkik" % self.settings_node, "%s.visibility" % ik_ctl.ctl) cmds.connectAttr("%s.fkik" % self.settings_node, "%s.visibility" % self.ik.anno) # Connect base Fk control cmds.pointConstraint(self.ik.base_null, self.fk.fk_joints[0], mo=True) cmds.connectAttr("%s.fkik" % self.settings_node, "%s.ikBlend" % self.ik.ik)
def makeSpring(self,*args): self.springRadius=mc.getAttr("{0}.springRadius".format(self.radCntrl[0])) #get diameter (width) self.upWidth=self.springRadius*2 #create base spring mesh using polyHelix self.springBase=mc.polyHelix(c=20,h=4,w=self.upWidth, r=0.2,sa=24,sco=24, sc=0,ax=(0,1,0),rcp=0,cuv=3,ch=1, name="springGeo") mc.pointConstraint(self.baseLoc,self.topLoc,self.springBase[0]) mc.aimConstraint(self.topLoc,self.springBase[0],aimVector=(0,1,0)) #connect height attribute of helix to distance node mc.connectAttr("{0}.distance".format(self.dNode),"{0}.height".format(self.springBase[1]), force=True) mc.delete(self.radCntrl) mc.select(self.baseLoc,self.topLoc,self.conCurve,self.springBase) #select all spring parts self.selection=mc.ls(sl=True) #loop through the parts and rename them accordingly for x in self.selection: mc.rename(x,(x+"_#")) #create a group for the springs self.springGrp=mc.group(name="spring_GRP_#") #delete tmp group mc.delete(self.tmpGrp) #add GRP elements to set mc.sets(self.springGrp, add=self.springSetName)
def __init__(self, objs = [], vertices = []): self.objs = objs self.vertices = vertices #lattice -divisions 2 3 2 -objectCentered true -ol 1; #mc.select( self.objs, self.vertices ) #CREATION grp = mn.Node( mc.group( n = "head_toon_GRP", em = True ) ) deGrp = mn.Node( mc.group( n = "head_toon_deformer_GRP", em = True ) ) deGrp.parent = grp deGrp.a.v.v = False deGrp.a.v.locked = True latNods = mc.lattice( self.objs, self.vertices, divisions = [ 2,3,2], objectCentered = True, ol = 1, n = 'head_toon_LAT' ) latBase = mn.Node( latNods[2] ) latBase.parent = deGrp lat = mn.Node( latNods[1] ) lat.parent = deGrp #mc.select( lat + ".pt[0:1][2][0]", lat + ".pt[0:1][2][1]" ) topClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][2][0]", lat.shape.name + ".pt[0:1][2][1]", n = 'top_face_toon_CLU' )[1] ) topClus.a.v.v = False topClus.a.v.locked = True #mc.select( lat + ".pt[0:1][1][0]", lat + ".pt[0:1][1][1]" ) midClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][1][0]", lat.shape.name + ".pt[0:1][1][1]", n = 'mid_face_toon_CLU' )[1] ) #mc.select( lat + ".pt[0:1][0][0]", lat + ".pt[0:1][0][1]" ) lowClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][0][0]", lat.shape.name + ".pt[0:1][0][1]", n = 'low_face_toon_CLU' )[1] ) ctl = crv.Curve( "head_toon_CTL" ) ctl = ctl.create( "sphere" ) ctl.a.t.v = topClus.worldPosition mc.makeIdentity( ctl.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) topClus.parent = ctl midClus.parent = deGrp lowClus.parent = deGrp ctl.parent = grp #CONSTRAINS midClus.a.r >> topClus.a.r mc.pointConstraint( topClus.name, lowClus.name, midClus.name, mo = True ) #SCALE FOR MID CLUSTER dist = mn.createNode( 'distanceBetween', n = 'head_toon_DIS' ) ctl.a.worldMatrix >> dist.a.inMatrix1 ctl.a.rp >> dist.a.point1 lowClus.a.worldMatrix >> dist.a.inMatrix2 lowClus.a.rp >> dist.a.point2 mul = mn.createNode( 'multiplyDivide', n = 'head_toon_scale_MUL' ) mul.a.input1.v = [dist.a.distance.v]*3 mul.a.operation.v = 2 dist.a.distance >> mul.a.input2X dist.a.distance >> mul.a.input2Y dist.a.distance >> mul.a.input2Z mul.a.output >> midClus.a.s #AIM CONSTRAINT upLocGrp = mn.Node( mc.group( n = "head_upVector_GRP", em = True ) ) upLocGrp.a.t.v = midClus.worldPosition mc.makeIdentity( upLocGrp.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) upLocGrp.parent = deGrp mc.orientConstraint( ctl.name, lowClus.name, upLocGrp.name, mo = True ) upLoc = mn.Node( mc.spaceLocator( n = 'head_upVector_LOC' )[0] ) upLoc.a.t.v = midClus.worldPosition upLoc.a.tz.v = upLoc.a.tz.v + 5 mc.aimConstraint( topClus.name, midClus.name, mo = True, weight = 1, aimVector = [1, 0, 0], upVector = [0, 1, 0], worldUpType = "object", worldUpObject = upLoc.name ) upLoc.parent = upLocGrp mc.pointConstraint( topClus.name, lowClus.name, upLoc.name, mo = True )
def rollSetup(firstJoint, lastJoint): rollJoint = mc.joint(name= firstJoint + nameLib.prefixNames.rollJoint, radius=3) # display local rotation axes mc.setAttr(rollJoint + ".displayLocalAxis", 1) # posittion rollJoint mc.delete(mc.parentConstraint(firstJoint, rollJoint)) mc.pointConstraint(firstJoint, rollJoint) mc.delete(mc.pointConstraint(lastJoint, rollJoint)) mc.makeIdentity(rollJoint, rotate=True, apply=True) # parent rollJoint under firstJoint mc.parent(rollJoint, firstJoint) # set color for joints mc.setAttr(rollJoint + ".overrideEnabled", 1) mc.setAttr(rollJoint + ".overrideColor", 15) # finish roll function if "elbow" in rollJoint: makeRoll(firstJoint, lastJoint, rollJoint) if "knee" in rollJoint: makeRoll(firstJoint, lastJoint, rollJoint)
def setSpring(self,*args): self.springName="spring" #create a set to put all of the spring elements inside self.springSetName="spring_SET" if mc.objExists(self.springSetName): print (self.springSetName + " exists.") else: mc.sets(name=self.springSetName) #create guides self.set_connector(self.springName) #create radius circle self.radCntrl=mc.circle(name="radius_CTRL",c=(0,0,0), nr=(0,1,0), sw=360, r=3, d=3, ut=0, tol=0.01, s=8, ch=1) #create springRadius attribute mc.addAttr(self.radCntrl, sn="sr", ln="springRadius", k=1, defaultValue=3.0, min=0.1, max=15) #connect the springRadius attribute to the circle mc.connectAttr("radius_CTRL.springRadius", "{0}.radius".format(self.radCntrl[1])) #position radCntrl between locators and aim mc.pointConstraint(self.baseLoc, self.topLoc,self.radCntrl[0]) mc.aimConstraint(self.topLoc,self.radCntrl[0],aimVector=(0,1,0)) self.lockHide(self.radCntrl[0]) #create tmp group for easy deletion mc.select(self.baseLoc,self.topLoc,self.conCurve,self.radCntrl) self.selSpringObjs=mc.ls(sl=True,type="transform") self.createTmp(self.selSpringObjs)
def RMCreateLineBetwenPoints (self, Point1, Point2): Curve = cmds.curve (degree=1, p=[[0,0,0],[1,0,0]], name = "curveLineBetweenPnts") Curve = self.NameConv.RMRenameBasedOnBaseName(Point1, Curve, NewName = Curve) NumCVs = cmds.getAttr (Curve + ".controlPoints" , size = True) Cluster1, Cluster1Handle = cmds.cluster (Curve+".cv[0]", relative=True, name = "clusterLineBetweenPnts") Cluster1 = self.NameConv.RMRenameBasedOnBaseName(Point1 , Cluster1, NewName = Cluster1) Cluster1Handle = self.NameConv.RMRenameBasedOnBaseName(Point1 , Cluster1Handle, NewName = Cluster1Handle) Cluster2, Cluster2Handle = cmds.cluster (Curve+".cv[1]", relative=True, name = "clusterLineBetweenPnts") Cluster2 = self.NameConv.RMRenameBasedOnBaseName(Point2 , Cluster2, NewName = Cluster2) Cluster2Handle = self.NameConv.RMRenameBasedOnBaseName(Point2 , Cluster2Handle, NewName = Cluster2Handle) cmds.setAttr(Curve+".overrideEnabled",1) cmds.setAttr(Curve+".overrideDisplayType",1) RMAlign (Point1, Cluster1Handle, 1) RMAlign (Point2, Cluster1Handle, 1) PointConstraint1 = cmds.pointConstraint (Point1, Cluster1Handle, name = "PointConstraintLineBetweenPnts")[0] PointConstraint1 = self.NameConv.RMRenameBasedOnBaseName(Point1 , PointConstraint1, NewName = PointConstraint1) PointConstraint2 = cmds.pointConstraint (Point2, Cluster2Handle, name = "PointConstraintLineBetweenPnts")[0] PointConstraint2 = self.NameConv.RMRenameBasedOnBaseName(Point2 , PointConstraint2, NewName = PointConstraint2) DataGroup = cmds.group (em = True,name = "DataLineBetweenPnts") DataGroup = self.NameConv.RMRenameBasedOnBaseName(Point1 , DataGroup, NewName = DataGroup) cmds.parent (Cluster1Handle, DataGroup) cmds.parent (Cluster2Handle, DataGroup) cmds.parent (Curve, DataGroup) return DataGroup , Curve
def _create_constraints(self, joints, side): """Creates the constraints between the hydraulics pieces. @param joints: the joints @param side: the side @type joints: list @type side: String """ name = joints[0].split('_start_%s' % self.nc.joint)[0] world_up_object = cmds.spaceLocator(n='%s_%s' % (name, self.nc.locator))[0] cmds.setAttr('%s.v' % world_up_object, 0) self.c.snap_a_to_b(world_up_object, joints[0]) ac1 = cmds.aimConstraint(joints[0], joints[-1], mo=False, weight=1, aimVector=(1, 0, 0), upVector=(0, 1, 0), worldUpType='object', worldUpObject=world_up_object)[0] ac2 = cmds.aimConstraint(joints[-1], joints[0], mo=False, weight=1, aimVector=(1, 0, 0), upVector=(0, 1, 0), worldUpType='object', worldUpObject=world_up_object)[0] cmds.delete(ac1, ac2) self._place_world_up_object(world_up_object, joints[0], joints[-1], side) ac1 = cmds.aimConstraint(joints[0], joints[-1], mo=False, weight=1, aimVector=(1, 0, 0), upVector=(0, 1, 0), worldUpType='object', worldUpObject=world_up_object)[0] ac2 = cmds.aimConstraint(joints[-1], joints[0], mo=False, weight=1, aimVector=(1, 0, 0), upVector=(0, 1, 0), worldUpType='object', worldUpObject=world_up_object)[0] if len(joints) == 3: cmds.aimConstraint(joints[-1], joints[1], mo=False, weight=1) cmds.pointConstraint(joints[0], joints[-1], joints[1], mo=False, weight=1) # END if return world_up_object
def myPrimer(myjtText,mycvText): #myjtText=cmds.textField('jtText',q=1,text=1) #mycvText=cmds.textField('cvText',q=1,text=1) #mypadInt=cmds.intField('padInt',q=1,v=1) mypadInt=3 cmds.pointConstraint(myjtText,mycvText,n='tmpCt') cmds.delete('tmpCt') print myjtText print mycvText cmds.parent(mycvText,myjtText) i=0 while(i<mypadInt): if(i==0): newname=[mycvText[0] + '_wa'] topNode=newname else: newname=[mycvText[0] + '_pad'] cmds.group(mycvText,n=newname[0]) i=i+1 print topNode cmds.select(topNode) cmds.parent(w=1) cmds.makeIdentity(mycvText,apply=1,t=1,r=1,s=1,n=0)
def RMRedistributeConstraint(self,ListOfDrivers, ListOfConstrained, MaxInfluences, KeepBorders = True, ConstraintType = "parent"): DeltaMaxInfluence = 1/(float (len(ListOfDrivers))-1) CentersControlDic = {} for i in range (0,len( ListOfDrivers)): CentersControlDic[ListOfDrivers[i]] = ( DeltaMaxInfluence*i) pprint.pprint (CentersControlDic) DeltaPositionConstrained = float(1/(float(len(ListOfConstrained))-1)) PositionConstDic = {} for i in range(0,len( ListOfConstrained)): PositionConstDic[ListOfConstrained[i]] = (DeltaPositionConstrained*i) pprint.pprint (PositionConstDic) reach = MaxInfluences * DeltaMaxInfluence for eachConstrained in ListOfConstrained: for eachDriver in ListOfDrivers: weight = self.RMGaussCosine( PositionConstDic [ eachConstrained ], CentersControlDic [ eachDriver ], reach ) if weight > 0: if ConstraintType == "parent": cmds.parentConstraint(eachDriver, eachConstrained , weight = weight,mo = True) elif ConstraintType == "point": cmds.pointConstraint(eachDriver, eachConstrained , weight = weight,mo = True) elif ConstraintType == "orient": cmds.orientConstraint(eachDriver, eachConstrained , weight = weight,mo = True) else: print "not valid costraintType requested, valid types are point, parent, or orient"
def doPointConstraintObjectGroup(targets,object,mode=0): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Groups an object and constrains that group to the other objects ARGUMENTS: targets(list) object(string mode(int) - 0 - equal influence 1 - distance spread RETURNS: group(string) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ objGroup = rigging.groupMeObject(object,True,True) constraint = mc.pointConstraint (targets,objGroup, maintainOffset=True) if mode == 1: distances = [] for target in targets: distances.append(distance.returnDistanceBetweenObjects(target,objGroup)) normalizedDistances = cgmMath.normList(distances) targetWeights = mc.pointConstraint(constraint,q=True, weightAliasList=True) cnt=1 for value in normalizedDistances: mc.setAttr(('%s%s%s' % (constraint[0],'.',targetWeights[cnt])),value ) cnt-=1 return objGroup
def getParentConstraintDic (self, parentConstraint) : returnedDic = {'alias':{}, "object":None } aliasDic={} if cmds.objectType(parentConstraint)=="parentConstraint": WA = cmds.parentConstraint (parentConstraint, q = True, weightAliasList = True) TL = cmds.parentConstraint (parentConstraint, q = True, targetList = True) elif cmds.objectType(parentConstraint)=="orientConstraint": WA = cmds.orientConstraint (parentConstraint, q = True, weightAliasList = True) TL = cmds.orientConstraint (parentConstraint, q = True, targetList = True) elif cmds.objectType(parentConstraint)=="pointConstraint": WA = cmds.pointConstraint (parentConstraint, q = True, weightAliasList = True) TL = cmds.pointConstraint (parentConstraint, q = True, targetList = True) else: "error No constraint Type identified" if len(WA) == len(TL): for eachWAIndex in range(0,len(WA)): aliasDic[WA[eachWAIndex]] = TL[eachWAIndex] returnedDic["object"] = cmds.listConnections(parentConstraint + ".constraintRotateX")[0] returnedDic["alias"] = aliasDic return returnedDic
def _constrainLocators(self,locators=None): ''' Constrain locators for stretch / aim / twist behaviour. locators * -- Locators to constrain: { 'topLocs':[['name_topLoc_pos'], ['name_topLoc_aim'], ['name_topLoc_up']], 'midLocs':[['name_midLoc_pos'], ['name_midLoc_aim'], ['name_midLoc_up'], ['name_midLoc_off']], 'btmLocs':[['name_btmLoc_pos'], ['name_btmLoc_aim'], ['name_btmLoc_up']] } * This is the return value of _createLocators() ''' if self.logger: self.logger.info('_constrainLocators(): Starting...') if not locators: if self.logger: self.logger.error('_constrainLocators(): No locators passed in by caller.') raise Exception('No locators passed in by caller.') cmds.aimConstraint(locators['btmLocs'][0][0], locators['topLocs'][1][0], aim=[0,-1,0], u=[1,0,0], worldUpType='object', worldUpObject=locators['topLocs'][2][0],mo=False) cmds.aimConstraint(locators['topLocs'][0][0], locators['btmLocs'][1][0], aim=[0,1,0], u=[1,0,0], worldUpType='object', worldUpObject=locators['btmLocs'][2][0],mo=False) cmds.aimConstraint(locators['topLocs'][0][0], locators['midLocs'][1][0], aim=[0,1,0], u=[1,0,0], worldUpType='object', worldUpObject=locators['midLocs'][2][0],mo=False) cmds.pointConstraint(locators['topLocs'][0][0], locators['btmLocs'][0][0], locators['midLocs'][0][0], mo=True) cmds.pointConstraint(locators['topLocs'][2][0], locators['btmLocs'][2][0], locators['midLocs'][2][0], mo=True) if self.logger: self.logger.info('_constrainLocators(): End.')
def primeControl(driver, driven): ''' # Priming a control Return driver, grp, driven ''' # Group needs to be created # Name group after control icon that is going to be created. grpNamePieces = driven.split("_") if( len(grpNamePieces) > 1 ): grpNamePieces = grpNamePieces[0:-1] grpNamePieces.append("grp") grpName = "_".join(grpNamePieces) grp = cmds.group( name=grpName, em=True, world=True ) pc = cmds.pointConstraint( driver, grp ) oc = cmds.orientConstraint( driver, grp ) cmds.delete(pc, oc) # Option to snap control to position. pc = cmds.pointConstraint( driver, driven ) cmds.delete( pc ) cmds.parent( driven, grp ) cmds.makeIdentity( apply=True, t=1, r=1, s=1, n=0 ) # Position option to constrain driver to driven # Options: Point, Orient, Parent, and None return [driver, grp, driven]
def crvTendon(curve,geo,precision=4,prefix='tendon'): ''' ''' # rebuildCurve degree 1 baseCurve = mc.rebuildCurve(curve,ch=0,s=1,d=1,rpo=1,rt=0,end=1,kr=0,kcp=0,kep=1,kt=1) # create cv locators baseLocs = glTools.utils.curve.locatorCurve(baseCurve,prefix=prefix+'_baseCrv') # generate geo constraint curve geoCurve = mc.rebuildCurve(baseCurve,ch=1,s=precsion,d=1,rpo=0,rt=0,end=1,kr=0,kcp=0,kep=1,kt=1) geoCurveLocs = glTools.utils.curve.locatorCurve(geoCurve,prefix=prefix+'_geoCrv') # generate reference curve refCurve = mc.rebuildCurve(baseCurve,ch=1,s=precsion,d=1,rpo=0,rt=0,end=1,kr=0,kcp=0,kep=1,kt=1) refCurveInfo = mc.createNode('curveInfo',n=prefix+'_ref_curveInfo') mc.connectAttr(refCurve+'.worldSpace[0]',refCurveInfo+'.inputCurve',f=True) refCurveLocs = [] for i in range(precsion+1): refNull = mc.group(em=True,n=prefix+'_ref'+str(i)+'_null') mc.connectAttr(refCurveInfo+'.controlPoints['+str(i)+']',refNull+'.t') refCurveLocs.append(refNull) # Locator Constraints for i in range(precsion+1): mc.pointConstraint(refCurveLocs[i],geoCurveLocs[i]) mc.geometryConstraint(geo,geoCurveLocs[i]) # fitBspline bSpline = mc.fitBspline(geoCurve,ch=1)
def displayConnect_arrow( _obj ): # 타겟 오브젝트 _pointA = _obj[0] _pointB = _obj[1] # 라인생성 _createNode = cmds.createNode('annotationShape') _listRelatives = cmds.listRelatives( _createNode, parent=True ) _annotation = [_listRelatives[0], _createNode] print _annotation _loc = cmds.spaceLocator() _listRelatives = cmds.listRelatives( _loc[0], s=True ) _locator = [ _loc[0], _listRelatives[0] ] cmds.connectAttr( _locator[1]+'.worldMatrix[0]', _annotation[1]+'.dagObjectMatrix[0]') # pointCurveConstraint로 생성된 로케이터를 타겟 오브젝트에 붙임 cmds.pointConstraint( _pointA, _annotation[0]) cmds.pointConstraint( _pointB, _locator[0]) # 로케이터 가림 cmds.setAttr (_locator[1]+'.visibility', 0) # return return [_annotation[0], _locator[0]]
def __init__(self, joints, parentGroup, groupToConstraint): # joints[0] = snapTo joint # joints[1] = local parent # parentGroup = where to parent spaceSwitch groups # what group will be driven rootGroup = makeGroup.MakeGroup(name=joints[0] + "_spaceSwitch_GRP") worldGroup = makeGroup.MakeGroup(name=joints[0] + "_world", snapTo=joints[0]) localGroup = makeGroup.MakeGroup(name=joints[0] + "_local", snapTo=joints[0]) mc.parent(worldGroup.groupName, rootGroup.groupName) mc.parent(localGroup.groupName, rootGroup.groupName) mc.parent(rootGroup.groupName, parentGroup) # constraint setup for groups mc.parentConstraint(joints[1], localGroup.groupName, maintainOffset=True) mc.pointConstraint(localGroup.groupName, worldGroup.groupName) mc.orientConstraint(nameLib.prefixNames.globalControl + nameLib.prefixNames.controlSuffix, worldGroup.groupName, maintainOffset=True) # sonctraint for groupToConstraint for i in [worldGroup.groupName, localGroup.groupName]: swConstraint = mc.parentConstraint(i, groupToConstraint)[0] driver = joints[0] + ".parent" reverseNode = mc.shadingNode("reverse", name = joints[0] + "_swReverse", asUtility=True) # connect channels mc.connectAttr(driver, reverseNode + ".input.inputX") mc.connectAttr(driver, swConstraint + "." + joints[0] + "_worldW0") mc.connectAttr(reverseNode + ".output.outputX", swConstraint + "." + joints[0] + "_localW1")
def joint(side, lowerJoint, upperJoint, useSphere=0, sharedUpper=0, sharedLower=0, show=1, heightScale=1): name = lowerJoint + "_" + upperJoint upperName = "SKEL_" if sharedUpper == 0: upperName += side + "_" upperName += upperJoint lowerName = "SKEL_" if sharedLower == 0: lowerName += side + "_" lowerName += lowerJoint print name cmds.spaceLocator(name="%s_%s" % (side, name)) cmds.pointConstraint(lowerName, "%s_%s" % (side, name)) cmds.pointConstraint(upperName, "%s_%s" % (side, name)) cmds.aimConstraint(upperName, "%s_%s" % (side, name)) if useSphere: cmds.sphere(name="%s_%s_C" % (side, name), radius=1) else: cmds.cylinder(name="%s_%s_C" % (side, name), radius=0.5, heightRatio=6 * heightScale) cmds.setAttr("%s_%s_C.doubleSided" % (side, name), 0) if show == 0: cmds.setAttr("%s_%s_C.primaryVisibility" % (side, name), 0) # cmds.rotate( 0, 0, 90, '%s_FOREARM_C' % (side) ) # cmds.makeIdentity( '%s_FOREARM_C' % (side), apply = 1, rotate = 1 ) cmds.select("%s_%s" % (side, name), "%s_%s_C" % (side, name)) cmds.parentConstraint() return
def ParentToJoint(): nodes = cmds.ls(selection=True) jnts = cmds.ls(selection=True, type='joint') nodes = list(set(nodes) - set(jnts)) for node in nodes: distances = [] for jnt in jnts: grp = cmds.group(empty=True) cmds.pointConstraint(node, grp) At = cmds.xform(grp, ws=True, q=True, t=True) Ax = At[0] Ay = At[1] Az = At[2] cmds.delete(grp) grp = cmds.group(empty=True) cmds.pointConstraint(jnt, grp) Bt = cmds.xform(grp, ws=True, q=True, t=True) Bx = Bt[0] By = Bt[1] Bz = Bt[2] cmds.delete(grp) distances.append(sqrt(pow(Ax - Bx, 2) + pow(Ay - By, 2) + pow(Az - Bz, 2))) minDist = min(distances) closestJnt = jnts[distances.index(minDist)] cmds.parentConstraint(closestJnt, node, maintainOffset=True)
def rigArm(self, *args): basicFilter = "*.json" fileName = cmds.fileDialog2(fileFilter=basicFilter, dialogStyle=2, fm=1, okc='Load') # Read the Json file # Call on the json_utils readJson method. data = json_utils.readJson(fileName) info = json.loads( data ) self.Rig_Info['fkJoints'] = rig_utils.createJointChain(info, 'fkj') self.Rig_Info['ikJoints'] = rig_utils.createJointChain(info, 'ikj') self.Rig_Info['rigJoints'] = rig_utils.createJointChain(info, 'rigj') # Setup the ik rig ctrlFile = 'C:/Users/Griffy/Documents/GitHub/Python101/rigging/controls/HandControl.ma' rig_utils.importControlObject(ctrlFile) self.Rig_Info['ikInfo'] = rig_utils.createIk(self.Rig_Info['ikJoints']) # Align the control to the last ik joint tmpConstraint = cmds.parentConstraint(self.Rig_Info['ikJoints'][2], 'grp_control', mo=False) cmds.delete(tmpConstraint) # Rename the control cmds.rename('grp_control', 'grp_ikArmCtrl') cmds.rename('control', 'ikArmCtrl') # Constrain the ikHandle to the control cmds.pointConstraint('ikArmCtrl', self.Rig_Info['ikInfo'][0]) # Make the fk controls # Connect the fk, ik, and rig ikJoints for i in range(len(self.Rig_Info['rigJoints'])): switchPCon = cmds.parentConstraint(self.Rig_Info['ikJoints'][i], self.Rig_Info['rigJoints'][i], mo=True) cmds.parentConstraint(self.Rig_Info['fkJoints'][i], self.Rig_Info['rigJoints'][i], mo=True) print switchPCon
def anchorCurve(control,anchor,template=True): ''' ''' # Check control if not mc.objExists(control): raise Exception('Control "'+control+'" does not exist!') if not mc.objExists(anchor): raise Exception('Anchor transform "'+anchor+'" does not exist!') # Create curve shape crv = mc.curve(p=[(0,0,0),(0,1,0)],k=[0,1],d=1,n=control+'Anchor') crvShape = mc.listRelatives(crv,s=True) # Create curve locators crvLoc = glTools.utils.curve.locatorCurve(crv,locatorScale=0.0,local=True,prefix=control) mc.parent(crvLoc,control) mc.setAttr(crvLoc[0]+'.t',0,0,0) mc.setAttr(crvLoc[1]+'.t',0,0,0) # Parent curve shape crvShape = mc.parent(crvShape,control,r=True,s=True)[0] # Delete original curve transform mc.delete(crv) # Connect to anchor mc.pointConstraint(anchor,crvLoc[1]) # Template if template: mc.setAttr(crvShape+'.template',1) # Set channel states glTools.utils.channelState.ChannelState().setFlags([2,2,2,2,2,2,2,2,2,1],crvLoc) # Return result return crvShape
def setUpStretchyJointSegment(self, rootJoint, endJoint): ## create polevector control poleVectorControl = cmds.spaceLocator(name = self.moduleName + ":" + util.stripNamespace(rootJoint)[1] + "_poleVectorLocator")[0] poleVectorControl_grp = cmds.group(poleVectorControl, name = self.moduleName + ":" + util.stripNamespace(rootJoint)[1] + "_poleVectorLocator_grp") cmds.setAttr(poleVectorControl + ".ty", -0.5) cmds.setAttr(poleVectorControl + ".v", 0) ## add stretch ik to joints stretchy_ik = util.stretchy_ik(rootJoint, endJoint, self.moduleName, poleVectorObject = poleVectorControl) rootLocator = stretchy_ik["rootLocator"] endLocator = stretchy_ik["endLocator"] ikHandle = stretchy_ik["ikHandle"] ## parent objects doNotTouch_grp =stretchy_ik["doNotTouch_grp"] ## determine the translation control names parentTranslationControl = self.moduleName + ":" + util.stripNamespace(rootJoint)[1] + "_translation_control" childTranslationControl = self.moduleName + ":" + util.stripNamespace(endJoint)[1] + "_translation_control" ## point constraint root locator to root joint rootLocator_pointConstraint = cmds.pointConstraint(rootJoint, rootLocator, maintainOffset = False, name = rootLocator + "_pointConstraint")[0] ## point constraint end locator to translation control endLocator_pointConstraint = cmds.pointConstraint(childTranslationControl, endLocator, maintainOffset = False, name = endLocator + "_childTranslationControlConstraint")[0] poleVectorControl_parentConstraint = cmds.parentConstraint(parentTranslationControl, poleVectorControl_grp, maintainOffset = False, name = rootLocator + "_poleVectorLocatorConstraint")[0] #cmds.parent(translation_controlGRP, self.controls_grp) return doNotTouch_grp, poleVectorControl_grp
def Neck_Control(*args, **kwargs): NeckJt = "Neck_Jt" NeckCtrl = [mc.curve(name="Neck_Ctrl",degree=3,point=[(-0.801407, 0, 0.00716748),(-0.802768, 0.023587, -0.220859), (-0.805489, 0.0707609, -0.676912), (0.761595, -0.283043, -0.667253), (1.045492, -0.194522, -0.0218101), (1.046678, -0.194804, 0.0403576),(0.758039, -0.282198, 0.63974), (-0.806291, 0.0676615, 0.650803),(-0.803035, 0.0225538, 0.221713),(-0.801407, 0, 0.00716748)]), mc.setAttr("Neck_Ctrl.overrideColor",18),mc.setAttr("Neck_Ctrl.overrideEnabled",1)] mc.scale(2.1,3.16,2.8) mc.makeIdentity( 'Neck_Ctrl', apply=True, translate=True,scale=True) lockScaling = mc.setAttr("Neck_Ctrl.scale",lock=True) # xform translation valNeck = mc.xform(NeckJt,ws=True,query=True,translation=True) mc.xform(NeckCtrl,ws=1,t = (valNeck[0],valNeck[1],valNeck[2])) mc.orientConstraint("Neck_Ctrl", NeckJt) mc.pointConstraint("Neck_Ctrl", NeckJt) grpNeck = mc.group("Neck_Ctrl", name="GRP_Neck") mc.parent("GRP_Neck","Front_Spine_Ctrl") #Lock translation for curve lockTranslation = mc.setAttr("Neck_Ctrl.translate",lock=True) return NeckCtrl,NeckJt
def create_joints(): '''Subelements: vertecies, faces, edges should be selected''' # Get selected object name selection_list = cmds.ls(selection=True) for selection in selection_list: selected_object = selection.split('.')[0] break old_loc_list = cmds.ls('*LOC*', flatten=True) #Create locators constrained to subelements HZrivet.UI.HZrivet_finalCC() current_loc_list = cmds.ls('*LOC*', flatten=True) #Filter created locators new_loc_list = [loc for loc in current_loc_list if loc not in old_loc_list] # Get list of locators names and apply it as a prefix to a joint name loc_list = [loc for loc in new_loc_list if 'Shape' not in loc] root_joint = 'root' if not cmds.objExists(root_joint): cmds.select(clear=True) cmds.joint(name=root_joint) root_p_constraint = cmds.pointConstraint(selected_object, root_joint) root_o_constraint = cmds.orientConstraint(selected_object, root_joint) cmds.delete(root_p_constraint, root_o_constraint) for loc in loc_list: joint_prefix = re.sub("\D", "", loc) joint_name = 'JNT_' + joint_prefix cmds.select(clear=True) cmds.joint(name=joint_name) cmds.pointConstraint(loc, joint_name) cmds.orientConstraint(loc, joint_name) cmds.parent(joint_name, 'root')
def fkFingerSetup(self): """ #- fk finger setup """ cmds.select(cl = True) for fingerElement in self.allfingers: for lr in self.lrPrefix: for elem in fingerElement[0:-1]: if lr == self.left: ctlColor = 6 else: ctlColor = 12 ctl = controller.circleController('%s%s_ctl' %(lr, elem), 'yz', 0.5, ctlColor, ['tr', 'sc', 'vi'], doublePadding = True) cmds.select('%s%s_jnt' %(lr, elem), r = True) cmds.select('%s_grp' %ctl, tgl = True) cmds.pointConstraint(mo = False, weight = 1) cmds.orientConstraint(mo = False, weight = 1) cmds.delete('%s_grp_pointConstraint1' %ctl) cmds.delete('%s_grp_orientConstraint1' %ctl) #- constrain joints cmds.select(ctl, r = True) cmds.select('%s%s_jnt' %(lr, elem), tgl = True) cmds.orientConstraint(mo = False, weight = 1) fingerElementTmp = fingerElement[:-1] fingerElementTmp.reverse() for i in range(len(fingerElementTmp)-1): self.util.parent('%s%s_ctl_grp' %(lr, fingerElementTmp[i]), '%s%s_ctl' %(lr, fingerElementTmp[i+1]))
def _create_wrist(self): """Creates the special wrist setup for the 3 different rotation axes of Dave's wrist. @todo: change the constraining to the PLY GRP to something save """ hand = '%s_hand_result_%s' % (self.side, self.nc.joint) hand_end = '%s_handEnd_result_%s' % (self.side, self.nc.joint) fore_arm = '%s_foreArm_result_%s' % (self.side, self.nc.joint) # joints cmds.select(cl=True) root_jnt = cmds.joint(n='%s_wristRoot_%s' % (self.side, self.nc.joint)) end_jnt = cmds.joint(n='%s_wristEnd_%s' % (self.side, self.nc.joint)) tmp_end_jnt = cmds.joint(n='%s_wristTmpEnd_%s' % (self.side, self.nc.joint)) self.c.snap_a_to_b(root_jnt, hand) self.c.snap_a_to_b(end_jnt, hand_end) self.c.snap_a_to_b(tmp_end_jnt, hand_end) # orient joints properly self.orient_joint(root_jnt) cmds.delete(tmp_end_jnt) cmds.parent(end_jnt, w=True) # constrain joints cmds.parentConstraint(hand, root_jnt, mo=True) cmds.pointConstraint(root_jnt, end_jnt, mo=True) cmds.orientConstraint(root_jnt, end_jnt, mo=True) # constrain hand const group cmds.parentConstraint('%s_wristRotZ_PLY_%s' % (self.side, self.nc.group), '%s_hand_const_%s' % (self.side, self.nc.group), mo=True) cmds.parent(root_jnt, end_jnt, '%s_hand_%s' % (self.side, self.nc.group))
def setupIK(self): #Create shoulder self.m_shoulderCtrl = cmds.spaceLocator( n=self.m_joints.m_shoulder.replace("_JNT", "_LOC") )[0] # Add to controls rc.addToControlDict(self.m_allControls, "%s_IKShoulder" %(self.m_baseName), self.m_shoulderCtrl) rc.addToLayer(self.m_sceneData, "hidden", self.m_shoulderCtrl) rc.orientControl(self.m_shoulderCtrl, self.m_joints.m_shoulder) rg.add3Groups(self.m_shoulderCtrl, ["_SDK", "_CONST", "_0"]) cmds.parent(self.m_shoulderCtrl+"_0", self.m_group, r=1) cmds.pointConstraint( self.m_shoulderCtrl, self.m_joints.m_shoulder, mo=1 ) desiredName = self.m_wristCtrl.replace("_CTRL", "_IK") self.m_ikHandle = cmds.ikHandle( n = desiredName, sj = self.m_joints.m_shoulder, ee = self.m_joints.m_wrist, sol = "ikRPsolver", see = True )[0] # deselect so we don't get errors cmds.select(d=1) rc.addToLayer(self.m_sceneData, "hidden", [self.m_ikHandle]) cmds.parent(self.m_ikHandle, self.m_wristCtrl) self.setupPoleVec()
def nullMeasurementRig(self,name): #finds starting position and orientation startPos = MeasuringTool.getPointLocation(self.objectStart) startOrient = cmds.xform(self.objectStart,q = True, ws = True, rotation = True) #create parent group parentGroup = cmds.group(empty = True, name = '%s_Stretch_Group'%name) #create main null mainNull = cmds.group(empty = True, parent = parentGroup,name = '%s_Main_Null'%name) #creates starting null startNull = cmds.group(empty = True,parent = parentGroup, name = '%s_Start_Null'%(name)) #creates end null endNull = cmds.group(empty = True, parent = startNull, name = '%s_End_Null'%(name)) cmds.move(startPos[0], startPos[1], startPos[2],parentGroup) cmds.rotate(startOrient[0],startOrient[1],startOrient[2],parentGroup) #finds end location pointDistance = self.getPointDistanceBetween() length = MeasuringTool.getVectorLength(pointDistance) cmds.move(length,0,0,endNull, a = True, os = True) cmds.move(length,0,0,mainNull, a = True, os = True) #create constraints cmds.aimConstraint(mainNull,startNull,aim = (1,0,0)) cmds.pointConstraint(mainNull,endNull) return [startNull,endNull,mainNull,parentGroup]
def aimRig(self,name): #query start location and orient startPosition = MeasuringTool.getPointLocation(self.objectStart) startOrient = MeasuringTool.getWorldEulerRotation(self.objectStart) #create locators aimLoc = cmds.spaceLocator(n = '%s_Aim_AimVector_Loc'%(name)) upLoc = cmds.spaceLocator(n = '%s_Aim_UpVector_Loc'%(name)) tgt = cmds.spaceLocator(n = '%s_Aim_Target_Loc'%(name)) #create hierarchy posNull = cmds.group(aimLoc[0],upLoc[0],tgt[0],n = '%s_Aim_Pos_Null'%(name)) cmds.move(startPosition[0],startPosition[1],startPosition[2],posNull) cmds.rotate(startOrient[0],startOrient[1],startOrient[2],posNull) #find vector length distance = self.getPointDistanceBetween() length = MeasuringTool.getVectorLength([distance[0],distance[1],distance[2]]) #move and apply constraints to target cmds.move(length,0,0,tgt, a = True, os = True) cmds.move(0,0,10,upLoc[0],os = True) cmds.parentConstraint(self.objectStart,posNull) cmds.pointConstraint(self.objectEnd,tgt[0]) cmds.aimConstraint(tgt,aimLoc, aimVector = (1,0,0), upVector = (0,0,1), worldUpType = "object", worldUpObject = upLoc[0])
def Jaw_Control(*args,**kwargs): prefix = "_" JawJt = "Lower_Jaw_Jt" JawCtrl = [mc.curve(name="Jaw"+prefix+"Ctrl",d=1, p=[(-0.484806, -0.465148, -0.560784 ),(-0.484806, -0.465148, 0.595512), (-0.275612, 0.538987, 0.636341),(1.356108, 0.120597, 0.636341 ), (2.161106, 0.0592024, 0.01008 ),(1.356108, 0.120597, -0.610974), (-0.275612, 0.538987, -0.610974),(-0.484806, -0.465148, -0.560784), (1.146913, -0.67078, -0.560784 ),(1.951911, -0.670601, 0.01008), (1.146913, -0.67078, 0.595512),(1.356108, 0.120597, 0.636341), (2.161106, 0.0592024, 0.01008),(1.356108, 0.120597, -0.610974), (1.146913, -0.67078, -0.560784),(1.146913, -0.67078, 0.595512), (-0.484806, -0.465148, 0.595512),(1.146913, -0.67078, 0.595512), (1.951911, -0.670601, 0.01008),(2.161106, 0.0592024, 0.01008)]), mc.setAttr("Jaw"+prefix+"Ctrl.overrideColor",18), mc.setAttr("Jaw"+prefix+"Ctrl.overrideEnabled",1),mc.scale(0.5,1,1.15)] #xform translation valPos = mc.xform(JawJt,query=True,ws=True,translation=True) mc.xform(JawCtrl[0],ws=1,t=(valPos[0],valPos[1],valPos[2])) #xform rotation valRot = mc.xform(JawJt,query=True,ws=True,rotation=True) mc.xform(JawCtrl[0],ws=1,ro=(valRot[0],valRot[1],valRot[2])) mc.setAttr("Jaw"+prefix+"Ctrl.rotateZ",-22) mc.makeIdentity(JawCtrl[0],a=True,r=True,t=True,s=True) mc.orientConstraint(JawCtrl[0], JawJt, mo=True) mc.pointConstraint(JawCtrl[0], JawJt, mo=True) mc.parent(JawCtrl[0],"Head_Ctrl") #Lock attributes for Jaw rig for lock in JawJt: mc.setAttr("Jaw"+prefix+"Ctrl.scale",lock=True), mc.setAttr("Jaw"+prefix+"Ctrl.translate",lock=True)
def create_controls(self): """Create controls""" # Make duplicate joint chain self._duplicate_joints() # Create ikHandle self.create_ik() # Create control ik_ctl = Control(self.position, self.description, 0) ik_ctl.create() # Style and lock attrs ik_ctl.set_style("cube") ik_ctl.lock_scales() # Append control self.controls[ik_ctl.name] = ik_ctl self.ik_ctl = ik_ctl # Create base null self.base_null = cmds.createNode("transform", name=name.set_suffix(ik_ctl.name, "baseNull")) xform.match_translates(self.base_null, self.ik_joints[0]) cmds.pointConstraint(self.base_null, self.ik_joints[0], mo=True) self.setups.append(self.base_null) return self.controls
def bind_skeletons(source, dest, method='connect', scales=False, verbose=False): ''' From 2 given root joints search through each hierarchy for child joints, match them based on node name, then connect their trans/rots directly, or parentConstrain them. Again cmds for speed :param source: the root node of the driving skeleton :param dest: the root node of the driven skeleton :param method: the method used for the connection, either 'connect' or 'constrain' :param scale: do we bind the scales of the destination skel to the source?? ''' sourceJoints = cmds.listRelatives(source, ad=True, f=True, type='joint') destJoints = cmds.listRelatives(dest, ad=True, f=True, type='joint') if verbose: result = cmds.confirmDialog( title='Bind Skeletons SCALES', message= ("Would you also like to process the SCALE channels within the bind?" ), button=['Yes', 'No'], messageAlign='center', icon='question', dismissString='Cancel') if result == 'Yes': scales = True else: scales = False # parent constrain the root nodes regardless of bindType, fixes issues where # we have additional rotated parent groups on the source cmds.parentConstraint(source, dest) if scales: cmds.scaleConstraint(source, dest, mo=True) attrs = [ 'rotateX', 'rotateY', 'rotateZ', 'translateX', 'translateY', 'translateZ' ] if scales: attrs = attrs + ['scaleX', 'scaleY', 'scaleZ'] for sJnt, dJnt in match_given_hierarchys(sourceJoints, destJoints): if method == 'connect': for attr in attrs: try: cmds.connectAttr('%s.%s' % (sJnt, attr), '%s.%s' % (dJnt, attr), f=True) except: pass elif method == 'constrain': # need to see if the channels are open if not, change this binding code try: cmds.parentConstraint(sJnt, dJnt, mo=True) except: chns = r9Anim.getSettableChannels(dJnt) if all([ 'translateX' in chns, 'translateY' in chns, 'translateZ' in chns ]): cmds.pointConstraint(sJnt, dJnt, mo=True) elif all( ['rotateX' in chns, 'rotateY' in chns, 'rotateZ' in chns]): cmds.orientConstraint(sJnt, dJnt, mo=True) else: log.info('Failed to Bind joints: %s >> %s' % (sJnt, dJnt)) # if we have incoming scale connections then run the scaleConstraint if scales: # and cmds.listConnections('%s.sx' % sJnt): try: cmds.scaleConstraint(sJnt, dJnt, mo=True) # turn off the compensation so that the rig can still be scaled correctly by the MasterNode # cmds.setAttr('%s.segmentScaleCompensate' % dJnt, 0) except: print 'failed : scales ', dJnt
import maya.cmds as cmds selection_list = cmds.ls(orderedSelection = True) # Finding which groups these locators belongs to. So we can create the cones under the same group first_loc = selection_list[0] loc_parent_grp = cmds.listRelatives( first_loc, p=True )[0] # Making cone group and making it child of the locator group cone_grp = cmds.group(em = True, name = '%s_cone' % loc_parent_grp, parent = loc_parent_grp) for obj in selection_list: # Making a cone and adding that under the cone_group cone_new = cmds.polyCone(r = 1, h = 3.3, name = '%s_%s' % (obj, 'Cone') ) cmds.parent( '%s_%s' % (obj, 'Cone'), cone_grp) # Bringing the pivot of the cone in to its own tip cone_vtx = cmds.ls('%s_%s.vtx[*]' % (obj, 'Cone'), fl=True) cone_tip = cone_vtx[-1] vtx_pos = cmds.xform(cone_tip, ws = 1, q = 1, t = 1) cmds.move( vtx_pos[0], vtx_pos[1], vtx_pos[2], ['%s_%s.scalePivot' % (obj, 'Cone'), '%s_%s.rotatePivot' % (obj, 'Cone')], relative=True ) cmds.rotate(0,0,180) cmds.pointConstraint(obj, cone_new) cmds.select(clear = True)
print 'Error: ',e raise Exception( 'Failed to rename rivet.') # Create controller try: self.createController(cnt) except Exception,e: print 'Error: ',e raise Exception('Failed to create controller: %s'%cnt) # Load part 2 GUI fields with created objects cmds.textFieldButtonGrp(self.controlField,e=True,text=cnt) cmds.textFieldButtonGrp(self.rivetField,e=True,text=rivet) # Snap controller to rivet and zero/orient to world temp = cmds.pointConstraint(rivet,cnt,mo=False) cmds.delete(temp) cmds.makeIdentity(cnt,apply=True,t=True,r=True,s=True,n=True) # Hide rivet shape visibility cmds.setAttr('%sShape.visibility'%rivet,0) def setupControl(self,*args): #Load variables name = cmds.textFieldGrp(self.nameField,q=True,text=True) control = cmds.textFieldButtonGrp(self.controlField,q=True,text=True) rivet = cmds.textFieldButtonGrp(self.rivetField,q=True,text=True) constObj = cmds.textFieldButtonGrp(self.jointField,q=True,text=True) #Load selection
def build(legJoints, topToeJoints, pvLocator, scapulaJnt='', prefix='l_leg', rigScale=1.0, baseRig=None): """ :param legJoints: list(str), shoulder - elbow - hand - toe - end toe :param topToeJoints: list(str), top metacarpal toe joints :param pvLocator: str, reference locator for position of Pole Vector control :param scapulaJnt: str, optional, scapula joint, parento fo top leg joint :param prefix: str, prefix to name new objects :param rigScale: float, scale factor for size of controls :param baseRig: instance of base.module.Base class :return: dictionary with rig module objects """ # make rig module rigmodule = module.Module(prefix=prefix, baseObject=baseRig) # make attach groups bodyAttachGrp = cmds.group(n=prefix + 'BodyAttach_grp', em=1, p=rigmodule.partsGrp) baseAttachGrp = cmds.group(n=prefix + 'BaseAttach_grp', em=1, p=rigmodule.partsGrp) # make controls if scapulaJnt: scapulaCtrl = control.Control( prefix=prefix + 'Scapula', translateTo=scapulaJnt, rotateTo=scapulaJnt, scale=rigScale * 3, parent=rigmodule.controlGrp, shape='sphere', lockChannels=['ty', 'rx', 'rz', 's', 'v']) footCtrl = control.Control(prefix=prefix + 'Foot', translateTo=legJoints[2], scale=rigScale * 3, parent=rigmodule.controlGrp, shape='circleY') ballCtrl = control.Control(prefix=prefix + 'Ball', translateTo=legJoints[3], rotateTo=legJoints[3], scale=rigScale * 2, parent=footCtrl.C, shape='circleZ') poleVectorCtrl = control.Control(prefix=prefix + 'PV', translateTo=pvLocator, scale=rigScale, parent=rigmodule.controlGrp, shape='sphere') toeIkControls = [] for topToeJnt in topToeJoints: toePrefix = name.removeSuffix(topToeJnt)[:-1] toeEndJnt = cmds.listRelatives(topToeJnt, ad=1, type='joint')[0] toeIkCtrl = control.Control(prefix=toePrefix, translateTo=toeEndJnt, scale=rigScale, parent=footCtrl.C, shape='circleY') toeIkControls.append(toeIkCtrl) # make IK handles if scapulaJnt: scapulaIK = cmds.ikHandle(n=prefix + 'Scapula_ikh', sol='ikSCsolver', sj=scapulaJnt, ee=legJoints[0])[0] legIk = cmds.ikHandle(n=prefix + 'Main_ikh', sol='ikRPsolver', sj=legJoints[0], ee=legJoints[2])[0] ballIK = cmds.ikHandle(n=prefix + 'Ball_ikh', sol='ikSCsolver', sj=legJoints[2], ee=legJoints[3])[0] mainToeIK = cmds.ikHandle(n=prefix + 'MainToe_ikh', sol='ikSCsolver', sj=legJoints[3], ee=legJoints[4])[0] cmds.hide(legIk, ballIK, mainToeIK) for i, topToeJnt in enumerate(topToeJoints): toePrefix = name.removeSuffix(topToeJnt)[:-1] toeJoints = joint.listHierarchy(topToeJnt) toeIk = cmds.ikHandle(n=toePrefix + '_ikh', sol='ikSCsolver', sj=toeJoints[1], ee=toeJoints[-1])[0] cmds.hide(toeIk) cmds.parent(toeIk, toeIkControls[i].C) # attach controls cmds.parentConstraint(bodyAttachGrp, poleVectorCtrl.Off, mo=1) if scapulaJnt: cmds.parentConstraint(baseAttachGrp, scapulaCtrl.Off, mo=1) # attach objects to controls cmds.parent(legIk, ballCtrl.C) cmds.parent(ballIK, mainToeIK, footCtrl.C) cmds.poleVectorConstraint(poleVectorCtrl.C, legIk) if scapulaJnt: cmds.parent(scapulaIK, scapulaCtrl.C) cmds.pointConstraint(scapulaCtrl.C, scapulaJnt) # make pole vector connection line pvLinePos1 = cmds.xform(legJoints[1], q=1, t=1, ws=1) pvLinePos2 = cmds.xform(pvLocator, q=1, t=1, ws=1) # create a straight line without span points(degree=1) poleVectorCrv = cmds.curve(n=prefix + 'Pv_crv', degree=1, p=[pvLinePos1, pvLinePos2]) cmds.cluster(poleVectorCrv + '.cv[0]', n=prefix + 'Pv1_cls', weightedNode=[legJoints[1], legJoints[1]], bindState=True) cmds.cluster(poleVectorCrv + '.cv[1]', n=prefix + 'Pv2_cls', wn=[poleVectorCtrl.C, poleVectorCtrl.C], bs=True) cmds.parent(poleVectorCrv, rigmodule.controlGrp) cmds.setAttr(poleVectorCrv + '.template', 1) return { 'module': rigmodule, 'baseAttachGrp': baseAttachGrp, 'bodyAttachGrp': bodyAttachGrp }
def applyMotionNodeConnections(self): spaceListGroup = [self.filterGroupNodeDic['fkSpace'], self.filterGroupNodeDic['ikSpace'], self.filterGroupNodeDic['outputSpace'], self.filterGroupNodeDic['controlFkSpace'], self.filterGroupNodeDic['controlIkSpace']] for node in self.filterGroupNodeDic['inputChildPlug'].iterkeys(): nodeLocal = util.fullPathName2Local(node) if nodeLocal[1].rfind('upleg') != -1: for spaceList in spaceListGroup: for spaceNode in spaceList: spaceNodeLocal = util.fullPathName2Local(spaceNode) if spaceNodeLocal[1].rfind('upleg') != -1: util.transformChannelBinding(node, spaceNode) elif nodeLocal[1].rfind('ball_twist') != -1: for controlIkSpace in self.filterGroupNodeDic['controlIkSpace']: controlIkSpaceLocal = util.fullPathName2Local(controlIkSpace) if controlIkSpaceLocal[1].rfind('Pole_Rot') != -1: cmds.orientConstraint(node, controlIkSpace) elif nodeLocal[1].rfind('foot_offset') != -1: footOffsetPlug = node ballJntOffsetPlug = '' tipJntOffsetPlug = '' uplegIkSpace = '' footIkSpace = '' ballIkSpaceLocal = '' tipIkSpaceLocal = '' controlIKSpaceLocalNodes = [] for controlIkSpace in self.filterGroupNodeDic['controlIkSpace']: controlIkSpaceLocal = util.fullPathName2Local(controlIkSpace) if controlIkSpaceLocal[1].rfind('space_local') != -1: controlIKSpaceLocalNodes.append(controlIkSpace) for spaceLocalNode in controlIKSpaceLocalNodes: spaceLocalNodeBaseStr = util.fullPathName2Local(spaceLocalNode) if spaceLocalNodeBaseStr[1].rfind('ball') != -1: ballIkSpaceLocal = spaceLocalNode elif spaceLocalNodeBaseStr[1].rfind('tip') != -1: tipIkSpaceLocal = spaceLocalNode for plugNode in self.filterGroupNodeDic['inputChildPlug'].iterkeys(): plugNodeLocal = util.fullPathName2Local(plugNode) if plugNodeLocal[1].rfind('ball_jnt') != -1: ballJntOffsetPlug = plugNode elif plugNodeLocal[1].rfind('tip_jnt') != -1: tipJntOffsetPlug = plugNode for controlIkSpace in self.filterGroupNodeDic['controlIkSpace']: controlIkSpaceLocalStr = util.fullPathName2Local(controlIkSpace) if controlIkSpaceLocalStr[1].rfind('upleg_con_ik') != -1: uplegIkSpace = controlIkSpace elif controlIkSpaceLocalStr[1].rfind('foot_con_ik') != -1 and controlIkSpaceLocalStr[1].rfind('local') == -1: footIkSpace = controlIkSpace matrixOps = util.localMatrixOp(self.moduleNameSpace, 'foot_Ik_Con_space') cmds.connectAttr(uplegIkSpace+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True) cmds.connectAttr(footOffsetPlug+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True) util.decompChannelBinding(matrixOps[1], footIkSpace) matrixOps = util.localMatrixOp(self.moduleNameSpace, 'ball_ik_Con_space') cmds.connectAttr(footOffsetPlug+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True) cmds.connectAttr(ballJntOffsetPlug+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True) util.decompChannelBinding(matrixOps[1], ballIkSpaceLocal) matrixOps = util.localMatrixOp(self.moduleNameSpace, 'tip_Ik_Con_space') cmds.connectAttr(footOffsetPlug+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True) cmds.connectAttr(tipJntOffsetPlug+'.worldMatrix', matrixOps[0]+'.matrixIn[0]', f=True) util.decompChannelBinding(matrixOps[1], tipIkSpaceLocal) for controlFkCon in self.filterGroupNodeDic['controlFkCon']: controlFkConLocal = util.fullPathName2Local(controlFkCon) matchStr = controlFkConLocal[1].replace('_fk_Con', 'Jnt_fk') for fkJntNode in self.filterGroupNodeDic['fkJnt']: fkJntNodeLocal = util.fullPathName2Local(fkJntNode) if fkJntNodeLocal[1] == matchStr: cmds.connectAttr(controlFkCon+'.rotate', fkJntNode+'.rotate', f=True) filterDic = {'foot':'ball', 'ball':'tip'} sourceNode = '' targetNode = '' targetUpNode = '' for key, value in filterDic.iteritems(): for ikJnt in self.filterGroupNodeDic['ikJnt']: ikJntLocal = util.fullPathName2Local(ikJnt) if ikJntLocal[1].rfind(key) != -1: sourceNode = ikJnt for controlRef in self.filterGroupNodeDic['controlRef']: controlRefLocal = util.fullPathName2Local(controlRef) if controlRefLocal[1].rfind(value) != -1: if controlRefLocal[1].rfind('Handle') != -1: targetNode = controlRef elif controlRefLocal[1].rfind('Pole') != -1: targetUpNode = controlRef cmds.aimConstraint(targetNode, sourceNode, aim = [1,0,0], u= [0,1,0], wut='object', wuo=targetUpNode) for spaceIkNode in self.filterGroupNodeDic['ikSpace']: spaceIkNodeLocal = util.fullPathName2Local(spaceIkNode) if spaceIkNodeLocal[1].rfind('soft') != -1: sourceNode = spaceIkNode for controlIkNode in self.filterGroupNodeDic['controlIkCon']: controlIkNodeLocal = util.fullPathName2Local(controlIkNode) if controlIkNodeLocal[1].rfind('foot') != -1 and controlIkNodeLocal[1].rfind('local') != -1: targetNode = controlIkNode elif controlIkNodeLocal[1].rfind('leg') != -1 and controlIkNodeLocal[1].rfind('Pole') != -1: targetUpNode = controlIkNode cmds.aimConstraint(targetNode, sourceNode, aim = [1,0,0], u= [0,1,0], wut='object', wuo=targetUpNode) for blendNode in self.filterGroupNodeDic['outputBlend']: blendNodeLocal = util.fullPathName2Local(blendNode) blendNodeLocalPrefix = blendNodeLocal[1].split('_')[0] blendNodeOp = util.createOpNode(self.moduleNameSpace, 'blendColors', blendNodeLocalPrefix+'_blend_op') cmds.connectAttr(self.filterGroupNodeDic['fk2ikCon'].keys()[0]+'.fk2ik', blendNodeOp+'.blender', f=True) for ikJntNode in self.filterGroupNodeDic['ikJnt']: ikJntNodeLocal = util.fullPathName2Local(ikJntNode) if blendNodeLocalPrefix+'_ik' == ikJntNodeLocal[1]: cmds.connectAttr(ikJntNode+'.rotate', blendNodeOp+'.color1', f=True) for fkJntNode in self.filterGroupNodeDic['fkJnt']: fkJntNodeLocal = util.fullPathName2Local(fkJntNode) if blendNodeLocalPrefix+'_fk' == fkJntNodeLocal[1]: cmds.connectAttr(fkJntNode+'.rotate', blendNodeOp+'.color2', f=True) cmds.connectAttr(blendNodeOp+'.output', blendNode+'.rotate', f=True) ikConDisplayOp = util.createOpNode(self.moduleNameSpace, 'condition', 'ik_con_display_op') cmds.setAttr(ikConDisplayOp+'.operation', 0) cmds.setAttr(ikConDisplayOp+'.secondTerm', 1) cmds.setAttr(ikConDisplayOp+'.colorIfTrueR', 1) cmds.setAttr(ikConDisplayOp+'.colorIfFalseR', 0) fkConDisplayOp = util.createOpNode(self.moduleNameSpace, 'condition', 'fk_con_display_op') cmds.setAttr(fkConDisplayOp+'.operation', 0) cmds.setAttr(fkConDisplayOp+'.secondTerm', 0) cmds.setAttr(fkConDisplayOp+'.colorIfTrueR', 1) cmds.setAttr(fkConDisplayOp+'.colorIfFalseR', 0) cmds.connectAttr(self.filterGroupNodeDic['fk2ikCon'].keys()[0]+'.controlDisplay', ikConDisplayOp+'.firstTerm', f=True) cmds.connectAttr(self.filterGroupNodeDic['fk2ikCon'].keys()[0]+'.controlDisplay', fkConDisplayOp+'.firstTerm', f=True) for blendNode in self.filterGroupNodeDic['outputBlend']: blendNodeLocal = util.fullPathName2Local(blendNode) if blendNodeLocal[1].rfind('upleg') != -1: cmds.connectAttr(blendNode+'.rotate', self.filterGroupNodeDic['fk2ikSpace'].keys()[0]+'.rotate', f=True) placementList = ['Fk', 'Ik'] for typeStr in placementList: for placementNode in self.filterGroupNodeDic['control'+typeStr+'Placement'].iterkeys(): placementNodeLocal = util.fullPathName2Local(placementNode) if placementNodeLocal[1].rfind('upleg') != -1 and placementNodeLocal[1].rfind('fk2ik') == -1: if typeStr == placementList[0]: cmds.connectAttr(fkConDisplayOp+'.outColorR', placementNode+'.visibility', f=True) else: cmds.connectAttr(ikConDisplayOp+'.outColorR', placementNode+'.visibility', f=True) legPoleAutoAssetPath = self.pathInfo.assetDirPath + 'poleVectorPosAutoOpAsset' + '.' + self.file_extenstion_str legPoleAutoOpNode = '' legPoleAutoOpNodeNew = '' fileCheck = cmds.file( legPoleAutoAssetPath, query=True, exists=True ) if fileCheck: cmds.file( legPoleAutoAssetPath, i=True, mergeNamespacesOnClash=True ) containerNodes = cmds.ls(type='container', l=True) if containerNodes != None: for containerNode in containerNodes: localStr = containerNode.split(':')[-1] if localStr == 'poleVectorPosAutoOp': legPoleAutoOpNode = containerNode if cmds.objExists(legPoleAutoOpNode): legPoleAutoOpNodeNew = cmds.rename(legPoleAutoOpNode, legPoleAutoOpNode + '_' + self.component_val) uplegIkMotion = '' legPoleAuto = '' legPoleSideAuto = '' legPoleFntAuto = '' footIkConLocal = '' uplegIkMotionStr = '' legPoleAutoStr = '' legPoleSideAutoStr = '' legPoleFntAutoStr = '' footIkConLocalStr = '' for conPoleAutoNode in self.filterGroupNodeDic['controlPoleAuto']: conPoleAutoNodeLocal = util.fullPathName2Local(conPoleAutoNode) if conPoleAutoNodeLocal[1].rfind('Pole_Auto') != -1: legPoleAuto = conPoleAutoNode legPoleAutoStr = conPoleAutoNodeLocal[1] elif conPoleAutoNodeLocal[1].rfind('Side') != -1: legPoleSideAuto = conPoleAutoNode legPoleSideAutoStr = conPoleAutoNodeLocal[1] elif conPoleAutoNodeLocal[1].rfind('Fnt') != -1: legPoleFntAuto = conPoleAutoNode legPoleFntAutoStr = conPoleAutoNodeLocal[1] for motinoIkSpaceNode in self.filterGroupNodeDic['ikSpace']: motinoIkSpaceNodeLocal = util.fullPathName2Local(motinoIkSpaceNode) if motinoIkSpaceNodeLocal[1].rfind('upleg') != -1: uplegIkMotion = motinoIkSpaceNode uplegIkMotionStr = motinoIkSpaceNodeLocal[1] for conIkNode in self.filterGroupNodeDic['controlIkCon']: conIkNodeLocal = util.fullPathName2Local(conIkNode) if conIkNodeLocal[1] == 'foot_ik_Con_local': footIkConLocal = conIkNode footIkConLocalStr = conIkNodeLocal[1] uplegIkMotionDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', uplegIkMotionStr+'_decomp') footIkConLocalDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', footIkConLocalStr+'_decomp') legPoleSideAutoDecompOp = util.createOpNode(self.moduleNameSpace, 'decomposeMatrix', legPoleSideAutoStr+'_decomp') cmds.connectAttr(uplegIkMotion+'.worldMatrix', uplegIkMotionDecompOp +'.inputMatrix', f=True) cmds.connectAttr(footIkConLocal+'.worldMatrix', footIkConLocalDecompOp +'.inputMatrix', f=True) cmds.connectAttr(legPoleSideAuto+'.worldMatrix', legPoleSideAutoDecompOp +'.inputMatrix', f=True) cmds.connectAttr(uplegIkMotionDecompOp+'.outputTranslate', legPoleAutoOpNodeNew +'.Input_ikSpaceWorldPos', f=True) cmds.connectAttr(footIkConLocalDecompOp+'.outputTranslate', legPoleAutoOpNodeNew +'.Input_conSpaceWorldPos', f=True) cmds.connectAttr(legPoleSideAutoDecompOp+'.outputTranslate', legPoleAutoOpNodeNew +'.Input_ikSideWorldPos', f=True) legPoleSideAutoCompOp = util.createOpNode(self.moduleNameSpace, 'composeMatrix', legPoleSideAutoStr+'_comp') cmds.connectAttr(legPoleAutoOpNodeNew+'.Output_poleVectorWorldPos', legPoleSideAutoCompOp +'.inputTranslate', f=True) matrixOps = util.localMatrixOp(self.moduleNameSpace, legPoleSideAutoStr+'_comp') cmds.connectAttr(legPoleAuto+'.worldInverseMatrix', matrixOps[0]+'.matrixIn[1]', f=True) cmds.connectAttr(legPoleSideAutoCompOp +'.outputMatrix', matrixOps[0]+'.matrixIn[0]', f=True) util.decompChannelBinding(matrixOps[1], legPoleFntAuto, option=2) for conIkSpaceNode in self.filterGroupNodeDic['controlIkSpace']: conIkSpaceNodeLocal = util.fullPathName2Local(conIkSpaceNode) if conIkSpaceNodeLocal[1].rfind('Pole_Pos') != -1: cmds.pointConstraint(legPoleFntAuto, conIkSpaceNode) legFk2IkConNode = self.filterGroupNodeDic['fk2ikCon'].keys()[0] if self._side == 'L': legFk2IkConShapeNode = cmds.listRelatives(legFk2IkConNode, shapes=True, f=True)[0] spanNums = cmds.getAttr(legFk2IkConShapeNode+'.spans') spanNums = spanNums + 1 for i in range(0, spanNums): originalPos = cmds.getAttr(legFk2IkConShapeNode+".controlPoints["+ str(i)+"].zValue") cmds.setAttr(legFk2IkConShapeNode+".controlPoints["+ str(i)+"].zValue", originalPos * -1)
def doPointAimConstraintObjectGroup(targets,object,mode=0): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGEMENT: Idea for this stype of constraint setup is from http://td-matt.blogspot.com/2011/01/spine-control-rig.html DESCRIPTION: Groups an object and constrains that group to the other objects ARGUMENTS: targets(list) - should be in format of from to back with the last one being the aim object object(string) mode(int) - 0 - equal influence 1 - distance spread RETURNS: group(string) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ returnList = [] """ figure out which is the aim direction """ aimVector = locators.returnLocalAimDirection(object,targets[-1]) upVector = locators.returnLocalUp(aimVector) """ create locators """ locs = [] toMake = ['point','aim','up'] for type in toMake: locBuffer = locators.locMeObject(object) attributes.storeInfo(locBuffer,'cgmName',object) attributes.storeInfo(locBuffer,'cgmTypeModifier',type) locs.append(NameFactory.doNameObject(locBuffer)) pointLoc = locs[0] aimLoc = locs[1] upLoc = locs[2] """ move the locators """ mc.xform(aimLoc,t=aimVector,r=True,os=True) mc.xform(upLoc,t=upVector,r=True,os=True) """group constraint""" objGroup = rigging.groupMeObject(object,True) attributes.storeInfo(objGroup,'cgmName',object) attributes.storeInfo(objGroup,'cgmTypeModifier','follow') objGroup = NameFactory.doNameObject(objGroup) pointConstraintBuffer = mc.pointConstraint (pointLoc,objGroup, maintainOffset=False) aimConstraintBuffer = mc.aimConstraint(aimLoc,objGroup,maintainOffset = False, weight = 1, aimVector = aimVector, upVector = upVector, worldUpObject = upLoc, worldUpType = 'object' ) """loc constraints""" locConstraints = [] for loc in locs: parentConstraintBuffer = mc.parentConstraint (targets,loc, maintainOffset=True) locConstraints.append(parentConstraintBuffer[0]) if mode == 1: distances = [] for target in targets: distances.append(distance.returnDistanceBetweenObjects(target,objGroup)) normalizedDistances = cgmMath.normList(distances) for constraint in locConstraints: targetWeights = mc.parentConstraint(constraint,q=True, weightAliasList=True) cnt=1 for value in normalizedDistances: mc.setAttr(('%s%s%s' % (constraint,'.',targetWeights[cnt])),value ) cnt-=1 returnList.append(objGroup) returnList.append(locs) return returnList
def armFkToIk(rigNS, side, bakeWrist=True, start=None, end=None, sampleBy=1): """ Bake FK arm animation to IK controls @param rigNS: IK/FK toggle attribute @type rigNS: str @param side: Arm side ("lf" or "rt") @type side: str @param bakeWrist: Bake wrist animation @type bakeWrist: bool @param start: Transfer animation start frame @type start: int or None @param end: Transfer animation end frame @type end: int or None @param sampleBy: Bake animation by N frames @type sampleBy: int """ # ========== # - Checks - # ========== # Get Start/End if start == None: start = cmds.playbackOptions(q=True, min=True) if end == None: end = cmds.playbackOptions(q=True, max=True) # Get FK Joints fkShoulder = rigNS + ':' + side + '_arm_fkA_jnt' fkElbow = rigNS + ':' + side + '_arm_fkB_jnt' fkWrist = rigNS + ':' + side + '_handA_jnt' # Get IK Controls ikWrist = rigNS + ':' + side + '_arm_ik_ctrl' ikElbow = rigNS + ':' + side + '_arm_pv_ctrl' # ===================== # - Transfer FK to IK - # ===================== # Set Arm to FK mode cmds.setAttr(rigNS + ':config.' + side + 'ArmIkFkBlend', 1) # FK # Bake Wrist to Locator wristLoc = None if bakeWrist: wristLoc = glTools.anim.utils.bakeAnimToLocator( obj=fkWrist, start=start, end=end, sampleBy=sampleBy, simulation=True, attrList=['rx', 'ry', 'rz']) # Duplicate IK Controls ikWristLoc = cmds.duplicate(ikWrist, po=True)[0] ikElbowLoc = cmds.duplicate(ikElbow, po=True)[0] # Constrain IK to FK joints ikWristCon = cmds.pointConstraint(fkWrist, ikWristLoc)[0] pvWristCon = cmds.pointConstraint(fkElbow, ikElbowLoc)[0] # Bake Constraint Keys cmds.refresh(suspend=True) cmds.bakeResults([ikWristLoc, ikElbowLoc], t=(start, end), at=['tx', 'ty', 'tz'], simulation=True, preserveOutsideKeys=True, sampleBy=sampleBy) cmds.refresh(suspend=False) # Transfer Keys to IK Controls cmds.copyKey(ikWristLoc, at=['tx', 'ty', 'tz'], t=(start, end)) cmds.pasteKey(ikWrist, at=['tx', 'ty', 'tz'], t=(start, end), option='replace') cmds.copyKey(ikElbowLoc, at=['tx', 'ty', 'tz'], t=(start, end)) cmds.pasteKey(ikElbow, at=['tx', 'ty', 'tz'], t=(start, end), option='replace') # Delete Duplicate Joints and Constraints for item in [ikWristLoc, ikElbowLoc]: if cmds.objExists(item): try: cmds.delete(item) except Exception, e: print('Error deleting node "' + str(item) + '"!') print(str(e))
def __init__(self, character): #before you switch, create a locator for the neck position neckLoc = cmds.spaceLocator(name="roto_neck_locator")[0] constraintNeckLoc = cmds.parentConstraint( character + ":neck_01_fk_anim", neckLoc)[0] cmds.delete(constraintNeckLoc) constraint = cmds.orientConstraint("spine_01", character + ":spine_01_anim")[0] cmds.setKeyframe(character + ":spine_01_anim") cmds.delete(constraint) constraint = cmds.orientConstraint(character + ":twist_splineIK_spine_03", character + ":spine_03_anim", skip=["y", "z"])[0] cmds.setKeyframe(character + ":spine_03_anim.rx") cmds.delete(constraint) constraint = cmds.orientConstraint(character + ":chest_ik_anim", character + ":spine_05_anim", skip=["y", "z"])[0] cmds.setKeyframe(character + ":spine_05_anim.rx") cmds.delete(constraint) #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# # # #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# #create (rotate) Y dist locators for the spine spineStartPointY = cmds.xform(character + ":twist_splineIK_spine_05", q=True, ws=True, t=True)[0] spineEndPointY = cmds.xform(character + ":spine_05_anim", q=True, ws=True, t=True)[0] spineDistY = cmds.distanceDimension(sp=(spineStartPointY, 0, 0), ep=(spineEndPointY, 0, 0)) spineDistYParent = cmds.listRelatives(spineDistY, parent=True)[0] spineLocs = cmds.listConnections(spineDistY) spineStartLocY = spineLocs[0] spineEndLocY = spineLocs[1] cmds.pointConstraint(character + ":twist_splineIK_spine_05", spineStartLocY, skip=["y", "z"], mo=True) cmds.pointConstraint(character + ":spine_05_anim", spineEndLocY, skip=["y", "z"], mo=True) #get the distance. if distance is greater than .05, then modify rotations currentYDist = cmds.getAttr(spineDistY + ".distance") self.checkDistance(character, spineDistY, currentYDist, currentYDist, ".ry", "spine_03_anim") try: cmds.delete(spineDistYParent) cmds.delete(spineStartLocY) cmds.delete(spineEndLocY) except: pass #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# # # #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# #create (rotate) Z dist locators for the spine spineStartPointZ = cmds.xform(character + ":twist_splineIK_spine_05", q=True, ws=True, t=True)[1] spineEndPointZ = cmds.xform(character + ":spine_05_anim", q=True, ws=True, t=True)[1] spineDistZ = cmds.distanceDimension(sp=(0, spineStartPointZ, 0), ep=(0, spineEndPointZ, 0)) spineDistZParent = cmds.listRelatives(spineDistZ, parent=True)[0] spineZLocs = cmds.listConnections(spineDistZ) spineStartLocZ = spineZLocs[0] spineEndLocZ = spineZLocs[1] cmds.pointConstraint(character + ":twist_splineIK_spine_05", spineStartLocZ, skip=["x", "z"], mo=True) cmds.pointConstraint(character + ":spine_05_anim", spineEndLocZ, skip=["x", "z"], mo=True) currentZDist = cmds.getAttr(spineDistZ + ".distance") self.checkDistance(character, spineDistZ, currentZDist, currentZDist, ".rz", "spine_03_anim") try: cmds.delete(spineDistZParent) cmds.delete(spineStartLocZ) cmds.delete(spineEndLocZ) except: pass #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# # # #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# cmds.setAttr(character + ":Rig_Settings.spine_ik", 0) cmds.setAttr(character + ":Rig_Settings.spine_fk", 1) #create (rotate) Y dist locators for the neck neckStartPointY = cmds.xform(neckLoc, q=True, ws=True, t=True)[0] neckEndPointY = cmds.xform(character + ":neck_01_fk_anim", q=True, ws=True, t=True)[0] neckDistY = cmds.distanceDimension(sp=(neckStartPointY, 0, 0), ep=(neckEndPointY, 0, 0)) neckDistYParent = cmds.listRelatives(neckDistY, parent=True)[0] neckYLocs = cmds.listConnections(neckDistY) neckStartLocY = neckYLocs[0] neckEndLocY = neckYLocs[1] cmds.pointConstraint(neckLoc, neckStartLocY, skip=["y", "z"], mo=True) cmds.pointConstraint(character + ":neck_01_fk_anim", neckEndLocY, skip=["y", "z"], mo=True) currentNeckYDist = cmds.getAttr(neckDistY + ".distance") self.checkDistance(character, neckDistY, currentNeckYDist, currentNeckYDist, ".ry", "spine_05_anim") try: cmds.delete(neckDistYParent) cmds.delete(neckStartLocY) cmds.delete(neckEndLocY) except: pass #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# # # #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# cmds.setAttr(character + ":Rig_Settings.spine_ik", 0) cmds.setAttr(character + ":Rig_Settings.spine_fk", 1) #create (rotate) Z dist locators for the neck neckStartPointZ = cmds.xform(neckLoc, q=True, ws=True, t=True)[1] neckEndPointZ = cmds.xform(character + ":neck_01_fk_anim", q=True, ws=True, t=True)[1] neckDistZ = cmds.distanceDimension(sp=(0, neckStartPointZ, 0), ep=(0, neckEndPointZ, 0)) neckDistZParent = cmds.listRelatives(neckDistZ, parent=True)[0] neckZLocs = cmds.listConnections(neckDistZ) neckStartLocZ = neckZLocs[0] neckEndLocZ = neckZLocs[1] cmds.pointConstraint(neckLoc, neckStartLocZ, skip=["x", "z"], mo=True) cmds.pointConstraint(character + ":neck_01_fk_anim", neckEndLocZ, skip=["x", "z"], mo=True) currentNeckZDist = cmds.getAttr(neckDistZ + ".distance") self.checkDistance(character, neckDistZ, currentNeckZDist, currentNeckZDist, ".rz", "spine_05_anim") try: cmds.delete(neckDistZParent) cmds.delete(neckStartLocZ) cmds.delete(neckEndLocZ) except: pass #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# # # #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@# cmds.delete(neckLoc)
def install_custom(self, joints, moduleGrp, moduleContainer): wristJoint = joints[3] handJoint = joints[4] """ The temp locator is used to find the position of each joint """ tempLocator = cmds.spaceLocator()[0] cmds.parent(tempLocator, handJoint, relative=True) cmds.parent(tempLocator, moduleGrp, absolute=True) handJoint_modulePos = [ cmds.getAttr(tempLocator + ".translateX"), cmds.getAttr(tempLocator + ".translateY"), cmds.getAttr(tempLocator + ".translateZ") ] cmds.parent(tempLocator, wristJoint) for attr in [".translateX", ".translateY", ".translateZ"]: cmds.setAttr(tempLocator + attr, 0) cmds.parent(tempLocator, moduleGrp, absolute=True) wristJoint_modulePos = [ cmds.getAttr(tempLocator + ".translateX"), cmds.getAttr(tempLocator + ".translateY"), cmds.getAttr(tempLocator + ".translateZ") ] cmds.delete(tempLocator) containedNodes = [] """ Pass in functionality from basic IK """ ikNodes = circleIK.CircleControlStretchyIK.install_custom( self, joints, moduleGrp, moduleContainer, createHandleControl=False, poleVectorAtRoot=False) ikEndPosLocator = ikNodes["endLocator"] ikPoleVectorLocator = ikNodes["poleVectorObject"] stretchinessAttribute = ikNodes["stretchinessAttribute"] name = "armControl" controlObjectInstance = controlObject.ControlObject() handControlInfo = controlObjectInstance.create(name, "handControl.ma", self, lod=1, translation=True, rotation=True, globalScale=False, spaceSwitching=True) handControl = handControlInfo[0] handControlRootParent = handControlInfo[1] """ Parent foot control to root parent """ cmds.parent(handControlRootParent, moduleGrp, relative=True) """ Position and orient foot control """ handControlPos = [ wristJoint_modulePos[0], handJoint_modulePos[1], wristJoint_modulePos[2] ] cmds.xform(handControl, objectSpace=True, absolute=True, translation=handControlPos) cmds.setAttr(handControl + ".rotateOrder", 3) #3 = xyz orientationVector = [ handJoint_modulePos[0] - wristJoint_modulePos[0], handJoint_modulePos[2] - wristJoint_modulePos[2] ] handControlRotation = atan2(orientationVector[1], orientationVector[0]) cmds.setAttr(handControl + ".rotateY", -degrees(handControlRotation)) pointConstraint = cmds.pointConstraint(handControl, ikEndPosLocator, maintainOffset=False, n=ikEndPosLocator + "_pointConstraint")[0] containedNodes.append(pointConstraint) """ Hookup stretchiness attribute """ cmds.select(handControl) cmds.addAttr(at="float", minValue=0.0, maxValue=1.0, defaultValue=1.0, keyable=True, longName="stretchiness") self.publishNameToModuleContainer(handControl + ".stretchiness", "stretchiness", publishToOuterContainers=True) cmds.connectAttr(handControl + ".stretchiness", stretchinessAttribute, force=True) """ Hand IK """ handIKNodes = cmds.ikHandle(sj=wristJoint, ee=handJoint, solver="ikRPsolver", n=handJoint + "_ikHandle") handIKNodes[1] = cmds.rename(handIKNodes[1], handIKNodes[1] + "_ikEffector") containedNodes.extend(handIKNodes) cmds.parent(handIKNodes[0], handControl) cmds.setAttr(handIKNodes[0] + ".visibility", 0) utils.addNodeToContainer(moduleContainer, containedNodes, ihb=True)
def __constraint(lDrivers, sDriven, bMaintainOffset=False, lSkipTranslate=None, lSkipRotate=None, lSkipScale=None, bForce=False, sType='parent'): lConnections = [] lLocks = [] lReturn = [] if sType == 'parent': lAttrConnect = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 't', 'r'] elif sType == 'point': lAttrConnect = ['tx', 'ty', 'tz', 't'] elif sType == 'orient': lAttrConnect = ['rx', 'ry', 'rz', 'r'] elif sType == 'scale': lAttrConnect = ['sx', 'sy', 'sz', 's'] elif sType == 'all': lAttrConnect = [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 't', 'r', 's' ] for sAttr in lAttrConnect: lConnectionsAttr = cmds.listConnections('%s.%s' % (sDriven, sAttr), s=True, scn=True, p=True) if lConnectionsAttr: for sConnection in lConnectionsAttr: lConnections.append([sConnection, sAttr]) bLock = cmds.getAttr('%s.%s' % (sDriven, sAttr), lock=True) if bLock: lLocks.append(sAttr) bConstraint = True if not bForce: if lConnections or lLocks: cmds.warning('%s already has input connections, skipped' % sDriven) bConstraint = False lReturn = None if bConstraint: for lConnectionAttr in lConnections: cmds.disconnectAttr('%s.%s' % (sDriven, lConnectionAttr[1]), lConnectionAttr[0]) for sLockAttr in lLocks: cmds.setAttr('%s.%s' % (sDriven, sLockAttr), lock=False) if bMaintainOffset: oNameDriven = naming.oName(sDriven) lNulls = [] for i, sDriver in enumerate(lDrivers): oNameDriver = naming.oName(sDriver) oNameDriver.sType = 'grp' oNameDriver.sPart = '%s%sConstraint' % (oNameDriver.sPart, sType.title()) sConstraintGrp = oNameDriver.sName if not cmds.objExists(sConstraintGrp): sConstraintGrp = transforms.createTransformNode( sConstraintGrp, sParent=sDriver) transforms.transformSnap([sDriver, sConstraintGrp], sType='all') cmds.setAttr('%s.v' % sConstraintGrp, 0) attributes.lockHideAttrs([ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ], sNode=sConstraintGrp) sNullOffset = naming.oName( sType='null', sSide=oNameDriven.sSide, sPart='%s%sConstraintOffsetW%d' % (oNameDriven.sPart, sType.title(), i), iIndex=oNameDriven.iIndex, iSuffix=oNameDriven.iSuffix).sName sNull = naming.oName(sType='null', sSide=oNameDriven.sSide, sPart='%s%sConstraintW%d' % (oNameDriven.sPart, sType.title(), i), iIndex=oNameDriven.iIndex, iSuffix=oNameDriven.iSuffix).sName iRotateOrder = cmds.getAttr('%s.ro' % sDriven) sNullOffset = transforms.createTransformNode( sNullOffset, sParent=sConstraintGrp, iRotateOrder=iRotateOrder) sNull = transforms.createTransformNode( sNull, sParent=sNullOffset, iRotateOrder=iRotateOrder) transforms.transformSnap([sDriven, sNullOffset], sType='all') attributes.lockHideAttrs([ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ], sNode=sNullOffset) attributes.lockHideAttrs([ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ], sNode=sNull) lNulls.append(sNull) lConstraints = lNulls else: lConstraints = lDrivers if sType == 'parent': sConstraint = cmds.parentConstraint(lConstraints, sDriven, mo=False, st=lSkipTranslate, sr=lSkipRotate)[0] cmds.setAttr('%s.interpType' % sConstraint, 2) lReturn.append(sConstraint) elif sType == 'point': sConstraint = cmds.pointConstraint(lConstraints, sDriven, mo=False, sk=lSkipTranslate)[0] lReturn.append(sConstraint) elif sType == 'orient': sConstraint = cmds.orientConstraint(lConstraints, sDriven, mo=False, sk=lSkipRotate)[0] cmds.setAttr('%s.interpType' % sConstraint, 2) lReturn.append(sConstraint) elif sType == 'scale': sConstraint = cmds.scaleConstraint(lConstraints, sDriven, mo=False, sk=lSkipScale)[0] lReturn.append(sConstraint) elif sType == 'all': sConstraint = cmds.parentConstraint(lConstraints, sDriven, mo=False, st=lSkipTranslate, sr=lSkipRotate)[0] cmds.setAttr('%s.interpType' % sConstraint, 2) lReturn.append(sConstraint) sConstraint = cmds.scaleConstraint(lConstraints, sDriven, mo=False, sk=lSkipScale)[0] lReturn.append(sConstraint) bConstraintInfo = cmds.attributeQuery('%sConstraints' % sType, node=sDriven, exists=True) if not bConstraintInfo: cmds.addAttr(sDriven, ln='%sConstraints' % sType, dt='string') sConstraintInfo = '' for sDriver in lDrivers: sConstraintInfo += '%s,' % sDriver cmds.setAttr('%s.%sConstraints' % (sDriven, sType), lock=False) cmds.setAttr('%s.%sConstraints' % (sDriven, sType), sConstraintInfo, type='string', lock=True) for sLockAttr in lLocks: cmds.setAttr('%s.%s' % (sDriven, sLockAttr), lock=True) return lReturn
def eyelidsCorners (self, upLidEpCrvPos, upLidCrv, lowLidEpCrvPos, lowLidCrv): '''Define eye corners position (for example if upper lid and lower lid curves are not 'closed'). Called by 'createDriverCrv' function. Call functions: None ''' cornerUp1 = upLidEpCrvPos [0] cornerUp2 = upLidEpCrvPos [4] cornerLow1 = lowLidEpCrvPos [0] cornerLow2 = lowLidEpCrvPos [4] # distance formula is: d = sqrt((Ax-Bx)**2 + (Ay-By)**2 + (Az-Bz)**2) distTEMP1 = math.sqrt( (cornerUp1[0] - cornerLow1[0])**2 + (cornerUp1[1] - cornerLow1[1])**2 + (cornerUp1[2] - cornerLow1[2])**2 ) distTEMP2 = math.sqrt( (cornerUp1[0] - cornerLow2[0])**2 + (cornerUp1[1] - cornerLow2[1])**2 + (cornerUp1[2] - cornerLow2[2])**2 ) # If cornerUp1 is closer to cornerLow2 than cornerLow1, # then the center of the distance between cornerUp1 and cornerLow2 # will be the "CornerA" and "CornerB" will be defined by # the other two points. if distTEMP1 > distTEMP2 : # CornerA cmds.select (cl = 1) cmds.select (upLidCrv + ".ep[0]") cmds.select (lowLidCrv + ".ep[4]", tgl = 1) clusterTEMP1 = cmds.cluster (en = 1) [1] locTEMP1 = cmds.spaceLocator () [0] cmds.pointConstraint (clusterTEMP1, locTEMP1, mo = 0, w = 1) self.cornerAPos = cmds.xform (locTEMP1, q = 1, ws = 1, t = 1) cmds.delete (clusterTEMP1) cmds.delete (locTEMP1) # CornerB cmds.select (cl = 1) cmds.select (upLidCrv + ".ep[4]") cmds.select (lowLidCrv + ".ep[0]", tgl = 1) clusterTEMP2 = cmds.cluster (en = 1) [1] locTEMP2 = cmds.spaceLocator () [0] cmds.pointConstraint (clusterTEMP2, locTEMP2, mo = 0, w = 1) self.cornerBPos = cmds.xform (locTEMP2, q = 1, ws = 1, t = 1) cmds.delete (clusterTEMP2) cmds.delete (locTEMP2) else: # CornerA cmds.select (cl = 1) cmds.select (upLidCrv + ".ep[0]") cmds.select (lowLidCrv + ".ep[0]", tgl = 1) clusterTEMP1 = cmds.cluster (en = 1) [1] locTEMP1 = cmds.spaceLocator () [0] cmds.pointConstraint (clusterTEMP1, locTEMP1, mo = 0, w = 1) self.cornerAPos = cmds.xform (locTEMP1, q = 1, ws = 1, t = 1) cmds.delete (clusterTEMP1) cmds.delete (locTEMP1) # CornerB cmds.select (cl = 1) cmds.select (upLidCrv + ".ep[4]") cmds.select (lowLidCrv + ".ep[4]", tgl = 1) clusterTEMP2 = cmds.cluster (en = 1) [1] locTEMP2 = cmds.spaceLocator () [0] cmds.pointConstraint (clusterTEMP2, locTEMP2, mo = 0, w = 1) self.cornerBPos = cmds.xform (locTEMP2, q = 1, ws = 1, t = 1) cmds.delete (clusterTEMP2) cmds.delete (locTEMP2) return self.cornerAPos, self.cornerBPos
def createFKControls(self, joints): """ You can define empty lists to store any items that may be created as you run through your for loops """ """ Any variables defined inside a for loop are throw away because they get overwritten when the loop runs again""" """ A list outside of the for loop used to store the fk control names. [] indicates an empty list. """ fkControls = [] """ Create another list to store the control groups """ fkADJGroups = [] """ Iterate through the joints and create a control for each """ for joint in joints: """ Define a name for our control by using the replace command """ fk_joint = ("FK_" + joint) fkJnt = ("FK" + joint) controlName = ("CTL_" + fkJnt) FKCTL = cmds.circle(name=controlName) cmds.setAttr(FKCTL[0] + ".overrideEnabled", 1) cmds.setAttr(FKCTL[0] + ".overrideColor", 13) """ Here is where we append the new fk control to the fkControl list """ fkControls.append(FKCTL) print joint """ PointConstrain the control to the joint. We do this so the control is moved to the position of the joint """ tempConstraint = cmds.pointConstraint(fk_joint, FKCTL) cmds.rotate(0, 90, 0) """ We no longer need the pointConstraint so we delete it """ cmds.delete(tempConstraint) cmds.makeIdentity(FKCTL[0], apply=True) cmds.delete(constructionHistory=True) """ Now we group the control so we can zero out the controls attributes """ """ This keeps the control at it's current position while creating clean channels for animation """ """ Lets make a name for this group """ ADJGrpName = ('ADJ_' + 'CTL_' + fkJnt) ADJGroup = cmds.group(em=True, name=ADJGrpName) tempConstraint = cmds.parentConstraint(fk_joint, ADJGroup) cmds.delete(tempConstraint) """ Parent the control to the control group """ cmds.parent(FKCTL[0], ADJGroup) """ Append the control group to the fkADJGroup list """ fkADJGroups.append(ADJGroup) """ orientConstrain the joint to the control """ cmds.orientConstraint(FKCTL[0], fk_joint, maintainOffset=True, weight=1) cmds.makeIdentity(FKCTL[0], apply=True) cmds.delete(constructionHistory=True) lockAttr = [ '.translateX', '.translateY', '.translateZ', '.scaleX', '.scaleY', '.scaleZ', '.visibility' ] for items in lockAttr: lock = cmds.setAttr(FKCTL[0] + items, lock=True, keyable=False, channelBox=False) """ Now you can do a new for loop for the parenting and orientation """ """ joints lives outside the for loop so you can still use it here """ """ Now we need to set up a hierarchy that will give us the functionality of an fk arm """ """ We can do this by parenting each control group to the joint that is one up in the chain. Or we can create a hierarchy of control objects. See the image in the post for details """ for index in range(len(fkControls)): if index != 0: cmds.parent(fkADJGroups[index], fkControls[index - 1][0]) for index in range(len(fkControls)): print fkControls[index][0] cmds.setAttr(fkControls[index][0] + ".rotateOrder", 2) print fkADJGroups for index in range(len(fkADJGroups)): print fkADJGroups[index] cmds.setAttr(fkADJGroups[index] + ".rotateOrder", 2) print fkADJGroups[index] groupFK = cmds.group(fkADJGroups[0], name='CTL_FKArm_GRP') cmds.setAttr(groupFK + ".rotateOrder", 2)
def build(self): """ """ super(Limb, self).build() self._ikfkSystem = rigIkFk.IkFkLimb( (self._startJoint.getPartialPath(), self._middleJoint.getPartialPath(), self._endJoint.getPartialPath())) self._ikfkSystem.create() self._ikfkSystem.setGroup( cmds.rename( self._ikfkSystem.getGroup(), "{0}_{1}".format(self._name, self._ikfkSystem.getGroup()))) cmds.parent(self._ikfkSystem.getGroup(), self._rigGroup.getPartialPath()) cmds.setAttr("{0}.v".format(self._ikfkSystem.getGroup()), 0) ikJointList = self._ikfkSystem.getIkJoints() fkJointList = self._ikfkSystem.getFkJoints() #------------------------------------------------- #FK SYSTEM #------------------------------------------------- fkControls = list() parent = self._rigGroup for jnt in (fkJointList): # create new control. ctrl = rigControl.Control( name=jnt.replace("{0}_{1}".format(rigName.BIND, rigName.FK), rigName.CONTROL), position=cmds.xform(jnt, q=True, ws=True, t=True), parent=parent, shape="circle", color=rigName.SIDECOLOR[rigName.getSide(self._name)]) ctrl.create() ctrl.setMatrix(cmds.xform(jnt, q=True, ws=True, m=True)) # constrain the joints to the controls cmds.pointConstraint(ctrl.getPartialPath(), jnt) cmds.orientConstraint(ctrl.getPartialPath(), jnt) # name the ctrl as the new parent and append to control list parent = ctrl fkControls.append(ctrl) #------------------------------------------------- # IK SYSTEM #------------------------------------------------- # create ik controls. ikCtrl = rigControl.Control( "{0}_{1}".format(self._name, rigName.CONTROL), position=self._endJoint.getPosition(), parent=self._rigGroup.getPartialPath(), shape="circle", color=rigName.SIDECOLOR[rigName.getSide(self._name)]) ikCtrl.create() offsetJnt = rigJoint.Joint("{0}_offset".format(ikJointList[-1].replace( "_{0}_".format(rigName.BIND), "")), parent=ikCtrl) offsetJnt.create() offsetJnt.setMatrix( cmds.xform(ikJointList[-1], q=True, ws=True, m=True)) rigJoint.Joint.rotateToOrient([offsetJnt.getPartialPath()]) cmds.parent(self._ikfkSystem.getHandle(), offsetJnt.getPartialPath()) cmds.setAttr("{0}.v".format(offsetJnt.getPartialPath()), 0) # renaming handle and setting the name back system self._ikfkSystem.setHandle( cmds.rename(self._ikfkSystem.getHandle(), "{0}_{1}".format(self._name, rigName.HANDLE))) # turn off the visibility of my ik handle cmds.setAttr("{0}.v".format(self._ikfkSystem.getHandle()), 0) # orient constrain the last ik joint in the chain to my offset joint cmds.orientConstraint(offsetJnt.getPartialPath(), ikJointList[-1]) # parent the ik handle pvPos = self._ikfkSystem.getPolevectorPosition( (self._startJoint.getPartialPath(), self._middleJoint.getPartialPath(), self._endJoint.getPartialPath())) pvCtrl = rigControl.Control( "{0}_pv_{1}".format(self._name, rigName.CONTROL), position=pvPos, parent=self._rigGroup.getPartialPath(), shape="circle", color=rigName.SIDECOLOR[rigName.getSide(self._name)]) pvCtrl.create() cmds.poleVectorConstraint(pvCtrl.getPartialPath(), self._ikfkSystem.getHandle()) for origJnt, blendJnt in zip(self._ikfkSystem.getOriginalJoints(), self._ikfkSystem.getBlendJoints()): cmds.parentConstraint(blendJnt, origJnt) #------------------------------------------------- # Param for IK/FK switching. #------------------------------------------------- # Create parameter node to drive ik/fk switching. paramLocator = cmds.spaceLocator()[0] paramNode = cmds.listRelatives(paramLocator, c=True, shapes=True)[0] paramNode = cmds.rename(paramNode, "{0}_param".format(self._name)) # parent cmds.parent(paramNode, pvCtrl.getPartialPath(), r=True, s=True) cmds.delete(paramLocator) del (paramLocator) cmds.setAttr("{0}.v".format(paramNode), 0) # lock and hide attributes rigAttribute.lockAndHide(paramNode, ["lpx", "lpy", "lpz", "lsx", "lsy", "lsz"]) # add ik/fk attribute to the param node cmds.addAttr(paramNode, ln="ikfk", at="double", min=0, max=1, dv=0, keyable=True) paramAttrIKFK = "{0}.ikfk".format(paramNode) # Loop through and create instance of paramNode on all of the controls. for ctrl in fkControls + [ikCtrl]: cmds.parent(paramNode, ctrl.getPartialPath(), r=True, s=True, add=True) # connect ikfk paramNode attr to the ikfk system attribute cmds.connectAttr(paramAttrIKFK, "{0}.ikfk".format(self._ikfkSystem.getGroup()), f=True) # hide controls when they shouldn't visible during ikfk switching. # create a reverse node reverseNode = cmds.createNode("reverse", n="{0}_{1}".format( self._name, rigName.REVERSE)) cmds.connectAttr("{0}.ikfk".format(self._ikfkSystem.getGroup()), "{0}.inputX".format(reverseNode), f=True) # param node ikfk attribute to the fk control visibility for ctrl in fkControls: cmds.connectAttr(paramAttrIKFK, "{0}.v".format(ctrl.getShape()), f=True) # connect reverse node to the ik controls for ctrl in (ikCtrl, pvCtrl): cmds.connectAttr("{0}.outputX".format(reverseNode), "{0}.v".format(ctrl.getShape()), f=True) self._fkControls = fkControls
def createCrvCtrls (self, eyePrefix, parentCtrl, ctrlJnts): '''Creates controller curve for each controller joint. Called by 'buildRig' function. Call functions: None ''' # Organize rig hierarchy hierarchySecondGrp = cmds.group (n = (eyePrefix + "_Eyelids_CTRL_GRP"), em = 1) hierarchyMainGrp = "Eyelids_CTRL_GRP" if parentCtrl != None : ctrlChildren = cmds.listRelatives (parentCtrl, children = 1) if hierarchyMainGrp in ctrlChildren : cmds.parent (hierarchySecondGrp, (parentCtrl + "|" + hierarchyMainGrp)) else : cmds.group (n = hierarchyMainGrp, em = 1, p = parentCtrl) cmds.parent (hierarchySecondGrp, (parentCtrl + "|" + hierarchyMainGrp)) else : if cmds.objExists ("|" + hierarchyMainGrp) : cmds.parent (hierarchySecondGrp, ("|" + hierarchyMainGrp)) else : cmds.group (n = hierarchyMainGrp, em = 1) cmds.parent (hierarchySecondGrp, ("|" + hierarchyMainGrp)) # Creates the controller object cmds.select (cl = 1) TEMP_CTRL1 = cmds.circle (r = 0.15) [0] TEMP_CTRL2 = cmds.duplicate () [0] cmds.setAttr (TEMP_CTRL2 + ".rotateY", 90) TEMP_CTRL3 = cmds.duplicate () [0] cmds.setAttr (TEMP_CTRL3 + ".rotateX", 90) cmds.parent (TEMP_CTRL2, TEMP_CTRL3, TEMP_CTRL1) cmds.makeIdentity (apply = 1, t = 1, r = 1, s = 1, n = 0, pn = 1) cmds.pickWalk (d = "down") cmds.select (TEMP_CTRL1, tgl = 1) cmds.parent (r = 1, s = 1) cmds.delete (TEMP_CTRL2, TEMP_CTRL3) cmds.select (cl = 1) # Place the controllers and constrain the joints self.ctrlList = [] ctrlOffsetGrpList = [] for jnt in ctrlJnts: ctrlName = jnt [:-9] ctrlName = "CTRL_" + ctrlName ctrl = cmds.duplicate (TEMP_CTRL1, n = ctrlName) [0] self.ctrlList.append (ctrl) pointC_TEMP = cmds.pointConstraint (jnt, ctrl) cmds.delete (pointC_TEMP) origName = "ORIG_" + ctrlName origGrp = cmds.group (n = origName, em = 1) parentC_TEMP = cmds.parentConstraint (ctrl, origGrp) cmds.delete (parentC_TEMP) if ctrl.find ("_Secondary") != -1 : # If controller is 'secondary' offsetGrpName = origName.replace ("ORIG_", "OFFSET_") offsetGrp = cmds.duplicate (origGrp, n = offsetGrpName) cmds.parent (ctrl, offsetGrp) cmds.parent (offsetGrp, origGrp) ctrlOffsetGrpList.extend (offsetGrp) else: cmds.parent (ctrl, origGrp) cmds.parent (origGrp, hierarchySecondGrp) cmds.parentConstraint (ctrl, jnt) cmds.delete (TEMP_CTRL1) cmds.select (cl = 1) # Constraints between main controllers and secondary ones # self.ctrlList = same order as 'ctrlJnts' list # [ctrl_CornerA, ctrl_upLidSecA, ctrl_upLidMain, ctrl_upLidSecB, ctrl_CornerB, ctrl_lowLidSecB, ctrl_lowLidMain, ctrl_lowLidSecA] # Index: 0 1 2 3 4 5 6 7 # ctrlOffsetGrpList = [OFFSET_Up_secondaryA, OFFSET_Up_secondaryB, OFFSET_Low_secondaryB, OFFSET_Low_secondaryA] # Index: 0 1 2 3 cmds.parentConstraint (self.ctrlList[0], ctrlOffsetGrpList[0], mo = 1) cmds.parentConstraint (self.ctrlList[2], ctrlOffsetGrpList[0], mo = 1) cmds.parentConstraint (self.ctrlList[2], ctrlOffsetGrpList[1], mo = 1) cmds.parentConstraint (self.ctrlList[4], ctrlOffsetGrpList[1], mo = 1) cmds.parentConstraint (self.ctrlList[4], ctrlOffsetGrpList[2], mo = 1) cmds.parentConstraint (self.ctrlList[6], ctrlOffsetGrpList[2], mo = 1) cmds.parentConstraint (self.ctrlList[6], ctrlOffsetGrpList[3], mo = 1) cmds.parentConstraint (self.ctrlList[0], ctrlOffsetGrpList[3], mo = 1) # Secondary controllers visibility (drove by main controllers) cmds.select (cl = 1) cmds.select (self.ctrlList[2], self.ctrlList[6]) cmds.addAttr (ln = "SecondaryControls", at = "bool", k = 0) cmds.setAttr ((self.ctrlList[2] + ".SecondaryControls"), 1, channelBox = 1) cmds.setAttr ((self.ctrlList[6] + ".SecondaryControls"), 1, channelBox = 1) # Upper lid cmds.connectAttr ((self.ctrlList[2] + ".SecondaryControls"), (self.ctrlList[1] + ".visibility"), f = 1) cmds.connectAttr ((self.ctrlList[2] + ".SecondaryControls"), (self.ctrlList[3] + ".visibility"), f = 1) # Lower lid cmds.connectAttr ((self.ctrlList[6] + ".SecondaryControls"), (self.ctrlList[5] + ".visibility"), f = 1) cmds.connectAttr ((self.ctrlList[6] + ".SecondaryControls"), (self.ctrlList[7] + ".visibility"), f = 1) # Lock and hide unused channels for ctrl in self.ctrlList : cmds.setAttr ((ctrl + ".sx"), lock = 1, keyable = 0, channelBox = 0) cmds.setAttr ((ctrl + ".sy"), lock = 1, keyable = 0, channelBox = 0) cmds.setAttr ((ctrl + ".sz"), lock = 1, keyable = 0, channelBox = 0) cmds.setAttr ((ctrl + ".v"), lock = 1, keyable = 0, channelBox = 0)
def build(startJoint, endJoint, clavOrient='', ctrlRotate=(0, 0, 0), prefix=''): ''' @param startJoint: Clavicle start joint @type startJoint: str @param endJoint: Clavicle end joint @type endJoint: str @param scaleAttr: Global character scale attribute @type scaleAttr: str @param clavOrient: Clavicle orient transform @type clavOrient: str @param clavOrient: Rotate clavicle control shape @type clavOrient: list or tuple @param prefix: Name prefix for new nodes @type prefix: str ''' # ========== # - Checks - # ========== if not mc.objExists(startJoint): raise Exception('Start joint "' + startJoint + '" does not exist!') if not mc.objExists(endJoint): raise Exception('End joint "' + endJoint + '" does not exist!') if clavOrient and not mc.objExists(clavOrient): raise Exception('Clavicle orient transform "' + clavOrient + '" does not exist!') # ====================== # - Configure Clavicle - # ====================== scaleAxis = 'x' rotateCtrlScale = 0.5 transCtrlScale = 0.2 blendAttr = 'stretchToControl' # ========================== # - Build Module Structure - # ========================== # Create control group ctrl_grp = mc.group(em=True, n=prefix + '_ctrl_grp', w=True) # Create rig group rig_grp = mc.group(em=True, n=prefix + '_rig_grp', w=True) # Create skel group skel_grp = mc.group(em=True, n=prefix + '_skel_grp', w=True) # Create module group module = mc.group(em=True, n=prefix + '_module') mc.parent([ctrl_grp, rig_grp, skel_grp], module) # - Uniform Scale - mc.addAttr(module, ln='uniformScale', min=0.001, dv=1.0) mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleX') mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleY') mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleZ') mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleX') mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleY') mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleZ') # ======================= # - Create Attach Joint - # ======================= mc.select(cl=True) # Attach joint attachJoint = mc.joint(n=prefix + '_attachA_jnt') attachJointGrp = glTools.utils.joint.group(attachJoint) # Attach joint display mc.setAttr(attachJoint + '.overrideEnabled', 1) mc.setAttr(attachJoint + '.overrideLevelOfDetail', 1) # Parent Attach Joint mc.parent(attachJointGrp, skel_grp) # ========================= # - Create Clavicle Joint - # ========================= # Add start joint buffer startJointGrp = glTools.utils.joint.group(startJoint) mc.delete(mc.pointConstraint(startJointGrp, attachJointGrp)) mc.parentConstraint(attachJoint, ctrl_grp, mo=True) mc.parent(startJointGrp, attachJoint) # =================== # - Create Controls - # =================== # Initialize control builder ctrlBuilder = glTools.tools.controlBuilder.ControlBuilder() # Calculate joint length jntLen = glTools.utils.joint.length(startJoint) # Rotate control clavRotateCtrl = mc.group(em=True, n=prefix + '_rot_ctrl') if clavOrient: mc.delete(mc.orientConstraint(clavOrient, clavRotateCtrl)) clavRotateCtrlShape = glTools.tools.controlBuilder.controlShape( clavRotateCtrl, 'anchor', rotate=ctrlRotate, scale=jntLen * rotateCtrlScale, orient=False) clavRotateCtrlGrp = glTools.utils.base.group(clavRotateCtrl, name=prefix + '_rot_ctrlGrp') glTools.rig.utils.tagCtrl(clavRotateCtrl, 'primary') # Translate control clavTransCtrl = ctrlBuilder.create('box', prefix + '_trans_ctrl', scale=jntLen * transCtrlScale) clavTransCtrlGrp = glTools.utils.base.group(clavTransCtrl, name=prefix + '_trans_ctrlGrp') glTools.rig.utils.tagCtrl(clavTransCtrl, 'primary') # Position Controls pt = glTools.utils.base.getPosition(startJoint) mc.move(pt[0], pt[1], pt[2], clavRotateCtrlGrp, ws=True, a=True) pt = glTools.utils.base.getPosition(endJoint) mc.move(pt[0], pt[1], pt[2], clavTransCtrlGrp, ws=True, a=True) # Parent Controls mc.parent(clavTransCtrlGrp, clavRotateCtrl) mc.parent(clavRotateCtrlGrp, ctrl_grp) # Constrain to Control mc.pointConstraint(clavRotateCtrl, startJoint) # ===================== # - Build Clavicle IK - # ===================== # Create ikHandle clavIk = glTools.tools.ikHandle.build(startJoint, endJoint, solver='ikSCsolver', prefix=prefix) # Parent ikHandle clavIkGrp = glTools.utils.base.group(clavIk, name=prefix + '_ikHandle_grp') mc.parent(clavIkGrp, clavTransCtrl) mc.setAttr(clavIkGrp + '.v', 0) # Create stretchy IK clavStretch = glTools.tools.stretchyIkChain.build( clavIk, scaleAxis=scaleAxis, scaleAttr=module + '.uniformScale', blendControl=clavTransCtrl, blendAttr=blendAttr, shrink=True, prefix=prefix) mc.setAttr(clavTransCtrl + '.' + blendAttr, 0.0) # ====================== # - Set Channel States - # ====================== chStateUtil = glTools.utils.channelState.ChannelState() chStateUtil.setFlags([0, 0, 0, 0, 0, 0, 2, 2, 2, 1], objectList=[clavRotateCtrl]) chStateUtil.setFlags([0, 0, 0, 2, 2, 2, 2, 2, 2, 1], objectList=[clavTransCtrl]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[clavRotateCtrlGrp, clavTransCtrlGrp]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[clavIk, clavIkGrp]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[endJoint, startJointGrp]) chStateUtil.setFlags([1, 1, 1, 1, 1, 1, 1, 2, 2, 1], objectList=[startJoint]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[attachJointGrp]) chStateUtil.setFlags([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], objectList=[attachJoint]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[module, ctrl_grp, rig_grp, skel_grp]) # ================= # - Return Result - # ================= # Define control list ctrlList = [clavRotateCtrl, clavTransCtrl] return [module, attachJoint]
def setPublishPose(rig, con): ###create pub group #query parent pnt = cmds.listRelatives(con, p=True)[0] pub_nul = '' #name sort if cmds.attributeQuery('publishPose', node='rig_GRP', ex=True) is False: cmds.addAttr(rig, k=True, ln='publishPose', at='double', min=0, max=1, dv=0) cmds.setAttr(rig + '.publishPose', 1) pub_nul = cmds.group(con, n=con.replace('_CON', 'PublishPose_NUL')) cmds.xform(pub_nul, os=True, rp=(0, 0, 0)) ###end create pub group ###set pub pose # loc = cmds.spaceLocator(n=con.replace('_CON', 'PubPose_LOC'))[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.rotInterpolation', 1) prefix = con.split('_')[0] if 'IK_foot' in con: pos1 = cmds.xform(prefix + '_IK_leg_JNT', q=True, rp=True, ws=True) pos2 = cmds.xform(prefix + '_IK_lowLeg_JNT', q=True, rp=True, ws=True) pos3 = cmds.xform(prefix + '_IK_foot_JNT', q=True, rp=True, ws=True) dis1 = abs( math.sqrt( math.pow(pos1[0] - pos2[0], 2) + math.pow(pos1[1] - pos2[1], 2) + math.pow(pos1[2] - pos2[2], 2))) dis2 = abs( math.sqrt( math.pow(pos2[0] - pos3[0], 2) + math.pow(pos2[1] - pos3[1], 2) + math.pow(pos2[2] - pos3[2], 2))) distance = dis1 + dis2 cmds.delete(cmds.pointConstraint(prefix + '_IK_leg_JNT', loc, w=True)) if 'Vec' in con: cmds.move(0, distance * -0.5, 5, loc, r=True) pbd = cmds.listConnections( con.replace('_CON', 'Space_NUL') + '.t')[0] dcm1 = cmds.listConnections(pbd + '.inTranslate1')[0] dcm2 = cmds.listConnections(pbd + '.inTranslate2')[0] mmx1 = cmds.listConnections(dcm1 + '.inputMatrix')[0] mmx2 = cmds.listConnections(dcm2 + '.inputMatrix')[0] loc1 = cmds.listConnections(mmx1 + '.matrixIn[0]')[0] loc2 = cmds.listConnections(mmx2 + '.matrixIn[0]')[0] t1 = cmds.getAttr(loc1 + '.t')[0] cmds.delete(cmds.parentConstraint(loc, loc1, w=True)) t2 = cmds.getAttr(loc1 + '.t')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.connectAttr(pbd + '.outTranslate', loc1 + '.t', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(loc1 + '.t', t1[0], t1[1], t1[2]) t1 = cmds.getAttr(loc2 + '.t')[0] cmds.delete(cmds.parentConstraint(loc, loc2, w=True)) t2 = cmds.getAttr(loc2 + '.t')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.connectAttr(pbd + '.outTranslate', loc2 + '.t', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(loc2 + '.t', t1[0], t1[1], t1[2]) cmds.delete(cmds.parentConstraint(loc, con, w=True)) cmds.setAttr(con + '.t', 0, 0, 0) else: cmds.delete(cmds.pointConstraint(con, loc, w=True, skip=('x', 'z'))) t1 = cmds.getAttr(con + '.t')[0] cmds.delete(cmds.pointConstraint(loc, con, w=True)) t2 = cmds.getAttr(con + '.t')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.connectAttr(pbd + '.outTranslate', pub_nul + '.t', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.t', t1[0], t1[1], t1[2]) if 'root' in con: pos0 = cmds.xform(con, q=True, rp=True, ws=True) pos1 = cmds.xform('L_IK_leg_JNT', q=True, rp=True, ws=True) pos2 = cmds.xform('L_IK_lowLeg_JNT', q=True, rp=True, ws=True) pos3 = cmds.xform('L_IK_foot_JNT', q=True, rp=True, ws=True) pos4 = cmds.xform('L_IK_ball_JNT', q=True, rp=True, ws=True) dis1 = abs( math.sqrt( math.pow(pos1[0] - pos1[0], 2) + math.pow(pos0[1] - pos1[1], 2) + math.pow(pos1[2] - pos1[2], 2))) dis2 = abs( math.sqrt( math.pow(pos1[0] - pos2[0], 2) + math.pow(pos1[1] - pos2[1], 2) + math.pow(pos1[2] - pos2[2], 2))) dis3 = abs( math.sqrt( math.pow(pos2[0] - pos3[0], 2) + math.pow(pos2[1] - pos3[1], 2) + math.pow(pos2[2] - pos3[2], 2))) dis4 = abs( math.sqrt( math.pow(pos3[0] - pos3[0], 2) + math.pow(pos3[1] - pos4[1], 2) + math.pow(pos3[2] - pos3[2], 2))) dis5 = abs( math.sqrt( math.pow(pos1[0] - pos3[0], 2) + math.pow(pos1[1] - pos3[1], 2) + math.pow(pos1[2] - pos3[2], 2))) distance = dis1 + dis2 + dis3 + dis4 * 0.95 cmds.setAttr(loc + '.t', 0, distance, 0) t1 = cmds.getAttr(con + '.t')[0] r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.parentConstraint(loc, con, w=True)) t2 = cmds.getAttr(con + '.t')[0] r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outTranslate', pub_nul + '.t', f=True) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.t', t1[0], t1[1], t1[2]) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'Body' in con: pos1 = cmds.xform(con, q=True, rp=True, ws=True) pos2 = cmds.xform('root_CON', q=True, rp=True, ws=True) distance = abs( math.sqrt( math.pow(pos1[0] - pos2[0], 2) + math.pow(pos1[1] - pos2[1], 2) + math.pow(pos1[2] - pos2[2], 2))) cmds.delete( cmds.pointConstraint('root_CON', loc, w=True, offset=(0, distance, 0))) t1 = cmds.getAttr(con + '.t')[0] r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.parentConstraint(loc, con, w=True)) t2 = cmds.getAttr(con + '.t')[0] r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outTranslate', pub_nul + '.t', f=True) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.t', t1[0], t1[1], t1[2]) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'hip' in con: pos1 = cmds.xform(con, q=True, rp=True, ws=True) pos2 = cmds.xform('root_CON', q=True, rp=True, ws=True) distance = abs( math.sqrt( math.pow(pos1[0] - pos2[0], 2) + math.pow(pos1[1] - pos2[1], 2) + math.pow(pos1[2] - pos2[2], 2))) cmds.delete( cmds.pointConstraint('root_CON', loc, w=True, offset=(0, distance * -1, 0))) t1 = cmds.getAttr(con + '.t')[0] r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.parentConstraint(loc, con, w=True)) t2 = cmds.getAttr(con + '.t')[0] r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outTranslate', pub_nul + '.t', f=True) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.t', t1[0], t1[1], t1[2]) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'head' in con: r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'FK_leg' in con: cmds.delete(cmds.orientConstraint(prefix + '_IK_leg_JNT', loc, w=True)) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'FK_lowLeg' in con: cmds.delete( cmds.orientConstraint(prefix + '_IK_lowLeg_JNT', loc, w=True)) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'FK_foot' in con: cmds.delete(cmds.orientConstraint(prefix + '_IK_foot_JNT', loc, w=True)) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'FK_upArm' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 0, 5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -180, -5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'FK_foreArm' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 0, -5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -180, 5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'FK_hand' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 0, -5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -180, 5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'IK_hand' in con: if 'Vec' in con: cmds.delete( cmds.parentConstraint(prefix + '_FK_foreArm_CON', loc, w=True)) pbd = cmds.listConnections( con.replace('_CON', 'Space_NUL') + '.t')[0] dcm1 = cmds.listConnections(pbd + '.inTranslate1')[0] dcm2 = cmds.listConnections(pbd + '.inTranslate2')[0] mmx1 = cmds.listConnections(dcm1 + '.inputMatrix')[0] mmx2 = cmds.listConnections(dcm2 + '.inputMatrix')[0] loc1 = cmds.listConnections(mmx1 + '.matrixIn[0]')[0] loc2 = cmds.listConnections(mmx2 + '.matrixIn[0]')[0] t1 = cmds.getAttr(loc1 + '.t')[0] cmds.delete(cmds.parentConstraint(loc, loc1, w=True)) cmds.move(0, 0, -2.5, loc1, r=True) t2 = cmds.getAttr(loc1 + '.t')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.connectAttr(pbd + '.outTranslate', loc1 + '.t', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(loc1 + '.t', t1[0], t1[1], t1[2]) t1 = cmds.getAttr(loc2 + '.t')[0] cmds.delete(cmds.parentConstraint(loc, loc2, w=True)) cmds.move(0, 0, -2.5, loc2, r=True) t2 = cmds.getAttr(loc2 + '.t')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.connectAttr(pbd + '.outTranslate', loc2 + '.t', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(loc2 + '.t', t1[0], t1[1], t1[2]) cmds.setAttr(con + '.t', 0, 0, 0) else: cmds.delete( cmds.parentConstraint(prefix + '_FK_hand_CON', loc, w=True)) t1 = cmds.getAttr(con + '.t')[0] cmds.delete(cmds.pointConstraint(loc, con, w=True)) t2 = cmds.getAttr(con + '.t')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inTranslate1', t1[0], t1[1], t1[2]) cmds.setAttr(pbd + '.inTranslate2', t2[0], t2[1], t2[2]) cmds.connectAttr(pbd + '.outTranslate', pub_nul + '.t', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.t', t1[0], t1[1], t1[2]) if 'Sub' in con: r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'thumb' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 80, -30, -30) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -100, 30, 30) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'index' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 0, -5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -180, 5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'middle' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 0, -5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -180, 5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'ring' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 0, -5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -180, 5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'pinky' in con: if 'L' in prefix: cmds.setAttr(loc + '.r', 0, -5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) if 'R' in prefix: cmds.setAttr(loc + '.r', -180, 5, 0) r1 = cmds.getAttr(con + '.r')[0] cmds.delete(cmds.orientConstraint(loc, con, w=True)) r2 = cmds.getAttr(con + '.r')[0] pbd = cmds.createNode('pairBlend') cmds.setAttr(pbd + '.inRotate1', r1[0], r1[1], r1[2]) cmds.setAttr(pbd + '.inRotate2', r2[0], r2[1], r2[2]) cmds.connectAttr(pbd + '.outRotate', pub_nul + '.r', f=True) cmds.connectAttr(rig + '.publishPose', pbd + '.weight', f=True) cmds.setAttr(con + '.r', r1[0], r1[1], r1[2]) cmds.setAttr('rig_GRP.publishPose', 0) cmds.delete(loc) return
def etc_set(self): ### attribute # sup con vis for x in range(8): cmds.addAttr(TP.AA['PL'][x], ln='sub_con_vis', at='enum', en='off:on:') cmds.setAttr(TP.AA['PL'][x] + '.sub_con_vis', e=1, keyable=1) cmds.connectAttr(TP.AA['PL'][x] + '.sub_con_vis', TP.AA['CL'][x] + '.visibility') # FK / IK switch for x in range(2): switchCon = controllerShape(TP.conVis['key'][x][0] + '_CON', 'cross', 'yellow') switchNul = cmds.group(switchCon, n=TP.conVis['key'][x][0] + '_NUL') cmds.delete(cmds.pointConstraint(TP.conVis['key'][x][1], switchNul)) cmds.parent(switchNul, TP.conVis['key'][x][1]) cmds.move(5, 0, 0, ws=1, r=1) cmds.addAttr(switchCon, ln=TP.conVis['attr'][0], at='enum', en='off:on:') cmds.setAttr(switchCon + '.' + TP.conVis['attr'][0], e=1, keyable=1) cmds.addAttr(switchCon, ln=TP.conVis['attr'][1], at='enum', en='off:on:') cmds.setAttr(switchCon + '.' + TP.conVis['attr'][1], e=1, keyable=1) for x in range(2): top_list = TP.conVis['vis'][x] for y in top_list: for z in y: if len(y) == 1: cmds.connectAttr( TP.conVis['key'][x][0] + '_CON.' + TP.conVis['attr'][0], z + '.visibility') else: cmds.connectAttr( TP.conVis['key'][x][0] + '_CON.' + TP.conVis['attr'][1], z + '.visibility') cmds.setAttr(TP.conVis['key'][x][0] + '_CON.IK_con_vis', 1) ### Parent node cmds.group(p='noneTransform_GRP', em=1, n='locator_GRP') cmds.parent(TP.noneTrans_list, 'locator_GRP') cmds.parent(TP.attach_list, 'attach_GRP') cmds.parent(TP.auxillary_list, 'auxillary_GRP') cmds.parent(TP.neck_list, 'C_neck_GRP') cmds.parent(TP.spine_list, 'C_spine_GRP') cmds.parent(TP.L_foreLeg_list, 'L_foreLeg_GRP') cmds.parent(TP.R_foreLeg_list, 'R_foreLeg_GRP') cmds.parent(TP.L_hindLeg_list, 'L_hindLeg_GRP') cmds.parent(TP.R_hindLeg_list, 'R_hindLeg_GRP') cmds.parent(TP.tail_list, 'C_tail_GRP') cmds.delete(TP.delete_list) cmds.select(TP.noneTrans_list, r=1) cmds.select('templateJoint_GRP', tgl=1) cmds.select(TP.hide_list, tgl=1) cmds.select(TP.hide_list2, tgl=1) cmds.HideSelectedObjects() ### Rotate controler self.controlerRotate(TP.rotate_con_list_A, 0, 0, -90) self.controlerRotate(TP.rotate_con_list_B, -90, 0, 0) ### controler Color for x in TP.R_con_list: conShapeName = cmds.listRelatives(x, s=1)[0] cmds.setAttr(conShapeName + '.overrideEnabled', 1) cmds.setAttr(conShapeName + '.overrideColor', 13) for x in TP.switch_con_list: conShapeName = cmds.listRelatives(x, s=1)[0] cmds.setAttr(conShapeName + '.overrideEnabled', 1) cmds.setAttr(conShapeName + '.overrideColor', 14) ### controler Scale for x in TP.scale_con_list: scale_value = 2 CRV_shape_name = cmds.listRelatives(x, s=1)[0] CRV_span_num = cmds.getAttr(CRV_shape_name + '.spans') cmds.select(x + '.cv[0:%s]' % (CRV_span_num)) cmds.scale(scale_value, scale_value, scale_value, r=1) ### controler Parent for x in range(2): PL = TP.parent_list['PL'][x] for y in TP.parent_list['CL'][x]: cmds.parentConstraint(PL, y, mo=1) ### hindLeg Parent cmds.setAttr('L_rig_hip_JNT.inheritsTransform', 0) cmds.setAttr('R_rig_hip_JNT.inheritsTransform', 0) itemList = ['.sx', '.sy', '.sz'] for x in TP.targetjointList: for y in itemList: cmds.connectAttr('place_CON.globalScale', x + y)
def returnHome(self, mom): x = 4 p = cmds.pointConstraint(mom.name, self.name) cmds.delete(p) cmds.parent(self.name, mom.name) cmds.scale(-4, -4, -4, absolute=True)
def ribbonJoints(sj, ej, bendyName, module, extraName='', moduleType=None, par=None, endCtrl=False, basePar=None): """ Create a ribbon setup. [Args]: sj (string) - ej (string) - bendyName (string) - The name of the ribbon setup module (class) - The class of the body part module extraName (string) - The extra name of the ribbon setup moduleType (string) - The type of module par (string) - The name of the mechanics parent endCtrl (bool) - Toggles creating an end control basePar (string) - The name of the joints parent [Returns]: bendyEndCtrl (class) - The end control class or False """ if not basePar: basePar = sj moduleName = utils.setupBodyPartName(module.extraName, module.side) bendyName = '{}{}'.format(moduleType, bendyName) col = utils.getColors(module.side) distance = cmds.getAttr('{}.tx'.format(ej)) nPlane = cmds.nurbsPlane(p=(distance / 2, 0, 0), lr=0.1, w=distance, axis=[0, 1, 0], u=3, d=3) nPlane = cmds.rename( nPlane[0], '{}{}Bendy{}'.format(moduleName, bendyName, suffix['nurbsSurface'])) if par: cmds.parent(nPlane, par) utils.matchTransforms(nPlane, sj) ## ctrl if not cmds.objExists('{}{}Ctrls{}'.format(moduleName, moduleType, suffix['group'])): ctrlGrp = cmds.group( n='{}{}Ctrls{}'.format(moduleName, moduleType, suffix['group'])) cmds.parent(ctrlGrp, module.rig.ctrlsGrp.name) bendyCtrl = ctrlFn.ctrl(name='{}{}Bendy'.format(extraName, bendyName), side=module.side, offsetGrpNum=2, skipNum=True, rig=module.rig, scaleOffset=module.rig.scaleOffset, parent='{}{}Ctrls{}'.format( moduleName, moduleType, suffix['group'])) bendyCtrl.modifyShape(color=col['col3'], shape='starFour', scale=(0.3, 0.3, 0.3)) cmds.pointConstraint(sj, ej, bendyCtrl.offsetGrps[0].name) cmds.orientConstraint(sj, bendyCtrl.offsetGrps[0].name, sk='x') orientConstr = cmds.orientConstraint(basePar, ej, bendyCtrl.offsetGrps[1].name, sk=['y', 'z'], mo=1) cmds.setAttr('{}.interpType'.format(orientConstr[0]), 2) ## clusters cmds.select('{}.cv[0:1][0:3]'.format(nPlane)) baseClu = utils.newNode('cluster', name='{}{}BendyBase'.format(extraName, bendyName), side=module.side, parent=par) cmds.select('{}.cv[2:3][0:3]'.format(nPlane)) midClu = utils.newNode('cluster', name='{}{}BendyMid'.format(extraName, bendyName), side=module.side, parent=par) bendyCtrl.constrain(midClu.name) bendyCtrl.constrain(midClu.name, typ='scale') endCluGrpTrans = utils.newNode('group', name='{}{}BendyEndCluTrans'.format( extraName, bendyName), side=module.side, parent=par) utils.matchTransforms(endCluGrpTrans.name, ej) endCluGrpOrientYZ = utils.newNode('group', name='{}{}BendyEndCluOrient'.format( extraName, bendyName), side=module.side, parent=endCluGrpTrans.name) utils.matchTransforms(endCluGrpOrientYZ.name, endCluGrpTrans.name) endCluGrpOrientX = utils.newNode('group', name='{}{}BendyEndCluOrientX'.format( extraName, bendyName), side=module.side, parent=endCluGrpOrientYZ.name) utils.matchTransforms(endCluGrpOrientX.name, endCluGrpOrientYZ.name) cmds.select('{}.cv[4:5][0:3]'.format(nPlane)) endClu = utils.newNode('cluster', name='{}{}BendyEnd'.format(extraName, bendyName), side=module.side, parent=endCluGrpOrientX.name) cmds.parentConstraint(basePar, baseClu.name, mo=1) cmds.scaleConstraint(basePar, baseClu.name, mo=1) if not endCtrl: cmds.pointConstraint(ej, endCluGrpTrans.name, mo=1) cmds.orientConstraint(ej, endCluGrpOrientX.name, mo=1, sk=['y', 'z']) cmds.orientConstraint(sj, endCluGrpOrientYZ.name, mo=1, sk='x') bendyEndCtrl = False else: bendyEndCtrl = ctrlFn.ctrl( name='{}{}BendyEnd'.format(extraName, bendyName), side=module.side, skipNum=True, rig=module.rig, scaleOffset=module.rig.scaleOffset, parent='{}{}Ctrls{}'.format(moduleName, moduleType, suffix['group'])) bendyEndCtrl.modifyShape(color=col['col3'], shape='starFour', scale=(0.3, 0.3, 0.3)) cmds.parentConstraint(ej, bendyEndCtrl.offsetGrps[0].name) bendyEndCtrl.constrain(endCluGrpTrans.name) bendyEndCtrl.constrain(endCluGrpTrans.name, typ='scale') ## rivets rivJntPar = sj for i in [0.1, 0.3, 0.5, 0.7, 0.9]: rivJnt = createRivet('{}Bendy'.format(bendyName), extraName, module, nPlane, pv=0.5, pu=i, parent=par, rivJntPar=rivJntPar) rivJntPar = rivJnt return bendyEndCtrl
un = '' ''' building joints for leg ''' # get position from locators pelvisPos = cmds.xform('COG', query=True, worldSpace=True, translation=True) hipPos = cmds.xform('hip', query=True, worldSpace=True, translation=True) kneePos = cmds.xform('knee', query=True, worldSpace=True, translation=True) anklePos = cmds.xform('ankle', query=True, worldSpace=True, translation=True) ballPos = cmds.xform('ball', query=True, worldSpace=True, translation=True) toePos = cmds.xform('toe', query=True, worldSpace=True, translation=True) pvKneeLoc = cmds.spaceLocator(n='KneeLocTemp') pvCtrlLoc = cmds.spaceLocator(n='pvKneeCtrlLoc') cmds.parent(pvCtrlLoc, pvKneeLoc) cmds.delete(cmds.pointConstraint('hip', 'ankle', pvKneeLoc)) cmds.select(pvKneeLoc, 'knee') cmds.align(x='mid', alignToLead=True) cmds.align(y='mid', alignToLead=True) cmds.move(0, 0, 20, pvCtrlLoc, localSpace=True) cmds.select(clear=True) # make bind joints pelvisJnt = cmds.joint(name='pelvis', absolute=True, radius=2, position=pelvisPos) hipJnt = cmds.joint(name=si + un + 'hip', absolute=True, radius=2,
def createRig(upperVertexList, lowerVertexList, prefix='L_', rigPartName='EyeLid', rigScale=1.0, eyeJoint='', numCtrl=5, ): if numCtrl < 3: cmds.error('numCtrl must bigger than 3!') return cmds.select(cl=1) # create eyeLid Module eyeLidRigModule = module.Module(prefix=prefix, rigPartName=rigPartName) # create upper eyelid Module upperLidRigModule = module.Module(prefix=prefix, rigPartName='upper_' + rigPartName) ##################### # Upper Eyelid Part # ##################### # create eyelid joint for each vertex upperEyeLidJointList = lib.vertex2Joints(vertexList=upperVertexList, prefix=prefix, rigPartName='upper_' + rigPartName, radius=0.05) # connect attr for joint in upperEyeLidJointList: if cmds.attributeQuery('slaveJoint', node=joint, exists=1): cmds.connectAttr(upperLidRigModule.topGrp + '.slaveJoint', joint + '.slaveJoint', f=1) # create eyelid parent joint for each eyelid joint upperEyeLidParentJntList = [] for i in upperEyeLidJointList: cmds.select(cl=1) parentJoint = cmds.joint(n=i + '_Parent', radius=0.05) cmds.delete(cmds.pointConstraint(eyeJoint, parentJoint, mo=0)) cmds.delete(cmds.aimConstraint(i, parentJoint, aimVector=(1, 0, 0), upVector=(0, -1, 0), worldUpType='scene', weight=1, offset=(0, 0, 0), mo=0)) cmds.parent(i, parentJoint) cmds.joint(i, e=1, oj='none', ch=1, zso=1) cmds.makeIdentity(parentJoint, apply=1, t=1, r=1, s=1) upperEyeLidParentJntList.append(parentJoint) cmds.select(cl=1) upperEyelidLocList = [] # create locator for each eyelid joint for i in upperEyeLidParentJntList: cmds.select(cl=1) eyelidJoint = cmds.listRelatives(i, c=1, type='joint', shapes=0)[0] ikHandle = cmds.ikHandle(n=eyelidJoint + '_IK', sj=i, ee=eyelidJoint, sol='ikSCsolver') eyelidLoc = cmds.spaceLocator(n=eyelidJoint + '_LOC')[0] cmds.delete(cmds.parentConstraint(eyelidJoint, eyelidLoc, mo=0)) cmds.select(cl=1) cmds.setAttr(ikHandle[0] + '.v', 0) LOCShape = cmds.listRelatives(eyelidLoc, p=0, c=1, s=1)[0] cmds.setAttr(LOCShape + '.localScaleX', 0.1) cmds.setAttr(LOCShape + '.localScaleY', 0.1) cmds.setAttr(LOCShape + '.localScaleZ', 0.1) cmds.parent(ikHandle[0], eyelidLoc) upperEyelidLocList.append(eyelidLoc) cmds.select(cl=1) # create high definition curve lowerPosList = [] for i in upperEyelidLocList: pos = cmds.xform(i, q=1, ws=1, t=1) lowerPosList.append(tuple(pos)) upperKList = [] for i in xrange(len(lowerPosList)): upperKList.append(i) upperHighDefCurve = cmds.curve(n=prefix + 'upper_' +rigPartName + '_HD_Crv', p=lowerPosList, k=upperKList, d=1) upperLowDefCurve = cmds.duplicate(upperHighDefCurve, n=prefix + 'lower_' + rigPartName + '_LD_Crv') upperHighDefCurveShape = cmds.listRelatives(upperHighDefCurve, p=0, c=0, s=1, path=1)[0] cmds.select(cl=1) # make each locator attach to the curve for i in upperEyelidLocList: pos = cmds.xform(i, q=1, ws=1, t=1) uParam = lib.getUParam(pos, upperHighDefCurveShape) PCI = cmds.createNode('pointOnCurveInfo', n=name.removeSuffix(i) + '_PCI') cmds.connectAttr(upperHighDefCurveShape + '.worldSpace', PCI + '.inputCurve', f=1) cmds.setAttr(PCI + '.parameter', uParam) cmds.connectAttr(PCI + '.position', i + '.t') cmds.select(cl=1) # make HD curve deformed by LD curve upperLowDefCurve = cmds.rebuildCurve(upperLowDefCurve, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=3, d=3) cmds.select(cl=1) upperWireDefomer = cmds.wire(upperHighDefCurve, gw=0, en=1, ce=0, li=0, w=upperLowDefCurve) upperWireTransNode = cmds.listConnections(upperWireDefomer[0] + '.baseWire[0]', source=1, destination=0) cmds.select(cl=1) # create control joint and controls for the LD curve upperControlJointList = [] eachADD = 1.0 / (numCtrl - 1) for i in xrange(numCtrl): newJnt = cmds.joint(n=prefix + 'upper_' + rigPartName + '_CtrlJnt_' + str(i), radius=0.1) cmds.select(cl=1) motionPath = cmds.pathAnimation(upperLowDefCurve, newJnt, n=prefix + rigPartName + '_MP_' + str(i), fractionMode=1, follow=1, followAxis='x', upAxis='z', worldUpType='scene', inverseUp=0, inverseFront=0, bank=0) cmds.cutKey(motionPath + '.u', time=()) cmds.setAttr(motionPath + '.uValue', eachADD * float(i)) for attr in ['t', 'r']: for axis in ['x', 'y', 'z']: cmds.delete(newJnt + '.%s%s' % (attr, axis), icn=1) cmds.delete(motionPath) cmds.select(cl=1) upperControlJointList.append(newJnt) cmds.setAttr(newJnt + '.r', 0, 0, 0) cmds.select(cl=1) # bind LD curve by control joint cmds.skinCluster(upperControlJointList[:], upperLowDefCurve) cmds.select(cl=1) upperJntCtrlGrpList = [] for i in xrange(len(upperControlJointList)): ctrl = control.Control(prefix=upperControlJointList[i], rigPartName='', scale=rigScale, shape='circleY', translateTo=upperControlJointList[i], rotateTo=upperControlJointList[i]) cmds.pointConstraint(ctrl.C, upperControlJointList[i], mo=0) cmds.orientConstraint(ctrl.C, upperControlJointList[i], mo=0) upperJntCtrlGrpList.append(ctrl.Off) cmds.select(cl=1) # clean hierarchy upperParentJntGrp = cmds.group(n=prefix + 'upper_' + rigPartName + '_skinJnt_Grp', em=1) upperLocGrp = cmds.group(n=prefix + 'upper_' + rigPartName + '_LOC_Grp', em=1) upperCurveGrp = cmds.group(n=prefix + 'upper_' + rigPartName + '_Crv_Grp', em=1) upperCtrlJntGrp = cmds.group(n=prefix + 'upper_' + rigPartName + '_ctrlJnt_Grp', em=1) upperCtrlGrp = cmds.group(n=prefix + 'upper_' + rigPartName + '_CtrlGrp', em=1) for i in upperEyeLidParentJntList: cmds.parent(i, upperParentJntGrp) for i in upperEyelidLocList: cmds.parent(i, upperLocGrp) cmds.parent(upperLowDefCurve, upperCurveGrp) cmds.parent(upperHighDefCurve, upperCurveGrp) cmds.parent(upperWireTransNode, upperCurveGrp) for i in upperControlJointList: cmds.parent(i, upperCtrlJntGrp) for i in upperJntCtrlGrpList: cmds.parent(i, upperCtrlGrp) cmds.setAttr(upperLocGrp + '.v', 0) cmds.setAttr(upperCurveGrp + '.v', 0) cmds.setAttr(upperCtrlJntGrp + '.v', 0) cmds.parent(upperParentJntGrp, upperLidRigModule.topGrp) cmds.parent(upperLocGrp, upperLidRigModule.topGrp) cmds.parent(upperCurveGrp, upperLidRigModule.topGrp) cmds.parent(upperCtrlJntGrp, upperLidRigModule.topGrp) cmds.parent(upperCtrlGrp, upperLidRigModule.topGrp) ################################################################################################################### ##################### # Lower Eyelid Part # ##################### # create lower eyelid Module lowerLidRigModule = module.Module(prefix=prefix, rigPartName='lower_' + rigPartName) # create eyelid joint for each vertex lowerEyeLidJointList = lib.vertex2Joints(vertexList=lowerVertexList, prefix=prefix, rigPartName='lower_' + rigPartName, radius=0.05) # connect attr for joint in lowerEyeLidJointList: if cmds.attributeQuery('slaveJoint', node=joint, exists=1): cmds.connectAttr(lowerLidRigModule.topGrp + '.slaveJoint', joint + '.slaveJoint', f=1) # create eyelid parent joint for each eyelid joint lowerEyeLidParentJntList = [] for i in lowerEyeLidJointList: cmds.select(cl=1) parentJoint = cmds.joint(n=i + '_Parent', radius=0.05) cmds.delete(cmds.pointConstraint(eyeJoint, parentJoint, mo=0)) cmds.delete(cmds.aimConstraint(i, parentJoint, aimVector=(1, 0, 0), upVector=(0, -1, 0), worldUpType='scene', weight=1, offset=(0, 0, 0), mo=0)) cmds.parent(i, parentJoint) cmds.joint(i, e=1, oj='none', ch=1, zso=1) cmds.makeIdentity(parentJoint, apply=1, t=1, r=1, s=1) lowerEyeLidParentJntList.append(parentJoint) cmds.select(cl=1) lowerEyelidLocList = [] # create locator for each eyelid joint for i in lowerEyeLidParentJntList: cmds.select(cl=1) eyelidJoint = cmds.listRelatives(i, c=1, type='joint', shapes=0)[0] ikHandle = cmds.ikHandle(n=eyelidJoint + '_IK', sj=i, ee=eyelidJoint, sol='ikSCsolver') eyelidLoc = cmds.spaceLocator(n=eyelidJoint + '_LOC')[0] cmds.delete(cmds.parentConstraint(eyelidJoint, eyelidLoc, mo=0)) cmds.select(cl=1) cmds.setAttr(ikHandle[0] + '.v', 0) LOCShape = cmds.listRelatives(eyelidLoc, p=0, c=1, s=1)[0] cmds.setAttr(LOCShape + '.localScaleX', 0.1) cmds.setAttr(LOCShape + '.localScaleY', 0.1) cmds.setAttr(LOCShape + '.localScaleZ', 0.1) cmds.parent(ikHandle[0], eyelidLoc) lowerEyelidLocList.append(eyelidLoc) cmds.select(cl=1) # create high definition curve lowerPosList = [] for i in lowerEyelidLocList: pos = cmds.xform(i, q=1, ws=1, t=1) lowerPosList.append(tuple(pos)) lowerKList = [] for i in xrange(len(lowerPosList)): lowerKList.append(i) lowerHighDefCurve = cmds.curve(n=prefix + 'lower_' + rigPartName + '_HD_Crv', p=lowerPosList, k=lowerKList, d=1) lowerLowDefCurve = cmds.duplicate(lowerHighDefCurve, n=prefix + 'lower_' + rigPartName + '_LD_Crv') lowerHighDefCurveShape = cmds.listRelatives(lowerHighDefCurve, p=0, c=0, s=1, path=1)[0] cmds.select(cl=1) # make each locator attach to the curve for i in lowerEyelidLocList: pos = cmds.xform(i, q=1, ws=1, t=1) uParam = lib.getUParam(pos, lowerHighDefCurveShape) PCI = cmds.createNode('pointOnCurveInfo', n=name.removeSuffix(i) + '_PCI') cmds.connectAttr(lowerHighDefCurveShape + '.worldSpace', PCI + '.inputCurve', f=1) cmds.setAttr(PCI + '.parameter', uParam) cmds.connectAttr(PCI + '.position', i + '.t') cmds.select(cl=1) # make HD curve deformed by LD curve lowerLowDefCurve = cmds.rebuildCurve(lowerLowDefCurve, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=3, d=3) cmds.select(cl=1) lowerWireDefomer = cmds.wire(lowerHighDefCurve, gw=0, en=1, ce=0, li=0, w=lowerLowDefCurve) lowerWireTransNode = cmds.listConnections(lowerWireDefomer[0] + '.baseWire[0]', source=1, destination=0) cmds.select(cl=1) # create control joint and controls for the LD curve lowerControlJointList = [] eachADD = 1.0 / (numCtrl - 1) for i in xrange(numCtrl - 2): newJnt = cmds.joint(n=prefix + 'lower_' + rigPartName + '_CtrlJnt_' + str(i + 1), radius=0.1) cmds.select(cl=1) motionPath = cmds.pathAnimation(lowerLowDefCurve, newJnt, n=prefix + rigPartName + '_MP_' + str(i + 1), fractionMode=1, follow=1, followAxis='x', upAxis='z', worldUpType='scene', inverseUp=0, inverseFront=0, bank=0) cmds.cutKey(motionPath + '.u', time=()) cmds.setAttr(motionPath + '.uValue', eachADD * float(i + 1)) for attr in ['t', 'r']: for axis in ['x', 'y', 'z']: cmds.delete(newJnt + '.%s%s' % (attr, axis), icn=1) cmds.delete(motionPath) cmds.select(cl=1) lowerControlJointList.append(newJnt) cmds.setAttr(newJnt + '.r', 0, 0, 0) cmds.select(cl=1) lowerControlJointList.insert(0, upperControlJointList[0]) lowerControlJointList.append(upperControlJointList[-1]) # bind LD curve by control joint cmds.skinCluster(lowerControlJointList[:], lowerLowDefCurve) cmds.select(cl=1) lowerJntCtrlGrpList = [] for i in xrange(len(lowerControlJointList[1:-1])): ctrl = control.Control(prefix=lowerControlJointList[i+1], rigPartName='', scale=rigScale, shape='circleY', translateTo=lowerControlJointList[i+1], rotateTo=lowerControlJointList[i+1]) cmds.pointConstraint(ctrl.C, lowerControlJointList[i+1], mo=0) cmds.orientConstraint(ctrl.C, lowerControlJointList[i+1], mo=0) lowerJntCtrlGrpList.append(ctrl.Off) cmds.select(cl=1) # clean hierarchy lowerParentJntGrp = cmds.group(n=prefix + 'lower_' + rigPartName + '_skinJnt_Grp', em=1) lowerLocGrp = cmds.group(n=prefix + 'lower_' + rigPartName + '_LOC_Grp', em=1) lowerCurveGrp = cmds.group(n=prefix + 'lower_' + rigPartName + '_Crv_Grp', em=1) lowerCtrlJntGrp = cmds.group(n=prefix + 'lower_' + rigPartName + '_ctrlJnt_Grp', em=1) lowerCtrlGrp = cmds.group(n=prefix + 'lower_' + rigPartName + '_CtrlGrp', em=1) for i in lowerEyeLidParentJntList: cmds.parent(i, lowerParentJntGrp) for i in lowerEyelidLocList: cmds.parent(i, lowerLocGrp) cmds.parent(lowerLowDefCurve, lowerCurveGrp) cmds.parent(lowerHighDefCurve, lowerCurveGrp) cmds.parent(lowerWireTransNode, lowerCurveGrp) for i in lowerControlJointList: cmds.parent(i, lowerCtrlJntGrp) for i in lowerJntCtrlGrpList: cmds.parent(i, lowerCtrlGrp) cmds.setAttr(lowerLocGrp + '.v', 0) cmds.setAttr(lowerCurveGrp + '.v', 0) cmds.setAttr(lowerCtrlJntGrp + '.v', 0) cmds.parent(lowerParentJntGrp, lowerLidRigModule.topGrp) cmds.parent(lowerLocGrp, lowerLidRigModule.topGrp) cmds.parent(lowerCurveGrp, lowerLidRigModule.topGrp) cmds.parent(lowerCtrlJntGrp, lowerLidRigModule.topGrp) cmds.parent(lowerCtrlGrp, lowerLidRigModule.topGrp) # final cmds.parent(upperLidRigModule.topGrp, eyeLidRigModule.topGrp) cmds.parent(lowerLidRigModule.topGrp, eyeLidRigModule.topGrp)
def create_pushButton_released(self): selCount = len(cmds.ls(sl=True)) #zero selected if selCount == 0: #create locator loc = cmds.spaceLocator(name='spherePreview_loc')[0] #create sphere nodes = self.sphereDist() #setup sphere cmds.pointConstraint(loc, nodes[1]) #setup loc cmds.move(0, 0, 1, loc) #attach metaData cmds.addAttr(loc, longName='metaParent', attributeType='message') cmds.connectAttr('%s.message' % nodes[2], '%s.metaParent' % loc) cmds.setAttr('%s.createJoints' % nodes[2], 'true', type='string') #one item selected if selCount == 1: #getting selection sel = cmds.ls(sl=True)[0] #create locator loc = cmds.spaceLocator(name='spherePreview_loc')[0] #create sphere nodes = self.sphereDist() #setup sphere cmds.pointConstraint(loc, nodes[1]) cmds.delete(cmds.pointConstraint(sel, nodes[0])) #setup loc cmds.delete(cmds.pointConstraint(sel, loc)) cmds.move(0, 0, 1, loc, relative=True) #attach metaData cmds.addAttr(loc, longName='metaParent', attributeType='message') cmds.connectAttr('%s.message' % nodes[2], '%s.metaParent' % loc) cmds.setAttr('%s.createJoints' % nodes[2], 'true', type='string') #one item selected if selCount == 2: #getting selection sel1 = cmds.ls(sl=True)[0] sel2 = cmds.ls(sl=True)[1] #create sphere nodes = self.sphereDist() #setup sphere cmds.pointConstraint(sel1, nodes[0]) cmds.pointConstraint(sel2, nodes[1]) #setup metaData cmds.setAttr('%s.createJoints' % nodes[2], 'false', type='string')
def grpsToMotionPath(curveName, grpList, name=None, pointConstraint=True, createTangentLocs=False): """ Creates locators matching the number of transforms (grpList) and a motion path for locator which positions locator along by the curve (curveName) and finally locator point constrains each transform (grpList), if so desired """ retData = {} retData['grpMap'] = {} name = name or curveName locList = [] mphList = [] pocList = [] npoc = cmds.createNode('nearestPointOnCurve') crvShape = curveName if not cmds.objectType(crvShape) == 'nurbsCurve': children = cmds.listRelatives(curveName, children=1, type='nurbsCurve') if not children: raise Exception( 'the supplied curve argument {0} is not a curve'.format( curveName)) crvShape = children[0] cmds.connectAttr('{0}.worldSpace[0]'.format(crvShape), '{0}.inputCurve'.format(npoc)) ''' cviName = names.nodeName('curveInfo', '{0}'.format(name)) cvi = cmds.createNode('curveInfo', n=cviName) cmds.connectAttr('{0}.worldSpace[0]'.format(crvShape), '{0}.inputCurve'.format(cvi)) arcLenAttr = '{0}.arcLength'.format(cvi) ''' for i, grp in enumerate(grpList): ''' i = 6 grp = 'test7_jnt' ''' retData['grpMap'][grp] = {} pos = cmds.xform(grp, t=1, ws=1, q=1) cmds.setAttr('{0}.inPosition'.format(npoc), pos[0], pos[1], pos[2]) param = cmds.getAttr('{0}.parameter'.format(npoc)) mphLocName = names.nodeName('locator', '{0}{1}'.format(name, i + 1)) mphLoc = cmds.spaceLocator(n=mphLocName)[0] locList.append(mphLoc) retData['grpMap'][grp]['loc'] = mphLoc crvMphName = names.nodeName('motionPath', '{0}{1}'.format(name, i + 1)) crvMph = cmds.createNode('motionPath', n=crvMphName) retData['grpMap'][grp]['mph'] = crvMph mphList.append(crvMph) cmds.setAttr('{0}.fractionMode'.format(crvMph), 1) cmds.connectAttr('{0}.worldSpace[0]'.format(crvShape), '{0}.geometryPath'.format(crvMph)) cmds.setAttr('{0}.uValue'.format(crvMph), param) cmds.connectAttr('{0}.xCoordinate'.format(crvMph), '{0}.tx'.format(mphLoc)) cmds.connectAttr('{0}.yCoordinate'.format(crvMph), '{0}.ty'.format(mphLoc)) cmds.connectAttr('{0}.zCoordinate'.format(crvMph), '{0}.tz'.format(mphLoc)) if pointConstraint: poc = cmds.pointConstraint(mphLoc, grp, mo=1, n=names.addModifier( grp, 'pointConstraint')) retData['grpMap'][grp]['poc'] = poc cmds.delete(npoc) retData['loc'] = locList retData['poc'] = pocList retData['mph'] = mphList # Start and End tangent locators retData['sTanLoc'] = {} retData['eTanLoc'] = {} if createTangentLocs: # Start mphLocName = names.nodeName('locator', '{0}StartTangent'.format(name)) mphLoc = cmds.spaceLocator(n=mphLocName)[0] retData['sTanLoc']['loc'] = mphLoc crvMphName = names.nodeName('motionPath', '{0}StartTangent'.format(name)) crvMph = cmds.createNode('motionPath', n=crvMphName) retData['sTanLoc']['mph'] = crvMph mphList.append(crvMph) cmds.setAttr('{0}.fractionMode'.format(crvMph), 1) # Start connections cmds.connectAttr('{0}.worldSpace[0]'.format(crvShape), '{0}.geometryPath'.format(crvMph)) cmds.setAttr('{0}.uValue'.format(crvMph), 0.001) cmds.connectAttr('{0}.xCoordinate'.format(crvMph), '{0}.tx'.format(mphLoc)) cmds.connectAttr('{0}.yCoordinate'.format(crvMph), '{0}.ty'.format(mphLoc)) cmds.connectAttr('{0}.zCoordinate'.format(crvMph), '{0}.tz'.format(mphLoc)) # End mphLocName = names.nodeName('locator', '{0}EndTangent'.format(name)) mphLoc = cmds.spaceLocator(n=mphLocName)[0] retData['eTanLoc']['loc'] = mphLoc crvMphName = names.nodeName('motionPath', '{0}EndTangent'.format(name)) crvMph = cmds.createNode('motionPath', n=crvMphName) retData['eTanLoc']['mph'] = crvMph mphList.append(crvMph) cmds.setAttr('{0}.fractionMode'.format(crvMph), 1) # Start connections cmds.connectAttr('{0}.worldSpace[0]'.format(crvShape), '{0}.geometryPath'.format(crvMph)) cmds.setAttr('{0}.uValue'.format(crvMph), 0.999) cmds.connectAttr('{0}.xCoordinate'.format(crvMph), '{0}.tx'.format(mphLoc)) cmds.connectAttr('{0}.yCoordinate'.format(crvMph), '{0}.ty'.format(mphLoc)) cmds.connectAttr('{0}.zCoordinate'.format(crvMph), '{0}.tz'.format(mphLoc)) return retData
def build(self): ''' This is where the builds will happen. ''' super(Face, self).build() # get all of the inputs to the node. jawJoint = self.getAttributeByName("jawJoint").getValue() faceUpperJoint = self.getAttributeByName("faceUpperJoint").getValue() headTipJoint = self.getAttributeByName("headTipJoint").getValue() faceLowerJoint = self.getAttributeByName("faceLowerJoint").getValue() faceMidJoint = self.getAttributeByName("faceMidJoint").getValue() noseBridgeJoint = self.getAttributeByName("noseBridge").getValue() noseJoint = self.getAttributeByName("nose").getValue() anchor = self.getAttributeByName("anchor").getValue() upperTeeth = self.getAttributeByName("upperTeeth").getValue() lowerTeeth = self.getAttributeByName("lowerTeeth").getValue() geometry = self.getAttributeByName("geometry").getValue() teethUpperJoint = self.getAttributeByName("upperTeeth").getValue() teethLowerJoint = self.getAttributeByName("lowerTeeth").getValue() # JAW if mc.objExists(jawJoint): # create the jaw control jawNul, jawDefAuto, jawCtrl = control.create( name="jaw", controlType="null", color=common.YELLOW, hierarchy=['nul', 'def_auto']) # position the jaw control and connect the joint to the control mc.xform(jawNul, ws=True, matrix=mc.xform(jawJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(jawCtrl, jawJoint) mc.orientConstraint(jawCtrl, jawJoint) # create jaw driver, parent it to the jaw nul, then move it to the correct position jawDriver = mc.createNode("joint", name="jaw_driver") mc.parent(jawDriver, jawNul) mc.xform(jawDriver, ws=True, matrix=mc.xform(jawNul, q=True, ws=True, matrix=True)) mc.orientConstraint(jawCtrl, jawDriver) # create normRX on the driver mc.addAttr(jawDriver, ln="normRX", at="double", keyable=True) multJaw = mc.createNode("multDoubleLinear", name="jaw_driver_norm_mult") mc.connectAttr("{}.rx".format(jawJoint), "{}.input1".format(multJaw), f=True) mc.setAttr("{}.input2".format(multJaw), .1) mc.connectAttr("{}.output".format(multJaw), "{}.normRX".format(jawDriver), f=True) # turn off the visibility of the driver mc.setAttr("{}.drawStyle".format(jawDriver), 2) # create the lip lower cluster lipLower = "lip_lower" cluster.create(geometry, name=lipLower, parent=jawCtrl) # rename the cluster and control mc.rename(lipLower, '{}_cluster'.format(lipLower)) mc.rename('{}_ctrl'.format(lipLower), lipLower) mc.xform("{}_nul".format(lipLower), ws=True, matrix=mc.xform(jawCtrl, q=True, ws=True, matrix=True)) mc.setAttr("{}.displayHandle".format(lipLower), 1) control.tagAsControl(lipLower) # Lowerteeth control if mc.objExists(teethLowerJoint): teethLowerNul, teethLowerDefAuto, teethLowerCtrl = control.create( name="teeth_lower", controlType="null", color=common.RED, hierarchy=['nul', 'def_auto'], parent=jawCtrl) mc.xform(teethLowerNul, ws=True, matrix=mc.xform(teethLowerJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(teethLowerCtrl, teethLowerJoint) mc.orientConstraint(teethLowerCtrl, teethLowerJoint) # FACE LOWER if mc.objExists(faceLowerJoint): # Create the faceLower and jaw control faceLowerNul, faceLowerCtrl = control.create(name="face_lower", controlType="null", color=common.YELLOW, hierarchy=['nul'], parent=anchor) # position the faceLowerNul and connect the joint to the control mc.xform(faceLowerNul, ws=True, matrix=mc.xform(faceLowerJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(faceLowerCtrl, faceLowerJoint) mc.orientConstraint(faceLowerCtrl, faceLowerJoint) # parent the jaw to face lower control if mc.objExists(jawJoint): mc.parent(jawNul, faceLowerCtrl) mouthMainName = "mouthMain" cluster.create(geometry, name=mouthMainName, parent=faceLowerCtrl) # rename the cluster and control mc.rename(mouthMainName, '{}_cluster'.format(mouthMainName)) mc.rename('{}_ctrl'.format(mouthMainName), mouthMainName) mc.xform("{}_nul".format(mouthMainName), ws=True, matrix=mc.xform(faceLowerCtrl, q=True, ws=True, matrix=True)) mc.setAttr("{}.displayHandle".format(mouthMainName), 1) control.tagAsControl(mouthMainName) elif mc.objExists(jawJoint) and mc.objExists(anchor): mc.parent(jawNul, anchor) if mc.objExists(faceUpperJoint): # Create the faceLower and jaw control faceUpperNul, faceUpperCtrl = control.create(name="face_upper", controlType="null", color=common.YELLOW, hierarchy=['nul'], parent=anchor) # position the faceLowerNul and connect the joint to the control mc.xform(faceUpperNul, ws=True, matrix=mc.xform(faceUpperJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(faceUpperCtrl, faceUpperJoint) mc.orientConstraint(faceUpperCtrl, faceUpperJoint) # setup the jaw compression jawCompressionJnt = "jaw_compression_driver" if not mc.objExists(jawCompressionJnt): jawCompressionJnt = mc.joint(name="jaw_compression_driver") mc.xform(jawCompressionJnt, ws=True, q=True, rotation=mc.xform(faceLowerJoint, q=True, ws=True, rotation=True)) mc.xform(jawCompressionJnt, ws=True, t=rigrpeo.libs.transform.getAveragePosition( [upperTeeth, lowerTeeth])) # create the faceDiff joint and parent it to the faceUpperCtrl faceDiff = mc.duplicate("jaw_compression_driver", po=True, name="face_upper_diff")[0] mc.parent(faceDiff, faceUpperCtrl) parent = self.rigGroup groupList = [ "jaw_compression_grp", "jaw_compression_nul", "jaw_compression_cnt", "jaw_compressiong_offset" ] for group in groupList: mc.createNode("transform", name=group) mc.parent(group, parent) parent = group # position the jaw groups mc.parentConstraint("skull_bind", groupList[0], mo=False) mc.xform(groupList[1], ws=True, matrix=mc.xform(jawJoint, q=True, ws=True, matrix=True)) for attr in ['t', 'r', 's']: mc.connectAttr("{}.{}".format(jawCtrl, attr), "{}.{}".format(groupList[2], attr), f=True) mc.xform(groupList[-1], ws=True, matrix=mc.xform(jawCompressionJnt, q=True, ws=True, matrix=True)) # parent the jawCompression joint to the last of the group nodes mc.parent(jawCompressionJnt, groupList[-1]) # point constrain the jawCompression joint to the faceDiff joint mc.pointConstraint(faceDiff, jawCompressionJnt, mo=False) # turn off the visibility of the joints for jnt in [faceDiff, jawCompressionJnt]: mc.setAttr("{}.v".format(jnt), 0) if mc.objExists(headTipJoint): # Create the faceLower and jaw control headTipNul, headTipCtrl = control.create(name="head_tip", controlType="null", color=common.YELLOW, hierarchy=['nul'], parent=faceUpperCtrl) # position the faceLowerNul and connect the joint to the control mc.xform(headTipNul, ws=True, matrix=mc.xform(headTipJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(headTipCtrl, headTipJoint) mc.orientConstraint(headTipCtrl, headTipJoint) if mc.objExists(noseBridgeJoint): # Create the faceLower and jaw control noseBridgeNul, noseBridgeDefAuto, noseBridgeRotDefAuto, noseBridgeCtrl = control.create( name="nose_bridge", controlType="null", color=common.YELLOW, hierarchy=['nul', 'def_auto', 'rot_def_auto']) if mc.objExists(faceUpperJoint): mc.parent(noseBridgeNul, faceUpperCtrl) # create the setDriven keys for the jaw control mc.setDrivenKeyframe("{}.rx".format(noseBridgeRotDefAuto), cd="{}.ty".format(jawCompressionJnt), v=15, dv=-0.7) mc.setDrivenKeyframe("{}.rx".format(noseBridgeRotDefAuto), cd="{}.ty".format(jawCompressionJnt), v=-0, dv=0) for attr in ['y', 'z']: mc.setDrivenKeyframe("{}.t{}".format( noseBridgeDefAuto, attr), cd="{}.ty".format(jawCompressionJnt), v=.01, dv=-0.7) mc.setDrivenKeyframe("{}.t{}".format( noseBridgeDefAuto, attr), cd="{}.ty".format(jawCompressionJnt), v=0, dv=0) else: mc.parent(noseBridgeNul, anchor) # position the faceLowerNul and connect the joint to the control mc.xform(noseBridgeNul, ws=True, matrix=mc.xform(noseBridgeJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(noseBridgeCtrl, noseBridgeJoint) mc.orientConstraint(noseBridgeCtrl, noseBridgeJoint) if mc.objExists(noseJoint): # Create the faceLower and jaw control noseNul, noseDefAuto, noseCtrl = control.create( name="nose", controlType="null", color=common.YELLOW, hierarchy=['nul', 'def_auto']) if mc.objExists(noseBridgeJoint): mc.parent(noseNul, noseBridgeCtrl) else: mc.parent(noseNul, anchor) # position the faceLowerNul and connect the joint to the control mc.xform(noseNul, ws=True, matrix=mc.xform(noseJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(noseCtrl, noseJoint) mc.orientConstraint(noseCtrl, noseJoint) # create the left sneer cluster sneerNameL = "sneer_l" cluster.create(geometry, name=sneerNameL, parent=noseCtrl) # rename the cluster and control mc.rename(sneerNameL, '{}_cluster'.format(sneerNameL)) mc.rename('{}_ctrl'.format(sneerNameL), sneerNameL) mc.xform("{}_nul".format(sneerNameL), ws=True, matrix=mc.xform(noseCtrl, q=True, ws=True, matrix=True)) mc.setAttr("{}.displayHandle".format(sneerNameL), 1) control.tagAsControl(sneerNameL) # create the right sneer cluster sneerNameR = "sneer_r" cluster.create(geometry, name=sneerNameR, parent=noseCtrl) # rename the cluster and control mc.rename(sneerNameR, '{}_cluster'.format(sneerNameR)) mc.rename('{}_ctrl'.format(sneerNameR), sneerNameR) mc.xform("{}_nul".format(sneerNameR), ws=True, matrix=mc.xform(noseCtrl, q=True, ws=True, matrix=True)) mc.setAttr("{}.displayHandle".format(sneerNameR), 1) control.tagAsControl(sneerNameR) if mc.objExists(faceMidJoint): parent = faceLowerCtrl groupList = [ "face_mid_nul", "face_upper_driver", "face_mid_offset", "face_mid_ort", "face_mid_def_auto" ] for group in groupList: mc.createNode("transform", name=group) mc.parent(group, parent) parent = group # make the driver joint and parent it to the def auto and turn off visibility midDriver = mc.joint(name="face_mid_driver") mc.setAttr("{}.drawStyle".format(midDriver), 2) mc.xform(groupList[0], ws=True, matrix=mc.xform(faceUpperCtrl, q=True, ws=True, matrix=True)) for attr in ['t', 'r', 's']: mc.connectAttr("{}.{}".format(faceUpperCtrl, attr), "{}.{}".format(groupList[1], attr), f=True) mc.xform(groupList[2], ws=True, matrix=mc.xform(faceMidJoint, q=True, ws=True, matrix=True)) # create the set drivens if mc.objExists(faceUpperJoint): # create the setDriven keys for the jaw control mc.setDrivenKeyframe("{}.rx".format(groupList[-1]), cd="{}.ty".format(jawCompressionJnt), v=10, dv=-0.7) mc.setDrivenKeyframe("{}.rx".format(groupList[-1]), cd="{}.ty".format(jawCompressionJnt), v=-0, dv=0) for attr in ['y', 'z']: mc.setDrivenKeyframe("{}.t{}".format(groupList[-1], attr), cd="{}.ty".format(jawCompressionJnt), v=-1, dv=-0.7) mc.setDrivenKeyframe("{}.t{}".format(groupList[-1], attr), cd="{}.ty".format(jawCompressionJnt), v=0, dv=0) # constrain the joint to the driver mc.pointConstraint(midDriver, faceMidJoint, mo=False) mc.orientConstraint(midDriver, faceMidJoint, mo=False) # parent the noseBridge to the proper group mc.parent(noseBridgeNul, groupList[-1]) # create the left sneer cluster lipUpper = "lip_upper" cluster.create(geometry, name=lipUpper, parent=midDriver) # rename the cluster and control mc.rename(lipUpper, '{}_cluster'.format(lipUpper)) mc.rename('{}_ctrl'.format(lipUpper), lipUpper) mc.xform("{}_nul".format(lipUpper), ws=True, matrix=mc.xform(midDriver, q=True, ws=True, matrix=True)) mc.setAttr("{}.displayHandle".format(lipUpper), 1) control.tagAsControl(lipUpper) # Lowerteeth control if mc.objExists(teethUpperJoint): teethUpperNul, teethUpperDefAuto, teethUpperCtrl = control.create( name="teeth_upper", controlType="null", color=common.RED, hierarchy=['nul', 'def_auto'], parent=midDriver) mc.xform(teethUpperNul, ws=True, matrix=mc.xform(teethUpperJoint, q=True, ws=True, matrix=True)) mc.pointConstraint(teethUpperCtrl, teethUpperJoint) mc.orientConstraint(teethUpperCtrl, teethUpperJoint)
def controlFromLocator( locList, ctrlType = 'transform', ctrlShape = 'box', ctrlScale = 0.1, ctrlLod = 'primary', driverType = None, orient = True, parentToLoc = False ): ''' Generate controls objects from a list of locators @param locList: List of locators to generate controls from. @type locList: list @param ctrlType: Control transform type. Accepted values include "transform" and "joint". @type ctrlType: str @param ctrlShape: Control transform type. @type ctrlShape: str @param ctrlScale: Control shape scale. @type ctrlScale: float @param ctrlLod: Control LOD type. @type ctrlLod: str @param driverType: Control driver type. If None, don't create control driver. @type driverType: str or None @param orient: Orient control to locator. @type orient: bool @param parentToLoc: Parent control group to locator. @type parentToLoc: bool ''' # ========== # - Checks - # ========== # Check Locators for loc in locList: if not mc.objExists(loc): raise Exception('Locator "'+loc+'" does not exist!') # Check Control LOD ctrlLodList = ['primary','secondary', 'tertiary'] if not ctrlLod in ctrlLodList: raise Exception('Invalid control LOD (level of detail)! ("'+ctrlLod+'")') # =================== # - Create Controls - # =================== ctrlBuilder = glTools.tools.controlBuilder.ControlBuilder() ctrlList = [] ctrlGrpList = [] driverList = [] driverGrpList = [] for loc in locList: # Clear Selection mc.select(cl=True) # Generate Naming Prefix prefix = glTools.utils.stringUtils.stripSuffix(loc) # Create Control ctrl = '' ctrlGrp = '' if ctrlType == 'transform': ctrl = mc.createNode(ctrlType,n=prefix+'_ctrl') ctrlGrp = mc.group(ctrl,n=prefix+'_ctrlGrp') elif ctrlType == 'joint': ctrl = mc.joint(n=prefix+'_jnt') ctrlGrp = glTools.utils.joint.group(ctrl,'A') mc.setAttr(ctrl+'.radius',ctrlScale) mc.setAttr(ctrlGrp+'.radius',ctrlScale) glTools.utils.base.displayOverride(ctrl,overrideEnable=1,overrideLOD=1) glTools.utils.base.displayOverride(ctrlGrp,overrideEnable=1,overrideLOD=1) if not driverType: glTools.rig.utils.tagBindJoint(ctrl) else: raise Exception('Invalid control transform type "'+ctrlType+'"!') # Parent to Locator if parentToLoc: mc.parent(ctrlGrp,loc) # Create Control Shape ctrlBuilder.controlShape(ctrl,controlType=ctrlShape,scale=ctrlScale) # Tag Control glTools.rig.utils.tagCtrl(ctrl,ctrlLod) # Create Driver driver = None driverGrp = None if driverType: # Clear Selection mc.select(cl=True) if driverType == 'transform': driver = mc.createNode(ctrlType,n=prefix+'_driver') driverGrp = mc.group(ctrl,n=prefix+'_driverGrp') elif driverType == 'joint': driver = mc.joint(n=prefix+'_driver') driverGrp = glTools.utils.joint.group(driver,'A') mc.setAttr(driver+'.radius',ctrlScale) mc.setAttr(driverGrp+'.radius',ctrlScale) glTools.utils.base.displayOverride(driver,overrideEnable=1,overrideLOD=1) glTools.utils.base.displayOverride(driverGrp,overrideEnable=1,overrideLOD=1) glTools.rig.utils.tagBindJoint(driver) else: raise Exception('Invalid control driver type "'+driverType+'"!') # Connect Driver for at in 'trs': mc.connectAttr(ctrl+'.'+at,driver+'.'+at,f=True) mc.connectAttr(driverGrp+'.'+at,ctrlGrp+'.'+at,f=True) # Position Driver Group mc.delete(mc.pointConstraint(loc,driverGrp)) if orient: mc.delete(mc.orientConstraint(loc,driverGrp)) # Parent to Locator if parentToLoc: mc.parent(driverGrp,loc) else: # Position Control Group mc.delete(mc.pointConstraint(loc,ctrlGrp)) if orient: mc.delete(mc.orientConstraint(loc,ctrlGrp)) # Append to Return Lists ctrlList.append(ctrl) ctrlGrpList.append(ctrlGrp) driverList.append(driver) driverGrpList.append(driverGrp) # ================= # - Return Result - # ================= result = {} result['ctrl'] = ctrlList result['ctrlGrp'] = ctrlGrpList result['driver'] = driverList result['driverGrp'] = driverGrpList return result
def ChangeXxbOldCameras_zwz(): if mc.confirmDialog(title=u'温馨提示', message=u'是否需要更新摄像机!', button=['Yes', 'No'], defaultButton='Yes', cancelButton='No', dismissString='No'): FirstP = '' SecondP = '' MyLL = MyLM = MyLR = MyRL = MyRM = MyRR = '' AllFirstP = [] allMyCameras = mc.listCameras(p=True) for MyCamera in allMyCameras: if not MyCamera.find('persp') >= 0: if MyCamera.find('camL_L') >= 0: MyLL = MyCamera firstP = mc.listRelatives(MyCamera, p=True)[0] AllFirstP.append(firstP) SecondP = mc.listRelatives(firstP, p=True)[0] SetUnlockCameras_zwz(MyCamera, False) mc.parent(MyCamera, w=True) SetkCamerastoZero_zwz(MyCamera) mc.setAttr('%s.ry' % MyCamera, 240) if MyCamera.find('camL_M') >= 0: MyLM = MyCamera firstP = mc.listRelatives(MyCamera, p=True)[0] AllFirstP.append(firstP) SetUnlockCameras_zwz(MyCamera, False) mc.parent(MyCamera, w=True) SetkCamerastoZero_zwz(MyCamera) mc.setAttr('%s.ry' % MyCamera, 180) if MyCamera.find('camL_R') >= 0: MyLR = MyCamera firstP = mc.listRelatives(MyCamera, p=True)[0] AllFirstP.append(firstP) SetUnlockCameras_zwz(MyCamera, False) mc.parent(MyCamera, w=True) SetkCamerastoZero_zwz(MyCamera) mc.setAttr('%s.ry' % MyCamera, 120) if MyCamera.find('camR_L') >= 0: MyRL = MyCamera firstP = mc.listRelatives(MyCamera, p=True)[0] AllFirstP.append(firstP) SetUnlockCameras_zwz(MyCamera, False) mc.parent(MyCamera, w=True) SetkCamerastoZero_zwz(MyCamera) mc.setAttr('%s.ry' % MyCamera, 240) if MyCamera.find('camR_M') >= 0: MyRM = MyCamera firstP = mc.listRelatives(MyCamera, p=True)[0] AllFirstP.append(firstP) SetUnlockCameras_zwz(MyCamera, False) mc.parent(MyCamera, w=True) SetkCamerastoZero_zwz(MyCamera) mc.setAttr('%s.ry' % MyCamera, 180) if MyCamera.find('camR_R') >= 0: MyRR = MyCamera firstP = mc.listRelatives(MyCamera, p=True)[0] AllFirstP.append(firstP) SetUnlockCameras_zwz(MyCamera, False) mc.parent(MyCamera, w=True) SetkCamerastoZero_zwz(MyCamera) mc.setAttr('%s.ry' % MyCamera, 120) for each in AllFirstP: try: mc.delete(each) except: pass if (MyLL and MyLM and MyLR and MyRL and MyRM and MyRR): myCamLG = mc.group(MyLL, MyLM, MyLR, name='Cam_L') mc.setAttr('%s.tx' % myCamLG, 0.034) myCamRG = mc.group(MyRL, MyRM, MyRR, name='Cam_R') mc.setAttr('%s.tx' % myCamRG, -0.034) mylocator = mc.spaceLocator(p=(0, 0, 0))[0] mc.pointConstraint(SecondP, mylocator, w=1) mc.orientConstraint(SecondP, mylocator, w=1) tmp = mc.getAttr('%s.tx' % mylocator) mc.setAttr('%s.tx' % myCamLG, tmp) mc.setAttr('%s.tx' % myCamRG, tmp) tmp = mc.getAttr('%s.ty' % mylocator) mc.setAttr('%s.ty' % myCamLG, tmp) mc.setAttr('%s.ty' % myCamRG, tmp) tmp = mc.getAttr('%s.tz' % mylocator) mc.setAttr('%s.tz' % myCamLG, tmp) mc.setAttr('%s.ty' % myCamRG, tmp) tmp = mc.getAttr('%s.rx' % mylocator) mc.setAttr('%s.rx' % myCamLG, tmp) mc.setAttr('%s.rx' % myCamRG, tmp) tmp = mc.getAttr('%s.ry' % mylocator) mc.setAttr('%s.ry' % myCamLG, tmp) mc.setAttr('%s.ry' % myCamRG, tmp) tmp = mc.getAttr('%s.rz' % mylocator) mc.setAttr('%s.rz' % myCamLG, tmp) mc.setAttr('%s.rz' % myCamRG, tmp) mc.parent(myCamLG, SecondP) mc.parent(myCamRG, SecondP) mc.xform(myCamLG, os=True, t=[0.034, 0, 0]) mc.xform(myCamRG, os=True, t=[-0.034, 0, 0]) SetUnlockCameras_zwz(MyLL, True) SetUnlockCameras_zwz(MyLM, True) SetUnlockCameras_zwz(MyLR, True) SetUnlockCameras_zwz(MyRL, True) SetUnlockCameras_zwz(MyRM, True) SetUnlockCameras_zwz(MyRR, True) mc.delete(mylocator) mc.confirmDialog(title=u'温馨提示', message=u'摄像机已更新!', button=['ok'], defaultButton='ok', dismissString='No') else: mc.confirmDialog(title=u'警告', message=u'没有相应的摄像机或其命名不对', button=['ok'], defaultButton='ok', dismissString='No')
def stretchyIK (self): #select control first, wrist bone second, elbow bone third, shoulder bone fourth sel = cmds.ls(sl = True) newName = sel[0] if newName.startswith('R_Arm_IK') or newName.startswith('L_Arm_IK') or newName.startswith('L_Leg_IK') or newName.startswith('R_Leg_IK'): #remove jnt at the end newName = newName[:6] #setting up attributes cmds.select(sel[0]) cmds.addAttr( shortName='Stretchy', longName='Stretchy', k = True, defaultValue=1.0, minValue=0, maxValue=1) cmds.addAttr( shortName='Length_1', longName='Length_1', k = True, defaultValue=1.0,) cmds.addAttr( shortName='Length_2', longName='Length_2', k = True, defaultValue=1.0,) #-------------setup nodes beginning---------------------- #initial sizes MD1 = cmds.shadingNode('multiplyDivide', n = newName + "Length 1_MD", asUtility=True) MD2 = cmds.shadingNode('multiplyDivide', n = newName + "Length 2_MD", asUtility=True) PMA1 = cmds.shadingNode('plusMinusAverage', n = newName + "TotalLength_PMA", asUtility=True) size1 = abs(cmds.getAttr(sel[2] + '.translateX')) size2 = abs(cmds.getAttr(sel[1] + '.translateX')) cmds.setAttr(MD1 + ".input1X", size1) cmds.setAttr(MD2 + ".input1X", size2) cmds.connectAttr( MD1 + ".outputX", PMA1 + ".input1D[0]") cmds.connectAttr( MD2 + ".outputX", PMA1 + ".input1D[1]") cmds.connectAttr(sel[0] + ".Length_1", MD1 + ".input2X") cmds.connectAttr(sel[0] + ".Length_2", MD2 + ".input2X") #create locators locator = cmds.spaceLocator(n = newName + "Shoulder Locator") locator2 = cmds.spaceLocator(n = newName + "Wrist Locator") cmds.pointConstraint(sel[3], locator, mo = False) cmds.pointConstraint(sel[0], locator2, mo = False) LocDist = cmds.shadingNode('distanceBetween', n = newName + "DistanceBetweenLocators_DB", asUtility=True) cmds.connectAttr(locator[0] + ".worldPosition[0]", LocDist + ".point1") cmds.connectAttr(locator2[0] + ".worldPosition[0]", LocDist + ".point2") #scalar value MD3 = cmds.shadingNode('multiplyDivide', n = newName + "ScalarValue_MD", asUtility=True) cmds.setAttr(MD3 + ".operation", 2) cmds.connectAttr(LocDist + ".distance", MD3 + ".input1X") cmds.connectAttr(PMA1 + ".output1D", MD3 + ".input2X") #condition node Cond = cmds.shadingNode('condition', n = newName + "Condition_C", asUtility = True) cmds.setAttr(Cond + ".operation", 2) #set to greater than cmds.connectAttr(MD3 + ".outputX", Cond + ".colorIfTrueR") cmds.connectAttr(PMA1 + ".output1D", Cond + ".secondTerm") cmds.connectAttr(LocDist + ".distance", Cond + ".firstTerm") #blend colors node BlendCol = cmds.shadingNode('blendColors', n = newName + "Blender_BC", asUtility = True) cmds.connectAttr(sel[0] + ".Stretchy", BlendCol + ".blender") cmds.connectAttr(Cond + ".outColorR", BlendCol + ".color1R") cmds.setAttr(BlendCol + ".color2R", 1) #Scale values MD4 = cmds.shadingNode('multiplyDivide', n = newName + "Length1_ScaledValue_MD", asUtility = True) MD5 = cmds.shadingNode('multiplyDivide', n = newName + "Length2_ScaledValue_MD", asUtility = True) cmds.connectAttr( MD1 + ".outputX", MD4 + ".input1X") cmds.connectAttr( MD2 + ".outputX", MD5 + ".input1X") cmds.connectAttr( BlendCol + ".outputR", MD4 + ".input2X") cmds.connectAttr( BlendCol + ".outputR", MD5 + ".input2X") #connect to bones cmds.connectAttr( MD4 + ".outputX", sel[2] + '.translateX') cmds.connectAttr( MD5 + ".outputX", sel[1] + '.translateX')
def twist_system(self): """ """ # set-up start group self.start_twist_grp = cmds.group(empty=True, name="{}_{}_startTwist_GRP".format( self.side, self.side)) cmds.xform(self.start_twist_grp, worldSpace=True, matrix=(cmds.xform(self.stretchy_chain[0], query=True, worldSpace=True, matrix=True))) # set-up joint chain distance_factor = 0.0 for i in range(0, self.number_twist_joints): unit = float(self.start_distance_attr_val / (self.number_twist_joints - 1)) jnt = cmds.createNode("joint", name="{}_{}{}_twist_JNT".format( self.side, self.name, i)) self.twist_joitns_chain.append(jnt) cmds.parent(self.twist_joitns_chain[i], self.start_twist_grp) if i == 0: cmds.xform(self.twist_joitns_chain[i], worldSpace=True, matrix=(cmds.xform(self.start_twist_grp, query=True, worldSpace=True, matrix=True))) cmds.makeIdentity(self.twist_joitns_chain[i], apply=True, t=True, r=True, scale=True, n=False, pn=True) else: cmds.xform(self.twist_joitns_chain[i], worldSpace=True, matrix=(cmds.xform(self.start_twist_grp, query=True, worldSpace=True, matrix=True))) cmds.makeIdentity(self.twist_joitns_chain[i], apply=True, t=True, r=True, scale=True, n=False, pn=True) distance_factor = distance_factor + unit if self.side == "L": cmds.setAttr( "{}.translateX".format(self.twist_joitns_chain[i]), distance_factor) else: cmds.setAttr( "{}.translateX".format(self.twist_joitns_chain[i]), distance_factor * (-1)) # aimConstraint -mo -weight 1 -aimVector 1 0 0 -upVector 0 1 0 -worldUpType "object" -worldUpObject locator2; cmds.aimConstraint(self.end_loc[0], self.start_twist_grp, aimVector=[1, 0, 0], upVector=[0, 1, 0], worldUpType="object", worldUpObject=self.up_loc[0], maintainOffset=True) cmds.pointConstraint(self.start_loc[0], self.start_twist_grp, maintainOffset=True) # set-up twist feature # cmds.orientConstraint(self.end_loc[0], self.twist_joitns_chain[-1], maintainOffset=True) mlm_node = cmds.createNode("multMatrix", name="{}_{}_opMatTwist_MLM".format( self.side, self.side)) dcm_node = cmds.createNode("decomposeMatrix", name="{}_{}_opMatTwist_DCM".format( self.side, self.side)) qte_node = cmds.createNode("quatToEuler", name="{}_{}_opMatTwist_QTE".format( self.side, self.side)) cmds.connectAttr("{}.worldMatrix[0]".format(self.end_loc[0]), "{}.matrixIn[0]".format(mlm_node), force=True) cmds.connectAttr("{}.worldInverseMatrix[0]".format(self.start_loc[0]), "{}.matrixIn[1]".format(mlm_node), force=True) cmds.connectAttr("{}.matrixSum".format(mlm_node), "{}.inputMatrix".format(dcm_node), force=True) cmds.connectAttr("{}.outputQuatX".format(dcm_node), "{}.inputQuatX".format(qte_node), force=True) cmds.connectAttr("{}.outputQuatW".format(dcm_node), "{}.inputQuatW".format(qte_node), force=True) factor = 0.0 for i in range(0, self.number_twist_joints): factor_unit = (1.0 / self.number_twist_joints) mld_node = cmds.createNode("multiplyDivide", name="{}_{}{}_opMatTwist_MLD".format( self.side, self.side, i)) cmds.connectAttr("{}.outputRotateX".format(qte_node), "{}.input1X".format(mld_node), force=True) cmds.connectAttr("{}.outputX".format(mld_node), "{}.rotateX".format(self.twist_joitns_chain[i]), force=True) if i == 0: cmds.setAttr("{}.input2X".format(mld_node), 0.0) else: factor = factor + factor_unit cmds.setAttr("{}.input2X".format(mld_node), factor) return True
def jointOrientCreateControl(): ''' Create joint orient control for each selected joint ''' # Check Window window = 'jointOrientUI' upAxis = (0, 1, 0) if mc.window(window, q=True, ex=1): # Build UpAxis List upAxisList = [((0, 1, 0), (0, 0, 1)), ((1, 0, 0), (0, 0, 1)), ((1, 0, 0), (0, 1, 0))] # Get Axis Selection aimAx = mc.radioButtonGrp('jointOrientPrimAxisRBG', q=True, sl=True) upAx = mc.radioButtonGrp('jointOrientAimAxisRBG', q=True, sl=True) # Build Axis Values upAxis = upAxisList[aimAx - 1][upAx - 1] # Create control jntList = mc.ls(sl=True, type='joint') ctrlList = [] for jnt in jntList: # Get child joint cJnt = mc.listRelatives(jnt, c=True, pa=True) if not cJnt: continue # Generate control prefix prefix = glTools.utils.stringUtils.stripSuffix(jnt) # Check for existing orien control if mc.objExists(prefix + '_ori01_orientGrp'): print('Orient control already exists for joint "' + jnt + '"!!') continue # Create orient control circle = mc.circle(c=(0, 0, 0), nr=(0, 1, 0), sw=360, r=1, d=3, ut=0, tol=0.01, s=8, ch=1, n=prefix + '_ori01_orientControl') for ch in ['tx', 'ty', 'tz', 'rx', 'rz', 'sx', 'sy', 'sz']: mc.setAttr(circle[0] + '.' + ch, l=True, k=False) # Create orient UP locator upLoc = mc.spaceLocator(n=prefix + '_up01_orientLoc') mc.parent(upLoc[0], circle[0]) mc.setAttr(upLoc[0] + '.tz', 1.0) mc.connectAttr(upLoc[0] + '.tz', circle[1] + '.radius', f=True) for ch in ['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']: mc.setAttr(upLoc[0] + '.' + ch, l=True, k=False) # Create orient control group ctrlGrp = mc.group(em=True, n=prefix + '_ori01_orientGrp') mc.parent(circle[0], ctrlGrp) # Position control group mc.delete(mc.pointConstraint(jnt, ctrlGrp)) mc.delete( mc.aimConstraint(cJnt[0], ctrlGrp, aimVector=(0, 1, 0), upVector=(0, 0, 1), wu=upAxis, wuo=jnt, wut='objectrotation')) # Scale control elements dist = glTools.utils.mathUtils.distanceBetween( mc.xform(jnt, q=True, ws=True, rp=True), mc.xform(cJnt[0], q=True, ws=True, rp=True)) mc.setAttr(upLoc[0] + '.tz', dist * 0.5) # Lock orient control group mc.parent(ctrlGrp, jnt) for ch in ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']: mc.setAttr(ctrlGrp + '.' + ch, l=True, k=False) # Add message connection form joint to orient control mc.addAttr(circle[0], ln='joint', at='message') mc.connectAttr(jnt + '.message', circle[0] + '.joint', f=True) # Append control list ctrlList.append(circle[0]) # Select controls mc.select(ctrlList)
def snap_from_to(snapeur, snaped): con = mc.pointConstraint(snapeur, snaped, maintainOffset=False) mc.delete(con)