def friendsCreateProxyCube() : # Create a polygon cube as a proxy of a hair mesh # Select joints then run script sels = mc.ls( sl=True ) selSize = len( sels ) cube = mc.polyCube( sx=1 , sy=len( sels )-1 , sz = 1 , ch=False )[0] for ix in range( selSize ) : # print sels[ len( sels ) - ix - 1 ] # select -r pCube1.vtx[0:1] pCube1.vtx[18:19] ; # select -r pCube1.vtx[2:3] pCube1.vtx[16:17] ; # CreateCluster; minA , maxA = 0 + ( ix*2 ) , 1 + ( ix*2 ) minB , maxB = ( selSize * 4 ) - 2 - ( ix*2 ) , ( selSize * 4 ) - 1 - ( ix*2 ) mc.select( '%s.vtx[%s:%s]' % ( cube , minA , maxA ) , r=True ) mc.select( '%s.vtx[%s:%s]' % ( cube , minB , maxB ) , add=True ) mm.eval( 'CreateCluster' ) clstr = mc.ls( sl=True )[0] zGrp = rigTools.zeroGroup( clstr ) mc.parentConstraint( sels[ ix ] , zGrp )
def constrainJoints(self): # Rivet & constrain joints to the ArcCtrl surface
rivetArgs=[]
cjLen=1
for j in self.jointHierarchy[1:]:
if self.spread:
cj=removeAll\
(
self.jointHierarchy[1:],
iterable(mc.listRelatives(j,c=True,type='transform'))
)
rivetArgs.extend(cj)
cjLen=len(cj)+1
rivetArgs.append(j)
skipRotate=[]
for sr in range(1,cjLen+1):
skipRotate.append(-sr)
rivetArgs.append(self.ArcCtrl.outputSurface)
self.rivet=Rivet(rivetArgs,constraint=True,skipRotate=skipRotate)
if not\
(
mc.connectionInfo(self.jointHierarchy[-1]+'.r',id=True) or
mc.connectionInfo(self.jointHierarchy[-1]+'.rx',id=True) or
mc.connectionInfo(self.jointHierarchy[-1]+'.ry',id=True) or
mc.connectionInfo(self.jointHierarchy[-1]+'.rz',id=True)
):
mc.parentConstraint(self.ArcCtrl.handles[-1],self.jointHierarchy[-1],st=('x','y','z'),mo=True)
if self.spread or self.curl:
for j in cj:
mc.parentConstraint(self.ArcCtrl.handles[-1],j,st=('x','y','z'),mo=True)
def connectBind(self):
#Create opposite node to blend
blendOpposite = rc.create1MinusNode(
"%s.%s" %(self.m_blendControl, self.m_blendAttr),
"%s_IKFKBlendOpp_CTRL" %(self.m_name)
)
for i in range(len(self.m_bindJoints)):
const1 = cmds.parentConstraint(
self.m_ikJoints[i],
self.m_bindJoints[i],
st = ["x", "y", "z"]
)[0]
const2 = cmds.parentConstraint(
self.m_fkJoints[i],
self.m_bindJoints[i],
st = ["x", "y", "z"]
)[0]
cmds.connectAttr(
blendOpposite,
"%s.blendParent2" %(self.m_bindJoints[i])
)
# Change to quarternion
pairBlend = cmds.listConnections(
"%s.constraintRotateX" %(const1),
d=1
)[0]
cmds.setAttr("%s.rotInterpolation" %(pairBlend), 1)
def addNoiseOnControl(Object, Control):
if Object.__class__ == list:
pass
elif Object.__class__ in [str, unicode]:
Object = [Object]
else:
"Not Valid Arguments on Add Noise"
return None
Expresion = """//{0}
{0}.rotateX=`noise((time+{2})*{1}.frequency)`*{1}.amplitud;
{0}.rotateY=`noise((time+{2}+30)*{1}.frequency)`*{1}.amplitud;
{0}.rotateZ=`noise((time+{2}+60)*{1}.frequency)`*{1}.amplitud;
{0}.ty=`noise((time+{2}+90)*{1}.frequency)`*{1}.movY + {1}.movY;
"""
if not isNoiseControl(Control):
addAttributes(Control)
for eachObject in Object:
constraints = constraintComponents(gessFrom=eachObject)
ResetGroup = RMRigTools.RMCreateGroupOnObj(eachObject, Type="child")
for eachkey in constraints.constraintDic:
cmds.delete(eachkey)
cmds.parentConstraint(ResetGroup, constraints.constraintDic[eachkey]["affected"], mo=True)
ExpressionNode = cmds.expression(
name="NoiseMainExpresion", string=Expresion.format(ResetGroup, Control, random.uniform(0, 100))
)
def keyToOn():
controller = mc.ls(sl=True)[0]
channelBox = mel.eval('global string $gChannelBoxName; $temp=$gChannelBoxName;') #fetch maya's main channelbox
attrs = mc.channelBox(channelBox, q=True, sma=True)
if attrs:
channel = controller + "." + attrs[0]
constraint = mc.listConnections(channel, type="constraint")[0]
currentTime = mc.currentTime( query=True )
# save rest pose on constraint
# mc.currentTime(currentTime-1)
constraintChannels = mc.listConnections(constraint, type="animCurve")
mc.parentConstraint(controller, constraint, edit=True, maintainOffset=True)
for i in constraintChannels:
value = mc.getAttr(mc.listConnections(i, plugs=True)[0])
setKeyframe(mc.listConnections(i, plugs=True)[0], currentTime, value)
# set key on 1 for controller
setKeyframe(channel, currentTime-1, value=0)
setKeyframe(channel, currentTime, value=1)
# mc.currentTime( currentTime )
else:
mc.warning("Select constrain channel!")
def creatSphere(*args):
circleSel = mc.ls(sl=1)[0]
radiusCircle = mc.circle(circleSel, q=1, r=1)
radiusSpere = radiusCircle*.75
particleSphere = mc.polySphere(n='%s_Sphere'%circleSel, r=radiusSpere, sx=float(radiusSpere), sy=float(radiusSpere), ax=[0, 1, 0])[0]
mc.parentConstraint(circleSel, particleSphere, mo=0, w=1)
#mc.parent(particleSphere, circleSel)
mc.setAttr('%s.tx'%particleSphere, 0)
mc.setAttr('%s.ty'%particleSphere, 0)
mc.setAttr('%s.tz'%particleSphere, 0)
mc.setAttr('%s.rx'%particleSphere, 0)
mc.setAttr('%s.ry'%particleSphere, 0)
mc.setAttr('%s.rz'%particleSphere, 0)
mc.setAttr('%s.v'%particleSphere, 0)
mc.select(particleSphere, r=1)
mc.emitter(type='surface', r=4, dx=1, dy=0, dz=0, n='%s_emitter'%circleSel )
mc.particle( n='%s_Particles'%circleSel )
mc.connectDynamic( '%s_Particles'%circleSel, em='%s_emitter'%circleSel )
particlesShape = mc.listRelatives('%s_Particles'%circleSel, s=1)[0]
mc.setAttr('%s.lifespanMode'%particlesShape, 1)
mc.setAttr('%s.lifespan'%particlesShape, 0.4)
mc.setAttr('%s.startFrame'%particlesShape, 1001)
mc.connectControl( 'numText', '%s.rate'%('%s_emitter'%circleSel) )
mc.shadingNode('blinn', n='%s_blinn'%circleSel, asShader=1)
mc.sets( n='%s_blinnSG'%circleSel, renderable=True, noSurfaceShader=True, empty=1)
mc.connectAttr('%s.outColor'%('%s_blinn'%circleSel), '%s.surfaceShader'%('%s_blinnSG'%circleSel))
mc.connectControl( 'myColorIndex', '%s.color'%('%s_blinn'%circleSel) )
mc.connectControl( 'lifeText', '%s.lifespan'%particlesShape )
mc.sets('%s_Particles'%circleSel, e=1, forceElement='%s'%('%s_blinnSG'%circleSel))
def create_spine_rig(base_curve, rig_region_name, pelvis, cog, spine_1, spine_2, spine_3, spine_4, neck):
# create group to contain all rigging nodes
cmds.select(cl=True)
spine_group = cmds.group(em=True, n=rig_region_name + '_group')
cmds.select(spine_group, base_curve, r=True)
cmds.parent()
# add the arm group node to the base curve rig nodes attr
add_node_to_rig_nodes(base_curve, rig_region_name, spine_group)
cog_curve, cog_curve_group = jt_ctl_curve.create(cog, 'star_5', lock_unused=False)
cmds.setAttr(cog_curve + '.scale', 3,3,3)
cmds.select(cog_curve, r=True)
cmds.makeIdentity(apply=True, t=0, r=0, s=1, n=0)
cmds.select(cog_curve, cog, r=True)
cmds.parentConstraint(mo=True, weight=1)
cmds.scaleConstraint(mo=True, weight=1)
cmds.select(cog_curve_group, base_curve, r=True)
cmds.parent()
pelvis_curve, pelvis_curve_group = jt_ctl_curve.create(pelvis, 'waist', True, True, True, True)
spine_1_curve, spine_1_curve_group = jt_ctl_curve.create(spine_1, 'circle', True, True, True, True)
spine_2_curve, spine_2_curve_group = jt_ctl_curve.create(spine_2, 'circle', True, True, True, True)
spine_3_curve, spine_3_curve_group = jt_ctl_curve.create(spine_3, 'circle', True, True, True, True)
spine_4_curve, spine_4_curve_group = jt_ctl_curve.create(spine_4, 'circle', True, True, True, True)
neck_curve, neck_curve_group = jt_ctl_curve.create(neck, 'circle', True, True, True, True)
# parent fk controlls to spine group
cmds.select(cog_curve_group, pelvis_curve_group, spine_1_curve_group, spine_2_curve_group, spine_3_curve_group, spine_4_curve_group, neck_curve_group, spine_group, r=True)
cmds.parent()
def __init__( self, fkik_snap_set ):
cmds.select( cl = True )
self.get_globals()
for obj in cmds.sets( fkik_snap_set, q = True ):
controller = DAG_Node( obj )
obj_snap_attr = '{0}.{1}'.format( controller.name(), self.snap_parent_str )
if cmds.objExists( obj_snap_attr ):
obj_snap = cmds.listConnections( obj_snap_attr )
if obj_snap:
obj_snap = obj_snap[0]
snap_grp = DAG_Node( cmds.group( n = '{0}_Snap_Grp'.format( obj.split( '|' )[-1] ), em = True ) )
snap_grp.set_parent( controller.parent() )
obj_tra = cmds.xform( controller.name(), ws = True, rp = True, q = True )
cmds.xform( snap_grp.name(), ws = True, t = obj_tra )
obj_rot = cmds.xform( controller.name(), ws = True, ro = True, q = True )
cmds.xform( snap_grp.name(), ws = True, ro = obj_rot )
cmds.makeIdentity( snap_grp.name(), a = True, t = True, r = True, s = True )
cmds.parentConstraint( obj_snap, snap_grp.name(), mo = True )
snap_grp_attr = Maya_Util().add_attr( snap_grp.name(), self.snap_parent_str, 'message' )
cmds.connectAttr( snap_grp_attr, obj_snap_attr, force = True )
cmds.select( cl = True )
def addJoint(side='L'):
if mc.objExists('%s_armPalm_bnd_0'%side):return
# make joint and locators
Joint = mc.createNode('joint', name='%s_armPalm_bnd_0'%side)
JointGroup = mc.group(Joint, name='%s_armPalm_bndgrp_0'%side)
FKloc = mc.spaceLocator(p=(0,0,0), name='%s_armPalmFK_loc_0'%side)[0]
IKloc = mc.spaceLocator(p=(0,0,0), name='%s_armPalmIK_loc_0'%side)[0]
# constraint
constraintNode = mc.parentConstraint(FKloc, IKloc, JointGroup)
# match position
mc.delete(mc.parentConstraint('%s_armMiddleAIK_jnt_0'%side, FKloc))
mc.delete(mc.parentConstraint('%s_armMiddleAIK_jnt_0'%side, IKloc))
# parent locator
mc.parent(FKloc, '%s_armWristFk_jnt_0'%side)
mc.parent(IKloc, '%s_armMiddleAIK_jnt_0'%side)
# make ikfk switch
reverseNode = [x.split('.')[0] for x in mc.connectionInfo('%s_armFkIk_ctl_0.FKIKBlend'%side, dfs=True) if mc.nodeType(x.split('.')[0])=='reverse'][0]
mc.connectAttr('%s.outputX'%reverseNode, '%s.%sW0'%(constraintNode[0], FKloc))
mc.connectAttr('%s_armFkIk_ctl_0.FKIKBlend'%side, '%s.%sW1'%(constraintNode[0], IKloc))
# add to bind set
mc.sets(Joint, e=True, forceElement='bind_joints_set')
# connect jointLayer
mc.connectAttr('jointLayer.drawInfo', '%s.drawOverride'%Joint)
# parent joint
mc.parent(JointGroup, '%s_armBind_org_0'%side)
def createControl( si, shape = 'circleX', childsAlso = True, par = None, lastAlso = False, constraint = True, connect = False, offsetGroup = True ): if not lastAlso and not si.children: return if shape == 'joint': mc.select( cl = True ) curv = mn.Node( mc.joint( n = si.name + "_jnt" ) ) elif shape == 'locator': curv = mn.Node( mc.spaceLocator( n = si.name + '_loc' )[0] ) else: curv = crv.Curve( si.name + "_ctl" ) curv = curv.create( shape ) if offsetGroup: grp = mn.createNode( "transform", ss = True ) grp.name = si.name + "_grp" trf.snap( si, grp ) curv.parent = grp curv.a.t.v = [0]*3 curv.a.r.v = [0]*3 if par: grp.parent = par else: trf.snap( si, curv ) curv.freeze() if constraint: mc.parentConstraint( curv, si, mo = True ) mc.scaleConstraint( curv, si, mo = True ) if connect: curv.a.t >> si.a.t curv.a.r >> si.a.r curv.a.s >> si.a.s if childsAlso and si.children: for c in si.children: c = mn.Node( c.name.split( '|' )[-1] ) createControl( c, shape, True, curv, lastAlso, constraint, connect, offsetGroup )
def BindSkeletons(source, dest, method='connect'):
'''
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
'''
sourceJoints = cmds.listRelatives(source, ad=True, f=True, type='joint')
destJoints = cmds.listRelatives(dest, ad=True, f=True, type='joint')
if cmds.nodeType(source) == 'joint':
sourceJoints.append(source)
if cmds.nodeType(dest) == 'joint':
destJoints.append(dest)
attrs = ['rotateX', 'rotateY', 'rotateZ', 'translateX', 'translateY', 'translateZ']
for sJnt, dJnt in MatchGivenHierarchys(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':
try:
cmds.parentConstraint(sJnt, dJnt, mo=True)
except:
pass
def on_actionStartMove_triggered(self, args=None):
if args==None:return
toMoveOBJ = str(self.MovedOBJLineEdit.text())
toKeepOBJ = str(self.KeepedOBJLineEdit.text())
if not mc.objExists(toMoveOBJ) or not mc.objExists(toKeepOBJ):return
if toMoveOBJ == toKeepOBJ:return
self.ConstraintDT = {}
self.ConstraintLocators = []
for Jnt in (toKeepOBJ, toMoveOBJ):
OldConstraintNode = [x for x in mc.listRelatives(Jnt, c=True, path=True) or [] if mc.nodeType(x).endswith('Constraint')]
for OCSN in OldConstraintNode:
ConstraintType = mc.nodeType(OCSN)
ConstraintOBJ = eval('mc.%s("%s", q=True, tl=True)'%(ConstraintType, OCSN))
self.ConstraintDT.setdefault(Jnt, {})['type'] = ConstraintType
self.ConstraintDT.setdefault(Jnt, {})['ConsOBJ'] = ConstraintOBJ
mc.delete(OCSN)
Loc = mc.spaceLocator(p=(0,0,0))
mc.delete(mc.parentConstraint(Jnt, Loc))
ConstraintNode = mc.parentConstraint(Loc[0], Jnt)
self.ConstraintLocators.append(Loc[0])
self.ConstraintLocators.append(ConstraintNode[0])
def locatorOnly(self):
sel = cmds.ls(sl=True)
# Gives error if more than one object is selected.
if len(sel) > 1:
cmds.error("Too many objects selected!")
# Creates and snaps a locator to object.
elif len(sel):
tObj = sel[0]
tLoc = "{0}_tLoc".format(tObj)
LScale = cmds.floatField(LocScale, q=True, v=True)
if cmds.objExists(tLoc):
cmds.delete(tLoc)
cmds.spaceLocator(n="{0}_tLoc".format(tObj))
cmds.scale(LScale, LScale, LScale)
cmds.parentConstraint(tObj, tLoc, mo=False)
cmds.parentConstraint(tObj, tLoc, rm=True)
print LScale
# Gives error if no objects are selected.
else:
cmds.error("No objects selected!")
def createGuide(self, *args):
Base.StartClass.createGuide(self)
# Custom GUIDE:
cmds.addAttr(self.moduleGrp, longName="flip", attributeType='bool')
cmds.setAttr(self.moduleGrp+".flip", 0)
cmds.addAttr(self.moduleGrp, longName="indirectSkin", attributeType='bool')
cmds.setAttr(self.moduleGrp+".indirectSkin", 0)
cmds.setAttr(self.moduleGrp+".moduleNamespace", self.moduleGrp[:self.moduleGrp.rfind(":")], type='string')
self.cvJointLoc, shapeSizeCH = ctrls.cvJointLoc(ctrlName=self.guideName+"_JointLoc1", r=0.3)
self.connectShapeSize(shapeSizeCH)
self.jGuide1 = cmds.joint(name=self.guideName+"_JGuide1", radius=0.001)
cmds.setAttr(self.jGuide1+".template", 1)
cmds.parent(self.jGuide1, self.moduleGrp, relative=True)
self.cvEndJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName+"_JointEnd", r=0.1)
self.connectShapeSize(shapeSizeCH)
cmds.parent(self.cvEndJoint, self.cvJointLoc)
cmds.setAttr(self.cvEndJoint+".tz", 1.3)
self.jGuideEnd = cmds.joint(name=self.guideName+"_JGuideEnd", radius=0.001)
cmds.setAttr(self.jGuideEnd+".template", 1)
cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False))
ctrls.setLockHide([self.cvEndJoint], ['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
cmds.parent(self.cvJointLoc, self.moduleGrp)
cmds.parent(self.jGuideEnd, self.jGuide1)
cmds.parentConstraint(self.cvJointLoc, self.jGuide1, maintainOffset=False, name=self.jGuide1+"_ParentConstraint")
cmds.parentConstraint(self.cvEndJoint, self.jGuideEnd, maintainOffset=False, name=self.jGuideEnd+"_ParentConstraint")
cmds.scaleConstraint(self.cvJointLoc, self.jGuide1, maintainOffset=False, name=self.jGuide1+"_ScaleConstraint")
cmds.scaleConstraint(self.cvEndJoint, self.jGuideEnd, maintainOffset=False, name=self.jGuideEnd+"_ScaleConstraint")
def cameraFrustum_build(cam_shape):
#make sure a camera is loaded
if cam_shape==0:
cmds.error('no camera loaded...select a camera and load')
else:
#create frustum only if one doesnt already exist
selCamXform = cmds.listRelatives(cam_shape[0], p=1)
prefix = 'frust_'
frustumGrpName = prefix + 'camera_frustum_all_grp'
if cmds.objExists(frustumGrpName)==0:
#create main grp
frustumMainGrp = cmds.group(em=1, n=frustumGrpName);
cmds.setAttr(frustumGrpName + '.tx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.ty', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.tz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.rx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.ry', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.rz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sy', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.v', lock=1, keyable=0, channelBox=0)
#create frustum geo
frustumGeo = cmds.polyCube(w=2, h=2, d=2, n=prefix + 'camera_frustum_geo')
cmds.delete(frustumGeo[0], constructionHistory=True)
cmds.parent(frustumGeo[0], frustumMainGrp)
#load plugin "nearestPointOnMesh.mll" if needed and connect
plugin = cmds.pluginInfo('nearestPointOnMesh.mll', q=1, l=1)
if plugin==0:
cmds.loadPlugin('nearestPointOnMesh.mll')
nearNodeName = prefix + 'npomNode'
npomNode = cmds.createNode('nearestPointOnMesh', n=nearNodeName)
cmds.connectAttr(frustumGeo[0] + '.worldMesh', npomNode + '.inMesh')
#create clusters
cmds.select(frustumGeo[0] + '.vtx[4:7]', r=1)
nearCluster = cmds.cluster(n=prefix + 'camera_nearFrustum_cluster')
cmds.select(frustumGeo[0] + '.vtx[0:3]', r=1)
farCluster = cmds.cluster(n=prefix + 'camera_farFrustum_cluster')
#create near/far/camera locs
cameraLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_loc')
cmds.parent(cameraLoc[0], frustumMainGrp)
nearLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_nearFrustum_loc')
cmds.move(0, 0, -1)
farLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_farFrustum_loc')
cmds.move(0, 0, 1)
#parent clusters under loc -- parent locs under camera loc
cmds.parent(nearCluster[1], nearLoc[0])
cmds.parent(farCluster[1], farLoc[0])
cmds.parent(nearLoc[0], cameraLoc[0])
cmds.parent(farLoc[0], cameraLoc[0])
#constrain camera loc to camera
cmds.parentConstraint(selCamXform, cameraLoc, weight=1)
return frustumGeo[0]
def RMCreateHipSystem(self):
#resetHipControl, hipControl = RMRigShapeControls.RMCircularControl(self.rootHip,radius = self.SpineLength *.7,name = "hip")
resetHipControl, hipControl = RMRigShapeControls.RMImportMoveControl(self.rootHip, scale = self.SpineLength, name = "hip",Type = "circleDeform")
cmds.parent( resetHipControl, self.COG)
cmds.parentConstraint( hipControl, self.hipJoints[0])
cmds.parent( self.rootHip, self.spineJoints[0])
return resetHipControl, hipControl
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 rigFace() :
jntGrp = 'facialJnt_grp'
if not mc.objExists(jntGrp) :
mc.group(em = True, n = jntGrp)
facePolyMap = {'L_brow_ply': 'L_brow_ctrl',
'L_baseEye_ply': 'L_baseEye_ctrl',
'L_eye_ply': 'L_eye_ctrl',
'R_brow_ply': 'R_brow_ctrl',
'R_baseEye_ply': 'R_baseEye_ctrl',
'R_eye_ply': 'R_eye_ctrl',
'nose_ply': 'noseface_ctrl',
'mouth_ply': 'mount_ctrl'
}
for each in facePolyMap :
poly = each
ctrl = facePolyMap[poly]
if mc.objExists(poly) :
movePivot(ctrl, poly)
joint = mc.createNode('joint', n = poly.replace('_ply', '_jnt'))
mc.delete(mc.pointConstraint(poly, joint))
mc.skinCluster(poly, joint, tsb = True)
mc.parentConstraint(ctrl, joint)
mc.scaleConstraint(ctrl, joint)
mc.parent(joint, jntGrp)
def CreateHydraulicRig(upDir, *args):
selection = cmds.ls(sl=True)
if len(selection) != 3:
cmds.confirmDialog(icon = "warning!!", title = "Hydraulic Rig Tool", message = "You must select exactly 3 objects. Top of hydraulic, bottom of hydraulic, and the up vector.")
return
else:
hyd_start_01_anim = selection[0]
hyd_start_02_anim = selection[1]
upObject = selection[2]
hyd_start_01 = hyd_start_01_anim.rpartition("_")[0]
hyd_start_02 = hyd_start_02_anim.rpartition("_")[0]
# Create a rig for the lower arm extra hydraulic piston.
cmds.delete("driver_"+hyd_start_01+"_parentConstraint1")
robo_lowarm_pistonrod_01_anim_sub = cmds.group(em=True, name=hyd_start_01_anim+"_sub", parent=hyd_start_01_anim)
const = cmds.parentConstraint(hyd_start_01_anim, robo_lowarm_pistonrod_01_anim_sub, weight=1, mo=False)
cmds.delete(const)
const = cmds.parentConstraint(robo_lowarm_pistonrod_01_anim_sub, "driver_"+hyd_start_01, weight=1, mo=True)
cmds.delete("driver_"+hyd_start_02+"_parentConstraint1")
robo_lowarm_pistonrod_02_anim_sub = cmds.group(em=True, name=hyd_start_02_anim+"_sub", parent=hyd_start_02_anim)
const = cmds.parentConstraint(hyd_start_02_anim, robo_lowarm_pistonrod_02_anim_sub, weight=1, mo=False)
cmds.delete(const)
const = cmds.parentConstraint(robo_lowarm_pistonrod_02_anim_sub, "driver_"+hyd_start_02, weight=1, mo=True)
# Hook up the hydraulics for the lowerarm piston.
const1 = cmds.aimConstraint(robo_lowarm_pistonrod_01_anim_sub, robo_lowarm_pistonrod_02_anim_sub, weight=1, mo=True, aimVector=(-1, 0, 0), upVector=(0, 0, upDir), worldUpType="object", worldUpVector=(0, 0, -1), worldUpObject=upObject)
const2 = cmds.aimConstraint(robo_lowarm_pistonrod_02_anim_sub, robo_lowarm_pistonrod_01_anim_sub, weight=1, mo=True, aimVector=(1, 0, 0), upVector=(0, 0, upDir), worldUpType="object", worldUpVector=(0, 0, -1), worldUpObject=upObject)
cmds.select(const1, const2)
def template_joints(joints=None, reorient_children=True, reset_orientation=True):
if joints is None:
joints = cmds.ls(sl=True, type='joint')
if not joints:
raise RuntimeError('No joint selected to orient.')
if reorient_children:
children = cmds.listRelatives(fullPath=True, allDescendents=True, type='joint')
joints.extend(children)
red, green, blue = create_shaders()
orient_group = cmds.createNode('transform', name=ORIENT_GROUP)
manips = []
for joint in joints:
if reset_orientation:
cmds.makeIdentity(joint, apply=True)
cmds.joint(joint, edit=True, orientJoint='xyz', secondaryAxisOrient='yup', children=False, zeroScaleOrient=True)
if not cmds.listRelatives(joint, children=True):
zero_orient([joint])
continue
group, manip = create_orient_manipulator(joint, blue)
manips.append(manip)
cmds.parent(group, orient_group)
cmds.parentConstraint(joint, group)
cmds.setAttr(joint + '.template', 1)
cmds.select(manips)
def createIKCtrlsOnJnts(ikCrv, parentCtrl, size=1):
ikCVNum = ll.getCurveCVCount(ikCrv)
prev=parentCtrl
for i in range(1, ikCVNum):
clus = mc.cluster('%s.cv[%d]'%(ikCrv, i), n=parentCtrl.replace('masterctrl','ikClus%d')%i)
cvPos = mc.xform('%s.cv[%d]'%(ikCrv, i), q=1, ws=1, t=1)
mc.select(parentCtrl)
meval('wireShape("plus")')
ikCtrl = mc.rename(masterCtrl.replace('masterctrl','ikCtrl%d'%i))
mc.xform(ikCtrl, t=cvPos, ws=1)
mc.scale(size, size, size, ikCtrl, ocp=1)
mc.makeIdentity(ikCtrl, a=1, s=1)
mc.parent(ikCtrl, parentCtrl)
lsZeroOut(ikCtrl)
ctrlPR = lsZeroOut(ikCtrl, 'PR')
mc.addAttr(ikCtrl, ln='SPACE', at='bool', k=1)
mc.setAttr(ikCtrl+'.SPACE', l=1)
mc.addAttr(ikCtrl, ln='parent', at='float', dv=0, min=0, max=1, k=1)
mc.addAttr(ikCtrl, ln='master', at='float', dv=1, min=0, max=1, k=1)
mc.addAttr(ikCtrl, ln='world', at='float', dv=0, min=0, max=1, k=1)
mc.parentConstraint(ikCtrl, clus)
cons = mc.parentConstraint(prev, parentCtrl, ctrlPR, mo=1)[0]
wal = mc.parentConstraint(cons, q=1, wal=1)
if len(wal) > 1:
mc.connectAttr(ikCtrl+'.parent', '%s.%s'%(cons, wal[0]), f=1)
mc.connectAttr(ikCtrl+'.master', '%s.%s'%(cons, wal[1]), f=1)
prev=ikCtrl
def tentacleRig():
sel = cmds.ls(sl=1)
if sel:
ns = sel[0].split(':')[0]
side = sel[0].split(':')[1][0]
g = cmds.group(n=plc.getUniqueName('__TENTACLERIG__'), em=True)
macros = tentacleMacro(ns, side)
micros = tentacleMicro(ns, side)
i = 0
j = 0
for macro in macros:
if i != 3:
# macroN = tentacleMacroCt(macro)
# cmds.parent(macroN, g)
microN = tentacleMicroCt(micros[j], macro)
cmds.parent(microN, g)
if i != 3:
macroFake = tentacleCt(parents=[macros[i], macros[i + 1]], j=j, ns=ns, side=side)
cmds.parent(macroFake, g)
i = i + 1
j = j + 3
# clean up
if len(sel) == 2:
cmds.parentConstraint(sel[1], g)
p = plc.assetParent(sel[0])
cmds.parent(g, p)
else:
message('Select an object or 2')
def rigBlendControl(self, _parent):
# Move and parent blend control
rc.orientControl(self.m_blendControl, _parent)
group = rg.addGroup(self.m_blendControl, "%s_0" %(self.m_blendControl))
moveValue = -2
if self.m_isMirrored:
moveValue *= -1
cmds.setAttr("%s.t%s" %(self.m_blendControl, self.m_twistAxis), moveValue)
cmds.parentConstraint(_parent, group, mo=1)
rc.lockAttrs(
self.m_blendControl,
[
"tx",
"ty",
"tz",
"rx",
"ry",
"rz",
"sx",
"sy",
"sz",
"visibility"
],
True,
True
)
def AddSpaceObject(self, ControlObject, SpaceObject, SpaceSwitchName = "spaceSwitch"):
SpaceSwDic = self.GetSpaceSwitchDic( ControlObject, SpaceSwitchName = SpaceSwitchName)
EnumDic = self.AddEnumParameters([self.NameConv.RMGetAShortName(SpaceObject)],ControlObject)
Switch = cmds.shadingNode('condition', asUtility=True, name = SpaceSwitchName + "SWCondition")
cmds.connectAttr(ControlObject + "." + SpaceSwitchName, Switch + ".firstTerm")
cmds.setAttr (Switch +".secondTerm", EnumDic[self.NameConv.RMGetAShortName(SpaceObject)])
cmds.setAttr (Switch +".operation", 0)
cmds.setAttr (Switch +".colorIfTrueR", 1)
cmds.setAttr (Switch +".colorIfFalseR", 0)
if self.NameConv.RMIsNameInFormat(ControlObject):
Switch = self.NameConv.RMRenameBasedOnBaseName(ControlObject, Switch, NewName = Switch)
else:
Switch = self.NameConv.RMRenameNameInFormat(Switch)
for eachConstraint in SpaceSwDic['constraints']:
Object = SpaceSwDic['constraints'][eachConstraint]['object']
parentConstraint = cmds.parentConstraint (SpaceObject, Object, mo = True)
WA = cmds.parentConstraint (parentConstraint, q = True, weightAliasList = True)
TL = cmds.parentConstraint (parentConstraint, q = True, targetList = True)
if SpaceObject in TL:
cmds.connectAttr (Switch + ".outColorR", parentConstraint[0] + "." + WA[TL.index(SpaceObject)])
else:
print "Error, cant find spaceobject in constraint targetList"
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 RMCreateTwist(self, TwistJoint, LookAtObject, NumberOfTB = 3, LookAtAxis = "Y"):
#LookAtObject = cmds.listRelatives( TwistJoint,type = "transform",children=True)[]
positionA = cmds.xform(TwistJoint ,q=True,ws=True,rp=True)
positionB = cmds.xform(LookAtObject ,q=True,ws=True,rp=True)
vectorA = om.MVector(positionA)
vectorB = om.MVector(positionB)
self.RMCreateBonesBetweenPoints(vectorA,vectorB,NumberOfTB, AlignObject = TwistJoint)
Distance = RMRigTools.RMPointDistance( TwistJoint, LookAtObject)
cmds.parentConstraint (TwistJoint,self.TwistResetJoints)
resetPoint , control = RMRigShapeControls.RMCreateBoxCtrl(self.TwistJoints[0], Xratio = .1, Yratio = .1, Zratio = .1, customSize = Distance/5 ,name = "TwistOrigin" + self.NameConv.RMGetAShortName (TwistJoint).title())
#control = self.NameConv.RMRenameBasedOnBaseName(TwistJoint , control, NewName = self.NameConv.RMGetAShortName(control))
#resetPoint = self.NameConv.RMRenameBasedOnBaseName(TwistJoint , resetPoint, NewName = self.NameConv.RMGetAShortName(resetPoint))
sign = 1
MoveDistance = Distance/5
if "-" in LookAtAxis:
sign = -1
if "Z" in LookAtAxis or "z" in LookAtAxis:
MoveList = [0,0, MoveDistance * sign]
WUV = [0,0,sign]
elif "Y" in LookAtAxis or "y" in LookAtAxis:
MoveList = [0,MoveDistance * sign,0 ]
WUV = [0,sign,0]
cmds.xform( resetPoint, os = True, relative=True, t = MoveList)
cmds.aimConstraint( LookAtObject,self.TwistJoints[0], aim = [1,0,0], worldUpVector = [0,0,1], worldUpType = "object", worldUpObject = control)
TwistJointDivide = cmds.shadingNode( "multiplyDivide", asUtility = True, name = "TwistJoint" + self.NameConv.RMGetAShortName( TwistJoint).title())
TwistJointDivide = self.NameConv.RMRenameBasedOnBaseName( TwistJoint , TwistJointDivide, NewName = self.NameConv.RMGetAShortName( TwistJointDivide))
TwistAddition = cmds.shadingNode( "plusMinusAverage", asUtility = True, name = "TwistJointAdd" + self.NameConv.RMGetAShortName( TwistJoint).title())
TwistAddition = self.NameConv.RMRenameBasedOnBaseName( TwistJoint , TwistAddition, NewName = self.NameConv.RMGetAShortName( TwistAddition))
NegativeLookAtRotation = cmds.shadingNode( "multiplyDivide", asUtility = True, name = "NegativeLookAtRotation" + self.NameConv.RMGetAShortName( TwistJoint).title())
NegativeLookAtRotation = self.NameConv.RMRenameBasedOnBaseName( TwistJoint , NegativeLookAtRotation, NewName = self.NameConv.RMGetAShortName( NegativeLookAtRotation))
cmds.connectAttr( LookAtObject + ".rotateX", NegativeLookAtRotation + ".input1X")
cmds.setAttr(NegativeLookAtRotation + ".input2X", -1 )
cmds.setAttr(NegativeLookAtRotation + ".operation", 1 )
cmds.connectAttr(self.TwistJoints[0]+".rotateX", TwistAddition + ".input1D[0]")
cmds.connectAttr( NegativeLookAtRotation + ".outputX", TwistAddition + ".input1D[1]")
cmds.connectAttr(TwistAddition + ".output1D", TwistJointDivide + ".input1X")
#cmds.connectAttr(self.TwistJoints[0]+".rotateX", TwistJointDivide + ".input1X") in this case the rotation of the lookatNode was not affecting
cmds.setAttr(TwistJointDivide + ".input2X", -(len(self.TwistJoints) - 1))
cmds.setAttr(TwistJointDivide + ".operation", 2 )
for eachJoint in self.TwistJoints[1:]:
cmds.connectAttr(TwistJointDivide+".outputX", eachJoint + ".rotateX")
self.TwistControlResetPoint = resetPoint
self.TwistControl = control
def closestPointOnModel(self , modelShape , obj):
closest_Point = []
modelShapeType = self.getObjType(modelShape)
temp = mc.createNode('transform',name=obj+'_point_temp')
mc.parentConstraint(obj,temp,mo = False)
#model type data
if modelShapeType == 'kNurbsSurface':
closest_Point = ['closestPointOnSurface' , temp+'_cpos' , 'local' , 'inputSurface']
elif modelShapeType == 'kMesh':
closest_Point = ['closestPointOnMesh' , temp+'_cpom' , 'outMesh' , 'inMesh']
#create getUV Node
closest_PointNode = mc.createNode( closest_Point[0] , name = closest_Point[1] )
mc.connectAttr( temp+'.translate' , closest_PointNode+'.inPosition' )
mc.connectAttr( modelShape + '.' + closest_Point[2] , closest_PointNode +'.' + closest_Point[3] )
#get UV
U = mc.getAttr(closest_PointNode + '.result.parameterU')
V = mc.getAttr(closest_PointNode + '.result.parameterV')
mc.delete(closest_PointNode,temp)
return {'u':U , 'v':V}
def create_ik_setup(self):
"""Creates the IK setup."""
ik = cmds.ikHandle(sj=self.result_jnts[0], ee=self.result_jnts[-1], sol='ikSplineSolver', ns=1)
cmds.rename(ik[1], '%s_%s_%s' % (self.side, 'neck', self.nc.effector))
curve = cmds.rename(ik[2], '%s_%s_%s' % (self.side, 'neck', self.nc.curve))
cmds.setAttr('%s.inheritsTransform' % curve, 0)
ik = cmds.rename(ik[0], '%s_%s_%s' % (self.side, 'neck', self.nc.ikhandle))
cmds.select(self.additional_jnts, curve)
cmds.skinCluster(tsb=True)
cmds.parent(ik, self.top_grp)
cmds.setAttr('%s.dTwistControlEnable' % ik, 1)
cmds.setAttr('%s.dWorldUpType' % ik, 4)
cmds.setAttr('%s.dWorldUpAxis' % ik, 4)
cmds.setAttr('%s.dWorldUpVectorY' % ik, -1)
cmds.setAttr('%s.dWorldUpVectorEndY' % ik, 1)
cmds.setAttr('%s.dWorldUpVectorEndZ' % ik, -1)
cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[0], '%s.dWorldUpMatrix' % ik, f=True)
cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[1], '%s.dWorldUpMatrixEnd' % ik, f=True)
self.head_grp = cmds.group(self.controls['head'])
self.head_grp = cmds.rename(self.head_grp, '%s_head_CTL_%s' % (self.side, self.nc.group))
cmds.parent(self.head_grp, self.top_grp)
self.c.move_pivot_to(self.guides['neckEnd'][0], self.guides['neckEnd'][1], self.guides['neckEnd'][2], self.head_grp)
cmds.parentConstraint(self.controls['head'], self.additional_jnts[-1], mo=True, weight=1)
cmds.orientConstraint(self.controls['head_rot'], self.result_jnts[-1], mo=True, weight=1)
def createArmSwitches(pairs, instance):
parents = []
enumvals = []
connodes = []
for p in range(len(pairs)):
parents.append(pairs[p][0])
con = cmds.shadingNode("condition", asUtility=True, n=instance + pairs[p][0] + 'Switch_CON')
connodes.append(con)
cmds.setAttr(con+'.secondTerm', p)
enumvals.append(pairs[p][2])
ctrlparent = cmds.listRelatives(pairs[0][1], p=True)[0]
switchgrpname = pairs[0][1].replace('_GRP', '_SWITCH' )
sgrp = cmds.group(n=switchgrpname, em=True)
tc = cmds.parentConstraint(pairs[0][1], sgrp, mo=False)
cmds.delete(tc)
cmds.parent(sgrp, ctrlparent)
cmds.parent(pairs[0][1], sgrp)
parentcon = cmds.parentConstraint(parents[0], parents[1], parents[2], parents[3], parents[4], sgrp, mo=True)
cmds.addAttr(pairs[p][2], at='enum', en="World:Root:COG:Pelvis:Chest:", shortName="switch", longName="switch", k=True)
for c in range(len(connodes)):
cmds.setAttr(connodes[c]+'.colorIfTrueR', 1)
cmds.setAttr(connodes[c]+'.colorIfTrueG', 1)
cmds.setAttr(connodes[c]+'.colorIfTrueB', 1)
cmds.setAttr(connodes[c]+'.colorIfFalseR', 0)
cmds.setAttr(connodes[c]+'.colorIfFalseG', 0)
cmds.setAttr(connodes[c]+'.colorIfFalseB', 0)
cmds.connectAttr(pairs[0][2]+'.switch', connodes[c]+'.firstTerm')
cmds.connectAttr(connodes[c]+'.outColorR', parentcon[0] + '.' + pairs[c][0] + 'W' + str(c))
def CreateFingerSquareRig(self,Finger): if self.NameConv.RMGetFromName(Finger[0],"Side")=="LF": sideVariation = 1 else: sideVariation = -1 BoxResetPoint , BoxControl = RMRigShapeControls.RMCreateBoxCtrl(Finger[len(Finger)-1], ParentBaseSize = True, Xratio = .5 ,Yratio = .5 ,Zratio = .5) self.RMaddFinguerControls(BoxControl) cmds.makeIdentity(BoxControl, apply = True , r = False, t = True, s = True, n = 0) cmds.parentConstraint(Finger[len(Finger)-1],BoxResetPoint) RMRigTools.RMLockAndHideAttributes(BoxControl,"0000000000") RMRigTools.RMConnectWithLimits (BoxControl + ".MidUD", Finger[0] + ".rotateY", [[-10,100],[0,0],[10,-100]]) RMRigTools.RMConnectWithLimits (BoxControl + ".MidLR", Finger[0] + ".rotateZ", [[-10,sideVariation * 120],[0,0],[10,sideVariation * -127]]) RMRigTools.RMConnectWithLimits (BoxControl + ".MidTwist", Finger[0] + ".rotateX" ,[[-10,sideVariation * 90],[0,0],[10,sideVariation * -90]]) index = 1 for eachjoint in range(0,len(Finger)-1): RMRigTools.RMConnectWithLimits (BoxControl + ".UD" + str(index), Finger[eachjoint] + ".rotateY", [[-10,100],[0,0],[10,-100]]) RMRigTools.RMConnectWithLimits (BoxControl + ".LR" + str(index), Finger[eachjoint] + ".rotateZ", [[-10,sideVariation * 120],[0,0],[10,sideVariation * -127]]) RMRigTools.RMConnectWithLimits (BoxControl + ".Twist" + str(index), Finger[eachjoint] + ".rotateX" ,[[-10, sideVariation * 90],[0,0],[10, sideVariation * -90]]) index += 1 self.fingerControlsReset.append(BoxResetPoint) self.fingerContols.append(BoxControl)
def spaceSwitchSetup(targets, contained):
contained_grp = utility.getPrt(contained)
if not contained_grp or utility.getShapes(contained_grp):
contained_grp = groupIt([contained])[0]
select_list = []
# check if it already parentconstrainted
constraint = cmds.listConnections(
"%s.translateX" % contained_grp, d=0, s=1)
oldLoc = ''
loc_name = contained.split("|")[-1].split(":")[-1] + '_loc'
if constraint:
constraint = constraint[0]
loc_weight_name = cmds.listAttr(constraint, st=loc_name+"*", ud=1)
print(loc_name)
print(loc_weight_name)
if loc_weight_name:
target_name = cmds.listConnections(
constraint+'.'+loc_weight_name[0], d=1, s=0, p=1)[0]
target_name = target_name.replace(
'targetWeight', 'targetTranslate')
oldLoc = cmds.listConnections(target_name, d=0, s=1)[0]
if not oldLoc:
loc = cmds.spaceLocator(name=loc_name)[0]
cmds.matchTransform(loc, contained_grp)
contained_grp_prt = utility.getPrt(contained_grp)
if contained_grp_prt:
loc = cmds.parent(loc, contained_grp_prt)[0]
cmds.setAttr("%s.v"%loc, 0)
utility.fixedObj([loc])
oldLoc = loc
print(oldLoc)
select_list.append(oldLoc)
loc_name = oldLoc.split("|")[-1].split(":")[-1]
print(loc_name)
for target in targets:
select_list.append(target)
select_list.append(contained_grp)
cmds.select(cl=1)
for obj in select_list:
cmds.select(obj, add=1)
constraint = cmds.parentConstraint(mo=1)[0]
target_list = cmds.listAttr(constraint, st="*W*", ud=1)
print(target_list)
# edit enum
enumName = ''
parentInx = 0
for inx, target in enumerate(target_list):
if loc_name == target[0:-2]:
parentInx = inx
enumName = enumName + ":origin"
else:
enumName = enumName + ":" + target[0:-2]
enumName = enumName[1:]
if cmds.attributeQuery('follow', node=contained, ex=1):
# edit
cmds.addAttr("%s.follow" % contained, k=1, e=1,
ln="follow", at="enum", en=enumName)
else:
# create
cmds.addAttr(contained, k=1, ln="follow", at="enum", en=enumName)
# set to parent as defualt
cmds.setAttr("%s.follow" % contained, parentInx)
condition_nodes = cmds.listConnections("%s.follow" % contained, d=1, s=0)
# print(condition_nodes)
if condition_nodes:
for nodes in condition_nodes:
cmds.delete(nodes)
# connect node
for inx, target in enumerate(target_list):
condition_node = cmds.shadingNode("condition", au=1)
cmds.connectAttr("%s.follow" % contained,
"%s.firstTerm" % condition_node, f=1)
weight_name = constraint+"."+target
cmds.connectAttr("%s.outColorR" % condition_node, weight_name, f=1)
cmds.setAttr("%s.secondTerm" % condition_node, inx)
cmds.setAttr("%s.operation" % condition_node, 1)
cmds.select(contained)
def addParentConstraint(parentLs, childLs):
if len(parentLs) != len(childLs):
print "number of parents is not equal to number of children"
return None
for i in xrange(len(parentLs)):
cmds.parentConstraint(parentLs[i], childLs[i], maintainOffset=True)
def makeHeadStreatch(jointCount=5):
# -> testing guide
if not getHeadStreatchGuide(): return
# -> make curve
attachCurve = makeAttachCurve()
upVectorCurve = mc.duplicate(attachCurve)[0]
baseDistanceCurve = mc.duplicate(attachCurve)[0]
# -> move up vector curve
mc.move(mc.arclen(upVectorCurve, ch=False) / 18,
0,
0,
upVectorCurve,
r=True)
# -> make joints
Joints, upLocators = makeAttachJoints(attachCurve, upVectorCurve,
jointCount)
moreWeghtJnt = mc.createNode('joint')
mc.delete(mc.parentConstraint(Joints[0], moreWeghtJnt))
mc.setAttr('%s.radius' % moreWeghtJnt, 1.5)
# -> make bend Joints
BendJoints = []
for i, jnt in enumerate(Joints):
BendJoints.append(mc.createNode('joint'))
mc.delete(mc.parentConstraint(jnt, BendJoints[i]))
mc.makeIdentity(BendJoints[i], t=True, r=True, s=True, apply=True)
if i > 0:
mc.parent(BendJoints[i], BendJoints[i - 1])
# -> make streatch
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
distanceValueNode = mc.arclen(attachCurve, ch=True)
baseValueNode = mc.arclen(baseDistanceCurve, ch=True)
divdeNode = mc.createNode('multiplyDivide')
for attr in ('input2X', 'input1Y', 'input2Z'):
mc.connectAttr('%s.arcLength' % distanceValueNode,
'%s.%s' % (divdeNode, attr))
for attr in ('input1X', 'input2Y', 'input1Z'):
mc.connectAttr('%s.arcLength' % baseValueNode,
'%s.%s' % (divdeNode, attr))
mc.setAttr('%s.operation' % divdeNode, 2)
for jnt in Joints:
for attr in 'XYZ':
mc.connectAttr('%s.output%s' % (divdeNode, attr),
'%s.scale%s' % (jnt, attr))
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
DisStartLocator = mc.spaceLocator(p=(0, 0, 0))[0]
DisEndLocator = mc.spaceLocator(p=(0, 0, 0))[0]
DistanceNode = mc.createNode('distanceBetween')
DisDivideNode = mc.createNode('multiplyDivide')
mc.delete(mc.parentConstraint(BendJoints[0], DisStartLocator))
mc.delete(mc.parentConstraint(BendJoints[-1], DisEndLocator))
mc.connectAttr(
'%s.worldPosition[0]' %
mc.listRelatives(DisStartLocator, s=True, path=True)[0],
'%s.point1' % DistanceNode)
mc.connectAttr(
'%s.worldPosition[0]' %
mc.listRelatives(DisEndLocator, s=True, path=True)[0],
'%s.point2' % DistanceNode)
mc.connectAttr('%s.distance' % DistanceNode, '%s.input1Y' % DisDivideNode)
mc.setAttr('%s.input2Y' % DisDivideNode,
mc.getAttr('%s.input1Y' % DisDivideNode))
mc.setAttr('%s.operation' % DisDivideNode, 2)
for jnt in BendJoints:
mc.connectAttr('%s.outputY' % DisDivideNode, '%s.sy' % jnt)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
# -> Rig
# - bend joints -
#BendIKHandle = mc.ikHandle(sj=BendJoints[0], ee=BendJoints[1])
VectorLoc = mc.spaceLocator(p=(0, 0, 0))[0]
mc.delete(mc.parentConstraint(Joints[0], VectorLoc))
mc.move(mc.arclen(upVectorCurve, ch=False) / 18, 0, 0, VectorLoc, r=True)
for i, jnt in enumerate(BendJoints):
if i > 0:
mc.connectAttr('%s.rotate' % BendJoints[0], '%s.rotate' % jnt)
# - skin bind Curve -
mc.skinCluster(BendJoints, attachCurve)
mc.skinCluster(BendJoints, upVectorCurve)
# - make Cotrol -
localStartControl = mc.circle(nr=(0, 1, 0), ch=False)[0]
localEndControl = mc.circle(nr=(0, 1, 0), ch=False)[0]
localStartControlGrp = mc.group(localStartControl)
localEndControlGrp = mc.group(localEndControl)
startControl = mc.circle(nr=(0, 1, 0), ch=False)[0]
endControl = mc.circle(nr=(0, 1, 0), ch=False)[0]
startControlGrp = mc.group(startControl)
endControlGrp = mc.group(endControl)
# - match position -
mc.delete(mc.parentConstraint(Joints[0], localStartControlGrp))
mc.delete(mc.parentConstraint(Joints[-1], localEndControlGrp))
mc.delete(mc.parentConstraint(Joints[0], startControlGrp))
mc.delete(mc.parentConstraint(Joints[-1], endControlGrp))
# - add Attribute -
mc.addAttr(endControl, ln='range', min=0, max=3, dv=1)
mc.setAttr('%s.range' % endControl, k=False, cb=True)
# - connect -
for i, attr in enumerate(
('tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v')):
mc.connectAttr('%s.%s' % (startControl, attr),
'%s.%s' % (localStartControl, attr))
if i < 3:
multiNode = mc.createNode('multDoubleLinear')
mc.connectAttr('%s.%s' % (endControl, attr),
'%s.input1' % multiNode)
mc.connectAttr('%s.range' % endControl, '%s.input2' % multiNode)
mc.connectAttr('%s.output' % multiNode,
'%s.%s' % (localEndControl, attr))
else:
mc.connectAttr('%s.%s' % (endControl, attr),
'%s.%s' % (localEndControl, attr))
if i > 2:
mc.setAttr('%s.%s' % (startControl, attr), l=True, k=False)
mc.setAttr('%s.%s' % (endControl, attr), l=True, k=False)
# - constraint -
mc.pointConstraint(localStartControl, BendJoints[0])
mc.aimConstraint(localEndControl,
BendJoints[0],
aim=(0, 1, 0),
wu=(1, 0, 0),
wuo=VectorLoc,
wut='object')
# -> Compile
JointGrp = mc.group(Joints, moreWeghtJnt)
LocatorGrp = mc.group(upLocators)
CurveGrp = mc.group(attachCurve, upVectorCurve, baseDistanceCurve)
BendJointGrp = mc.group(BendJoints[0])
controlGrp = mc.group(startControlGrp, endControlGrp)
localControlGrp = mc.group(localStartControlGrp, localEndControlGrp)
setGrp = mc.group(JointGrp, BendJointGrp, LocatorGrp, CurveGrp)
rootGrp = mc.group(controlGrp, localControlGrp, setGrp)
mc.parent(DisStartLocator, localStartControl)
mc.parent(DisEndLocator, localEndControl)
mc.parent(VectorLoc, localStartControl)
# -> rename
# - bend set -
DisStartLocator = mc.rename(DisStartLocator, 'C_HSbendDisStart_loc_0')
DisEndLocator = mc.rename(DisEndLocator, 'C_HSbendDisEnd_loc_0')
for i, jnt in enumerate(BendJoints):
BendJoints[i] = mc.rename(jnt,
'C_HSbend%s_jnt_0' % string.uppercase[i])
BendJointGrp = mc.rename(BendJointGrp, 'C_HSbendJoint_jnh_0')
VectorLoc = mc.rename(VectorLoc, 'C_HSBendVector_loc_0')
# - joint -
for i, jnt in enumerate(Joints):
Joints[i] = mc.rename(jnt,
'C_headStreatch%s_bnd_0' % string.uppercase[i])
moreWeghtJnt = mc.rename(moreWeghtJnt, 'C_headStreatch_bnd_0')
JointGrp = mc.rename(JointGrp, 'C_headStreatch_bndG_0')
# - locator -
for i, loc in enumerate(upLocators):
upLocators[i] = mc.rename(
loc, 'C_headStreatchUp%s_loc_0' % string.uppercase[i])
mc.rename(LocatorGrp, 'C_headStreatch_locG_0')
# - control -
startControl = mc.rename(startControl, 'C_HSstart_ctl_0')
endControl = mc.rename(endControl, 'C_HSend_ctl_0')
startControlGrp = mc.rename(startControlGrp, 'C_HSstart_cth_0')
endControlGrp = mc.rename(endControlGrp, 'C_HSend_cth_0')
localStartControl = mc.rename(localStartControl, 'C_HSstartLocal_ctl_0')
localEndControl = mc.rename(localEndControl, 'C_HSendLocal_ctl_0')
localStartControlGrp = mc.rename(localStartControlGrp,
'C_HSstartLocal_cth_0')
localEndControlGrp = mc.rename(localEndControlGrp, 'C_HSendLocal_cth_0')
controlGrp = mc.rename(controlGrp, 'C_headStreatch_cth_0')
localControlGrp = mc.rename(localControlGrp, 'C_headStreatchLocal_cth_0')
# - curve -
attachCurve = mc.rename(attachCurve, 'C_HSJointAttach_cus_0')
upVectorCurve = mc.rename(upVectorCurve, 'C_HSLocatorAttach_cus_0')
baseDistanceCurve = mc.rename(baseDistanceCurve, 'C_HSDistance_cus_0')
mc.rename(CurveGrp, 'C_HeadStreatch_cusgrp_0')
# - comp group -
mc.rename(setGrp, 'C_headStreatch_setg_0')
mc.rename(rootGrp, 'C_headStreatch_grp_0')
# -> clean up
mc.hide(upLocators)
mc.hide(upVectorCurve, baseDistanceCurve)
mc.hide(localControlGrp)
mc.hide(BendJointGrp)
mc.setAttr('%s.template' % attachCurve, 1)
# -> create selection sets
mc.sets(Joints, moreWeghtJnt, name='C_HSJoint_set_0')
mc.sets(startControl, endControl, name='C_HSControl_set_0')
# Grab all joints from selection
selected_joints = cmds.ls(selection=True, type='joint')
# For every joint that doesn't contain "end" or "eye", do something
for jnt in selected_joints:
if 'end' in jnt or 'eye' in jnt:
pass
else:
#Create Ctrl in the same way we did before
joint_name = jnt[:-3]
ctrl = cmds.circle(name=joint_name + 'ctrl',
normal=[1, 0, 0],
radius=1.5,
ch=False)
grp = cmds.group(name=(ctrl[0] + 'grp'))
constraint = cmds.parentConstraint(jnt, grp)
cmds.delete(constraint)
cmds.parentConstraint(ctrl[0], jnt)
#Auto parents new controls
# "or []" Accounts for root joint that doesn't have a parent, it forces it to be a list instead of "NoneType"
jnt_parent = cmds.listRelatives(jnt, allParents=True) or []
if len(jnt_parent) == 0:
pass
else:
parent_ctrl = (jnt_parent[0][:-3] + 'ctrl')
print(parent_ctrl)
if cmds.objExists(parent_ctrl):
cmds.parent(grp, parent_ctrl)
def upperArmTwist(color, rollGrpParent, fkArmJoint, ikArmJoint, suffix, name,
prefix, upperArm, lowerArm):
print "START Building the " + suffix + " UPPER arm twists---------------------------------------"
#create a nice name
name = prefix + name + suffix
if name.find("_") == 0:
name = name.partition("_")[2]
# define the joints for this rig.
upperarm = prefix + upperArm + suffix
lowerarm = prefix + lowerArm + suffix
driver_clavicle = "driver_" + prefix + "clavicle" + suffix
driver_upperarm = "driver_deltoid_" + prefix + upperArm + suffix
driver_lowerarm = "driver_" + prefix + lowerArm + suffix
numRolls = 0
for joint in [
"_twist_01", "_twist_02", "_twist_03", "_twist_04",
"_twist_05", "_twist_06"
]:
if cmds.objExists("driver_" + prefix + upperArm + joint + suffix):
numRolls = numRolls + 1
print "...There are a total of " + str(numRolls) + " to build."
for i in range(int(numRolls)):
print "...Building upper arm twist_0" + str(i + 1)
driver_upperarm_twist = "driver_" + prefix + upperArm + "_twist_0" + str(
i + 1) + suffix
rollGrp = cmds.group(empty=True,
name=upperarm + "_roll_grp_0" + str(i + 1))
cmds.parent(rollGrp, "arm_sys_grp")
# Move the driver_upperarm_twist joint to its correct position between the driver_upperarm and its driver_lowerarm using a point constraint.
const = cmds.parentConstraint(driver_upperarm,
driver_upperarm_twist,
n=driver_upperarm +
"_temp_parentConst",
weight=1)
cmds.delete(const)
const = cmds.pointConstraint(driver_upperarm,
driver_lowerarm,
driver_upperarm_twist,
n=driver_upperarm +
"_temp_PointConst",
weight=1)
cmds.delete(const)
# Duplicate the driver_upperarm, driver_lowerarm, and driver_upperarm_twist joints
blendJnts = []
blend_driver_upperarmParent = cmds.duplicate(
driver_upperarm,
n="Blend_" + driver_upperarm + "_parent_ignore_0" + str(i + 1),
ic=True,
po=True)[0]
blendJnts.append(blend_driver_upperarmParent)
blend_driver_lowerarm = cmds.duplicate(
driver_lowerarm,
n="Blend_" + driver_lowerarm + "_ignore_0" + str(i + 1),
ic=True,
po=True)[0]
blendJnts.append(blend_driver_lowerarm)
blend_driver_upperarm = cmds.duplicate(
driver_upperarm,
n="Blend_" + driver_upperarm + "_ignore_0" + str(i + 1),
po=True)[0]
blendJnts.append(blend_driver_upperarm)
blend_driver_upperarm_twist = cmds.duplicate(
driver_upperarm_twist,
n="Blend_" + driver_upperarm_twist + "_ignore_0" + str(i + 1),
ic=True,
po=True)[0]
blendJnts.append(blend_driver_upperarm_twist)
cmds.parent(blend_driver_lowerarm, blend_driver_upperarm_twist,
blend_driver_upperarmParent)
cmds.parent(blend_driver_upperarm, blend_driver_upperarm_twist)
# Set the parent bone to have zyx rotation order
cmds.setAttr(blend_driver_upperarmParent + ".rotateOrder", 2)
originalJnts = [driver_upperarm, driver_lowerarm]
#print originalJnts
# Now we are going to disconnect the constraints that were driving the original driver_upperarm
# and driver_lowerarm joints and re-connect them to the parent_ignore and ignore joints that were duped from them.
# This is so that we can create new constraints on the driver_upperarm and driver_lowerarm joints for the rig.
j = 0
a = 0
#while a < len(originalJnts):
for a in range(0, len(originalJnts)):
# Go through the inputs of the original joints and disconnect them
origConn = cmds.listConnections(originalJnts[a],
d=False,
c=+ True,
p=True)
for j in range(0, len(origConn), 2):
cmds.disconnectAttr(origConn[j + 1], origConn[j])
nameList = origConn[j + 1].split(".")[0]
destConn = cmds.listConnections(nameList, s=False)
# Find out if the node that was an input to the original joint is also an output
if originalJnts[a] in destConn:
sourceConn = cmds.listConnections(nameList,
d=False,
c=True,
p=True)
for k in range(0, len(sourceConn), 2):
# Get the input connections to the node that are connected to the original joint
nameConnList = sourceConn[k + 1].split(".")
if (nameConnList[0] == originalJnts[a]):
# Disconnect from the original joint and connect to the blend joint
cmds.disconnectAttr(sourceConn[k + 1],
sourceConn[k])
nameConnList[0] = blendJnts[a]
cmds.connectAttr(
nameConnList[0] + "." + nameConnList[-1],
sourceConn[k])
# create the manual twist control
if i == 0:
twistCtrl = utils.createControl("circle", 15,
upperarm + "_twist_anim")
else:
twistCtrl = utils.createControl(
"circle", 15, upperarm + "_twist" + str(i + 1) + "_anim")
cmds.setAttr(twistCtrl + ".ry", -90)
cmds.setAttr(twistCtrl + ".sx", 0.8)
cmds.setAttr(twistCtrl + ".sy", 0.8)
cmds.setAttr(twistCtrl + ".sz", 0.8)
cmds.makeIdentity(twistCtrl, r=1, s=1, apply=True)
# move the manual control to the correct location
constraint = cmds.parentConstraint(blend_driver_upperarm_twist,
twistCtrl)[0]
cmds.delete(constraint)
# create a group for the manual control and parent the twist to it.
twistCtrlGrp = cmds.group(empty=True, name=twistCtrl + "_grp")
constraint = cmds.parentConstraint(blend_driver_upperarm_twist,
twistCtrlGrp)[0]
cmds.delete(constraint)
cmds.parent(twistCtrl, twistCtrlGrp)
cmds.parent(twistCtrlGrp, rollGrp)
cmds.makeIdentity(twistCtrl, t=1, r=1, s=1, apply=True)
cmds.parentConstraint(blend_driver_upperarm_twist, twistCtrlGrp)
# set the manual controls visibility settings
cmds.setAttr(twistCtrl + ".overrideEnabled", 1)
cmds.setAttr(twistCtrl + ".overrideColor", color)
for attr in [".sx", ".sy", ".sz"]:
cmds.setAttr(twistCtrl + attr, lock=True, keyable=False)
cmds.setAttr(twistCtrl + ".v", keyable=False)
# add attr on rig settings for manual twist control visibility
cmds.select("Rig_Settings")
if i == 0:
cmds.addAttr(longName=(name + "twistCtrlVisUpper"),
at='bool',
dv=0,
keyable=True)
cmds.connectAttr("Rig_Settings." + name + "twistCtrlVisUpper",
twistCtrl + ".v")
# add attr to rig settings for the twist ammount values
cmds.select("Rig_Settings")
cmds.addAttr(longName=(name + "UpperarmTwist" + str(i + 1) +
"Amount"),
defaultValue=0.5,
minValue=0,
maxValue=1,
keyable=True)
for u in range(int(i + 1)):
cmds.setAttr(
"Rig_Settings." + name + "UpperarmTwist" + str(u + 1) +
"Amount", (1.0 / (i + 2.0) * ((2.0 - u) + (i - 1.0))))
cmds.parent(blend_driver_upperarmParent, rollGrp)
# Constrain the original joints to the blend joints
cmds.orientConstraint(blend_driver_upperarm,
driver_upperarm,
n=driver_upperarm + "_0" + str(i + 1) +
"_OrntCnst",
mo=True,
w=1)
cmds.pointConstraint(blend_driver_upperarm,
driver_upperarm,
n=driver_upperarm + "_0" + str(i + 1) +
"_PtCnst",
mo=True,
w=1)
cmds.orientConstraint(blend_driver_lowerarm,
driver_lowerarm,
n=driver_lowerarm + "_0" + str(i + 1) +
"_OrntCnst",
mo=True,
w=1)
cmds.pointConstraint(blend_driver_lowerarm,
driver_lowerarm,
n=driver_lowerarm + "_0" + str(i + 1) +
"_PtCnst",
mo=True,
w=1)
cmds.orientConstraint(twistCtrl,
driver_upperarm_twist,
n=driver_upperarm_twist + "_0" + str(i + 1) +
"_OrntCnst",
mo=True,
w=1)
cmds.pointConstraint(twistCtrl,
driver_upperarm_twist,
n=driver_upperarm_twist + "_0" + str(i + 1) +
"_PtCnst",
mo=True,
w=1)
# Create a driver_upperarm_twist multiplier to multiply the driver_upperarm_twist values by -.5 to counter rotate the driver_upperarm_twist and driver_upperarm back from the overall limb's driver_upperarm_twist amount.
twistMult = cmds.shadingNode("multiplyDivide",
asUtility=True,
name=blend_driver_upperarm_twist +
"_0" + str(i + 1) + "_MDnode")
twistMultDrive = cmds.shadingNode(
"multiplyDivide",
asUtility=True,
name=blend_driver_upperarm_twist + "_0" + str(i + 1) +
"_Drive_MDnode")
twistMultDriveInv = cmds.shadingNode(
"multiplyDivide",
asUtility=True,
name=blend_driver_upperarm_twist + "_0" + str(i + 1) +
"_DriveInv_MDnode")
twistMultMultiplier = cmds.shadingNode(
"multiplyDivide",
asUtility=True,
name=blend_driver_upperarm_twist + "_0" + str(i + 1) +
"_Multiplier_MDnode")
twistMultMultiplierInv = cmds.shadingNode(
"multiplyDivide",
asUtility=True,
name=blend_driver_upperarm_twist + "_0" + str(i + 1) +
"_MultiplierInv_MDnode")
twistReverse = cmds.shadingNode("reverse",
asUtility=True,
name=blend_driver_upperarm_twist +
"_0" + str(i + 1) + "_REVnode")
cmds.connectAttr(blend_driver_upperarmParent + ".rotateX",
twistMult + ".input1X",
force=True)
cmds.connectAttr(
"Rig_Settings." + name + "UpperarmTwist" + str(i + 1) +
"Amount", twistReverse + ".inputX")
cmds.connectAttr(
"Rig_Settings." + name + "UpperarmTwist" + str(i + 1) +
"Amount", twistMultMultiplierInv + ".input1X")
cmds.connectAttr(twistReverse + ".outputX",
twistMultMultiplier + ".input1X",
force=True)
cmds.connectAttr(twistMult + ".outputX",
twistMultDrive + ".input1X",
force=True)
cmds.connectAttr(twistMultMultiplier + ".outputX",
twistMultDrive + ".input2X",
force=True)
cmds.connectAttr(twistMult + ".outputX",
twistMultDriveInv + ".input1X",
force=True)
cmds.connectAttr(twistMultMultiplierInv + ".outputX",
twistMultDriveInv + ".input2X",
force=True)
cmds.connectAttr(twistMultDrive + ".outputX",
blend_driver_upperarm_twist + ".rotateX",
force=True)
cmds.connectAttr(twistMultDriveInv + ".outputX",
blend_driver_upperarm + ".rotateX",
force=True)
cmds.setAttr(twistMult + ".input2X", -0.5)
cmds.setAttr(twistMult + ".input2X", l=True)
cmds.setAttr(twistMultMultiplier + ".input2X", 2)
cmds.setAttr(twistMultMultiplierInv + ".input2X", 2)
cmds.select(blend_driver_upperarmParent)
cmds.parentConstraint(driver_clavicle, rollGrp, mo=True)
print ".END Building the " + suffix + " UPPER arm twists---------------------------------------"
def Position_Fn(self):
if self.Check_Selection():
cmds.delete(cmds.parentConstraint( adv,Ziva_Rig[i] ))
else:
cmds.warning(u"q")
cmds.headsUpMessage(u"请选择组进行获取")
def connect(self):
# Parent spine module
mc.parentConstraint(self.com_rig['ctrl'],
self.spine_rig['module'].topGrp,
mo=True)
# Parent leg module
mc.parentConstraint('c_pelvis_IK_ctrl',
self.l_leg_rig['base_attach_grp'],
mo=True)
mc.parentConstraint('c_pelvis_IK_ctrl',
self.r_leg_rig['base_attach_grp'],
mo=True)
# Parent arm module
mc.parentConstraint('c_spineEnd_IK_ctrl',
self.l_arm_rig['base_attach_grp'],
mo=True)
mc.parentConstraint('c_spineEnd_IK_ctrl',
self.r_arm_rig['base_attach_grp'],
mo=True)
# Parent hand module
mc.parentConstraint('l_armEnd_result_jnt',
self.l_hand_rig['body_attach_grp'],
mo=True)
mc.parentConstraint('r_armEnd_result_jnt',
self.r_hand_rig['body_attach_grp'],
mo=True)
# Parent neck module
mc.parentConstraint('c_spineEnd_IK_ctrl',
self.neck_rig['base_attach_grp'],
mo=True)
# Parent head module
mc.parentConstraint('c_head_ctrl',
self.head_rig['base_attach_grp'],
mo=True)
def rigModule(self, *args):
Base.StartClass.rigModule(self)
# verify if the guide exists:
if cmds.objExists(self.moduleGrp):
try:
hideJoints = cmds.checkBox('hideJointsCB',
query=True,
value=True)
except:
hideJoints = 1
# create lists to be integrated:
# start as no having mirror:
sideList = [""]
# analisys the mirror module:
self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis")
if self.mirrorAxis != 'off':
# get rigs names:
self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName")
# get first and last letters to use as side initials (prefix):
sideList = [
self.mirrorNames[0] + '_',
self.mirrorNames[len(self.mirrorNames) - 1] + '_'
]
for s, side in enumerate(sideList):
duplicated = cmds.duplicate(
self.moduleGrp,
name=side + self.userGuideName + '_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated,
allDescendents=True)
for item in allGuideList:
cmds.rename(item,
side + self.userGuideName + "_" + item)
self.mirrorGrp = cmds.group(name="Guide_Base_Grp",
empty=True)
cmds.parent(side + self.userGuideName + '_Guide_Base',
self.mirrorGrp,
absolute=True)
# re-rename grp:
cmds.rename(
self.mirrorGrp,
side + self.userGuideName + '_' + self.mirrorGrp)
# do a group mirror with negative scaling:
if s == 1:
for axis in self.mirrorAxis:
cmds.setAttr(
side + self.userGuideName + '_' +
self.mirrorGrp + '.scale' + axis, -1)
# joint labelling:
jointLabelAdd = 1
else: # if not mirror:
duplicated = cmds.duplicate(self.moduleGrp,
name=self.userGuideName +
'_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated,
allDescendents=True)
for item in allGuideList:
cmds.rename(item, self.userGuideName + "_" + item)
self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base',
name="Guide_Base_Grp",
relative=True)
# re-rename grp:
cmds.rename(self.mirrorGrp,
self.userGuideName + '_' + self.mirrorGrp)
# joint labelling:
jointLabelAdd = 0
# store the number of this guide by module type
dpAR_count = utils.findModuleLastNumber(CLASS_NAME,
"dpAR_type") + 1
# run for all sides
for s, side in enumerate(sideList):
# redeclaring variables:
self.base = side + self.userGuideName + "_Guide_Base"
self.cvFootLoc = side + self.userGuideName + "_Guide_Foot"
self.cvRFALoc = side + self.userGuideName + "_Guide_RfA"
self.cvRFBLoc = side + self.userGuideName + "_Guide_RfB"
self.cvRFCLoc = side + self.userGuideName + "_Guide_RfC"
self.cvRFDLoc = side + self.userGuideName + "_Guide_RfD"
self.cvRFELoc = side + self.userGuideName + "_Guide_RfE"
self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd"
# declaring attributes reading from dictionary:
ankleRFAttr = self.langDic[self.langName]['c009_leg_extrem']
middleRFAttr = self.langDic[
self.langName]['c017_RevFoot_middle']
outsideRFAttr = self.langDic[self.langName]['c010_RevFoot_A']
insideRFAttr = self.langDic[self.langName]['c011_RevFoot_B']
heelRFAttr = self.langDic[self.langName]['c012_RevFoot_C']
toeRFAttr = self.langDic[self.langName]['c013_RevFoot_D']
ballRFAttr = self.langDic[self.langName]['c014_RevFoot_E']
footRFAttr = self.langDic[self.langName]['c015_RevFoot_F']
sideRFAttr = self.langDic[self.langName]['c016_RevFoot_G']
rfRoll = self.langDic[
self.langName]['c018_RevFoot_roll'].capitalize()
rfSpin = self.langDic[
self.langName]['c019_RevFoot_spin'].capitalize()
rfTurn = self.langDic[
self.langName]['c020_RevFoot_turn'].capitalize()
rfAngle = self.langDic[
self.langName]['c102_angle'].capitalize()
rfPlant = self.langDic[
self.langName]['c103_plant'].capitalize()
showCtrlsAttr = self.langDic[
self.langName]['c021_showControls']
# creating joints:
cmds.select(clear=True)
self.footJnt = cmds.joint(name=side + self.userGuideName +
"_" + ankleRFAttr.capitalize() +
"_Jnt")
utils.setJointLabel(
self.footJnt, s + jointLabelAdd, 18,
self.userGuideName + "_" + ankleRFAttr.capitalize())
self.middleFootJxt = cmds.joint(
name=side + self.userGuideName + "_" +
middleRFAttr.capitalize() + "_Jxt")
self.endJnt = cmds.joint(name=side + self.userGuideName +
"_JEnd")
cmds.select(clear=True)
self.middleFootJnt = cmds.joint(
name=side + self.userGuideName + "_" +
middleRFAttr.capitalize() + "_Jnt")
utils.setJointLabel(
self.middleFootJnt, s + jointLabelAdd, 18,
self.userGuideName + "_" + middleRFAttr.capitalize())
self.endBJnt = cmds.joint(name=side + self.userGuideName +
"B_JEnd")
cmds.parent(self.middleFootJnt, self.middleFootJxt)
cmds.addAttr(self.footJnt,
longName='dpAR_joint',
attributeType='float',
keyable=False)
cmds.addAttr(self.middleFootJnt,
longName='dpAR_joint',
attributeType='float',
keyable=False)
cmds.select(clear=True)
'''
Deactivate the segment scale compensate on the bone to prevent scaling problem in maya 2016
It will prevent a double scale problem that will come from the upper parent in the rig
'''
if (int(cmds.about(version=True)[:4]) >= 2016):
cmds.setAttr(self.footJnt + ".segmentScaleCompensate", 0)
cmds.setAttr(
self.middleFootJxt + ".segmentScaleCompensate", 0)
cmds.setAttr(
self.middleFootJnt + ".segmentScaleCompensate", 0)
# reverse foot controls:
self.RFACtrl = self.ctrls.cvControl(
"id_018_FootReverse",
side + self.userGuideName + "_" +
outsideRFAttr.capitalize() + "_Ctrl",
r=(self.ctrlRadius * 0.1),
d=self.curveDegree)
self.RFBCtrl = self.ctrls.cvControl(
"id_018_FootReverse",
side + self.userGuideName + "_" +
insideRFAttr.capitalize() + "_Ctrl",
r=(self.ctrlRadius * 0.1),
d=self.curveDegree)
self.RFCCtrl = self.ctrls.cvControl(
"id_018_FootReverse",
side + self.userGuideName + "_" + heelRFAttr.capitalize() +
"_Ctrl",
r=(self.ctrlRadius * 0.1),
d=self.curveDegree,
dir="+Y",
rot=(0, 90, 0))
self.RFDCtrl = self.ctrls.cvControl(
"id_018_FootReverse",
side + self.userGuideName + "_" + toeRFAttr.capitalize() +
"_Ctrl",
r=(self.ctrlRadius * 0.1),
d=self.curveDegree,
dir="+Y",
rot=(0, 90, 0))
self.RFECtrl = self.ctrls.cvControl(
"id_019_FootReverseE",
side + self.userGuideName + "_" + ballRFAttr.capitalize() +
"_Ctrl",
r=(self.ctrlRadius * 0.1),
d=self.curveDegree,
rot=(0, 90, 0))
# reverse foot groups:
self.RFAGrp = cmds.group(self.RFACtrl,
name=self.RFACtrl + "_Grp")
self.RFBGrp = cmds.group(self.RFBCtrl,
name=self.RFBCtrl + "_Grp")
self.RFCGrp = cmds.group(self.RFCCtrl,
name=self.RFCCtrl + "_Grp")
self.RFDGrp = cmds.group(self.RFDCtrl,
name=self.RFDCtrl + "_Grp")
self.RFEGrp = cmds.group(self.RFECtrl,
name=self.RFECtrl + "_Grp")
rfGrpList = [
self.RFAGrp, self.RFBGrp, self.RFCGrp, self.RFDGrp,
self.RFEGrp
]
self.ballRFList.append(self.RFEGrp)
# putting groups in the correct place:
tempToDelA = cmds.parentConstraint(self.cvFootLoc,
self.footJnt,
maintainOffset=False)
tempToDelB = cmds.parentConstraint(self.cvRFELoc,
self.middleFootJxt,
maintainOffset=False)
tempToDelC = cmds.parentConstraint(self.cvEndJoint,
self.endJnt,
maintainOffset=False)
tempToDelD = cmds.parentConstraint(self.cvEndJoint,
self.endBJnt,
maintainOffset=False)
tempToDelE = cmds.parentConstraint(self.cvRFALoc,
self.RFAGrp,
maintainOffset=False)
tempToDelF = cmds.parentConstraint(self.cvRFBLoc,
self.RFBGrp,
maintainOffset=False)
tempToDelG = cmds.parentConstraint(self.cvRFCLoc,
self.RFCGrp,
maintainOffset=False)
tempToDelH = cmds.parentConstraint(self.cvRFDLoc,
self.RFDGrp,
maintainOffset=False)
tempToDelI = cmds.parentConstraint(self.cvRFELoc,
self.RFEGrp,
maintainOffset=False)
cmds.delete(tempToDelA, tempToDelB, tempToDelC, tempToDelD,
tempToDelE, tempToDelF, tempToDelG, tempToDelH,
tempToDelI)
# mounting hierarchy:
cmds.parent(self.RFBGrp, self.RFACtrl)
cmds.parent(self.RFCGrp, self.RFBCtrl)
cmds.parent(self.RFDGrp, self.RFCCtrl)
cmds.parent(self.RFEGrp, self.RFDCtrl)
# reverse foot zero out groups:
self.RFEZero = utils.zeroOut([self.RFEGrp])[0]
self.RFEZeroExtra = utils.zeroOut([self.RFEZero])[0]
self.RFDZero = utils.zeroOut([self.RFDGrp])[0]
self.RFCZero = utils.zeroOut([self.RFCGrp])[0]
self.RFBZero = utils.zeroOut([self.RFBGrp])[0]
self.RFAZero = utils.zeroOut([self.RFAGrp])[0]
self.RFAZeroExtra = utils.zeroOut([self.RFAZero])[0]
rfJointZeroList = [
self.RFAZero, self.RFBZero, self.RFCZero, self.RFDZero,
self.RFEZero
]
# fixing side rool rotation order:
cmds.setAttr(self.RFBZero + ".rotateOrder", 5)
# creating ikHandles:
ikHandleAnkleList = cmds.ikHandle(
name=side + self.userGuideName + "_" +
ankleRFAttr.capitalize() + "_IkHandle",
startJoint=self.footJnt,
endEffector=self.middleFootJxt,
solver='ikSCsolver')
ikHandleMiddleList = cmds.ikHandle(
name=side + self.userGuideName + "_" +
middleRFAttr.capitalize() + "_IkHandle",
startJoint=self.middleFootJxt,
endEffector=self.endJnt,
solver='ikSCsolver')
cmds.rename(ikHandleAnkleList[1],
ikHandleAnkleList[0] + "_Effector")
cmds.rename(ikHandleMiddleList[1],
ikHandleMiddleList[0] + "_Effector")
cmds.setAttr(ikHandleAnkleList[0] + '.visibility', 0)
cmds.setAttr(ikHandleMiddleList[0] + '.visibility', 0)
# creating Fk controls:
self.footCtrl = self.ctrls.cvControl(
"id_020_FootFk",
side + self.userGuideName + "_" +
self.langDic[self.langName]['c009_leg_extrem'] + "_Ctrl",
r=(self.ctrlRadius * 0.5),
d=self.curveDegree,
dir="+Z")
self.footCtrlList.append(self.footCtrl)
cmds.setAttr(self.footCtrl + ".rotateOrder", 1)
self.revFootCtrlShapeList.append(
cmds.listRelatives(self.footCtrl,
children=True,
type='nurbsCurve')[0])
self.middleFootCtrl = self.ctrls.cvControl(
"id_021_FootMiddle",
side + self.userGuideName + "_" + self.langDic[
self.langName]['c017_RevFoot_middle'].capitalize() +
"_Ctrl",
r=(self.ctrlRadius * 0.5),
d=self.curveDegree)
cmds.setAttr(self.middleFootCtrl + '.overrideEnabled', 1)
cmds.setAttr(self.middleFootCtrl + ".rotateOrder", 4)
tempToDelA = cmds.parentConstraint(self.cvFootLoc,
self.footCtrl,
maintainOffset=False)
tempToDelB = cmds.parentConstraint(self.cvRFELoc,
self.middleFootCtrl,
maintainOffset=False)
cmds.delete(tempToDelA, tempToDelB)
if s == 1:
cmds.setAttr(self.middleFootCtrl + ".scaleX", -1)
cmds.setAttr(self.middleFootCtrl + ".scaleY", -1)
cmds.setAttr(self.middleFootCtrl + ".scaleZ", -1)
self.footCtrlZeroList = utils.zeroOut(
[self.footCtrl, self.middleFootCtrl])
self.middleFootCtrlList.append(self.middleFootCtrl)
# mount hierarchy:
cmds.parent(self.footCtrlZeroList[1],
self.RFDCtrl,
absolute=True)
cmds.parent(ikHandleMiddleList[0],
self.middleFootCtrl,
absolute=True)
self.toLimbIkHandleGrp = cmds.group(
empty=True,
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c009_leg_extrem'] + "_Grp")
self.toLimbIkHandleGrpList.append(self.toLimbIkHandleGrp)
cmds.parent(ikHandleAnkleList[0],
self.toLimbIkHandleGrp,
self.RFECtrl,
absolute=True)
cmds.makeIdentity(self.toLimbIkHandleGrp,
apply=True,
translate=True,
rotate=True,
scale=True)
parentConst = cmds.parentConstraint(self.RFECtrl,
self.footJnt,
maintainOffset=True,
name=self.footJnt +
"_ParentConstraint")[0]
self.parentConstList.append(parentConst)
self.footJntList.append(self.footJnt)
cmds.parent(self.RFAZeroExtra, self.footCtrl, absolute=True)
scaleConst = cmds.scaleConstraint(self.footCtrl,
self.footJnt,
maintainOffset=True,
name=self.footJnt +
"_ScaleConstraint")
self.scaleConstList.append(scaleConst)
cmds.parentConstraint(self.middleFootCtrl,
self.middleFootJnt,
maintainOffset=True,
name=self.middleFootJnt +
"_ParentConstraint")
cmds.scaleConstraint(self.middleFootCtrl,
self.middleFootJnt,
maintainOffset=True,
name=self.middleFootJnt +
"_ScaleConstraint")
# add attributes to footCtrl and connect them to reverseFoot groups rotation:
rfAttrList = [
outsideRFAttr, insideRFAttr, heelRFAttr, toeRFAttr,
ballRFAttr
]
rfTypeAttrList = [rfRoll, rfSpin]
for j, rfAttr in enumerate(rfAttrList):
for t, rfType in enumerate(rfTypeAttrList):
if t == 1 and j == (len(rfAttrList) -
1): # create turn attr to ball
cmds.addAttr(self.footCtrl,
longName=rfAttr + rfTurn,
attributeType='float',
keyable=True)
cmds.connectAttr(self.footCtrl + "." + rfAttr +
rfTurn,
rfGrpList[j] + ".rotateZ",
force=True)
self.reverseFootAttrList.append(rfAttr + rfTurn)
cmds.addAttr(self.footCtrl,
longName=rfAttr + rfType,
attributeType='float',
keyable=True)
self.reverseFootAttrList.append(rfAttr + rfType)
if t == 0:
if j > 1:
cmds.connectAttr(self.footCtrl + "." + rfAttr +
rfType,
rfGrpList[j] + ".rotateX",
force=True)
else:
cmds.connectAttr(self.footCtrl + "." + rfAttr +
rfType,
rfGrpList[j] + ".rotateZ",
force=True)
else:
cmds.connectAttr(self.footCtrl + "." + rfAttr +
rfType,
rfGrpList[j] + ".rotateY",
force=True)
# creating the originedFrom attributes (in order to permit integrated parents in the future):
utils.originedFrom(objName=self.footCtrl,
attrString=self.base + ";" +
self.cvFootLoc + ";" + self.cvRFALoc + ";" +
self.cvRFBLoc + ";" + self.cvRFCLoc + ";" +
self.cvRFDLoc)
utils.originedFrom(objName=self.middleFootCtrl,
attrString=self.cvRFELoc + ";" +
self.cvEndJoint)
# creating pre-defined attributes for footRoll and sideRoll attributes, also rollAngle:
cmds.addAttr(self.footCtrl,
longName=footRFAttr + rfRoll,
attributeType='float',
keyable=True)
cmds.addAttr(self.footCtrl,
longName=footRFAttr + rfRoll + rfAngle,
attributeType='float',
defaultValue=30,
keyable=True)
cmds.addAttr(self.footCtrl,
longName=footRFAttr + rfRoll + rfPlant,
attributeType='float',
defaultValue=0,
keyable=True)
cmds.addAttr(self.footCtrl,
longName=sideRFAttr + rfRoll,
attributeType='float',
keyable=True)
# create clampNodes in order to limit the side rotations:
sideClamp = cmds.createNode("clamp",
name=side + self.userGuideName +
"_Side_Clp")
# outside values in R
cmds.setAttr(sideClamp + ".minR", -360)
# inside values in G
cmds.setAttr(sideClamp + ".maxG", 360)
# inverting sideRoll values:
sideMD = cmds.createNode("multiplyDivide",
name=side + self.userGuideName +
"_Side_MD")
cmds.setAttr(sideMD + ".input2X", -1)
# connections:
cmds.connectAttr(self.footCtrl + "." + sideRFAttr + rfRoll,
sideMD + ".input1X",
force=True)
cmds.connectAttr(sideMD + ".outputX",
sideClamp + ".inputR",
force=True)
cmds.connectAttr(sideMD + ".outputX",
sideClamp + ".inputG",
force=True)
cmds.connectAttr(sideClamp + ".outputR",
self.RFAZero + ".rotateZ",
force=True)
cmds.connectAttr(sideClamp + ".outputG",
self.RFBZero + ".rotateZ",
force=True)
# for footRoll:
footHeelClp = cmds.createNode("clamp",
name=side + self.userGuideName +
"_Roll_Heel_Clp")
# heel values in R
cmds.setAttr(footHeelClp + ".minR", -360)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll,
footHeelClp + ".inputR",
force=True)
cmds.connectAttr(footHeelClp + ".outputR",
self.RFCZero + ".rotateX",
force=True)
# footRoll with angle limit:
footPMA = cmds.createNode("plusMinusAverage",
name=side + self.userGuideName +
"_Roll_PMA")
footSR = cmds.createNode("setRange",
name=side + self.userGuideName +
"_Roll_SR")
cmds.setAttr(footSR + ".oldMaxY", 180)
cmds.setAttr(footPMA + ".input1D[0]", 180)
cmds.setAttr(footPMA + ".operation", 2) #substract
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll,
footSR + ".valueX",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll,
footSR + ".valueY",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfAngle,
footSR + ".maxX",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfAngle,
footSR + ".oldMinY",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfAngle,
footSR + ".oldMaxX",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfAngle,
footPMA + ".input1D[1]",
force=True)
cmds.connectAttr(footPMA + ".output1D",
footSR + ".maxY",
force=True)
# plant angle for foot roll:
footPlantClp = cmds.createNode("clamp",
name=side + self.userGuideName +
"_Roll_Plant_Clp")
footPlantCnd = cmds.createNode("condition",
name=side + self.userGuideName +
"_Roll_Plant_Cnd")
cmds.setAttr(footPlantCnd + ".operation", 4) #less than
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll,
footPlantClp + ".inputR",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfPlant,
footPlantClp + ".maxR",
force=True)
cmds.connectAttr(footPlantClp + ".outputR",
footPlantCnd + ".firstTerm",
force=True)
cmds.connectAttr(footPlantClp + ".outputR",
footPlantCnd + ".colorIfTrueR",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfPlant,
footPlantCnd + ".secondTerm",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfPlant,
footPlantCnd + ".colorIfFalseR",
force=True)
# back to zero footRoll when greather then angle plus plant values:
anglePlantPMA = cmds.createNode(
"plusMinusAverage",
name=side + self.userGuideName + "_AnglePlant_PMA")
anglePlantMD = cmds.createNode("multiplyDivide",
name=side + self.userGuideName +
"_AnglePlant_MD")
anglePlantRmV = cmds.createNode(
"remapValue",
name=side + self.userGuideName + "_AnglePlant_RmV")
anglePlantCnd = cmds.createNode(
"condition",
name=side + self.userGuideName + "_AnglePlant_Cnd")
cmds.setAttr(anglePlantMD + ".input2X", -1)
cmds.setAttr(anglePlantRmV + ".inputMax", 90)
cmds.setAttr(anglePlantRmV + ".value[0].value_Interp",
3) #spline
cmds.setAttr(anglePlantRmV + ".value[1].value_Interp",
3) #spline
cmds.setAttr(anglePlantCnd + ".operation", 2) #greather than
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfAngle,
anglePlantPMA + ".input1D[0]",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll +
rfPlant,
anglePlantPMA + ".input1D[1]",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll,
anglePlantCnd + ".firstTerm",
force=True)
cmds.connectAttr(anglePlantPMA + ".output1D",
anglePlantCnd + ".secondTerm",
force=True)
cmds.connectAttr(anglePlantPMA + ".output1D",
anglePlantMD + ".input1X",
force=True)
cmds.connectAttr(anglePlantPMA + ".output1D",
anglePlantRmV + ".inputMin",
force=True)
cmds.connectAttr(anglePlantMD + ".outputX",
anglePlantRmV + ".outputMax",
force=True)
cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll,
anglePlantRmV + ".inputValue",
force=True)
cmds.connectAttr(anglePlantRmV + ".outColorR",
anglePlantCnd + ".colorIfTrueR",
force=True)
cmds.connectAttr(anglePlantCnd + ".outColorR",
self.RFEZeroExtra + ".rotateX",
force=True)
# connect to groups in order to rotate them:
cmds.connectAttr(footSR + ".outValueY",
self.RFDZero + ".rotateX",
force=True)
cmds.connectAttr(footSR + ".outValueX",
self.RFEZero + ".rotateX",
force=True)
if s == 0: #left
cmds.connectAttr(footPlantCnd + ".outColorR",
self.footCtrlZeroList[1] + ".rotateX",
force=True)
else: #fix right side mirror
footPlantInvMD = cmds.createNode(
"multiplyDivide",
name=side + self.userGuideName + "_Plant_Inv_MD")
cmds.setAttr(footPlantInvMD + ".input2X", -1)
cmds.connectAttr(footPlantCnd + ".outColorR",
footPlantInvMD + ".input1X",
force=True)
cmds.connectAttr(footPlantInvMD + ".outputX",
self.footCtrlZeroList[1] + ".rotateX",
force=True)
# organizing keyable attributes:
self.ctrls.setLockHide([self.middleFootCtrl, self.footCtrl],
['v'],
l=False)
# show or hide reverseFoot controls:
cmds.addAttr(self.footCtrl,
longName=showCtrlsAttr,
attributeType='long',
min=0,
max=1,
defaultValue=1)
cmds.setAttr(self.footCtrl + "." + showCtrlsAttr,
keyable=False,
channelBox=True)
showHideCtrlList = [
self.RFACtrl, self.RFBCtrl, self.RFCCtrl, self.RFDCtrl
]
for rfCtrl in showHideCtrlList:
rfCtrlShape = cmds.listRelatives(rfCtrl,
children=True,
type='nurbsCurve')[0]
cmds.connectAttr(self.footCtrl + "." + showCtrlsAttr,
rfCtrlShape + ".visibility",
force=True)
# create a masterModuleGrp to be checked if this rig exists:
self.toCtrlHookGrp = cmds.group(
self.footCtrlZeroList[0],
name=side + self.userGuideName + "_Control_Grp")
self.revFootCtrlGrpFinalList.append(self.toCtrlHookGrp)
self.toScalableHookGrp = cmds.createNode(
"transform", name=side + self.userGuideName + "_Joint_Grp")
mWorldFoot = cmds.getAttr(self.footJnt + ".worldMatrix")
cmds.xform(self.toScalableHookGrp,
matrix=mWorldFoot,
worldSpace=True)
cmds.parent(self.footJnt,
self.toScalableHookGrp,
absolute=True)
#Remove the Joint orient to make sure the bone is at the same orientation than it's parent
cmds.setAttr(self.footJnt + ".jointOrientX", 0)
cmds.setAttr(self.footJnt + ".jointOrientY", 0)
cmds.setAttr(self.footJnt + ".jointOrientZ", 0)
self.aScalableGrp.append(self.toScalableHookGrp)
self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp,
self.toScalableHookGrp,
name=side +
self.userGuideName + "_Grp")
cmds.addAttr(self.toStaticHookGrp,
longName="dpAR_name",
dataType="string")
cmds.addAttr(self.toStaticHookGrp,
longName="dpAR_type",
dataType="string")
cmds.setAttr(self.toStaticHookGrp + ".dpAR_name",
self.userGuideName,
type="string")
cmds.setAttr(self.toStaticHookGrp + ".dpAR_type",
CLASS_NAME,
type="string")
# add module type counter value
cmds.addAttr(self.toStaticHookGrp,
longName='dpAR_count',
attributeType='long',
keyable=False)
cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count)
# create a locator in order to avoid delete static group
loc = cmds.spaceLocator(name=side + self.userGuideName +
"_DO_NOT_DELETE")[0]
cmds.parent(loc, self.toStaticHookGrp, absolute=True)
cmds.setAttr(loc + ".visibility", 0)
self.ctrls.setLockHide([loc], [
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
])
# add hook attributes to be read when rigging integrated modules:
utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook')
utils.addHook(objName=self.toScalableHookGrp,
hookType='scalableHook')
utils.addHook(objName=self.toStaticHookGrp,
hookType='staticHook')
if hideJoints:
cmds.setAttr(self.toScalableHookGrp + ".visibility", 0)
# delete duplicated group for side (mirror):
cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp)
# finalize this rig:
self.integratingInfo()
cmds.select(clear=True)
# delete UI (moduleLayout), GUIDE and moduleInstance namespace:
self.deleteModule()
def install(self, *args):
# Collect layout info
print "Install"
sel = cmds.ls(sl=True)
userDefinedName = sel[0].partition('PartRoot_')[0]
lytObs = part_utils.collectLayoutInfo(sel)
# Find the side we are on
#side = part_utils.getSide(self.lyt_info['layoutRoot'])
# Create an rig joint chain
self.jnt_info['rigJnts'] = part_utils.createJoints('rigj_', lytObs)
# Create an ik joint chain
self.jnt_info['iksJnts'] = part_utils.createJoints('ikSj_', lytObs)
self.jnt_info['ikrJnts'] = part_utils.createJoints('ikRj_', lytObs)
#self.jnt_info['ikJnts'] = part_utils.createJoints('ikj_', lytObs)
spl = len(self.jnt_info['iksJnts']) - 1
# Create a new joint at the root and the top of the iksJoint chain.
rootJointList = ([
'ikBRoot_' + userDefinedName,
cmds.xform(self.jnt_info['iksJnts'][0], q=True, ws=True, t=True)
], [
'ikTRoot_' + userDefinedName,
cmds.xform(self.jnt_info['iksJnts'][spl], q=True, ws=True, t=True)
])
rootJoints = []
for i in rootJointList:
cmds.select(d=True)
rootJoints.append(cmds.joint(n=i[0], p=i[1]))
cmds.select(d=True)
self.jnt_info['rootJnts'] = rootJoints
# Define names for components involved in ik setup
#ikHandleName = "ikHandle_%s_leg" % (side)
ikHandleName = userDefinedName + 'ikh'
#ctrlName = "ctrl_%s_leg" % (side)
ctrlName = userDefinedName + 'ctrl'
# Draw a splineIK from the root to the last iksJnt.
ikSol = cmds.ikHandle(n='iks_spine_Ik',
solver='ikSplineSolver',
sj=self.jnt_info['iksJnts'][0],
ee=self.jnt_info['iksJnts'][spl],
ccv=True)
cmds.select(d=True)
# Bind the splineIK curve to those 2 new joints.
cmds.select('curve1', rootJoints)
cmds.skinCluster(tsb=True)
#Rename the curve
cmds.rename('curve1', userDefinedName + '_aSpine_curve')
# Draw an iKhandle between each self.jnt_info['ikrJnts']
ikHandles = []
for j in range(spl):
if j < spl:
ikh = cmds.ikHandle(n='ikH_' + self.jnt_info['ikrJnts'][j],
sol='ikRPsolver',
sj=self.jnt_info['ikrJnts'][j],
ee=self.jnt_info['ikrJnts'][j + 1])
cmds.parent(ikh, self.jnt_info['iksJnts'][j])
ikHandles.append(ikh)
# Point constrain 1st iks to 1st ikb
for j in range(spl + 1):
cmds.pointConstraint(self.jnt_info['iksJnts'][j],
self.jnt_info['ikrJnts'][j],
mo=True)
cmds.pointConstraint(self.jnt_info['ikrJnts'][j],
self.jnt_info['rigJnts'][j],
mo=True)
# Create a locator for each ikh
locator_groups = []
for i in range(spl + 1):
bPos = cmds.xform(self.jnt_info['iksJnts'][i],
q=True,
ws=True,
t=True)
nPos = [bPos[0], bPos[1], bPos[2] + 1.0]
lctr = cmds.spaceLocator(name='lctr_' +
self.jnt_info['iksJnts'][i],
a=True)
cmds.xform(lctr, ws=True, t=nPos)
grp = cmds.group(name='grp_lctr_' + self.jnt_info['iksJnts'][i],
em=True)
cmds.xform(grp, ws=True, t=bPos)
cmds.parent(lctr, grp)
# Create pole vector constraints
if i < spl:
cmds.poleVectorConstraint(lctr, ikHandles[i][0])
cmds.parent(grp, self.jnt_info['iksJnts'][i])
cmds.makeIdentity(grp, apply=True)
locator_groups.append(grp)
self.jnt_info['locator_groups'] = locator_groups
# Create PMA nodes to control the twist
# NOTE: This is tricky if we want to allow for more joints. For now I am coding for 5 but need a solution for more.
pma_nodes = []
for i in range(spl + 1):
if spl > 5:
print " I currently only support 5 joints"
return
else:
pmaNode_Name = self.jnt_info['iksJnts'][i].replace(
'ikSj', 'pmaTwist_')
pma = cmds.shadingNode("plusMinusAverage",
asUtility=True,
n=pmaNode_Name)
cmds.setAttr(pma + '.operation', 3) #average
pma_nodes.append(pma)
# Now connect the Pma
self.jnt_info['twistPma'] = pma_nodes
cmds.connectAttr(self.jnt_info['rootJnts'][0] + '.ry',
self.jnt_info['twistPma'][2] + '.input1D[0]')
cmds.connectAttr(self.jnt_info['rootJnts'][1] + '.ry',
self.jnt_info['twistPma'][2] + '.input1D[1]')
cmds.connectAttr(self.jnt_info['twistPma'][2] + '.output1D',
self.jnt_info['locator_groups'][2] + '.rx')
cmds.connectAttr(self.jnt_info['twistPma'][0] + '.output1D',
self.jnt_info['twistPma'][1] + '.input1D[0]')
cmds.connectAttr(self.jnt_info['rootJnts'][0] + '.ry',
self.jnt_info['twistPma'][1] + '.input1D[1]')
cmds.connectAttr(self.jnt_info['twistPma'][1] + '.output1D',
self.jnt_info['locator_groups'][1] + '.rx')
cmds.connectAttr(self.jnt_info['rootJnts'][0] + '.ry',
self.jnt_info['twistPma'][0] + '.input1D[0]')
cmds.connectAttr(self.jnt_info['twistPma'][0] + '.output1D',
self.jnt_info['locator_groups'][0] + '.rx')
cmds.connectAttr(self.jnt_info['rootJnts'][0] + '.ry',
self.jnt_info['twistPma'][3] + '.input1D[0]')
cmds.connectAttr(self.jnt_info['twistPma'][2] + '.output1D',
self.jnt_info['twistPma'][3] + '.input1D[1]')
cmds.connectAttr(self.jnt_info['twistPma'][3] + '.output1D',
self.jnt_info['locator_groups'][3] + '.rx')
cmds.connectAttr(self.jnt_info['rootJnts'][1] + '.ry',
self.jnt_info['twistPma'][4] + '.input1D[0]')
cmds.connectAttr(self.jnt_info['twistPma'][4] + '.output1D',
self.jnt_info['locator_groups'][4] + '.ry')
# Make the spine stretch.
# NOTE: Try the expression method
# NOTE: Add stretch ammount attribute.
#cmds.expression( s= 'surface1.sx = %s.arcLength' % curveInfoNode )
curveInfoNode = cmds.arclen(userDefinedName + '_aSpine_curve', ch=True)
mdsNode_Name = self.jnt_info['iksJnts'][0].replace('ikSj', 'mdStretch')
mds = cmds.shadingNode("multiplyDivide",
asUtility=True,
n=mdsNode_Name)
cmds.setAttr(mds + '.operation', 2) #divide
cmds.connectAttr(curveInfoNode + '.arcLength', mds + '.input1X')
#cmds.connectAttr(curveInfoNode+'.arcLength', mda+'.input2X')
crvLen = cmds.getAttr(curveInfoNode + '.arcLength')
print crvLen
cmds.setAttr(mds + '.input2X', crvLen)
# Connect stretch to joints
for i in range(len(self.jnt_info['iksJnts']) - 1):
cmds.connectAttr(mds + '.outputX',
self.jnt_info['iksJnts'][i] + '.sx')
cmds.rename(curveInfoNode, userDefinedName + '_curveInfo')
# Setup controls
suffix = userDefinedName
ctrlAttrs = []
for i in range(len(self.jnt_info['rootJnts'])):
ctrlName = userDefinedName + 'ctrl_' + str(i)
ctrlPos = cmds.xform(self.jnt_info['rootJnts'][i],
q=True,
ws=True,
t=True)
# NOTE: Dynamically generate the control objects
spineControl = part_utils.setupControlObject(
"SpineControl.ma", ctrlName, ctrlAttrs, ctrlPos,
os.environ['Parts_Maya_Controls'])
cmds.parentConstraint(spineControl, self.jnt_info['rootJnts'][i])
def createGuide(self, *args):
Base.StartClass.createGuide(self)
# Custom GUIDE:
cmds.setAttr(self.moduleGrp + ".moduleNamespace",
self.moduleGrp[:self.moduleGrp.rfind(":")],
type='string')
# create cvJointLoc and cvLocators:
self.cvFootLoc, shapeSizeCH = self.ctrls.cvJointLoc(
ctrlName=self.guideName + "_Foot", r=0.3, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
self.cvRFALoc, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_RfA", r=0.3, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
self.cvRFBLoc, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_RfB", r=0.3, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
self.cvRFCLoc, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_RfC", r=0.3, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
self.cvRFDLoc, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_RfD", r=0.3, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
self.cvRFELoc, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_RfE", r=0.3, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
# create jointGuides:
self.jGuideFoot = cmds.joint(name=self.guideName + "_JGuideFoot",
radius=0.001)
self.jGuideRFE = cmds.joint(name=self.guideName + "_JGuideRfE",
radius=0.001)
cmds.select(clear=True)
self.jGuideRFA = cmds.joint(name=self.guideName + "_JGuideRfA",
radius=0.001)
self.jGuideRFD = cmds.joint(name=self.guideName + "_JGuideRfD",
radius=0.001)
self.jGuideRFB = cmds.joint(name=self.guideName + "_JGuideRfB",
radius=0.001)
self.jGuideRFC = cmds.joint(name=self.guideName + "_JGuideRfC",
radius=0.001)
self.jGuideRFAC = cmds.joint(name=self.guideName + "_JGuideRfAC",
radius=0.001)
# set jointGuides as templates:
cmds.setAttr(self.jGuideFoot + ".template", 1)
cmds.setAttr(self.jGuideRFA + ".template", 1)
cmds.setAttr(self.jGuideRFB + ".template", 1)
cmds.setAttr(self.jGuideRFC + ".template", 1)
cmds.setAttr(self.jGuideRFD + ".template", 1)
cmds.setAttr(self.jGuideRFE + ".template", 1)
cmds.parent(self.jGuideFoot,
self.jGuideRFA,
self.moduleGrp,
relative=True)
# create cvEnd:
self.cvEndJoint, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_JointEnd", r=0.1, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
cmds.parent(self.cvEndJoint, self.cvRFELoc)
cmds.setAttr(self.cvEndJoint + ".tz", 1.3)
self.jGuideEnd = cmds.joint(name=self.guideName + "_JGuideEnd",
radius=0.001)
cmds.setAttr(self.jGuideEnd + ".template", 1)
cmds.parent(self.jGuideEnd, self.jGuideRFE)
# make parents between cvLocs:
cmds.parent(self.cvFootLoc, self.cvRFALoc, self.cvRFBLoc,
self.cvRFCLoc, self.cvRFDLoc, self.moduleGrp)
cmds.parent(self.cvRFELoc, self.cvFootLoc)
# connect cvLocs in jointGuides:
self.ctrls.directConnect(self.cvFootLoc, self.jGuideFoot,
['tx', 'ty', 'tz', 'rx', 'ry', 'rz'])
cmds.parentConstraint(self.cvRFALoc,
self.jGuideRFA,
maintainOffset=False,
name=self.jGuideRFA + "_ParentConstraint")
cmds.parentConstraint(self.cvRFBLoc,
self.jGuideRFB,
maintainOffset=False,
name=self.jGuideRFB + "_ParentConstraint")
cmds.parentConstraint(self.cvRFCLoc,
self.jGuideRFC,
maintainOffset=False,
name=self.jGuideRFC + "_ParentConstraint")
cmds.parentConstraint(self.cvRFDLoc,
self.jGuideRFD,
maintainOffset=False,
name=self.jGuideRFD + "_ParentConstraint")
cmds.parentConstraint(self.cvRFELoc,
self.jGuideRFE,
maintainOffset=False,
name=self.jGuideRFE + "_ParentConstraint")
cmds.parentConstraint(self.cvRFALoc,
self.jGuideRFAC,
maintainOffset=False,
name=self.jGuideRFAC + "_ParentConstraint")
self.ctrls.directConnect(self.cvEndJoint, self.jGuideEnd,
['tx', 'ty', 'tz', 'rx', 'ry', 'rz'])
# limit, lock and hide cvEnd:
cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False))
self.ctrls.setLockHide(
[self.cvEndJoint],
['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
# transform cvLocs in order to put as a good foot guide:
cmds.setAttr(self.cvFootLoc + ".translateZ", 2)
cmds.setAttr(self.cvFootLoc + ".rotateX", 90)
cmds.setAttr(self.cvFootLoc + ".rotateZ", -90)
cmds.setAttr(self.cvRFELoc + ".translateY", -1)
cmds.setAttr(self.cvRFELoc + ".translateZ", 2.5)
cmds.setAttr(self.cvRFALoc + ".translateX", -0.6)
cmds.setAttr(self.cvRFALoc + ".translateY", -1)
cmds.setAttr(self.cvRFALoc + ".rotateX", 90)
cmds.setAttr(self.cvRFALoc + ".rotateZ", -90)
cmds.setAttr(self.cvRFBLoc + ".translateX", -0.6)
cmds.setAttr(self.cvRFBLoc + ".translateY", 1)
cmds.setAttr(self.cvRFBLoc + ".rotateX", 90)
cmds.setAttr(self.cvRFBLoc + ".rotateZ", -90)
cmds.setAttr(self.cvRFCLoc + ".translateX", 1)
cmds.setAttr(self.cvRFCLoc + ".rotateX", 90)
cmds.setAttr(self.cvRFCLoc + ".rotateZ", -90)
cmds.setAttr(self.cvRFDLoc + ".translateX", -3.5)
cmds.setAttr(self.cvRFDLoc + ".rotateX", 90)
cmds.setAttr(self.cvRFDLoc + ".rotateZ", -90)
cmds.setAttr(self.moduleGrp + ".rotateX", -90)
cmds.setAttr(self.moduleGrp + ".rotateY", 90)
def bakeOffsets(self):
"""
Tales selected modules listed in the QListWidget and bakes the offset mover values up to the global mover
parent. This is achieved by creating a locator in the space of the offset mover, zeroing the offset mover
out, and constraining the global mover to the constraint. Finally, the constraints are removed and the
locators deleted.
"""
selected = self.bakeOffsetsWin_moduleList.selectedItems()
items = []
for each in selected:
items.append(each.text())
constraints = []
locators = []
# go through each module and create the locators for the offset movers
for each in self.mainUI.moduleInstances:
name = each.name
if name in items:
# get movers
jointMovers = each.returnJointMovers
# separate mover lists
globalMovers = jointMovers[0]
offsetMovers = jointMovers[1]
# create locators for the offsetMovers, then zero out offset mover
for mover in offsetMovers:
locatorName = mover.partition("_offset")[0] + "_loc"
loc = cmds.spaceLocator(name=locatorName)[0]
# constrain locator
constraint = cmds.parentConstraint(mover, loc)[0]
cmds.delete(constraint)
# parent locator under a copy of the locatorName
parentLoc = cmds.duplicate(loc)[0]
cmds.parent(loc, parentLoc)
locators.append(parentLoc)
for mover in offsetMovers:
for attr in [".tx", ".ty", ".tz", ".rx", ".ry", ".rz"]:
try:
cmds.setAttr(mover + attr, 0)
except:
pass
# now, for each global mover, find child groups that are constrained to them
for each in self.mainUI.moduleInstances:
name = each.name
if name in items:
# get movers
jointMovers = each.returnJointMovers
# separate mover lists
globalMovers = jointMovers[0]
offsetMovers = jointMovers[1]
childGrps = []
for mover in globalMovers:
try:
# find the mover group constrained to this mover (if any)
connection = cmds.listConnections(
mover, type="parentConstraint")[0]
grp = cmds.listConnections(connection +
".constraintRotateX")[0]
if grp.find("_mover_grp") != -1:
childGrps.append([mover, grp])
# now take this group and delete the constraints
cmds.select(grp)
cmds.delete(constraints=True)
except Exception, e:
print e
def Ribbon_Leg_L():
Scale_Guide=cmds.xform('Guide_Scale_Grp',ws=True, q=True, s=True )[0]
Create_Nurb_Rib_Leg_L= cmds.nurbsPlane(n="Rib_Leg_L",p=[0,0,0],ax=[0,0,1],w=6,lr=0.167,d=3,u=6,v=1,ch=1)#CREAR PLANO_Leg
Get_Trans_Rot('J_Leg_Neutral_L')
Set_Trans_Rot(Create_Nurb_Rib_Leg_L)
cmds.parent("Rib_Leg_L","J_Leg_Neutral_L")
cmds.rename('makeNurbPlane1', 'makeRib_Leg_L')
Extract_TransX_ForeLeg_L = cmds.getAttr ("J_ForeLeg_Neutral_L.translateX")
Divide_TransX_ForeLeg_L= ((Extract_TransX_ForeLeg_L)/2)
Move_TransX_RibLeg_L = cmds.setAttr ("Rib_Leg_L.translateX",Divide_TransX_ForeLeg_L)
Scale_Nurb_Rib_Leg_L= cmds.setAttr ("makeRib_Leg_L.width", Extract_TransX_ForeLeg_L)
Create_Nurb_Rib_ForeLeg_L= cmds.nurbsPlane(n="Rib_ForeLeg_L",p=[0,0,0],ax=[0,0,1],w=6,lr=0.167,d=3,u=6,v=1,ch=1)#CREAR PLANO_FORELeg
Get_Trans_Rot('J_ForeLeg_Neutral_L')
Set_Trans_Rot(Create_Nurb_Rib_ForeLeg_L)
Parent_J_ForeLeg_Neutral_L=cmds.parent("Rib_ForeLeg_L","J_ForeLeg_Neutral_L")
Rename_MakeNurb=cmds.rename('makeNurbPlane1', 'makeRib_ForeLeg_L')
Extract_TransX_Ankle_L = cmds.getAttr ("J_Ankle_Neutral_L.translateX")
Divide_TransX_Ankle_L= ((Extract_TransX_Ankle_L)/2)
Move_TransX_RibForeLeg_L = cmds.setAttr ("Rib_ForeLeg_L.translateX",Divide_TransX_Ankle_L)
Scale_Nurb_Rib_ForeLeg_L= cmds.setAttr ("makeRib_ForeLeg_L.width", Extract_TransX_Ankle_L)
cmds.parent("Rib_Leg_L",w=True)
cmds.parent("Rib_ForeLeg_L",w=True)
cmds.select(cl=True)
List_Pos_J_Legs=['J_Leg_Neutral_L','J_ForeLeg_Neutral_L']
Joints=('J_ForeLeg_Neutral_L')
for J_1 in List_Pos_J_Legs:#FOR PARA POSICIONAR Y ORIENTAR LOS CTRLS BENDY
N = J_1.split("_Neutral_L")[0]
New_Name=N.split("J_")[1]
cmds.joint(n='J_Bendy_1_'+New_Name+'_L',r=True,rad=1*Scale_Guide)#1
cmds.group(n='Z_J_Bendy_1_'+New_Name+'_L')
cmds.hide('Z_J_Bendy_1_'+New_Name+'_L')
cmds.select(cl=True)
cmds.parent('Z_J_Bendy_1_'+New_Name+'_L','L_Bendy'+New_Name+'_01_CTL')
cmds.select(cl=True)
Get_Trans_Rot(J_1)
Set_Trans_Rot('P_L_Bendy'+New_Name+'_01_CTL')
cmds.joint(n='J_Bendy_2_'+New_Name+'_L',r=True,rad=1*Scale_Guide)#2
cmds.group(n='Z_J_Bendy_2_'+New_Name+'_L')
cmds.hide('Z_J_Bendy_2_'+New_Name+'_L')
cmds.parent('Z_J_Bendy_2_'+New_Name+'_L','L_Bendy'+New_Name+'_02_CTL')
cmds.select(cl=True)
Get_Trans_Rot(J_1)
Set_Trans_Rot('P_L_Bendy'+New_Name+'_02_CTL')
cmds.parent('P_L_Bendy'+New_Name+'_02_CTL',J_1)
cmds.setAttr ('P_L_Bendy'+New_Name+'_02_CTL.translateX',Divide_TransX_ForeLeg_L)
cmds.parent('P_L_Bendy'+New_Name+'_02_CTL',w=True)
cmds.select(cl=True)
cmds.joint(n='J_Bendy_3_'+New_Name+'_L',r=True,rad=1*Scale_Guide)#3
cmds.group(n='Z_J_Bendy_3_'+New_Name+'_L')
cmds.parent('Z_J_Bendy_3_'+New_Name+'_L','L_Bendy'+New_Name+'_03_CTL')
cmds.select(cl=True)
Get_Trans_Rot(Joints)
Set_Trans_Rot('P_L_Bendy'+New_Name+'_03_CTL')
Joints=('J_Ankle_Neutral_L')
Divide_TransX_ForeLeg_L=Divide_TransX_Ankle_L
Get_Trans_Rot('J_ForeLeg_Neutral_L')
Set_Trans_Rot('P_L_BendyMasterLeg_CTL')
Skn_Leg_Rib_L=cmds.skinCluster('J_Bendy_1_Leg_L', 'J_Bendy_2_Leg_L','J_Bendy_3_Leg_L', 'Rib_Leg_L',dr=4,tsb=True,mi=4)[0]
Skn_For_ForeLeg_L=cmds.skinCluster('J_Bendy_1_ForeLeg_L','J_Bendy_2_ForeLeg_L','J_Bendy_3_ForeLeg_L', 'Rib_ForeLeg_L',dr=4,tsb=True,mi=4)[0]
List_J_Bendys_Leg=[Skn_Leg_Rib_L,Skn_For_ForeLeg_L]#LISTA DE LOS NOMBRES DE LOS SKINS DE LOS PLANOS
Name_Nurb='Rib_Leg_L'
Joint_Skin='Leg_'
for Skn in List_J_Bendys_Leg:#FOR PARA LIMPIAR LOS PESOS DEL SKIN DE LOS PLANOS
cmds.skinPercent(Skn,Name_Nurb+'.cv[0][0:3]',tv=['J_Bendy_1_'+Joint_Skin+'L',1])
cmds.skinPercent(Skn,Name_Nurb+'.cv[1][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',0.2])
cmds.skinPercent(Skn,Name_Nurb+'.cv[1][0:3]',tv=['J_Bendy_3_'+Joint_Skin+'L',0])
cmds.skinPercent(Skn,Name_Nurb+'.cv[2][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',0.6])
cmds.skinPercent(Skn,Name_Nurb+'.cv[2][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',0.6])
cmds.skinPercent(Skn,Name_Nurb+'.cv[2][0:3]',tv=['J_Bendy_3_'+Joint_Skin+'L',0])
cmds.skinPercent(Skn,Name_Nurb+'.cv[3][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',0.9])
cmds.skinPercent(Skn,Name_Nurb+'.cv[3][0:3]',tv=['J_Bendy_3_'+Joint_Skin+'L',0])
cmds.skinPercent(Skn,Name_Nurb+'.cv[4][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',1])
cmds.skinPercent(Skn,Name_Nurb+'.cv[5][0:3]',tv=['J_Bendy_1_'+Joint_Skin+'L',0])
cmds.skinPercent(Skn,Name_Nurb+'.cv[5][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',0.9])
cmds.skinPercent(Skn,Name_Nurb+'.cv[6][0:3]',tv=['J_Bendy_1_'+Joint_Skin+'L',0])
cmds.skinPercent(Skn,Name_Nurb+'.cv[6][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',0.6])
cmds.skinPercent(Skn,Name_Nurb+'.cv[7][0:3]',tv=['J_Bendy_1_'+Joint_Skin+'L',0])
cmds.skinPercent(Skn,Name_Nurb+'.cv[7][0:3]',tv=['J_Bendy_2_'+Joint_Skin+'L',0.2])
cmds.skinPercent(Skn,Name_Nurb+'.cv[8][0:3]',tv=['J_Bendy_3_'+Joint_Skin+'L',1])
Name_Nurb='Rib_ForeLeg_L'
Joint_Skin='ForeLeg_'
Point_Cons('L_BendyMasterLeg_CTL','Z_L_BendyLeg_03_CTL')
Point_Cons('L_BendyMasterLeg_CTL','Z_L_BendyForeLeg_01_CTL')
Point_Cons('L_BendyMasterLeg_CTL','Z_L_BendyForeLeg_02_CTL')
Point_Cons('L_BendyMasterLeg_CTL','Z_L_BendyLeg_02_CTL')
Point_Cons('L_BendyForeLeg_03_CTL','Z_L_BendyForeLeg_02_CTL')
Point_Cons('L_BendyLeg_01_CTL','Z_L_BendyLeg_02_CTL')
XYZ=['X','Y','Z']
Ctrls_Bendy=['L_BendyForeLeg_01_CTL','L_BendyLeg_03_CTL']
for Ctrl in Ctrls_Bendy: #FOR PARA CONECTAR LAS ROTATICIONES DEL CTR_BENDY_MASTER A LOS CONTROLES 1_FORELeg Y 3_Leg
for xyz in XYZ:
cmds.connectAttr('L_BendyMasterLeg_CTL.rotate'+xyz,Ctrl+'.rotate'+xyz, f=True)
cmds.hide('L_BendyLeg_03_CTL','L_BendyLeg_01_CTL','L_BendyForeLeg_01_CTL','L_BendyForeLeg_03_CTL','L_BendyForeLeg_01_CTL')
#FOR PARA CONTRAINTS AIMS
Joints=['Leg','ForeLeg']
Valor_Pos=1
Valor_Neg=-1
Num_Ctrl_Father='1'
Num_Ctrl_Children_1='3'
Num_Ctrl_Children_2='1'
Num_Ctrl_Children_3='2'
for Ctrl in Joints:
cmds.aimConstraint('L_Bendy'+Ctrl+'_0'+Num_Ctrl_Father+'_CTL','Z_L_Bendy'+Ctrl+'_0'+Num_Ctrl_Children_1+'_CTL',mo=True,aim=[Valor_Neg,0,0],u=[1,0,0],wu=[0,1,0],wut="objectrotation",worldUpObject='L_Bendy'+Ctrl+'_0'+Num_Ctrl_Father+'_CTL')
cmds.aimConstraint('L_BendyMasterLeg_CTL','Z_L_Bendy'+Ctrl+'_0'+Num_Ctrl_Children_2+'_CTL',mo=True,aim=[Valor_Pos,0,0],u=[1,0,0],wu=[0,1,0],wut="objectrotation",worldUpObject='L_BendyMasterLeg_CTL')
cmds.aimConstraint('L_BendyMasterLeg_CTL','Z_L_Bendy'+Ctrl+'_0'+Num_Ctrl_Children_3+'_CTL',mo=True,aim=[Valor_Pos,0,0],u=[1,0,0],wu=[0,1,0],wut="objectrotation",worldUpObject='L_BendyMasterLeg_CTL')
Valor_Pos=-1
Valor_Neg=1
Num_Ctrl_Father='3'
Num_Ctrl_Children_1='1'
Num_Ctrl_Children_2='2'
Num_Ctrl_Children_3='3'
#FOR PARA CONTRAINTS AIMS
cmds.group(n='Z_Ribs_Nurb_Leg_L',em=True)
cmds.parent('Rib_ForeLeg_L','Z_Ribs_Nurb_Leg_L')
cmds.parent('Rib_Leg_L','Z_Ribs_Nurb_Leg_L')
cmds.select(cl=True)
cmds.select('Rib_Leg_L','Rib_ForeLeg_L')
sel= cmds.ls (selection=True)
lsel= len(sel)
for nurb in range(lsel):#FOR PARA LOS RIVETS DE LOS RIBBON
cmds.group(n=('Locs_'+(sel[nurb])),em=True)
Gett_Spans_Nurb=cmds.getAttr(sel[nurb]+'.spansU')
print Gett_Spans_Nurb
if Gett_Spans_Nurb>1:
U='U'
V='V'
maxValue=cmds.getAttr(sel[nurb]+'.minMaxRangeU.maxValue'+U)
else:
U='V'
V='U'
maxValue=cmds.getAttr(sel[nurb]+'.minMaxRangeV.maxValue'+U)
Gett_Spans_Nurb=cmds.getAttr(sel[nurb]+'.spansV')
Distancia=1/float(Gett_Spans_Nurb)*maxValue
Repeticiones=Distancia/2
num=0
XYZ=['X','Y','Z']
XYZ_min=['x','y','z']
for Loc in range(Gett_Spans_Nurb):
Change_Name=sel[nurb].split('Rib_')[1]
Locator_Create=cmds.spaceLocator(n='Loc_Rivet_'+(sel[nurb])+'_0'+str(num),a=True)[0]
cmds.joint(Locator_Create,n='J_Bind_'+str(num)+'_'+Change_Name,rad=.4*Scale_Guide)
cmds.parent(Locator_Create,('Locs_'+(sel[nurb])))
Node_POS=cmds.shadingNode('pointOnSurfaceInfo',n='POS',au=True)
SetPU=cmds.setAttr((Node_POS)+'.parameter'+(U),Repeticiones)
SetPV=cmds.setAttr((Node_POS)+'.parameter'+(V),.5)
Node_FBFM=cmds.shadingNode('fourByFourMatrix',n='FBFM',au=True)
Node_DCM=cmds.shadingNode('decomposeMatrix',n='DCM',au=True)
Num30=30
Num0=0
for xyz in XYZ:
cmds.connectAttr((Node_POS)+'.position'+xyz,(Node_FBFM)+'.in'+str(Num30),f=True)
cmds.connectAttr((Node_POS)+'.normal'+xyz,(Node_FBFM)+'.in0'+str(Num0),f=True)
Num30=Num30+1
Num0=Num0+1
Num10=10
Num20=20
for xyz2 in XYZ_min:
cmds.connectAttr((Node_POS)+'.tangentU'+xyz2,(Node_FBFM)+'.in'+str(Num10),f=True)
cmds.connectAttr((Node_POS)+'.tangentV'+xyz2,(Node_FBFM)+'.in'+str(Num20),f=True)
Num10=Num10+1
Num20=Num20+1
cmds.connectAttr((Node_FBFM)+'.output',(Node_DCM)+'.inputMatrix',f=True)
cmds.connectAttr((sel[nurb])+'.worldSpace',(Node_POS)+'.inputSurface',f=True)
cmds.connectAttr((Node_DCM)+'.outputRotate',(Locator_Create)+'.rotate',f=True)
cmds.connectAttr((Node_DCM)+'.outputTranslate',(Locator_Create)+'.translate',f=True)
Repeticiones=Repeticiones+Distancia
num=num+1
print Repeticiones
cmds.select(d=True)
cmds.connectAttr('J_Leg_Neutral_L.scale','J_Bendy_2_Leg_L.scale')
cmds.connectAttr('J_ForeLeg_Neutral_L.scale','J_Bendy_2_ForeLeg_L.scale')
cmds.parentConstraint('J_ForeLeg_Neutral_L','P_L_BendyMasterLeg_CTL',mo=True)
cmds.parentConstraint('J_ForeLeg_Neutral_L','P_L_BendyForeLeg_01_CTL',mo=True)
cmds.parentConstraint('J_Ankle_Neutral_L','P_L_BendyForeLeg_03_CTL',mo=True)
cmds.parentConstraint('J_Leg_Neutral_L','P_L_BendyLeg_01_CTL',mo=True)
List=['Leg','ForeLeg']
for J in List:
cmds.orientConstraint('J_'+J+'_Neutral_L','P_L_Bendy'+J+'_02_CTL',mo=True)
if J=='ForeLeg':
print 'no'
else:
cmds.orientConstraint('J_'+J+'_Neutral_L','P_L_Bendy'+J+'_03_CTL',mo=True)
cmds.select(d=True)
def buildFKSpine(self):
#find the number of spine bones from the skeleton settings
spineJoints = self.getSpineJoints()
fkControls = []
parent = None
for joint in spineJoints:
if joint == "spine_01":
#add space switcher node to base of spine
spaceSwitcherFollow = cmds.group(empty=True,
name=joint +
"_space_switcher_follow")
constraint = cmds.parentConstraint(joint,
spaceSwitcherFollow)[0]
cmds.delete(constraint)
spaceSwitcher = cmds.duplicate(spaceSwitcherFollow,
name=joint +
"_space_switcher")[0]
cmds.parent(spaceSwitcher, spaceSwitcherFollow)
#create an empty group in the same space as the joint
group = cmds.group(empty=True, name=joint + "_anim_grp")
constraint = cmds.parentConstraint(joint, group)[0]
cmds.delete(constraint)
#create an additional layer of group that has zeroed attrs
offsetGroup = cmds.group(empty=True,
name=joint + "_anim_offset_grp")
constraint = cmds.parentConstraint(joint, offsetGroup)[0]
cmds.delete(constraint)
cmds.parent(offsetGroup, group)
#create a control object in the same space as the joint
control = utils.createControl("circle", 45, joint + "_anim")
tempDupe = cmds.duplicate(control)[0]
constraint = cmds.parentConstraint(joint, control)[0]
cmds.delete(constraint)
fkControls.append(control)
#parent the control object to the group
cmds.parent(control, offsetGroup)
constraint = cmds.orientConstraint(tempDupe,
control,
skip=["x", "z"])[0]
cmds.delete(constraint)
cmds.makeIdentity(control, t=1, r=1, s=1, apply=True)
#setup hierarchy
if parent != None:
cmds.parent(group, parent, absolute=True)
else:
cmds.parent(group, spaceSwitcher)
cmds.parent(spaceSwitcherFollow, "body_anim")
#set the parent to be the current spine control
parent = control
#clean up
cmds.delete(tempDupe)
for attr in [".v"]:
cmds.setAttr(control + attr, lock=True, keyable=False)
#set the control's color
cmds.setAttr(control + ".overrideEnabled", 1)
cmds.setAttr(control + ".overrideColor", 18)
return fkControls
def smallIKStretch(*args):
"""
create the 2 joint chain at the start and end of the shock/spring/whatever. select the base joint and run this.Then you'll hook up the top/bottom locators to whatever they're connected to (parentConstraint, etc) and hook the geo onto the original joints (parentConstraint, etc)
"""
#select the joint, give as arg the name(?) of the setup
sel = cmds.ls(sl=True)
origJnt = sel[0]
#get child joint of this joint
origChild = cmds.listRelatives(origJnt, c=True)[0]
#create locators at joint start and end positions
orig1Pos = cmds.xform(origJnt, ws=True, q=True, rp=True)
orig2Pos = cmds.xform(origChild, ws=True, q=True, rp=True)
orig1Loc = cmds.spaceLocator(n="%s_LOC" % origJnt)[0]
orig2Loc = cmds.spaceLocator(n="%s_LOC" % origChild)[0]
cmds.xform(orig1Loc, ws=True, t=orig1Pos)
cmds.xform(orig2Loc, ws=True, t=orig2Pos)
#dupe the joint, rename it, measure it
dupeJnts = cmds.duplicate(origJnt)
mJnt1Orig = dupeJnts[0]
mJnt1 = cmds.rename(mJnt1Orig, "measure_%s" % origJnt)
mJnt2orig = cmds.listRelatives(mJnt1, c=True, f=True)[0]
mJnt2 = cmds.rename(mJnt2orig, "measure_%s" % origChild)
#create IK handles on orig joints, parent handle to second loc
ik = cmds.ikHandle(n="%s_IK" % origJnt, sj=origJnt, ee=origChild)[0]
cmds.parent(ik, orig2Loc)
print orig2Loc
#measure from the base measure joint to the ik handle
origM = rig.measureDistance((origJnt + "orig_dist"), mJnt1, mJnt2)
activeM = rig.measureDistance((origJnt + "active_dist"), mJnt1, orig2Loc)
#create mult node to compare the two measures
mult = cmds.shadingNode("multiplyDivide",
asUtility=True,
n="%s_mult" % origJnt)
cmds.setAttr("%s.operation" % mult, 2)
cmds.connectAttr("%s.distance" % activeM, "%s.input1X" % mult)
cmds.connectAttr("%s.distance" % origM, "%s.input2X" % mult)
#---use this code if you want to set up a non-scaling piston geo
# #create a condition node to tell when to use what value
# cond = cmds.shadingNode("condition", asUtility=True, n="%s_cond"%origJnt)
# cmds.setAttr("%s.secondTerm"%cond, 1)
# cmds.setAttr("%s.operation"%cond, 2)
# cmds.connectAttr("%s.outputX"%mult, "%s.firstTerm"%cond)
# cmds.connectAttr("%s.outputX"%mult, "%s.colorIfTrueR"%cond)
# cmds.setAttr("%s.colorIfFalseR"%cond, 1)
# #hook the condition node into the scale of the ik joint (in x for now)
# cmds.connectAttr("%s.outColorR"%cond, "%s.sx"%origJnt)
#hook the mult into the scale of the joint (comment this line out if you use the commented code above)
cmds.connectAttr("%s.outputX" % mult, "%s.sx" % origJnt)
#connect the orig joint to the base of the setup (loc)
cmds.parentConstraint(orig1Loc, origJnt, mo=True)
#hide measure joints
cmds.setAttr("%s.visibility" % mJnt1, 0)
#package up objects in group
group = cmds.group(empty=True, n="%s_GRP" % origJnt)
cmds.parent(mJnt1, origJnt, orig1Loc)
cmds.parent(orig1Loc, orig2Loc, group)
def mkTwistSplineControllers(pfx, numCVs, spread, closed=False):
""" Make and position all the controller objects
Arguments:
pfx (str): The user name of the spline. Will be formatted into the given naming convention
numCVs (int): The number of CVs to create for a spline
spread (float): The distance between each controller (including tangents)
closed (bool): Whether the spline forms a closed loop
Returns:
[str, ...]: All the CV's
[str, ...]: All the CV Buffers
[str, ...]: All the Out-Tangents
[str, ...]: All the In-Tangents
[str, ...]: All the Auto-Out-Tangents
[str, ...]: All the Auto-In-Tangents
[str, ...]: All the Twisters
[str, ...]: All the Twister Buffers
str: The base controller
"""
# Make bases for the controllers
cvCtrl, outTanCtrl, inTanCtrl, twistCtrl, masterCtrl = _mkMasterControllers(
)
master = cmds.duplicate(masterCtrl, name=MASTER_FMT.format(pfx))[0]
cmds.addAttr(master,
longName="Offset",
attributeType='double',
defaultValue=0.0)
cmds.setAttr(master + '.Offset', edit=True, keyable=True)
cmds.addAttr(master,
longName="Stretch",
attributeType='double',
defaultValue=1.0,
minValue=0.0001)
cmds.setAttr(master + '.Stretch', edit=True, keyable=True)
# make the requested number of CV's
# don't hide the .rx attribute
cvs, tws, cvBfrs, twBfrs = [], [], [], []
controlsGrp = cmds.createNode("transform", name=CTRL_ORG_FMT.format(pfx))
cmds.parentConstraint(master, controlsGrp, mo=True)
cmds.scaleConstraint(master, controlsGrp, mo=True)
for i in range(numCVs):
cvBfr = cmds.createNode("transform",
name=BFR_CV_FMT.format(pfx, i + 1),
parent=controlsGrp)
cv = cmds.duplicate(cvCtrl, name=CTRL_CV_FMT.format(pfx, i + 1))[0]
twBfr = cmds.createNode("transform",
name=BFR_TWIST_FMT.format(pfx, i + 1),
parent=controlsGrp)
tw = cmds.duplicate(twistCtrl, name=CTRL_TWIST_FMT.format(pfx,
i + 1))[0]
cmds.addAttr(cv,
longName="Pin",
attributeType='double',
defaultValue=0.0,
minValue=0.0,
maxValue=1.0)
cmds.setAttr(cv + '.Pin', edit=True, keyable=True)
cmds.addAttr(cv,
longName="PinParam",
attributeType='double',
defaultValue=0.0,
minValue=0.0)
cmds.setAttr(cv + '.PinParam', edit=True, keyable=True)
for h in [
'.tx', '.ty', '.tz', '.ry', '.rz', '.sx', '.sy', '.sz', '.v'
]:
cmds.setAttr(tw + h, lock=True, keyable=False, channelBox=False)
cmds.addAttr(tw,
longName="UseTwist",
attributeType='double',
defaultValue=0.0,
minValue=0.0,
maxValue=1.0)
cmds.setAttr(tw + '.UseTwist', edit=True, keyable=True)
cv, = cmds.parent(cv, cvBfr)
twBfr, = cmds.parent(twBfr, cv)
tw, = cmds.parent(tw, twBfr)
cmds.xform(cvBfr, translation=(spread * 3 * i, 0, 0))
cvs.append(cv)
tws.append(tw)
cvBfrs.append(cvBfr)
twBfrs.append(twBfr)
# make the tangents and auto-tangents
oTans, iTans, aoTans, aiTans = [], [], [], []
segments = numCVs if closed else numCVs - 1
for i in range(segments):
# make oTan, and iTan
otNum = i
itNum = (i + 1) % numCVs
oTan = cmds.duplicate(outTanCtrl,
name=CTRL_OUTTAN_FMT.format(pfx, otNum + 1))[0]
iTan = cmds.duplicate(inTanCtrl,
name=CTRL_INTAN_FMT.format(pfx, itNum + 1))[0]
for ndTan in [oTan, iTan]:
cmds.addAttr(ndTan,
longName="Auto",
attributeType='double',
defaultValue=1.0,
minValue=0.0,
maxValue=1.0)
cmds.setAttr(ndTan + '.Auto', edit=True, keyable=True)
cmds.addAttr(ndTan,
longName="Smooth",
attributeType='double',
defaultValue=1.0,
minValue=0.0,
maxValue=1.0)
cmds.setAttr(ndTan + '.Smooth', edit=True, keyable=True)
cmds.addAttr(ndTan,
longName="Weight",
attributeType='double',
defaultValue=1.0,
minValue=0.0001,
maxValue=5.0)
cmds.setAttr(ndTan + '.Weight', edit=True, keyable=True)
cmds.xform(oTan, translation=(spread * (3 * otNum + 1), 0, 0))
cmds.xform(iTan, translation=(spread * (3 * itNum - 1), 0, 0))
aoTan = cmds.createNode("transform",
name=BFR_AOUTTAN_FMT.format(pfx, otNum + 1),
parent=cvs[otNum])
aiTan = cmds.createNode("transform",
name=BFR_AINTAN_FMT.format(pfx, itNum + 1),
parent=cvs[itNum])
cmds.xform(aoTan, translation=(spread * (3 * otNum + 1), 0, 0))
cmds.xform(aiTan, translation=(spread * (3 * itNum - 1), 0, 0))
oTan = cmds.parent(oTan, cvs[otNum])[0]
iTan = cmds.parent(iTan, cvs[itNum])[0]
oTans.append(oTan)
iTans.append(iTan)
aoTans.append(aoTan)
aiTans.append(aiTan)
for nd in [aiTan, aoTan]:
cmds.setAttr(nd + ".overrideEnabled", 1)
cmds.setAttr(nd + ".overrideDisplayType", 2)
cmds.setAttr(nd + ".visibility", 0)
makeLinkLine(aoTan, cvs[otNum], selectNode=oTan)
makeLinkLine(aiTan, cvs[itNum], selectNode=iTan)
cmds.delete((cvCtrl, outTanCtrl, inTanCtrl, twistCtrl, masterCtrl))
return cvs, cvBfrs, oTans, iTans, aoTans, aiTans, tws, twBfrs, master
class ART_BakeOffsets():
"""
This clas builds a UI that allows the rigger to select modules to bake offset mover values up to the global mover
controls, making the offset movers no longer offset from their global mover parents. It can be found on the rig
creator toolbar with the following icon:
.. image:: /images/bakeOffsetsButton.png
The full interface looks like this, listing found modules in the scene to select and bake offsets down to.
.. image:: /images/bakeOffsets.png
"""
def __init__(self, mainUI):
"""
Instantiates the class, getting the QSettings and then calling on ART_BakeOffsetsUI.buildBakeOffsetsUI to
create the interface.
:param mainUI: The instance of the Rig Creator UI where this class was called from.
.. seealso:: ART_BakeOffsetsUI.buildBakeOffsetsUI
"""
# get the directory path of the tools
settings = QtCore.QSettings("Epic Games", "ARTv2")
self.toolsPath = settings.value("toolsPath")
self.iconsPath = settings.value("iconPath")
self.mainUI = mainUI
# build the UI
self.buildBakeOffsetsUI()
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
def buildBakeOffsetsUI(self):
"""
Builds the interface, finding all modules and listing them for selection.
"""
if cmds.window("ART_BakeOffsetsWin", exists=True):
cmds.deleteUI("ART_BakeOffsetsWin", wnd=True)
# launch a UI to get the name information
self.bakeOffsetsWin = QtWidgets.QMainWindow(self.mainUI)
# load stylesheet
styleSheetFile = utils.returnNicePath(
self.toolsPath,
"Core/Scripts/Interfaces/StyleSheets/mainScheme.qss")
f = open(styleSheetFile, "r")
self.style = f.read()
f.close()
self.bakeOffsetsWin.setStyleSheet(self.style)
# size policies
mainSizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed)
# create the main widget
self.bakeOffsetsWin_mainWidget = QtWidgets.QWidget()
self.bakeOffsetsWin.setCentralWidget(self.bakeOffsetsWin_mainWidget)
# set qt object name
self.bakeOffsetsWin.setObjectName("ART_BakeOffsetsWin")
self.bakeOffsetsWin.setWindowTitle("Bake Offsets")
# create the mainLayout for the rig creator UI
self.bakeOffsetsWin_mainLayout = QtWidgets.QVBoxLayout(
self.bakeOffsetsWin_mainWidget)
self.bakeOffsetsWin_mainLayout.setContentsMargins(0, 0, 0, 0)
self.bakeOffsetsWin.resize(400, 250)
self.bakeOffsetsWin.setSizePolicy(mainSizePolicy)
self.bakeOffsetsWin.setMinimumSize(QtCore.QSize(400, 250))
self.bakeOffsetsWin.setMaximumSize(QtCore.QSize(400, 250))
# create the background
self.bakeOffsetsWin_frame = QtWidgets.QFrame()
self.bakeOffsetsWin_mainLayout.addWidget(self.bakeOffsetsWin_frame)
# create the layout for the widgets
self.bakeOffsetsWin_widgetLayout = QtWidgets.QHBoxLayout(
self.bakeOffsetsWin_frame)
self.bakeOffsetsWin_widgetLayout.setContentsMargins(5, 5, 5, 5)
# add the QListWidget Frame
self.bakeOffsetsWin_moduleListFrame = QtWidgets.QFrame()
self.bakeOffsetsWin_moduleListFrame.setMinimumSize(
QtCore.QSize(265, 200))
self.bakeOffsetsWin_moduleListFrame.setMaximumSize(
QtCore.QSize(265, 200))
self.bakeOffsetsWin_moduleListFrame.setContentsMargins(20, 0, 20, 0)
# create the list widget
self.bakeOffsetsWin_moduleList = QtWidgets.QListWidget(
self.bakeOffsetsWin_moduleListFrame)
self.bakeOffsetsWin_widgetLayout.addWidget(
self.bakeOffsetsWin_moduleListFrame)
self.bakeOffsetsWin_moduleList.setMinimumSize(QtCore.QSize(265, 200))
self.bakeOffsetsWin_moduleList.setMaximumSize(QtCore.QSize(265, 200))
self.bakeOffsetsWin_moduleList.setSelectionMode(
QtWidgets.QAbstractItemView.MultiSelection)
self.bakeOffsetsWin_moduleList.setSpacing(3)
# add the layout for the buttons
self.bakeOffsetsWin_buttonLayoutAll = QtWidgets.QVBoxLayout()
self.bakeOffsetsWin_widgetLayout.addLayout(
self.bakeOffsetsWin_buttonLayoutAll)
self.bakeOffsetsWin_buttonLayoutAll.setContentsMargins(5, 20, 5, 20)
# add the selection buttons
self.bakeOffsetsWin_selectionButtonLayout = QtWidgets.QVBoxLayout()
self.bakeOffsetsWin_buttonLayoutAll.addLayout(
self.bakeOffsetsWin_selectionButtonLayout)
self.bakeOffsetsWin_selectAllButton = QtWidgets.QPushButton(
"Select All")
self.bakeOffsetsWin_selectAllButton.setMinimumSize(
QtCore.QSize(115, 25))
self.bakeOffsetsWin_selectAllButton.setMaximumSize(
QtCore.QSize(115, 25))
self.bakeOffsetsWin_selectionButtonLayout.addWidget(
self.bakeOffsetsWin_selectAllButton)
self.bakeOffsetsWin_selectAllButton.clicked.connect(
self.bakeOffsetsWin_moduleList.selectAll)
self.bakeOffsetsWin_selectAllButton.setObjectName("blueButton")
self.bakeOffsetsWin_selectNoneButton = QtWidgets.QPushButton(
"Clear Selection")
self.bakeOffsetsWin_selectNoneButton.setMinimumSize(
QtCore.QSize(115, 25))
self.bakeOffsetsWin_selectNoneButton.setMaximumSize(
QtCore.QSize(115, 25))
self.bakeOffsetsWin_selectionButtonLayout.addWidget(
self.bakeOffsetsWin_selectNoneButton)
self.bakeOffsetsWin_selectNoneButton.clicked.connect(
self.bakeOffsetsWin_moduleList.clearSelection)
self.bakeOffsetsWin_selectNoneButton.setObjectName("blueButton")
# spacer
spacerItem = QtWidgets.QSpacerItem(20, 80,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.bakeOffsetsWin_selectionButtonLayout.addItem(spacerItem)
# add the buttons for reset settings and reset transforms
self.bakeOffsetsWin_bakeOFfsetsBtn = QtWidgets.QPushButton(
"Bake Offsets")
self.bakeOffsetsWin_bakeOFfsetsBtn.setMinimumSize(QtCore.QSize(
115, 25))
self.bakeOffsetsWin_bakeOFfsetsBtn.setMaximumSize(QtCore.QSize(
115, 25))
self.bakeOffsetsWin_selectionButtonLayout.addWidget(
self.bakeOffsetsWin_bakeOFfsetsBtn)
self.bakeOffsetsWin_bakeOFfsetsBtn.setToolTip(
"Turn on Aim Mode for selected modules.")
self.bakeOffsetsWin_bakeOFfsetsBtn.clicked.connect(
partial(self.bakeOffsets))
self.bakeOffsetsWin_bakeOFfsetsBtn.setObjectName("blueButton")
# populate the list widget
modules = utils.returnRigModules()
for module in modules:
# get module name
moduleName = cmds.getAttr(module + ".moduleName")
if moduleName != "root":
self.bakeOffsetsWin_moduleList.addItem(moduleName)
# show the window
self.bakeOffsetsWin.show()
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
def bakeOffsets(self):
"""
Tales selected modules listed in the QListWidget and bakes the offset mover values up to the global mover
parent. This is achieved by creating a locator in the space of the offset mover, zeroing the offset mover
out, and constraining the global mover to the constraint. Finally, the constraints are removed and the
locators deleted.
"""
selected = self.bakeOffsetsWin_moduleList.selectedItems()
items = []
for each in selected:
items.append(each.text())
constraints = []
locators = []
# go through each module and create the locators for the offset movers
for each in self.mainUI.moduleInstances:
name = each.name
if name in items:
# get movers
jointMovers = each.returnJointMovers
# separate mover lists
globalMovers = jointMovers[0]
offsetMovers = jointMovers[1]
# create locators for the offsetMovers, then zero out offset mover
for mover in offsetMovers:
locatorName = mover.partition("_offset")[0] + "_loc"
loc = cmds.spaceLocator(name=locatorName)[0]
# constrain locator
constraint = cmds.parentConstraint(mover, loc)[0]
cmds.delete(constraint)
# parent locator under a copy of the locatorName
parentLoc = cmds.duplicate(loc)[0]
cmds.parent(loc, parentLoc)
locators.append(parentLoc)
for mover in offsetMovers:
for attr in [".tx", ".ty", ".tz", ".rx", ".ry", ".rz"]:
try:
cmds.setAttr(mover + attr, 0)
except:
pass
# now, for each global mover, find child groups that are constrained to them
for each in self.mainUI.moduleInstances:
name = each.name
if name in items:
# get movers
jointMovers = each.returnJointMovers
# separate mover lists
globalMovers = jointMovers[0]
offsetMovers = jointMovers[1]
childGrps = []
for mover in globalMovers:
try:
# find the mover group constrained to this mover (if any)
connection = cmds.listConnections(
mover, type="parentConstraint")[0]
grp = cmds.listConnections(connection +
".constraintRotateX")[0]
if grp.find("_mover_grp") != -1:
childGrps.append([mover, grp])
# now take this group and delete the constraints
cmds.select(grp)
cmds.delete(constraints=True)
except Exception, e:
print e
# now snap global movers to offset movers
for each in self.mainUI.moduleInstances:
name = each.name
if name in items:
# get movers
jointMovers = each.returnJointMovers
# separate mover lists
globalMovers = jointMovers[0]
offsetMovers = jointMovers[1]
for mover in globalMovers:
if cmds.objExists(mover + "_loc"):
constraint = cmds.parentConstraint(
mover + "_loc", mover)[0]
constraints.append(constraint)
# now remove all locs
for const in constraints:
cmds.delete(const)
for loc in locators:
cmds.delete(loc)
# finally, reconstrain mover_grps to their movers
cmds.refresh(force=True)
for group in childGrps:
cmds.parentConstraint(group[0], group[1], mo=True)
cmds.scaleConstraint(group[0], group[1])
cmds.select(clear=True)
def make_ik_joint_chain(self, side, shoulder, knee, elbow_end, wrist,
color):
# make ik handle and control
cmds.ikHandle(n='ik_arm_' + side,
sj=shoulder,
ee=elbow_end,
sol='ikRPsolver')
ik_arm = 'ik_arm_' + side
cmds.parent(ik_arm, 'IKs')
c = custom_controls.create_custom_controls()
arm_control = c.cube_curve('ANIM_arm_' + side)
cmds.setAttr(arm_control + '.lineWidth', 2)
self.l.override_colors(arm_control, color)
cmds.xform(arm_control, cp=True)
arm_control_grp = cmds.group(arm_control, n='grp_ANIM_arm_' + side)
cmds.matchTransform(arm_control_grp, elbow_end, pos=True, rot=True)
self.controls.append(arm_control_grp)
cmds.parent(arm_control_grp, 'controls')
cmds.parentConstraint(arm_control, 'ik_arm_' + side)
#create a pole vector
pv = self.l.create_pole_vector(side, shoulder, knee, elbow_end, 'arm',
'ik_arm_' + side, color)
orient_constraint_wrist = cmds.orientConstraint(arm_control, wrist)[0]
cmds.setDrivenKeyframe(orient_constraint_wrist + '.' + wrist + '_Ctl' +
'W0',
cd=self.ik_fk_control + '.ikfk',
v=0,
dv=0)
cmds.setDrivenKeyframe(orient_constraint_wrist + '.' + wrist + '_Ctl' +
'W0',
cd=self.ik_fk_control + '.ikfk',
v=1,
dv=1)
cmds.setDrivenKeyframe(orient_constraint_wrist + '.ANIM_arm_' + side +
'W1',
cd=self.ik_fk_control + '.ikfk',
v=1,
dv=0)
cmds.setDrivenKeyframe(orient_constraint_wrist + '.ANIM_arm_' + side +
'W1',
cd=self.ik_fk_control + '.ikfk',
v=0,
dv=1)
#hide visiblity
condition = cmds.shadingNode('condition',
asUtility=True,
n='condition_node' + arm_control)
cmds.connectAttr(self.ik_fk_control + '.ikfk',
condition + '.firstTerm')
cmds.connectAttr(condition + '.outColorR', arm_control + '.visibility')
cmds.connectAttr(condition + '.outColorR', pv + '.visibility')
cmds.setAttr(condition + '.colorIfTrueR', 1)
cmds.setAttr(condition + '.colorIfFalseR', 0)
#make a joint for stretching
self.stretchy_joint = cmds.joint()
cmds.setAttr(self.stretchy_joint + '.drawStyle', 2)
cmds.matchTransform(self.stretchy_joint, arm_control)
cmds.parent(self.stretchy_joint, arm_control)
def rigModule(self, *args):
Base.StartClass.rigModule(self)
# verify if the guide exists:
if cmds.objExists(self.moduleGrp):
try:
hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True)
except:
hideJoints = 1
# declare lists to store names and attributes:
self.worldRefList, self.headCtrlList = [], []
self.aCtrls, self.aLCtrls, self.aRCtrls = [], [], []
# start as no having mirror:
sideList = [""]
# analisys the mirror module:
self.mirrorAxis = cmds.getAttr(self.moduleGrp+".mirrorAxis")
if self.mirrorAxis != 'off':
# get rigs names:
self.mirrorNames = cmds.getAttr(self.moduleGrp+".mirrorName")
# get first and last letters to use as side initials (prefix):
sideList = [ self.mirrorNames[0]+'_', self.mirrorNames[len(self.mirrorNames)-1]+'_' ]
for s, side in enumerate(sideList):
duplicated = cmds.duplicate(self.moduleGrp, name=side+self.userGuideName+'_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated, allDescendents=True)
for item in allGuideList:
cmds.rename(item, side+self.userGuideName+"_"+item)
self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True)
cmds.parent(side+self.userGuideName+'_Guide_Base', self.mirrorGrp, absolute=True)
# re-rename grp:
cmds.rename(self.mirrorGrp, side+self.userGuideName+'_'+self.mirrorGrp)
# do a group mirror with negative scaling:
if s == 1:
for axis in self.mirrorAxis:
cmds.setAttr(side+self.userGuideName+'_'+self.mirrorGrp+'.scale'+axis, -1)
else: # if not mirror:
duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName+'_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated, allDescendents=True)
for item in allGuideList:
cmds.rename(item, self.userGuideName+"_"+item)
self.mirrorGrp = cmds.group(self.userGuideName+'_Guide_Base', name="Guide_Base_Grp", relative=True)
# re-rename grp:
cmds.rename(self.mirrorGrp, self.userGuideName+'_'+self.mirrorGrp)
# store the number of this guide by module type
dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1
# run for all sides
for s, side in enumerate(sideList):
# redeclaring variables:
self.base = side+self.userGuideName+"_Guide_Base"
self.cvNeckLoc = side+self.userGuideName+"_Guide_neck"
self.cvHeadLoc = side+self.userGuideName+"_Guide_head"
self.cvJawLoc = side+self.userGuideName+"_Guide_jaw"
self.cvChinLoc = side+self.userGuideName+"_Guide_chin"
self.cvLLipLoc = side+self.userGuideName+"_Guide_lLip"
self.cvRLipLoc = side+self.userGuideName+"_Guide_rLip"
self.cvEndJoint = side+self.userGuideName+"_Guide_JointEnd"
# creating joints:
self.neckJnt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['c_neck']+"_Jnt")
self.headJxt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['c_head']+"_Jxt")
cmds.select(clear=True)
self.headJnt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['c_head']+"_Jnt", scaleCompensate=False)
self.jawJnt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['c_jaw']+"_Jnt", scaleCompensate=False)
self.chinJnt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['c_chin']+"_Jnt", scaleCompensate=False)
self.endJnt = cmds.joint(name=side+self.userGuideName+"_JEnd", scaleCompensate=False)
cmds.select(clear=True)
self.lLipJnt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['p002_left']+"_"+self.langDic[self.langName]['c_lip']+"_Jnt", scaleCompensate=False)
cmds.select(clear=True)
self.rLipJnt = cmds.joint(name=side+self.userGuideName+"_"+self.langDic[self.langName]['p003_right']+"_"+self.langDic[self.langName]['c_lip']+"_Jnt", scaleCompensate=False)
dpARJointList = [self.neckJnt, self.headJnt, self.jawJnt, self.chinJnt, self.lLipJnt, self.rLipJnt]
for dpARJoint in dpARJointList:
cmds.addAttr(dpARJoint, longName='dpAR_joint', attributeType='float', keyable=False)
# creating controls:
self.neckCtrl = ctrls.cvNeck(ctrlName=side+self.userGuideName+"_"+self.langDic[self.langName]['c_neck']+"_Ctrl", r=self.ctrlRadius/2.0)
self.headCtrl = ctrls.cvHead(ctrlName=side+self.userGuideName+"_"+self.langDic[self.langName]['c_head']+"_Ctrl", r=self.ctrlRadius/2.0)
self.jawCtrl = ctrls.cvJaw( ctrlName=side+self.userGuideName+"_"+self.langDic[self.langName]['c_jaw']+"_Ctrl", r=self.ctrlRadius/2.0)
self.chinCtrl = ctrls.cvChin(ctrlName=side+self.userGuideName+"_"+self.langDic[self.langName]['c_chin']+"_Ctrl", r=self.ctrlRadius/2.0)
self.lLipCtrl = cmds.circle(name=self.langDic[self.langName]['p002_left']+"_"+side+self.userGuideName+"_"+self.langDic[self.langName]['c_lip']+"_Ctrl", ch=False, o=True, nr=(0, 0, 1), d=3, s=8, radius=(self.ctrlRadius * 0.25))[0]
self.rLipCtrl = cmds.circle(name=self.langDic[self.langName]['p003_right']+"_"+side+self.userGuideName+"_"+self.langDic[self.langName]['c_lip']+"_Ctrl", ch=False, o=True, nr=(0, 0, 1), d=3, s=8, radius=(self.ctrlRadius * 0.25))[0]
self.headCtrlList.append(self.headCtrl)
self.aCtrls.append([self.neckCtrl, self.headCtrl, self.jawCtrl, self.chinCtrl])
self.aLCtrls.append([self.lLipCtrl])
self.aRCtrls.append([self.rLipCtrl])
#Setup Axis Order
if self.rigType == Base.RigType.quadruped:
cmds.setAttr(self.neckCtrl + ".rotateOrder", 1)
cmds.setAttr(self.headCtrl + ".rotateOrder", 1)
cmds.setAttr(self.jawCtrl + ".rotateOrder", 1)
else:
cmds.setAttr(self.neckCtrl + ".rotateOrder", 3)
cmds.setAttr(self.headCtrl + ".rotateOrder", 3)
cmds.setAttr(self.jawCtrl + ".rotateOrder", 3)
# creating the originedFrom attributes (in order to permit integrated parents in the future):
utils.originedFrom(objName=self.neckCtrl, attrString=self.base+";"+self.cvNeckLoc)
utils.originedFrom(objName=self.headCtrl, attrString=self.cvHeadLoc)
utils.originedFrom(objName=self.jawCtrl, attrString=self.cvJawLoc)
utils.originedFrom(objName=self.chinCtrl, attrString=self.cvChinLoc+";"+self.cvEndJoint)
# edit the mirror shape to a good direction of controls:
ctrlList = [ self.neckCtrl, self.headCtrl, self.jawCtrl, self.chinCtrl ]
if s == 1:
for ctrl in ctrlList:
if self.mirrorAxis == 'X':
cmds.setAttr(ctrl+'.rotateY', 180)
elif self.mirrorAxis == 'Y':
cmds.setAttr(ctrl+'.rotateY', 180)
elif self.mirrorAxis == 'Z':
cmds.setAttr(ctrl+'.rotateX', 180)
cmds.setAttr(ctrl+'.rotateZ', 180)
elif self.mirrorAxis == 'XYZ':
cmds.setAttr(ctrl+'.rotateX', 180)
cmds.setAttr(ctrl+'.rotateZ', 180)
cmds.makeIdentity(ctrlList, apply=True, translate=False, rotate=True, scale=False)
# temporary parentConstraints:
tempDelNeck = cmds.parentConstraint(self.cvNeckLoc, self.neckCtrl, maintainOffset=False)
tempDelHead = cmds.parentConstraint(self.cvHeadLoc, self.headCtrl, maintainOffset=False)
tempDelJaw = cmds.parentConstraint(self.cvJawLoc, self.jawCtrl, maintainOffset=False)
tempDelChin = cmds.parentConstraint(self.cvChinLoc, self.chinCtrl, maintainOffset=False)
tempDelLLip = cmds.parentConstraint(self.cvLLipLoc, self.lLipCtrl, maintainOffset=False)
tempDelRLip = cmds.parentConstraint(self.cvRLipLoc, self.rLipCtrl, maintainOffset=False)
cmds.delete(tempDelNeck, tempDelHead, tempDelJaw, tempDelChin, tempDelLLip, tempDelRLip)
# zeroOut controls:
self.zeroLipCtrlList = utils.zeroOut([self.lLipCtrl, self.rLipCtrl])
self.lLipGrp = cmds.group(self.lLipCtrl, name=self.lLipCtrl+"_Grp")
self.rLipGrp = cmds.group(self.rLipCtrl, name=self.rLipCtrl+"_Grp")
self.zeroCtrlList = utils.zeroOut([self.neckCtrl, self.headCtrl, self.jawCtrl, self.chinCtrl, self.zeroLipCtrlList[0], self.zeroLipCtrlList[1]])
# make joints be ride by controls:
cmds.makeIdentity(self.neckJnt, self.headJxt, self.headJnt, self.jawJnt, self.chinJnt, self.endJnt, rotate=True, apply=True)
cmds.parentConstraint(self.neckCtrl, self.neckJnt, maintainOffset=False, name=self.neckJnt+"_ParentConstraint")
cmds.scaleConstraint(self.neckCtrl, self.neckJnt, maintainOffset=False, name=self.neckJnt+"_ScaleConstraint")
cmds.delete(cmds.parentConstraint(self.headCtrl, self.headJxt, maintainOffset=False))
cmds.parentConstraint(self.headCtrl, self.headJnt, maintainOffset=False, name=self.headJnt+"_ParentConstraint")
cmds.parentConstraint(self.jawCtrl, self.jawJnt, maintainOffset=False, name=self.jawJnt+"_ParentConstraint")
cmds.parentConstraint(self.chinCtrl, self.chinJnt, maintainOffset=False, name=self.chinJnt+"_ParentConstraint")
cmds.parentConstraint(self.lLipCtrl, self.lLipJnt, maintainOffset=False, name=self.lLipJnt+"_ParentConstraint")
cmds.parentConstraint(self.rLipCtrl, self.rLipJnt, maintainOffset=False, name=self.rLipJnt+"_ParentConstraint")
cmds.scaleConstraint(self.headCtrl, self.headJnt, maintainOffset=False, name=self.headJnt+"_ScaleConstraint")
cmds.scaleConstraint(self.jawCtrl, self.jawJnt, maintainOffset=False, name=self.jawJnt+"_ScaleConstraint")
cmds.scaleConstraint(self.chinCtrl, self.chinJnt, maintainOffset=False, name=self.chinJnt+"_ScaleConstraint")
cmds.scaleConstraint(self.lLipCtrl, self.lLipJnt, maintainOffset=False, name=self.lLipJnt+"_ScaleConstraint")
cmds.scaleConstraint(self.rLipCtrl, self.rLipJnt, maintainOffset=False, name=self.rLipJnt+"_ScaleConstraint")
cmds.delete(cmds.parentConstraint(self.cvEndJoint, self.endJnt, maintainOffset=False))
cmds.setAttr(self.jawJnt+".segmentScaleCompensate", 0)
cmds.setAttr(self.chinJnt+".segmentScaleCompensate", 0)
# create interations between neck and head:
self.grpNeck = cmds.group(self.zeroCtrlList[0], name=self.neckCtrl+"_Grp")
self.grpHeadA = cmds.group(empty=True, name=self.headCtrl+"_A_Grp")
self.grpHead = cmds.group(self.grpHeadA, name=self.headCtrl+"_Grp")
# arrange pivots:
self.neckPivot = cmds.xform(self.neckCtrl, query=True, worldSpace=True, translation=True)
self.headPivot = cmds.xform(self.headCtrl, query=True, worldSpace=True, translation=True)
cmds.xform(self.grpNeck, pivots=(self.neckPivot[0], self.neckPivot[1], self.neckPivot[2]))
cmds.xform(self.grpHead, self.grpHeadA, pivots=(self.headPivot[0], self.headPivot[1], self.headPivot[2]))
self.worldRef = cmds.group(empty=True, name=side+self.userGuideName+"_WorldRef")
self.worldRefList.append(self.worldRef)
cmds.delete(cmds.parentConstraint(self.neckCtrl, self.worldRef, maintainOffset=False))
cmds.parentConstraint(self.neckCtrl, self.grpHeadA, maintainOffset=True, skipRotate=["x", "y", "z"], name=self.grpHeadA+"_ParentConstraint")
orientConst = cmds.orientConstraint(self.neckCtrl, self.worldRef, self.grpHeadA, maintainOffset=False, name=self.grpHeadA+"_OrientConstraint")[0]
cmds.scaleConstraint(self.neckCtrl, self.grpHeadA, maintainOffset=True, name=self.grpHeadA+"_ScaleConstraint")
cmds.parent(self.zeroCtrlList[1], self.grpHeadA, absolute=True)
# connect reverseNode:
cmds.addAttr(self.headCtrl, longName=self.langDic[self.langName]['c_Follow'], attributeType='float', minValue=0, maxValue=1, keyable=True)
cmds.connectAttr(self.headCtrl+'.'+self.langDic[self.langName]['c_Follow'], orientConst+"."+self.neckCtrl+"W0", force=True)
self.headRevNode = cmds.createNode('reverse', name=side+self.userGuideName+"_Rev")
cmds.connectAttr(self.headCtrl+'.'+self.langDic[self.langName]['c_Follow'], self.headRevNode+".inputX", force=True)
cmds.connectAttr(self.headRevNode+'.outputX', orientConst+"."+self.worldRef+"W1", force=True)
# mount controls hierarchy:
cmds.parent(self.zeroCtrlList[3], self.jawCtrl, absolute=True)
# jaw follow head or root ctrl (using worldRef)
jawParentConst = cmds.parentConstraint(self.headCtrl, self.worldRef, self.zeroCtrlList[2], maintainOffset=True, name=self.zeroCtrlList[2]+"_ParentConstraint")[0]
cmds.setAttr(jawParentConst+".interpType", 2) #Shortest, no flip cause problem with scrubing
cmds.addAttr(self.jawCtrl, longName=self.langDic[self.langName]['c_Follow'], attributeType="float", minValue=0, maxValue=1, defaultValue=1, keyable=True)
cmds.connectAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_Follow'], jawParentConst+"."+self.headCtrl+"W0", force=True)
jawFollowRev = cmds.createNode("reverse", name=self.jawCtrl+"_Rev")
cmds.connectAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_Follow'], jawFollowRev+".inputX", force=True)
cmds.connectAttr(jawFollowRev+".outputX", jawParentConst+"."+self.worldRef+"W1", force=True)
cmds.scaleConstraint(self.headCtrl, self.zeroCtrlList[2], maintainOffset=True, name=self.zeroCtrlList[2]+"_ScaleConstraint")[0]
# setup jaw auto translation
self.jawSdkGrp = cmds.group(self.jawCtrl, name=self.jawCtrl+"_SDK_Grp")
cmds.addAttr(self.jawCtrl, longName=self.langDic[self.langName]['c_moveIntensity']+"Y", attributeType='float', keyable=True)
cmds.addAttr(self.jawCtrl, longName=self.langDic[self.langName]['c_moveIntensity']+"Z", attributeType='float', keyable=True)
cmds.addAttr(self.jawCtrl, longName=self.langDic[self.langName]['c_moveStartRotation'], attributeType='float', keyable=True)
cmds.setAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveIntensity']+"Y", keyable=False, channelBox=True)
cmds.setAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveIntensity']+"Z", keyable=False, channelBox=True)
cmds.setAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveStartRotation'], keyable=False, channelBox=True)
cmds.setAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveIntensity']+"Y", 1)
cmds.setAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveIntensity']+"Z", 2)
cmds.setAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveStartRotation'], 10)
self.jawIntensityFixUnitMD = cmds.createNode('multiplyDivide', name="JawMoveIntensityFixUnit_MD")
self.jawIntensityMD = cmds.createNode('multiplyDivide', name="JawMoveIntensity_MD")
self.jawIntensityZMD = cmds.createNode('multiplyDivide', name="JawMoveIntensityZ_MD")
self.jawStartIntensityMD = cmds.createNode('multiplyDivide', name="JawMoveIntensityStart_MD")
self.jawIntensityPMA = cmds.createNode('plusMinusAverage', name="JawMoveIntensity_PMA")
self.jawIntensityCnd = cmds.createNode('condition', name="JawMoveIntensity_Cnd")
cmds.connectAttr(self.jawCtrl+".rotateX", self.jawIntensityMD+".input1Y", force=True)
cmds.connectAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveIntensity']+"Y", self.jawIntensityFixUnitMD+".input1Y", force=True)
cmds.connectAttr(self.jawIntensityFixUnitMD+".outputY", self.jawIntensityMD+".input2Y", force=True)
cmds.setAttr(self.jawIntensityFixUnitMD+".input2Y", -0.01)
cmds.connectAttr(self.jawIntensityFixUnitMD+".outputY", self.jawStartIntensityMD+".input1X", force=True)
cmds.connectAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveStartRotation'], self.jawStartIntensityMD+".input2X", force=True)
cmds.setAttr(self.jawIntensityPMA+".operation", 2)
cmds.connectAttr(self.jawIntensityMD+".outputY", self.jawIntensityPMA+".input1D[0]", force=True)
cmds.connectAttr(self.jawStartIntensityMD+".outputX", self.jawIntensityPMA+".input1D[1]", force=True)
cmds.connectAttr(self.jawIntensityPMA+".output1D", self.jawIntensityCnd+".colorIfTrueG", force=True)
cmds.connectAttr(self.jawCtrl+".rotateX", self.jawIntensityCnd+".firstTerm", force=True)
cmds.connectAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveStartRotation'], self.jawIntensityCnd+".secondTerm", force=True)
cmds.setAttr(self.jawIntensityCnd+".operation", 2)
cmds.setAttr(self.jawIntensityCnd+".colorIfFalseG", 0)
cmds.connectAttr(self.jawIntensityCnd+".outColorG", self.jawSdkGrp+".translateY", force=True)
cmds.connectAttr(self.jawIntensityCnd+".outColorG", self.jawIntensityZMD+".input1Z", force=True)
cmds.connectAttr(self.jawCtrl+"."+self.langDic[self.langName]['c_moveIntensity']+"Z", self.jawIntensityFixUnitMD+".input1Z", force=True)
cmds.setAttr(self.jawIntensityFixUnitMD+".input2Z", -0.1)
cmds.connectAttr(self.jawIntensityFixUnitMD+".outputZ", self.jawIntensityZMD+".input2Z", force=True)
cmds.connectAttr(self.jawIntensityZMD+".outputZ", self.jawSdkGrp+".translateZ", force=True)
# create lip setup:
# left side lip:
lLipParentConst = cmds.parentConstraint(self.jawCtrl, self.headCtrl, self.lLipGrp, maintainOffset=True, name=self.lLipGrp+"_ParentConstraint")[0]
cmds.setAttr(lLipParentConst+".interpType", 2)
cmds.addAttr(self.lLipCtrl, longName=self.langDic[self.langName]['c_Follow'], attributeType='float', minValue=0, maxValue=1, defaultValue=0.5, keyable=True)
cmds.connectAttr(self.lLipCtrl+'.'+self.langDic[self.langName]['c_Follow'], lLipParentConst+"."+self.jawCtrl+"W0", force=True)
self.lLipRevNode = cmds.createNode('reverse', name=side+self.userGuideName+"_"+self.langDic[self.langName]['p002_left']+"_"+self.langDic[self.langName]['c_lip']+"_Rev")
cmds.connectAttr(self.lLipCtrl+'.'+self.langDic[self.langName]['c_Follow'], self.lLipRevNode+".inputX", force=True)
cmds.connectAttr(self.lLipRevNode+'.outputX', lLipParentConst+"."+self.headCtrl+"W1", force=True)
cmds.scaleConstraint(self.headCtrl, self.lLipGrp, maintainOffset=True, name=self.lLipGrp+"_ScaleConstraint")[0]
# right side lip:
rLipParentConst = cmds.parentConstraint(self.jawCtrl, self.headCtrl, self.rLipGrp, maintainOffset=True, name=self.rLipGrp+"_ParentConstraint")[0]
cmds.setAttr(rLipParentConst+".interpType", 2)
cmds.addAttr(self.rLipCtrl, longName=self.langDic[self.langName]['c_Follow'], attributeType='float', minValue=0, maxValue=1, defaultValue=0.5, keyable=True)
cmds.connectAttr(self.rLipCtrl+'.'+self.langDic[self.langName]['c_Follow'], rLipParentConst+"."+self.jawCtrl+"W0", force=True)
self.rLipRevNode = cmds.createNode('reverse', name=side+self.userGuideName+"_"+self.langDic[self.langName]['p003_right']+"_"+self.langDic[self.langName]['c_lip']+"_Rev")
cmds.connectAttr(self.rLipCtrl+'.'+self.langDic[self.langName]['c_Follow'], self.rLipRevNode+".inputX", force=True)
cmds.connectAttr(self.rLipRevNode+'.outputX', rLipParentConst+"."+self.headCtrl+"W1", force=True)
cmds.scaleConstraint(self.headCtrl, self.rLipGrp, maintainOffset=True, name=self.rLipGrp+"_ScaleConstraint")[0]
# create a locator in order to avoid delete static group
loc = cmds.spaceLocator(name=side+self.userGuideName+"_DO_NOT_DELETE")[0]
cmds.parent(loc, self.worldRef, absolute=True)
cmds.setAttr(loc+".visibility", 0)
ctrls.setLockHide([loc], ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'])
# hiding visibility attributes:
ctrls.setLockHide([self.headCtrl, self.neckCtrl, self.jawCtrl, self.chinCtrl], ['v'], l=False)
# create a masterModuleGrp to be checked if this rig exists:
self.toCtrlHookGrp = cmds.group(self.grpNeck, self.grpHead, self.zeroCtrlList[2], self.zeroCtrlList[4], self.zeroCtrlList[5], name=side+self.userGuideName+"_Control_Grp")
self.toScalableHookGrp = cmds.group(self.neckJnt, self.headJnt, self.lLipJnt, self.rLipJnt, name=side+self.userGuideName+"_Joint_Grp")
self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, self.grpHead, self.worldRef, name=side+self.userGuideName+"_Grp")
cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string")
cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string")
cmds.setAttr(self.toStaticHookGrp+".dpAR_name", self.userGuideName, type="string")
cmds.setAttr(self.toStaticHookGrp+".dpAR_type", CLASS_NAME, type="string")
# add module type counter value
cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False)
cmds.setAttr(self.toStaticHookGrp+'.dpAR_count', dpAR_count)
# add hook attributes to be read when rigging integrated modules:
utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook')
utils.addHook(objName=self.grpHead, hookType='rootHook')
utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook')
utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook')
#Ensure head Jxt matrix
mHead = cmds.getAttr(self.headCtrl + ".worldMatrix")
cmds.xform(self.headJxt, m=mHead, ws=True)
if hideJoints:
cmds.setAttr(self.toScalableHookGrp+".visibility", 0)
# delete duplicated group for side (mirror):
cmds.delete(side+self.userGuideName+'_'+self.mirrorGrp)
# finalize this rig:
self.integratingInfo()
cmds.select(clear=True)
# delete UI (moduleLayout), GUIDE and moduleInstance namespace:
self.deleteModule()
def build_hip(hip,
pelvis,
numJoints=4,
hipAim='x',
hipFront='y',
pelvisAim='x',
pelvisFront='y',
enableCtrl=False,
prefix=''):
'''
Build hip twist using custom hipConstraint node
@param hip: Hip or upper leg joint
@type hip: str
@param pelvis: Pelvis joint
@type pelvis: str
@param numJoint: Number of twist joints to generate
@type numJoint: int
@param hipAim: Axis along the length of the hip/leg joint
@type hipAim: list or tuple
@param hipFront: Forward facing axis of the hip/leg joint
@type hipFront: list or tuple
@param pelvisAim: Axis along the length of the pelvis joint
@type pelvisAim: list or tuple
@param pelvisFront: Forward facing axis of the pelvis joint
@type pelvisFront: list or tuple
@param enableCtrl: Enable the twist child joint as a control
@type enableCtrl: bool
@param prefix: Naming prefix for created nodes
@type prefix: str
'''
# ==========
# - Checks -
# ==========
# Define Axis Dictionary
axisDict = {
'x': (1, 0, 0),
'y': (0, 1, 0),
'z': (0, 0, 1),
'-x': (-1, 0, 0),
'-y': (0, -1, 0),
'-z': (0, 0, -1)
}
if not mc.objExists(hip):
raise Exception('Hip joint "' + hip + '" does not exist!')
if not mc.objExists(pelvis):
raise Exception('Pelvis joint "' + pelvis + '" does not exist!')
if not axisDict.has_key(hipAim):
raise Exception('Invalid hip aim axis value! ("' + hipAim + '")')
if not axisDict.has_key(hipFront):
raise Exception('Invalid hip front axis value! ("' + hipFront + '")')
if not axisDict.has_key(pelvisAim):
raise Exception('Invalid pelvis aim axis value! ("' + pelvisAim + '")')
if not axisDict.has_key(pelvisFront):
raise Exception('Invalid pelvis front axis value! ("' + pelvisFront +
'")')
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(hip)
# Check Plugin
if not mc.pluginInfo('twistConstraint', q=True, l=True):
try:
mc.loadPlugin('twistConstraint')
except:
raise Exception('Unable to load plugin "twistConstraint"!')
# ======================
# - Configure Modifier -
# ======================
twistCtrlScale = 0.2
ctrlBuilder = glTools.tools.controlBuilder.ControlBuilder()
# =======================
# - Create Twist Joints -
# =======================
twistJoints = createTwistJoints(joint=hip,
numTwistJoints=numJoints,
offsetAxis=hipAim[-1],
prefix=prefix)
# Reverse twist joint list
twistJoints.reverse()
# Create Twist Driver Joint
mc.select(cl=True)
hipTwist = mc.joint(n=prefix + '_twistDrive_jnt')
hipTwistGrp = glTools.utils.joint.group(hipTwist)
mc.delete(mc.parentConstraint(hip, hipTwistGrp))
mc.parent(hipTwistGrp, hip)
glTools.utils.base.displayOverride(hipTwist,
overrideEnable=1,
overrideDisplay=2,
overrideLOD=0)
# Create Hip Twist Joints
twistJointGrps = []
twistFactor = 1.0 / (len(twistJoints) - 1)
jntLen = glTools.utils.joint.length(hip)
for i in range(len(twistJoints)):
# Add Twist Control Attribute
mc.addAttr(twistJoints[i],
ln='twist',
min=-1.0,
max=1.0,
dv=twistFactor * i)
# Add Twist Joint Group
twistJointGrp = glTools.utils.joint.group(twistJoints[i],
indexStr='Twist')
twistJointGrps.append(twistJointGrp)
# Tag Bind Joint
glTools.rig.utils.tagBindJoint(twistJoints[i], True)
# Create Joint Control
if enableCtrl:
glTools.rig.utils.tagCtrl(twistJoints[i], 'tertiary')
ctrlBuilder.controlShape(transform=twistJoints[i],
controlType='sphere',
controlScale=twistCtrlScale)
# Set Display Override
if enableCtrl:
glTools.utils.base.displayOverride(twistJoints[i],
overrideEnable=1,
overrideDisplay=0,
overrideLOD=1)
else:
glTools.utils.base.displayOverride(twistJoints[i],
overrideEnable=1,
overrideDisplay=2,
overrideLOD=0)
# Create Twist Group
twistGrp = mc.joint(n=prefix + '_twistJoint_grp')
glTools.utils.base.displayOverride(twistGrp,
overrideEnable=1,
overrideLOD=1)
glTools.utils.transform.match(twistGrp, hip)
mc.setAttr(twistGrp + '.segmentScaleCompensate', 0)
mc.setAttr(twistGrp + '.drawStyle', 2) # None
mc.setAttr(twistGrp + '.radius', 0)
mc.parent(twistGrp, hip)
mc.parent(twistJointGrps, twistGrp)
# Connect Inverse Scale
for twistJointGrp in twistJointGrps:
mc.connectAttr(hip + '.scale', twistJointGrp + '.inverseScale', f=True)
# ==========================
# - Create Hip Twist Setup -
# ==========================
# Create hipConstraint node
hipCon = mc.createNode('hipConstraint', n=prefix + '_hipConstraint')
# Set and connect hipConstraint attributes
mc.connectAttr(hip + '.worldMatrix[0]', hipCon + '.hip', f=True)
mc.connectAttr(pelvis + '.worldMatrix[0]', hipCon + '.pelvis', f=True)
mc.connectAttr(hipTwist + '.parentInverseMatrix[0]',
hipCon + '.parentInverseMatrix',
f=True)
mc.connectAttr(hipTwist + '.rotateOrder', hipCon + '.rotateOrder', f=True)
mc.connectAttr(hipTwist + '.jointOrient', hipCon + '.jointOrient', f=True)
mc.setAttr(hipCon + '.hipAim', *axisDict[hipAim])
mc.setAttr(hipCon + '.hipFront', *axisDict[hipFront])
mc.setAttr(hipCon + '.pelvisAim', *axisDict[pelvisAim])
mc.setAttr(hipCon + '.pelvisFront', *axisDict[pelvisFront])
# Connect to hip twist joint
mc.connectAttr(hipCon + '.outRotate', hipTwist + '.rotate', f=True)
# Correct initial offset
twistOffset = mc.getAttr(hipTwist + '.r' + hipAim[-1])
mc.setAttr(hipTwist + '.jo' + hipAim[-1], twistOffset)
# ========================
# - Connect Twist Joints -
# ========================
twistMultNode = []
for i in range(len(twistJoints)):
alphaInd = glTools.utils.stringUtils.alphaIndex(i, upper=True)
twistMult = mc.createNode('multDoubleLinear',
n=prefix + '_twist' + alphaInd +
'_multDoubleLinear')
mc.connectAttr(hipTwist + '.r' + hipAim[-1],
twistMult + '.input1',
f=True)
mc.connectAttr(twistJoints[i] + '.twist',
twistMult + '.input2',
f=True)
mc.connectAttr(twistMult + '.output',
twistJointGrps[i] + '.r' + hipAim[-1],
f=True)
twistMultNode.append(twistMult)
# Reverse twist joint list
twistJoints.reverse()
# ======================
# - Set Channel States -
# ======================
chStateUtil = glTools.utils.channelState.ChannelState()
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[twistGrp])
chStateUtil.setFlags([0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
objectList=twistJoints)
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
objectList=twistJointGrps)
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
objectList=[hipTwistGrp])
chStateUtil.setFlags([2, 2, 2, 1, 1, 1, 2, 2, 2, 1], objectList=[hipTwist])
# =================
# - Return Result -
# =================
result = {}
result['twistGrp'] = twistGrp
result['twistJoints'] = twistJoints
result['twistJointGrps'] = twistJointGrps
result['twistDriveJoint'] = hipTwist
result['twistConstraint'] = hipCon
result['twistMultNodes'] = twistMultNode
return result
def make_arm_rig(self, side, clavicle, shoulder, elbow, wrist, color):
#variables
if not cmds.objExists('joints'):
cmds.group(em=True, n='joints')
cmds.group(em=True, n='controls')
cmds.group(em=True, n='IKs')
else:
pass
self.controls = []
# disconnect shoulder joint
cmds.disconnectJoint(shoulder)
new_joint = cmds.pickWalk(clavicle, d='down')
clavicle_end = cmds.rename(new_joint, clavicle + '_end')
cmds.disconnectJoint(wrist)
new_joint = cmds.pickWalk(elbow, d='down')
elbow_end = cmds.rename(new_joint, elbow + '_end')
# duplicate arm
cmds.duplicate(shoulder, n='shoulder_' + side + '_ik')
cmds.duplicate(shoulder, n='shoulder_' + side + '_fk')
# variables for fk chain
fk_shoulder = 'shoulder_' + side + '_fk'
temp = cmds.pickWalk(fk_shoulder, d='down')
fk_elbow = cmds.rename(temp, 'elbow_' + side + '_fk')
temp = cmds.pickWalk(fk_elbow, d='down')
fk_elbow_end = cmds.rename(temp, 'elbow_' + side + '_end_fk')
cmds.parent(fk_shoulder, clavicle_end)
# variables for ik chain
ik_shoulder = 'shoulder_' + side + '_ik'
temp = cmds.pickWalk(ik_shoulder, d='down')
ik_elbow = cmds.rename(temp, 'elbow_' + side + '_ik')
temp = cmds.pickWalk(ik_elbow, d='down')
ik_elbow_end = cmds.rename(temp, 'elbow_' + side + '_end_ik')
# create ik_fk_switch control
legs = leg_rig.create_rig()
legs.create_ik_fk_switch(side, 'wrist_' + side + '_bind', 'arm', color,
0, 0, -5, [0, 1, 0])
cmds.matchTransform('ik_fk_arm_' + side + '_Grp', wrist)
self.ik_fk_control = 'ik_fk_arm_' + side
cmds.parent(wrist, elbow_end)
#create ik fk chains
self.make_fk_joint_chain(fk_shoulder, fk_elbow, wrist, color)
cmds.parent(fk_shoulder, w=True)
self.make_ik_joint_chain(side, ik_shoulder, ik_elbow, ik_elbow_end,
wrist, color)
# create ikfk switch
self.ik_fk_switch(fk_shoulder, ik_shoulder, shoulder)
self.ik_fk_switch(fk_elbow, ik_elbow, elbow)
# make clavicle controls
self.make_clavicle_controls(clavicle, side, color)
cmds.parentConstraint(cmds.pickWalk(clavicle, d='down'), ik_shoulder)
# parent everything to groups
cmds.parent(fk_shoulder, ik_shoulder, shoulder, 'joints')
self.l.stretchy(ik_shoulder, wrist, 'arm_stretchy_curve_' + side, side,
shoulder, elbow, self.stretchy_joint,
self.ik_fk_control)
def intersect():
activeSelList = om.MGlobal.getActiveSelectionList()
selListIt = om.MItSelectionList(activeSelList)
sportLightTransformNode = None
# spotLightDP = None
# meshTransformNode = None
meshDP = None
while not selListIt.isDone():
nodeDP = selListIt.getDagPath()
if nodeDP.apiType() == om.MFn.kTransform:
dagNodeFn = om.MFnDagNode(nodeDP)
nodeDP = dagNodeFn.child(0)
if nodeDP.apiType() == om.MFn.kSpotLight:
# spotLightDP = nodeDP
sportLightTransformNode = dagNodeFn
elif nodeDP.apiType() == om.MFn.kMesh:
meshDP = nodeDP
# meshTransformNode = dagNodeFn
selListIt.next()
tx = sportLightTransformNode.findPlug('tx', False).asFloat()
ty = sportLightTransformNode.findPlug('ty', False).asFloat()
tz = sportLightTransformNode.findPlug('tz', False).asFloat()
fpSource = om.MFloatPoint(tx, ty, tz)
fvRayDir = getLightDirection(sportLightTransformNode.name())
meshFn = om.MFnMesh(om.MDagPath.getAPathTo(meshDP))
mmAccelParams = meshFn.autoUniformGridParams()
hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2 = meshFn.anyIntersection(
fpSource,
fvRayDir,
om.MSpace.kWorld,
9999.,
False,
accelParams=mmAccelParams,
tolerance=float(1e-6))
if hitRayParam == 0.0:
print('There were no intersection points detected')
return
hitPoints, hitRayParams, hitFaces, hitTriangles, hitBary1s, hitBary2s = meshFn.allIntersections(
fpSource, fvRayDir, om.MSpace.kWorld, 9999., False, tolerance=0.000001)
normals = meshFn.getNormals(om.MSpace.kWorld)
i = 0
for hp in hitPoints:
arrow = RayArrow()
constraint = cmds.pointConstraint(sportLightTransformNode.name(),
arrow.botHandle)
cmds.delete(constraint)
cube = cmds.polyCube()
cmds.move(hp.x, hp.y, hp.z, ws=1)
constraint = cmds.pointConstraint(cube[0], arrow.topHandle)
cmds.delete(cube + constraint)
arrow.orient()
# reflection
# R = 2(N dot L)N - L
# L: fvRayDir
faceId = hitFaces[i]
# N
faceNormal = normals[meshFn.getFaceNormalIds(faceId)[0]]
# R
refl = 2 * (faceNormal * fvRayDir) * faceNormal - fvRayDir
# reflection arrow
arrowRefl = RayArrow()
constraint = cmds.pointConstraint(arrow.topHandle, arrowRefl.botHandle)
cmds.delete(constraint)
selListIt = om.MSelectionList()
selListIt.add(arrowRefl.botHandle)
selListIt.add(arrowRefl.topHandle)
# move and rotate botHandle
reflBotTran = om.MFnTransform(selListIt.getDagPath(0))
reflBotTran.setRotation(om.MEulerRotation(refl), om.MSpace.kTransform)
# move and rotate topHandle
constraint = cmds.parentConstraint(arrowRefl.botHandle,
arrowRefl.topHandle,
mo=0)
cmds.delete(constraint)
# reflTopTran = om.MFnTransform(selListIt.getDagPath(1))
# #reflTopTran.setRotation(om.MEulerRotation(refl), om.MSpace.kTransform)
# # topMove = om.MVector(refl)
# #topMove = om.MVector(refl + om.MFloatVector(0, 6, 0)) * reflTopTran.transformationMatrix()
# topMove = om.MVector(refl * om.MFloatVector(1, 6, 1)) * reflBotTran.transformationMatrix()
# # topMove.y += 6
# reflTopTran.setTranslation(topMove, om.MSpace.kTransform)
cmds.move(0, 6, 0, arrowRefl.topHandle, r=1, os=1, wd=1)
arrowRefl.orient()
# refraction arrow
# T = ((1/fl*N) dot L) - sqrt(1 - 1/(fl*fl)*(1 - (N dot L)*(N dot L))) * N - 1/fl * L
fl = .750
fl2 = 0.5627813555039173
a = (fl * faceNormal) * fvRayDir
b = math.sqrt(1 - fl2 * abs(1 - math.pow(faceNormal * fvRayDir, 2)))
c = a - b
refr = c * faceNormal - fl * fvRayDir
refrArrow = RayArrow()
constraint = cmds.pointConstraint(arrow.topHandle, refrArrow.botHandle)
cmds.delete(constraint)
selListIt = om.MSelectionList()
selListIt.add(refrArrow.botHandle)
selListIt.add(refrArrow.topHandle)
# move and rotate botHandle
reflBotTran = om.MFnTransform(selListIt.getDagPath(0))
reflBotTran.setRotation(om.MEulerRotation(refr), om.MSpace.kTransform)
# move and rotate topHandle
constraint = cmds.parentConstraint(refrArrow.botHandle,
refrArrow.topHandle,
mo=0)
cmds.delete(constraint)
cmds.move(0, -6, 0, refrArrow.topHandle, r=1, os=1, wd=1)
refrArrow.orient()
i += 1
def _Parent_Controller(self,light,obj,*argv):
print 'parent',light,obj
if light:
for l in light:
cmds.parentConstraint(obj,l,mo=1)
def Position_Fn(self):
self.Check_Selection
cmds.delete(cmds.parentConstraint(adv, Ziva_Rig[i]))
def VK_system(num_ctr=1, num_jt=20, fk=True):
"""
final assembly of the entire system
"""
fk_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s' % (node, a), l=b, k=not b)
for a in 'tx,ty,tz,sx,sy,sz,v'.split(',')
]
ik_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s' % (node, a), l=b, k=not b)
for a in 'tx,ty,tz,ry,rz,sx,sy,sz,v'.split(',')
]
ctrl_hide_attr = lambda node, b: [
cmds.setAttr('%s.%s' % (node, a), l=b, k=not b)
for a in 'rx,ry,rz,sx,sy,sz,v'.split(',')
]
orig_cu = setup.get_curve()[0]
cu = cmds.duplicate(orig_cu, n='vks_curve#')[0]
jts = setup.chain(cu, num_jt, 'vks_orig_joint')
d_jts = setup.chain(cu, num_jt, 'vks_skin_joint')
cmds.toggle(d_jts, localAxis=True)
parameter_attr(jts)
#loft,skin
surf = create_loft(jts, 'vks_lofted_mesh')
surf_s = cmds.listRelatives(surf, c=1)[0]
#hierarchical groups
vks_grp = cmds.group(surf, name='VariableKinematicsSystem#')
mov_grp = cmds.group(em=True, parent=vks_grp, name='vks_move_grp#')
rig_grp = cmds.group(em=True, parent=vks_grp, name='vks_rig_grp#')
flc_grp = cmds.group(em=True, parent=rig_grp, name='vks_follice_grp#')
setup.lock_attr(flc_grp, 1)
setup.off_vis(rig_grp)
#create vks controls
vks_ctr = []
vks_ctr_grp = []
for i in range(num_ctr):
#create follice
vPos = setup.linstep(0., num_ctr - 1, i)
flc = setup.create_follicle(surf_s, 0.5, vPos, 'vks_follice')
flc_tr = cmds.listRelatives(flc, p=1)[0]
cmds.parent(flc_tr, flc_grp)
#create control
vkss = create_control(flc, 'vks_parametric')
vks_ctr_grp.append(vkss[0])
vks_ctr.append(vkss[-1])
#ikspline
ikhnd = cmds.ikHandle(sj=jts[0],
ee=jts[-1],
c=cu,
ccv=False,
sol='ikSplineSolver')
#create joint orig group
org_grp = cmds.group(jts[0], parent=rig_grp, n='vks_orig_grp#')
rot = cmds.xform(jts[0], q=True, ws=True, ro=True)
cmds.xform(org_grp, ws=True, ro=(rot[0], rot[1], rot[2]), piv=(0, 0, 0))
cmds.parent(cu, ikhnd[0], rig_grp)
#building explicit control
m_ctr = setup.ctrl_cube('vks_explicit#', sz=2)
cmds.parent(m_ctr, vks_grp)
tr = cmds.xform(jts[0], q=True, ws=True, t=True)
cmds.xform(m_ctr, ws=True, t=tr)
cmds.makeIdentity(m_ctr, apply=1, t=1, r=1, s=1, n=0)
cmds.parent(vks_ctr_grp, m_ctr)
cmds.parentConstraint(m_ctr, org_grp, mo=1)
cmds.parentConstraint(m_ctr, mov_grp, mo=1)
cmds.scaleConstraint(m_ctr, mov_grp)
if fk: #FK module
for c in vks_ctr:
fk_hide_attr(c, 1)
for j in jts:
jgroup = cmds.group(j, n='%s_%s' % (j, c))
piv = cmds.xform(j, q=True, ws=True, piv=True)
cmds.xform(jgroup, ws=True, piv=(piv[0], piv[1], piv[2]))
connection(c, j, jgroup)
for n, j in enumerate(jts):
cmds.parentConstraint(j, d_jts[n])
#fk length
cmds.addAttr(m_ctr, ln='length', at='double', k=1, min=0, max=10, dv=1)
v_tx = cmds.getAttr('%s.tx' % jts[1])
pma = cmds.createNode('plusMinusAverage',
n='vfk_lengthConversion_%s' % m_ctr)
cmds.setAttr("%s.input1D[0]" % pma, -1)
cmds.setAttr("%s.input1D[1]" % pma, v_tx)
cmds.connectAttr('%s.length' % m_ctr, '%s.input1D[2]' % pma)
for j in jts[1:-1]:
cmds.connectAttr('%s.output1D' % pma, '%s.tx' % j)
cmds.scaleConstraint(m_ctr, org_grp)
cmds.parent(d_jts[0], mov_grp)
cmds.delete(ikhnd)
if not fk: #IK module
jj = [j for j in jts]
for c in vks_ctr:
ik_hide_attr(c, 1)
for n, j in enumerate(jts):
jgroup = cmds.group(em=True, n='%s_%s' % (j, c), parent=jj[n])
jj[n] = jgroup
connection(c, j, jgroup)
for n in range(num_jt):
cmds.parentConstraint(jj[n], d_jts[n])
#ik stretch
cu_sc = ik_stretch(ikhnd[0])
cmds.addAttr(m_ctr,
ln="stretch",
at='double',
k=1,
min=0,
max=10,
dv=10)
ucn = setup.onetenthNode(m_ctr, 'stretch')
cmds.connectAttr('%s.output' % ucn, '%s.ik_stretch' % ikhnd[0])
cls_grp = cmds.group(em=True, name='vks_cluster_grp#')
setup.off_vis(cls_grp)
ik_cls = cluster_on_curve(cu)
for ik_cl in ik_cls:
l_ctrl, l_null = setup.local_cluster_control2(ik_cl)
ctrl_hide_attr(l_ctrl, 1)
cmds.parent(l_ctrl, m_ctr)
cmds.parent(ik_cl, l_null, cls_grp)
cmds.parent(d_jts[0], cls_grp, cu_sc, mov_grp)
cmds.select(cl=True)
def publishAsset(self, iAObj=None):
'''Publish the asset defined by the provided *iAObj*.'''
pubMessage = 'Published cameraasset asset'
# Only export selection when exporting camera
iAObj.options['exportMode'] = 'Selection'
publishedComponents = []
totalSteps = self.getTotalSteps(steps=[
iAObj.options['cameraBake'], iAObj.options['cameraMaya'],
iAObj.options['cameraAlembic'], iAObj.options['mayaPublishScene']
])
panelComInstance = panelcom.PanelComInstance.instance()
panelComInstance.setTotalExportSteps(totalSteps + 1)
# Get original selection
nodes = mc.ls(sl=True)
# Get camera shape and parent transforms
cameraShape = ''
for node in nodes:
if mc.nodeType(node) == 'camera':
cameraShape = node
else:
cameraShapes = mc.listRelatives(node,
allDescendents=True,
type='camera')
if len(cameraShapes) > 0:
# We only care about one camera
cameraShape = cameraShapes[0]
if cameraShape == '':
return None, 'No camera selected'
cameraTransform = mc.listRelatives(cameraShape,
type='transform',
parent=True)
cameraTransform = cameraTransform[0]
if iAObj.options['cameraBake']:
tmpCamComponents = mc.duplicate(cameraTransform, un=1, rc=1)
if mc.nodeType(tmpCamComponents[0]) == 'transform':
tmpCam = tmpCamComponents[0]
else:
tmpCam = mc.ls(tmpCamComponents, type='transform')[0]
pConstraint = mc.parentConstraint(cameraTransform, tmpCam)
try:
mc.parent(tmpCam, world=True)
except RuntimeError:
print 'camera already in world space'
mc.bakeResults(tmpCam,
simulation=True,
t=(float(iAObj.options['frameStart']),
float(iAObj.options['frameEnd'])),
sb=1,
at=['tx', 'ty', 'tz', 'rx', 'ry', 'rz'],
hi='below')
mc.delete(pConstraint)
cameraTransform = tmpCam
panelComInstance.emitPublishProgressStep()
if iAObj.options['cameraLock']:
# Get original lock values so we can revert after exporting
origCamLocktx = mc.getAttr('{0}.tx'.format(cameraTransform),
l=True)
origCamLockty = mc.getAttr('{0}.ty'.format(cameraTransform),
l=True)
origCamLocktz = mc.getAttr('{0}.tz'.format(cameraTransform),
l=True)
origCamLockrx = mc.getAttr('{0}.rx'.format(cameraTransform),
l=True)
origCamLockry = mc.getAttr('{0}.ry'.format(cameraTransform),
l=True)
origCamLockrz = mc.getAttr('{0}.rz'.format(cameraTransform),
l=True)
origCamLocksx = mc.getAttr('{0}.sx'.format(cameraTransform),
l=True)
origCamLocksy = mc.getAttr('{0}.sy'.format(cameraTransform),
l=True)
origCamLocksz = mc.getAttr('{0}.sz'.format(cameraTransform),
l=True)
# Lock transform
mc.setAttr('{0}.tx'.format(cameraTransform), l=True)
mc.setAttr('{0}.ty'.format(cameraTransform), l=True)
mc.setAttr('{0}.tz'.format(cameraTransform), l=True)
mc.setAttr('{0}.rx'.format(cameraTransform), l=True)
mc.setAttr('{0}.ry'.format(cameraTransform), l=True)
mc.setAttr('{0}.rz'.format(cameraTransform), l=True)
mc.setAttr('{0}.sx'.format(cameraTransform), l=True)
mc.setAttr('{0}.sy'.format(cameraTransform), l=True)
mc.setAttr('{0}.sz'.format(cameraTransform), l=True)
if iAObj.options['cameraMaya']:
iAObj.setTotalSteps = False
mayaComponents, message = GenericAsset.publishAsset(self, iAObj)
publishedComponents += mayaComponents
if iAObj.options['cameraAlembic']:
mc.loadPlugin('AbcExport.so', qt=1)
temporaryPath = HelpFunctions.temporaryFile(suffix='.abc')
publishedComponents.append(
FTComponent(componentname='alembic', path=temporaryPath))
alembicJobArgs = ''
alembicJobArgs += '-fr {0} {1}'.format(iAObj.options['frameStart'],
iAObj.options['frameEnd'])
objCommand = '-root ' + cameraTransform + ' '
alembicJobArgs += ' ' + objCommand + '-file ' + temporaryPath
alembicJobArgs += ' -step ' + str(iAObj.options['alembicSteps'])
try:
mc.AbcExport(j=alembicJobArgs)
except:
import traceback
var = traceback.format_exc()
return None, var
panelComInstance.emitPublishProgressStep()
if iAObj.options['cameraLock']:
# Revert camera locks to original
mc.setAttr('{0}.tx'.format(cameraTransform), l=origCamLocktx)
mc.setAttr('{0}.ty'.format(cameraTransform), l=origCamLockty)
mc.setAttr('{0}.tz'.format(cameraTransform), l=origCamLocktz)
mc.setAttr('{0}.rx'.format(cameraTransform), l=origCamLockrx)
mc.setAttr('{0}.ry'.format(cameraTransform), l=origCamLockry)
mc.setAttr('{0}.rz'.format(cameraTransform), l=origCamLockrz)
mc.setAttr('{0}.sx'.format(cameraTransform), l=origCamLocksx)
mc.setAttr('{0}.sy'.format(cameraTransform), l=origCamLocksy)
mc.setAttr('{0}.sz'.format(cameraTransform), l=origCamLocksz)
if iAObj.options['cameraBake']:
mc.delete(cameraTransform)
# Set back original selection
mc.select(nodes)
panelComInstance.emitPublishProgressStep()
if iAObj.options['mayaPublishScene']:
iAObjCopy = self.getSceneSettingsObj(iAObj)
sceneComponents, message = GenericAsset.publishAsset(
self, iAObjCopy)
publishedComponents += sceneComponents
return publishedComponents, pubMessage
import maya.cmds as cmds
def RunAutoRig(radioBtn):
print (radioBtn)
if radioBtn == 1:
selected = cmds.ls(selection = True)
parents = []
children = []
for i in range(0, len(selected):
if i % 2:
parents.append(selected[i])
else :
children.append(selected[i])
for j in range(0,len(selected) / 2):
cmds.parentConstraint(parents[j],children[j])
if radioBtn == 2:
selected = cmds.ls(selection = True)
parents = []
children = []
for i in range(0, len(selected)):
if i <= len()selected) / 2 -1:
else:
children.append(select[i])
for j in range(0,len(selected) / 2):
cmds.parentConstraint(parents[j],children[j])
def _createHockIkHierarchy(self):
"""Create IK hock control hierarchy. """
ik_hock_ctl = mc.circle(n="{}_{}_hockIk_ctl_{}".format(self.side, self.name, self.instance_num), r=1)[0]
ik_hock_grp = mc.group(ik_hock_ctl, n=ik_hock_ctl.replace("ctl", "grp"))
ik_hock_zero = mc.group(ik_hock_grp, n=ik_hock_ctl.replace("ctl", "zero"))
inverse_hock_grp = mc.group(n=ik_hock_ctl.replace("_ctl", "_Inverse_grp"), em=1)
inverse_hock_zero = mc.group(inverse_hock_grp, n=ik_hock_ctl.replace("_ctl", "_Inverse_zero"))
mc.setAttr(inverse_hock_grp + ".rotateOrder", 5)
mc.connectAttr(self.ik_controllers["hindleg"] + ".ikFk", ik_hock_zero + ".v")
mc.parent(inverse_hock_zero, ik_hock_ctl)
mc.parent(ik_hock_zero, self.mod_dict["IKcontrol"])
mc.xform(ik_hock_zero, ws=1, matrix=self.guides["foot"][2])
par_del = mc.parentConstraint(self.ik_controllers["footIk"], inverse_hock_zero)
mc.delete(par_del)
mult = mc.createNode("multiplyDivide", n=inverse_hock_grp.replace("grp", "mdn"))
mc.setAttr(mult + ".input2X", -1)
mc.setAttr(mult + ".input2Y", -1)
mc.setAttr(mult + ".input2Z", -1)
mc.connectAttr(self.misc["hockslave1"] + ".r", mult + ".input1")
mc.connectAttr(mult + ".output", inverse_hock_grp + ".r")
hock_grp = mc.listRelatives(self.ik_controllers["footIkOffset"], ad=1)[1]
rjc.constrain_object(hock_grp, ik_hock_zero, "parent", 1)
rollIn_grp = mc.group(n=ik_hock_ctl.replace("ctl", "rollIn_org"), em=1)
rollOut_grp = mc.group(n=ik_hock_ctl.replace("ctl", "rollOut_org"), em=1)
rollHeel_ctl = mc.circle(n=ik_hock_ctl.replace("ctl", "rollHeel_ctl"), r=.4)[0]
rollHeel_cth = mc.group(rollHeel_ctl, n=ik_hock_ctl.replace("ctl", "rollHeel_cth"))
rollHeel_org = mc.group(rollHeel_cth, n=ik_hock_ctl.replace("ctl", "rollHeel_org"))
rollToe_ctl = mc.circle(n=ik_hock_ctl.replace("ctl", "rollToe_ctl"), r=.4)[0]
rollToe_cth = mc.group(rollToe_ctl, n=ik_hock_ctl.replace("ctl", "rollToe_cth"))
rollToe_org = mc.group(rollToe_cth, n=ik_hock_ctl.replace("ctl", "rollToe_org"))
ballIk_ctl = mc.circle(n=ik_hock_ctl.replace("hockIk_ctl", "ballIk_ctl"), r=.4)[0]
ballIk_cth = mc.group(ballIk_ctl, n=ballIk_ctl.replace("ctl", "cth"))
ballIk_org = mc.group(ballIk_cth, n=ballIk_ctl.replace("ctl", "org"))
footIk_grp = mc.group(n=ik_hock_ctl.replace("ctl", "footHook_grp"), em=1)
footIk_cth = mc.group(footIk_grp, n=footIk_grp.replace("grp", "cth"))
footIk_org = mc.group(footIk_cth, n=footIk_grp.replace("grp", "org"))
footIkRev_org = mc.group(footIk_org, n=footIk_grp.replace("_grp", "Inverse_org"))
footIkAttr_org = mc.group(footIkRev_org, n=footIk_grp.replace("_grp", "Attr_org"))
mc.xform(rollIn_grp, ws=1, t=self.guides["rollIn"][1])
mc.xform(rollOut_grp, ws=1, t=self.guides["rollOut"][1])
mc.xform(rollHeel_org, ws=1, t=self.guides["rollHeel"][1])
mc.xform(rollToe_org, ws=1, t=self.guides["toeEnd"][1])
mc.xform(ballIk_org, ws=1, t=self.guides["ball"][1])
mc.xform(footIkAttr_org, ws=1, t=self.guides["ball"][1])
mc.xform(footIk_org, ws=1, matrix=self.guides["foot"][2])
mc.parent(rollIn_grp, inverse_hock_grp)
mc.parent(rollOut_grp, rollIn_grp)
mc.parent(rollHeel_org, rollOut_grp)
mc.parent(rollToe_org, rollHeel_ctl)
mc.parent(ballIk_org, rollToe_ctl)
mc.parent(footIkAttr_org, ballIk_ctl)
mc.connectAttr(self.misc["hockslave1"] + ".r", footIkRev_org + ".r")
mc.parentConstraint(ballIk_cth, self.joint_dict["ball" + "IK"], n=ballIk_cth.replace("cth", "prc"), mo=1)
par = mc.parentConstraint(ballIk_cth, self.joint_dict["ball" + "FK"], self.joint_dict["ball" + "FINAL"],
n=self.joint_dict["ball" + "FK"].replace("jnt", "prc").replace("parentConstraint1",
""), mo=1)[0]
mc.connectAttr(self.ik_controllers["hindleg"] + ".ikFk", par + "." + ballIk_cth + "W0")
rev = mc.createNode("reverse", n=self.joint_dict["ball" + "FK"].replace("jnt", "rev"))
mc.connectAttr(self.ik_controllers["hindleg"] + ".ikFk", rev + ".inputX")
mc.connectAttr(rev + ".outputX", par + "." + self.joint_dict["ball" + "FK"] + "W1")
self.misc["footHook"] = footIk_grp
self.misc["footHookCth"] = footIk_cth
self.misc["footHookAttr"] = footIkAttr_org
self.misc["rollToe"] = rollToe_cth
self.misc["rollHeel"] = rollHeel_cth
self.misc["rollIn"] = rollIn_grp
self.misc["rollOut"] = rollOut_grp
def __init__(self, ctrlGrp, neckJnt, headJnt, headUpJnt, headLowJnt,
jawJnt, noseJnt, eyebrowJnt, upperTeethJnt, lowerTeethJnt,
tongue01Jnt, tongue02Jnt, tongue03Jnt, tongue04Jnt, earLFTJnt,
earRGTJnt, noseTipJnt, chinJnt, throatJnt, scale,
nostrilLFTJnt, cheekUpLFTJnt, cheekUpOutLFTJnt,
cheekDownLFTJnt, eyebrowInLFTJnt, eyebrowMidLFTJnt,
eyebrowOutLFTJnt, browInUpLFTJnt, browMidUpLFTJnt,
browOutUpLFTJnt, eyelidPinchInLFTJnt, browInDownLFTJnt,
browMidDownLFTJnt, browOutDownLFTJnt, eyelidPinchOutLFTJnt,
nostrilRGTJnt, cheekUpRGTJnt, cheekUpOutRGTJnt,
cheekDownRGTJnt, eyebrowInRGTJnt, eyebrowMidRGTJnt,
eyebrowOutRGTJnt, browInUpRGTJnt, browMidUpRGTJnt,
browOutUpRGTJnt, eyelidPinchInRGTJnt, browInDownRGTJnt,
browMidDownRGTJnt, browOutDownRGTJnt, eyelidPinchOutRGTJnt,
sideLFT, sideRGT, eyeballJntLFT, eyeballJntRGT,
prefixEyeballAim, positionEyeAimCtrl, objectFolMesh,
directionBrowIn, directionBrowMid, directionBrowOut,
directionBrowPinchIn, directionBrowPinchOut, headCtrlSSNode):
# BUILD CONTROLLER
ctrlFaceGroup = mc.group(em=1, n='faceCtrl_grp')
main = mn.Build(
ctrlGrp=ctrlGrp,
objectFolMesh=objectFolMesh,
neckJnt=neckJnt,
headJnt=headJnt,
noseJnt=noseJnt,
headUpJnt=headUpJnt,
headLowJnt=headLowJnt,
eyebrowJnt=eyebrowJnt,
jawJnt=jawJnt,
upperTeethJnt=upperTeethJnt,
lowerTeethJnt=lowerTeethJnt,
tongue01Jnt=tongue01Jnt,
tongue02Jnt=tongue02Jnt,
tongue03Jnt=tongue03Jnt,
tongue04Jnt=tongue04Jnt,
noseTipJnt=noseTipJnt,
chinJnt=chinJnt,
throatJnt=throatJnt,
scale=scale,
eyeballJntLFT=eyeballJntLFT,
eyeballJntRGT=eyeballJntRGT,
prefixEyeballAim=prefixEyeballAim,
positionEyeAimCtrl=positionEyeAimCtrl,
headCtrlSSNode=headCtrlSSNode,
)
secLFT = sc.Build(objectFolMesh=objectFolMesh,
nostrilJnt=nostrilLFTJnt,
earJnt=earLFTJnt,
headCtrl=main.headCtrl,
headUpCtrl=main.headUpCtrl,
headLowCtrl=main.headLowCtrl,
cheekUpJnt=cheekUpLFTJnt,
cheekUpOutJnt=cheekUpOutLFTJnt,
cheekDownJnt=cheekDownLFTJnt,
eyebrowInJnt=eyebrowInLFTJnt,
eyebrowMidJnt=eyebrowMidLFTJnt,
eyebrowOutJnt=eyebrowOutLFTJnt,
browInUpJnt=browInUpLFTJnt,
browMidUpJnt=browMidUpLFTJnt,
browOutUpJnt=browOutUpLFTJnt,
eyelidPinchInJnt=eyelidPinchInLFTJnt,
browInDownJnt=browInDownLFTJnt,
browMidDownJnt=browMidDownLFTJnt,
browOutDownJnt=browOutDownLFTJnt,
eyelidPinchOutJnt=eyelidPinchOutLFTJnt,
sideRGT=sideRGT,
sideLFT=sideLFT,
scale=scale,
side=sideLFT,
directionBrowIn=directionBrowIn,
directionBrowMid=directionBrowMid,
directionBrowOut=directionBrowOut,
directionBrowPinchIn=directionBrowPinchIn,
directionBrowPinchOut=directionBrowPinchOut)
secRGT = sc.Build(objectFolMesh=objectFolMesh,
nostrilJnt=nostrilRGTJnt,
earJnt=earRGTJnt,
cheekUpJnt=cheekUpRGTJnt,
cheekUpOutJnt=cheekUpOutRGTJnt,
headCtrl=main.headCtrl,
headUpCtrl=main.headUpCtrl,
headLowCtrl=main.headLowCtrl,
cheekDownJnt=cheekDownRGTJnt,
eyebrowInJnt=eyebrowInRGTJnt,
eyebrowMidJnt=eyebrowMidRGTJnt,
eyebrowOutJnt=eyebrowOutRGTJnt,
browInUpJnt=browInUpRGTJnt,
browMidUpJnt=browMidUpRGTJnt,
browOutUpJnt=browOutUpRGTJnt,
eyelidPinchInJnt=eyelidPinchInRGTJnt,
browInDownJnt=browInDownRGTJnt,
browMidDownJnt=browMidDownRGTJnt,
browOutDownJnt=browOutDownRGTJnt,
eyelidPinchOutJnt=eyelidPinchOutRGTJnt,
sideRGT=sideRGT,
sideLFT=sideLFT,
scale=scale,
side=sideRGT,
directionBrowIn=directionBrowIn,
directionBrowMid=directionBrowMid,
directionBrowOut=directionBrowOut,
directionBrowPinchIn=directionBrowPinchIn,
directionBrowPinchOut=directionBrowPinchOut)
self.headUpCtrlGrpParent = main.headUpCtrlGrp
self.headUpCtrl = main.headUpCtrl
self.headLowCtrl = main.headLowCtrl
self.jawCtrl = main.jawCtrl
# CONSTRAINT CHEEK DOWN JNT
prntConsLFT = mc.parentConstraint(main.headLowCtrl,
main.jawCtrl,
secLFT.cheekDownJntGrp,
mo=1)[0]
mc.setAttr(prntConsLFT + '.interpType', 2)
prntConsRGT = mc.parentConstraint(main.headLowCtrl,
main.jawCtrl,
secRGT.cheekDownJntGrp,
mo=1)[0]
mc.setAttr(prntConsRGT + '.interpType', 2)
mc.parent(secLFT.eyebrowCtrlGrp, secRGT.eyebrowCtrlGrp,
main.headUpCtrl)
mc.parent(secLFT.earCtrlGrp, secRGT.earCtrlGrp, main.headCtrlGimbal)
mc.parent(secLFT.follicleTransformAll, secRGT.follicleTransformAll,
main.follicleTransformAll, main.headCtrlGrp,
main.headCtrlGrp, ctrlFaceGroup)
self.ctrlFaceGroup = ctrlFaceGroup
# self.neckCtrlGrp = main.neckCtrlGrp
self.eyeballAimMainCtrlGrp = main.eyeballAimMainCtrlGrp
self.eyeballAimMainCtrl = main.eyeballAimMainCtrl
self.headCtrlGrp = main.headCtrlGrp
def initial_pose_joints(ptsList,
baseNames,
orientOrder,
upOrientAxis,
primaryAxis="x",
upAxis="y"):
"""
ptsList (list of vec3's): locs for jnts
baseNames (list of strings): names of joints
orientOrder (string): "xyz", etc for init jnt orient
upOrientAxis (string): "yup", etc for init jnt orient
primaryAxis (string): "x", etc for manual jnt orient
upAxis (string): "y", etc for manual jnt orient
"""
# get and pass values for orient order and uporient axis
# put joint in ref display layer temporarily
joints = create_joint_chain(ptsList, baseNames, orientOrder, upOrientAxis)
poseCtrls, poseGrps, octrls, ogrps = create_controls_and_orients_at_joints(
joints[:-1],
"sphere",
primaryAxis,
"poseCTRL",
orient=True,
upAxis=upAxis)
lockAttrs = ["s", "tx", "ty", "tz"]
ctrlHierList = zip(poseCtrls, poseGrps, joints, octrls, ogrps)
poseConstraints = []
for i in range(len(ctrlHierList)):
if i > 0:
oc = cmds.orientConstraint(ctrlHierList[i - 1][2],
ctrlHierList[i][1],
mo=False)[0]
poseConstraints.append(oc)
oc1 = cmds.orientConstraint(joints[i], ctrlHierList[i][4], mo=False)
cmds.delete(oc1)
const = cmds.parentConstraint(ctrlHierList[i][0],
ctrlHierList[i][2],
mo=True)[0]
poseConstraints.append(const)
if i > 0:
for attr in lockAttrs:
cmds.setAttr("{0}.{1}".format(ctrlHierList[i][0], attr),
l=True)
cmds.setAttr("{0}.t{1}".format(ctrlHierList[i][0], primaryAxis),
l=False)
if i == 1:
# unlock the bend attr
cmds.setAttr("{0}.rx".format(ctrlHierList[i][0]), l=True)
cmds.setAttr("{0}.ry".format(ctrlHierList[i][0]), l=True)
cmds.setAttr("{0}.rz".format(ctrlHierList[i][0]), l=True)
cmds.setAttr("{0}.r{1}".format(ctrlHierList[i][0], upAxis),
l=False)
if i == 0:
cmds.setAttr("{0}.tx".format(ctrlHierList[i][0]), l=False)
cmds.setAttr("{0}.ty".format(ctrlHierList[i][0]), l=False)
cmds.setAttr("{0}.tz".format(ctrlHierList[i][0]), l=False)
parent_hierarchy_grouped_controls(poseCtrls, poseGrps)
return (joints, poseCtrls, poseGrps, octrls, ogrps, poseConstraints)
def _stretchy(self):
"""Stretchy attribute and create connections to joints. """
stretchy_attr = self.ik_controllers["hindleg"] + ".stretchy"
dist_dict = {}
stretchy_grp = mc.group(n='{}_{}_stretchy_{}_{}'.format(self.side, self.name, self.suffix, self.instance_num),
em=True, p=self.mod_dict["IKcontrol"])
mc.hide(stretchy_grp)
start_loc = mc.spaceLocator(n=self.joint_dict["hipSPRING"].replace('jnt', 'loc'))[0]
end_loc = mc.spaceLocator(n=self.ik_controllers["footIkOffset"].replace('ctl', 'loc'))[0]
hip_loc_static = mc.spaceLocator(n=self.joint_dict["hipFINAL"].replace('_jnt', 'Static_loc'))[0]
knee_loc_static = mc.spaceLocator(n=self.joint_dict["kneeFINAL"].replace('_jnt', 'Static_loc'))[0]
foot_loc_static = mc.spaceLocator(n=self.joint_dict["footFINAL"].replace('_bnd', 'Static_loc'))[0]
ball_loc_static = mc.spaceLocator(n=self.joint_dict["ballFINAL"].replace('_bnd', 'Static_loc'))[0]
mc.parentConstraint(self.ik_controllers["footIkOffset"], end_loc, n=end_loc.replace("loc", "prc"))
mc.parentConstraint(self.joint_dict["hipSPRING"], start_loc, n=start_loc.replace("loc", "prc"))
del_hip = mc.parentConstraint(self.joint_dict["hipSPRING"], hip_loc_static)
del_knee = mc.parentConstraint(self.joint_dict["kneeSPRING"], knee_loc_static)
del_foot = mc.parentConstraint(self.joint_dict["footSPRING"], foot_loc_static)
del_ball = mc.parentConstraint(self.joint_dict["ballSPRING"], ball_loc_static)
[mc.delete(x) for x in [del_hip, del_knee, del_foot, del_ball]]
for i in [start_loc, end_loc, hip_loc_static, knee_loc_static, foot_loc_static, ball_loc_static]:
mc.parent(i, stretchy_grp)
dist_node = mc.createNode('distanceBetween')
for i in ["hip", "knee", "foot"]:
dist = mc.createNode('distanceBetween', n=self.joint_dict[i + "FINAL"].replace('_jnt', 'Static_dst'))
dist_dict[i] = dist
dist_pma = mc.createNode('plusMinusAverage', n=self.joint_dict["footFINAL"].replace('_bnd', 'Static_pma'))
mult1 = mc.createNode('multiplyDivide', n=stretchy_grp.replace("_grp", "Distance_mult"))
cond1 = mc.createNode('condition', n=mult1.replace('mult', 'cond'))
cond2 = mc.createNode('condition', n=cond1.replace('Distance', 'On'))
mc.connectAttr('{}.worldMatrix'.format(start_loc), '{}.inMatrix1.'.format(dist_node))
mc.connectAttr('{}.worldMatrix'.format(end_loc), '{}.inMatrix2.'.format(dist_node))
mc.connectAttr('{}.worldMatrix'.format(hip_loc_static), '{}.inMatrix1.'.format(dist_dict["hip"]))
mc.connectAttr('{}.worldMatrix'.format(knee_loc_static), '{}.inMatrix2.'.format(dist_dict["hip"]))
mc.connectAttr('{}.worldMatrix'.format(knee_loc_static), '{}.inMatrix1.'.format(dist_dict["knee"]))
mc.connectAttr('{}.worldMatrix'.format(foot_loc_static), '{}.inMatrix2.'.format(dist_dict["knee"]))
mc.connectAttr('{}.worldMatrix'.format(foot_loc_static), '{}.inMatrix1.'.format(dist_dict["foot"]))
mc.connectAttr('{}.worldMatrix'.format(ball_loc_static), '{}.inMatrix2.'.format(dist_dict["foot"]))
mc.connectAttr('{}.distance'.format(dist_dict["hip"]), '{}.input1D[0]'.format(dist_pma))
mc.connectAttr('{}.distance'.format(dist_dict["knee"]), '{}.input1D[1]'.format(dist_pma))
mc.connectAttr('{}.distance'.format(dist_dict["foot"]), '{}.input1D[2]'.format(dist_pma))
mc.setAttr('{}.operation'.format(mult1), 2)
mc.connectAttr('{}.output1D'.format(dist_pma), '{}.input2.input2X.'.format(mult1))
mc.connectAttr('{}.distance'.format(dist_node), '{}.input1.input1X.'.format(mult1))
mc.setAttr('{}.operation'.format(cond1), 3)
mc.connectAttr('{}.output.outputX'.format(mult1), '{}.firstTerm.'.format(cond1))
mc.setAttr('{}.secondTerm.'.format(cond1), 1)
mc.connectAttr('{}.output.outputX'.format(mult1), '{}.colorIfTrue.colorIfTrueR.'.format(cond1))
mc.setAttr('{}.secondTerm'.format(cond2), 1)
mc.connectAttr('{}.outColor.outColorR'.format(cond1), '{}.colorIfTrue.colorIfTrueR.'.format(cond2))
mc.connectAttr(stretchy_attr, '{}.firstTerm.'.format(cond2))
mc.connectAttr('{}.outColor.outColorR'.format(cond2), '{}.scale.scaleZ.'.format(self.joint_dict["hipIK"]))
mc.connectAttr('{}.outColor.outColorR'.format(cond2), '{}.scale.scaleZ.'.format(self.joint_dict["kneeIK"]))
