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)
