def makeRoll(firstJoint, lastJoint, rollJoint):
# place root group under its rig group
if "elbow" in firstJoint:
rigGroup = nameLib.groupNames.leftArmRigGroup["name"]
if "right" in firstJoint:
rigGroup = nameLib.groupNames.rightArmRigGroup["name"]
else:
rigGroup = nameLib.groupNames.leftLegRigGroup["name"]
if "right" in firstJoint:
rigGroup = nameLib.groupNames.rightLegRigGroup["name"]
rollSuffix = "_roll_null"
rootGroup = makeGroup.MakeGroup(name=rollJoint + "_rig" + nameLib.prefixNames.groupSuffix, snapTo=firstJoint, parent=rigGroup)
firstJointNull = makeGroup.MakeGroup(name=firstJoint + rollSuffix, snapTo= firstJoint, parent=rootGroup.groupName)
rollJointNull = makeGroup.MakeGroup(name=rollJoint + rollSuffix, snapTo= rollJoint, parent=rootGroup.groupName)
lastJointNull = makeGroup.MakeGroup(name=lastJoint + rollSuffix, snapTo= lastJoint, parent=rootGroup.groupName)
# make constraint setup
mc.parentConstraint(firstJoint, rootGroup.groupName, maintainOffset=True)
mc.parentConstraint(lastJoint, lastJointNull.groupName)
mc.orientConstraint(firstJointNull.groupName, rollJointNull.groupName, maintainOffset=True)
mc.orientConstraint(lastJointNull.groupName, rollJointNull.groupName, maintainOffset=True)
rollConstraint = mc.orientConstraint(rollJointNull.groupName, rollJoint, skip=["y", "z"])[0]
mc.setAttr(rollConstraint + ".interpType", 2)
def connectDeform(ikRigNodes, fingerSetupNodes):
armNodes = ikRigNodes[0]
legNodes = ikRigNodes[1]
fkJoints = nameLib.skeletonNames.allJoints
fkJoints = list(itertools.chain(*fkJoints))
for i in fkJoints:
deformJoint = i.replace(nameLib.prefixNames.jointSuffix, nameLib.prefixNames.deformSuffix)
if "hip" in i:
mc.parentConstraint(i, deformJoint)
else:
mc.orientConstraint(i, deformJoint)
# connect root_DEFORM joit to placement
mc.parentConstraint(nameLib.prefixNames.globalControl + nameLib.prefixNames.controlSuffix, "root" + nameLib.prefixNames.deformSuffix)
# connect ikBlend for arms to constraints
leftArmIkBlend = armNodes[0][0]
rightArmIkBlend = armNodes[1][0]
connectIkBlend(leftArmIkBlend, rightArmIkBlend, armNodes, fingers=fingerSetupNodes)
# connect ikBlend for legs to constraints
leftLegIkBlend = legNodes[0][0]
rightLegIkBlend = legNodes[1][0]
connectIkBlend(leftLegIkBlend, rightLegIkBlend, legNodes, fingers=fingerSetupNodes)
def setupSw(self):
for joint in self._joints:
name = joint.replace(nameLib.prefixNames.jointSuffix, "") + nameLib.prefixNames.locator
# create locators
worldLocator = mc.spaceLocator(name="world_" + name)
localLocator = mc.spaceLocator(name="local_" + name)
# group for locators
rootGroup = utils.makeGroup.MakeGroup(name=name + nameLib.prefixNames.offsetGroup)
mc.parent(worldLocator, rootGroup.groupName)
mc.parent(localLocator, rootGroup.groupName)
# snap locators to posittion
mc.delete(mc.parentConstraint(joint, rootGroup.groupName))
# put them into root group
mc.parent(rootGroup.groupName, self._parent)
# orient constrain from global control
mc.orientConstraint(nameLib.prefixNames.globalControl + nameLib.prefixNames.controlSuffix, worldLocator, maintainOffset=True)
# constraint from parent
parent = mc.listRelatives(joint, parent=True)[0].replace(nameLib.prefixNames.jointSuffix, "")
parentControl = nameLib.prefixNames.fkPrefix + parent + nameLib.prefixNames.controlSuffix
mc.parentConstraint(parentControl, rootGroup.groupName, maintainOffset=True)
# create constraint for cotroller's driven group
drivenGroup = nameLib.prefixNames.fkPrefix + name.replace(nameLib.prefixNames.locator, "") + nameLib.prefixNames.controlSuffix + nameLib.prefixNames.drivenGroup
localWorldConstraint = mc.parentConstraint(worldLocator, drivenGroup)
localWorldConstraint = mc.parentConstraint(localLocator, drivenGroup)
# create connections from controller
weightList = [worldLocator[0] + "W0", localLocator[0] + "W1"]
self.connectSW(localWorldConstraint[0], parentControl, weightList)
def __init__(self, joints, parentGroup, groupToConstraint):
# joints[0] = snapTo joint
# joints[1] = local parent
# parentGroup = where to parent spaceSwitch groups
# what group will be driven
rootGroup = makeGroup.MakeGroup(name=joints[0] + "_spaceSwitch_GRP")
worldGroup = makeGroup.MakeGroup(name=joints[0] + "_world", snapTo=joints[0])
localGroup = makeGroup.MakeGroup(name=joints[0] + "_local", snapTo=joints[0])
mc.parent(worldGroup.groupName, rootGroup.groupName)
mc.parent(localGroup.groupName, rootGroup.groupName)
mc.parent(rootGroup.groupName, parentGroup)
# constraint setup for groups
mc.parentConstraint(joints[1], localGroup.groupName, maintainOffset=True)
mc.pointConstraint(localGroup.groupName, worldGroup.groupName)
mc.orientConstraint(nameLib.prefixNames.globalControl + nameLib.prefixNames.controlSuffix, worldGroup.groupName, maintainOffset=True)
# sonctraint for groupToConstraint
for i in [worldGroup.groupName, localGroup.groupName]:
swConstraint = mc.parentConstraint(i, groupToConstraint)[0]
driver = joints[0] + ".parent"
reverseNode = mc.shadingNode("reverse", name = joints[0] + "_swReverse", asUtility=True)
# connect channels
mc.connectAttr(driver, reverseNode + ".input.inputX")
mc.connectAttr(driver, swConstraint + "." + joints[0] + "_worldW0")
mc.connectAttr(reverseNode + ".output.outputX", swConstraint + "." + joints[0] + "_localW1")
def setCST(self, constrainttype = 'parent', source = '', weight = 1, mo = True, remove = False, skip = "none"):
"""This can be used instead of the constraint class to constrain the current superObject to something quickly.
@param type: the type of constraint,valid options are point, parent, aim, scale, orient.
@param source: what you want to constrain to. single source only
@param weight: the weight of the constraint
@param mo: maintain offset
@param remove: remove from constraint
@type type: string
@type target: string
@type weight: int
@type mo: boolean
@type remove: boolean
"""
self.cstName = self.name + constrainttype + '_Constraint'
self.cstType = constrainttype
self.source = source
cstTypes = ['point', 'orient', 'aim', 'parent', 'scale']
if self.cstType not in cstTypes:
print 'Invalid constraint type called for superObject %s, try again' % self.name
elif self.cstType == 'point':
cmds.pointConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName, skip = skip)
elif self.cstType == 'parent':
cmds.parentConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName)
elif self.cstType == 'aim':
cmds.aimConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName)
elif self.cstType == 'scale':
cmds.scaleConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName)
elif self.cstType == 'orient':
cmds.orientConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName)
def createDriverSkeleton(self):
#there will always be a root bone, so let's duplicate that
dupe = cmds.duplicate("root", rc = True)[0]
cmds.select("root", hi = True)
joints = cmds.ls(sl = True)
cmds.select(dupe, hi = True)
dupeJoints = cmds.ls(sl = True)
driverJoints = []
for i in range(int(len(dupeJoints))):
if cmds.objExists(dupeJoints[i]):
driverJoint = cmds.rename(dupeJoints[i], "driver_" + joints[i])
driverJoints.append(driverJoint)
#create a direct connection between the driver and the export joints
for joint in driverJoints:
exportJoint = joint.partition("_")[2]
cmds.connectAttr(joint + ".translate", exportJoint + ".translate")
cmds.orientConstraint(joint, exportJoint)
cmds.connectAttr(joint + ".scale", exportJoint + ".scale")
def fkFingerSetup(self):
"""
#- fk finger setup
"""
cmds.select(cl = True)
for fingerElement in self.allfingers:
for lr in self.lrPrefix:
for elem in fingerElement[0:-1]:
if lr == self.left:
ctlColor = 6
else:
ctlColor = 12
ctl = controller.circleController('%s%s_ctl' %(lr, elem), 'yz', 0.5, ctlColor, ['tr', 'sc', 'vi'], doublePadding = True)
cmds.select('%s%s_jnt' %(lr, elem), r = True)
cmds.select('%s_grp' %ctl, tgl = True)
cmds.pointConstraint(mo = False, weight = 1)
cmds.orientConstraint(mo = False, weight = 1)
cmds.delete('%s_grp_pointConstraint1' %ctl)
cmds.delete('%s_grp_orientConstraint1' %ctl)
#- constrain joints
cmds.select(ctl, r = True)
cmds.select('%s%s_jnt' %(lr, elem), tgl = True)
cmds.orientConstraint(mo = False, weight = 1)
fingerElementTmp = fingerElement[:-1]
fingerElementTmp.reverse()
for i in range(len(fingerElementTmp)-1):
self.util.parent('%s%s_ctl_grp' %(lr, fingerElementTmp[i]), '%s%s_ctl' %(lr, fingerElementTmp[i+1]))
def create_joints():
'''Subelements: vertecies, faces, edges should be selected'''
# Get selected object name
selection_list = cmds.ls(selection=True)
for selection in selection_list:
selected_object = selection.split('.')[0]
break
old_loc_list = cmds.ls('*LOC*', flatten=True)
#Create locators constrained to subelements
HZrivet.UI.HZrivet_finalCC()
current_loc_list = cmds.ls('*LOC*', flatten=True)
#Filter created locators
new_loc_list = [loc for loc in current_loc_list if loc not in old_loc_list]
# Get list of locators names and apply it as a prefix to a joint name
loc_list = [loc for loc in new_loc_list if 'Shape' not in loc]
root_joint = 'root'
if not cmds.objExists(root_joint):
cmds.select(clear=True)
cmds.joint(name=root_joint)
root_p_constraint = cmds.pointConstraint(selected_object, root_joint)
root_o_constraint = cmds.orientConstraint(selected_object, root_joint)
cmds.delete(root_p_constraint, root_o_constraint)
for loc in loc_list:
joint_prefix = re.sub("\D", "", loc)
joint_name = 'JNT_' + joint_prefix
cmds.select(clear=True)
cmds.joint(name=joint_name)
cmds.pointConstraint(loc, joint_name)
cmds.orientConstraint(loc, joint_name)
cmds.parent(joint_name, 'root')
def Neck_Control(*args, **kwargs):
NeckJt = "Neck_Jt"
NeckCtrl = [mc.curve(name="Neck_Ctrl",degree=3,point=[(-0.801407, 0, 0.00716748),(-0.802768, 0.023587, -0.220859), (-0.805489, 0.0707609, -0.676912),
(0.761595, -0.283043, -0.667253), (1.045492, -0.194522, -0.0218101), (1.046678, -0.194804, 0.0403576),(0.758039, -0.282198, 0.63974),
(-0.806291, 0.0676615, 0.650803),(-0.803035, 0.0225538, 0.221713),(-0.801407, 0, 0.00716748)]),
mc.setAttr("Neck_Ctrl.overrideColor",18),mc.setAttr("Neck_Ctrl.overrideEnabled",1)]
mc.scale(2.1,3.16,2.8)
mc.makeIdentity( 'Neck_Ctrl', apply=True, translate=True,scale=True)
lockScaling = mc.setAttr("Neck_Ctrl.scale",lock=True)
# xform translation
valNeck = mc.xform(NeckJt,ws=True,query=True,translation=True)
mc.xform(NeckCtrl,ws=1,t = (valNeck[0],valNeck[1],valNeck[2]))
mc.orientConstraint("Neck_Ctrl", NeckJt)
mc.pointConstraint("Neck_Ctrl", NeckJt)
grpNeck = mc.group("Neck_Ctrl", name="GRP_Neck")
mc.parent("GRP_Neck","Front_Spine_Ctrl")
#Lock translation for curve
lockTranslation = mc.setAttr("Neck_Ctrl.translate",lock=True)
return NeckCtrl,NeckJt
def Jaw_Control(*args,**kwargs):
prefix = "_"
JawJt = "Lower_Jaw_Jt"
JawCtrl = [mc.curve(name="Jaw"+prefix+"Ctrl",d=1,
p=[(-0.484806, -0.465148, -0.560784 ),(-0.484806, -0.465148, 0.595512),
(-0.275612, 0.538987, 0.636341),(1.356108, 0.120597, 0.636341 ),
(2.161106, 0.0592024, 0.01008 ),(1.356108, 0.120597, -0.610974),
(-0.275612, 0.538987, -0.610974),(-0.484806, -0.465148, -0.560784),
(1.146913, -0.67078, -0.560784 ),(1.951911, -0.670601, 0.01008),
(1.146913, -0.67078, 0.595512),(1.356108, 0.120597, 0.636341),
(2.161106, 0.0592024, 0.01008),(1.356108, 0.120597, -0.610974),
(1.146913, -0.67078, -0.560784),(1.146913, -0.67078, 0.595512),
(-0.484806, -0.465148, 0.595512),(1.146913, -0.67078, 0.595512),
(1.951911, -0.670601, 0.01008),(2.161106, 0.0592024, 0.01008)]),
mc.setAttr("Jaw"+prefix+"Ctrl.overrideColor",18),
mc.setAttr("Jaw"+prefix+"Ctrl.overrideEnabled",1),mc.scale(0.5,1,1.15)]
#xform translation
valPos = mc.xform(JawJt,query=True,ws=True,translation=True)
mc.xform(JawCtrl[0],ws=1,t=(valPos[0],valPos[1],valPos[2]))
#xform rotation
valRot = mc.xform(JawJt,query=True,ws=True,rotation=True)
mc.xform(JawCtrl[0],ws=1,ro=(valRot[0],valRot[1],valRot[2]))
mc.setAttr("Jaw"+prefix+"Ctrl.rotateZ",-22)
mc.makeIdentity(JawCtrl[0],a=True,r=True,t=True,s=True)
mc.orientConstraint(JawCtrl[0], JawJt, mo=True)
mc.pointConstraint(JawCtrl[0], JawJt, mo=True)
mc.parent(JawCtrl[0],"Head_Ctrl")
#Lock attributes for Jaw rig
for lock in JawJt:
mc.setAttr("Jaw"+prefix+"Ctrl.scale",lock=True),
mc.setAttr("Jaw"+prefix+"Ctrl.translate",lock=True)
def _create_wrist(self):
"""Creates the special wrist setup for the 3 different rotation axes of
Dave's wrist.
@todo: change the constraining to the PLY GRP to something save
"""
hand = '%s_hand_result_%s' % (self.side, self.nc.joint)
hand_end = '%s_handEnd_result_%s' % (self.side, self.nc.joint)
fore_arm = '%s_foreArm_result_%s' % (self.side, self.nc.joint)
# joints
cmds.select(cl=True)
root_jnt = cmds.joint(n='%s_wristRoot_%s' % (self.side, self.nc.joint))
end_jnt = cmds.joint(n='%s_wristEnd_%s' % (self.side, self.nc.joint))
tmp_end_jnt = cmds.joint(n='%s_wristTmpEnd_%s' % (self.side, self.nc.joint))
self.c.snap_a_to_b(root_jnt, hand)
self.c.snap_a_to_b(end_jnt, hand_end)
self.c.snap_a_to_b(tmp_end_jnt, hand_end)
# orient joints properly
self.orient_joint(root_jnt)
cmds.delete(tmp_end_jnt)
cmds.parent(end_jnt, w=True)
# constrain joints
cmds.parentConstraint(hand, root_jnt, mo=True)
cmds.pointConstraint(root_jnt, end_jnt, mo=True)
cmds.orientConstraint(root_jnt, end_jnt, mo=True)
# constrain hand const group
cmds.parentConstraint('%s_wristRotZ_PLY_%s' % (self.side, self.nc.group),
'%s_hand_const_%s' % (self.side, self.nc.group), mo=True)
cmds.parent(root_jnt, end_jnt, '%s_hand_%s' % (self.side, self.nc.group))
def rigExtrudePlane() :
mc.select(cl = True)
lf_leg = ['lf_upLeg_nrJnt', 'L_leg_profileCrv']
rt_leg = ['rt_upLeg_nrJnt', 'R_leg_profileCrv']
lf_arm = ['lf_upArm_nrJnt', 'L_arm_profileCrv']
rt_arm = ['rt_upArm_nrJnt', 'R_arm_profileCrv']
set1 = [lf_leg, rt_leg, lf_arm, rt_arm]
for each in set1 :
# constraint nonRoll to profile curve
mc.orientConstraint(each[0], each[1], mo = True)
print each[0], each[1]
mc.select(cl = True)
naming1 = ['L_arm_pathCrv', 'L_arm_profileCrv', 'R_arm_pathCrv', 'R_arm_profileCrv']
naming2 = ['L_leg_pathCrv', 'L_leg_profileCrv', 'R_leg_pathCrv', 'R_leg_profileCrv']
mc.select(naming1, naming2)
mm.eval('tazGrp;')
mc.select(cl = True)
grp = ['L_armProfileCrv_zGrp', 'R_armProfileCrv_zGrp', 'L_legProfileCrv_zGrp', 'R_legProfileCrv_zGrp']
for each in grp :
mc.scaleConstraint('placement_ctrl', each)
# mc.select(cl = True)
# # bind skin
# mc.skinCluster('lf_upArm_jnt', 'lf_loArm_jnt', 'lf_wrist_jnt', 'L_arm_pathCrv', tsb = True)
# mc.skinCluster('lf_upArm_jnt', 'lf_loArm_jnt', 'lf_wrist_jnt', 'L_arm_pathCrv', tsb = True)
# mc.skinCluster('rt_upLeg_jnt', 'rt_loLeg_jnt', 'rt_ankle_jnt', 'R_leg_pathCrv', tsb = True)
# mc.skinCluster('rt_upArm_jnt', 'rt_loArm_jnt', 'rt_wrist_jnt', 'Larm_pathCrv', tsb = True)
# print 'Done'
def runWithRig() :
# clear name
allObjs = mc.ls()
for each in allObjs :
if 'Char_' in each :
try :
newName = each.replace('Char_', '')
mc.rename(each, newName)
except :
pass
allCtrlJntGrp = 'allJnt_grp'
allIkGrp = 'allIK_grp'
leftLeg = ['cnt_pelvis_jnt', 'lf_upLeg_jnt', 'lf_loLeg_jnt']
rightLeg = ['cnt_pelvis_jnt', 'rt_upLeg_jnt', 'rt_loLeg_jnt']
leftArm = ['lf_clavicle1_jnt', 'lf_upArm_jnt', 'lf_loArm_jnt']
rightArm = ['rt_clavicle1_jnt', 'rt_upArm_jnt', 'rt_loArm_jnt']
setupNonRoll = [leftLeg, rightLeg, leftArm, rightArm]
for each in setupNonRoll :
mc.select(each[1], each[2])
jnt1, jnt2, ik, nrJntGrp, ikAllGrp = run()
mc.orientConstraint(each[0], jnt1)
mc.parent(nrJntGrp, allCtrlJntGrp)
mc.parent(ikAllGrp, allIkGrp)
print 'Add nonroll'
def setupIKCtrl(self, x, IKHandle):
############# MODIFY FOR INHERITANCE #############
side = self.prefixList[x]
thisChain = self.IKChains[x]
#create a control for the ik
name = "%s_%s_IK_CTRL"%(side, self.limbName)
if x==0:
IKCtrl = rig.createControl(name, "cube", self.jAxis1, "blue")
if x==1:
IKCtrl = rig.createControl(name, "cube", self.jAxis1, "red")
self.IKCtrls.append(IKCtrl)
#strip to rotate and translate
rig.stripToRotateTranslate(IKCtrl)
#G.O. control
rig.groupOrient(thisChain[2], IKCtrl, self.groupSuffix)
#orient constraint joint 2 (wrist ankle) to control
cmds.orientConstraint(IKCtrl, thisChain[2])
#parent ik handle to control
cmds.parent(IKHandle, IKCtrl)
return IKCtrl
def connect_ikfk(self):
for ik_jnt, fk_ctl_key in zip(self.ik.ik_joints, self.fk.controls.keys()):
ctl = self.fk.controls[fk_ctl_key]
cmds.orientConstraint(ik_jnt, ctl.grp, mo=True)
ik_joints = self.ik.ik_joints
fk_ctls = [self.fk.controls[k] for k in self.fk.controls.keys()]
print len(self.ik.ik_joints) - len(self.fk.fk_joints), len(ik_joints)
for index in range(len(self.ik.ik_joints) - len(self.fk.fk_joints), len(ik_joints)):
fk_ctl = self.fk.get_control(index)
for child_index in range(index + 1, len(ik_joints)):
fk_child_ctl = self.fk.get_control(child_index)
if fk_child_ctl:
cons = cmds.listConnections(fk_child_ctl.inb, type='plusMinusAverage', scn=True, s=True, d=False, p=False)
if not cons:
pma = cmds.createNode("plusMinusAverage", name=name.set_suffix(fk_child_ctl.name, "ctlOrient"))
cmds.connectAttr("%s.output3D" % pma, "%s.rotate" % fk_child_ctl.inb)
else:
pma = cons[0]
v = cmds.getAttr("%s.input3D" % pma, size=True)
cmds.connectAttr("%s.rotate" % fk_ctl.ctl, "%s.input3D[%s]" % (pma, index))
def __init__(self, objs = [], vertices = []): self.objs = objs self.vertices = vertices #lattice -divisions 2 3 2 -objectCentered true -ol 1; #mc.select( self.objs, self.vertices ) #CREATION grp = mn.Node( mc.group( n = "head_toon_GRP", em = True ) ) deGrp = mn.Node( mc.group( n = "head_toon_deformer_GRP", em = True ) ) deGrp.parent = grp deGrp.a.v.v = False deGrp.a.v.locked = True latNods = mc.lattice( self.objs, self.vertices, divisions = [ 2,3,2], objectCentered = True, ol = 1, n = 'head_toon_LAT' ) latBase = mn.Node( latNods[2] ) latBase.parent = deGrp lat = mn.Node( latNods[1] ) lat.parent = deGrp #mc.select( lat + ".pt[0:1][2][0]", lat + ".pt[0:1][2][1]" ) topClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][2][0]", lat.shape.name + ".pt[0:1][2][1]", n = 'top_face_toon_CLU' )[1] ) topClus.a.v.v = False topClus.a.v.locked = True #mc.select( lat + ".pt[0:1][1][0]", lat + ".pt[0:1][1][1]" ) midClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][1][0]", lat.shape.name + ".pt[0:1][1][1]", n = 'mid_face_toon_CLU' )[1] ) #mc.select( lat + ".pt[0:1][0][0]", lat + ".pt[0:1][0][1]" ) lowClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][0][0]", lat.shape.name + ".pt[0:1][0][1]", n = 'low_face_toon_CLU' )[1] ) ctl = crv.Curve( "head_toon_CTL" ) ctl = ctl.create( "sphere" ) ctl.a.t.v = topClus.worldPosition mc.makeIdentity( ctl.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) topClus.parent = ctl midClus.parent = deGrp lowClus.parent = deGrp ctl.parent = grp #CONSTRAINS midClus.a.r >> topClus.a.r mc.pointConstraint( topClus.name, lowClus.name, midClus.name, mo = True ) #SCALE FOR MID CLUSTER dist = mn.createNode( 'distanceBetween', n = 'head_toon_DIS' ) ctl.a.worldMatrix >> dist.a.inMatrix1 ctl.a.rp >> dist.a.point1 lowClus.a.worldMatrix >> dist.a.inMatrix2 lowClus.a.rp >> dist.a.point2 mul = mn.createNode( 'multiplyDivide', n = 'head_toon_scale_MUL' ) mul.a.input1.v = [dist.a.distance.v]*3 mul.a.operation.v = 2 dist.a.distance >> mul.a.input2X dist.a.distance >> mul.a.input2Y dist.a.distance >> mul.a.input2Z mul.a.output >> midClus.a.s #AIM CONSTRAINT upLocGrp = mn.Node( mc.group( n = "head_upVector_GRP", em = True ) ) upLocGrp.a.t.v = midClus.worldPosition mc.makeIdentity( upLocGrp.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) upLocGrp.parent = deGrp mc.orientConstraint( ctl.name, lowClus.name, upLocGrp.name, mo = True ) upLoc = mn.Node( mc.spaceLocator( n = 'head_upVector_LOC' )[0] ) upLoc.a.t.v = midClus.worldPosition upLoc.a.tz.v = upLoc.a.tz.v + 5 mc.aimConstraint( topClus.name, midClus.name, mo = True, weight = 1, aimVector = [1, 0, 0], upVector = [0, 1, 0], worldUpType = "object", worldUpObject = upLoc.name ) upLoc.parent = upLocGrp mc.pointConstraint( topClus.name, lowClus.name, upLoc.name, mo = True )
def 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 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 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 shadowRig():
controls = [ "translateX", "translateY", "translateZ", \
"rotateX", "rotateY", "rotateZ", \
"scaleX", "scaleY", "scaleZ", "v" ]
negLightAttr = [ "decayRate", "emitSpecular", "useDepthMapShadows", \
"dmapResolution", "dmapFilterSize", "color", \
"shadowColor", "useRayTraceShadows", "lightRadius", \
"shadowRays"]
# Create group
shadowSpot = cmds.group(em=True, name='shadowSpot#')
# Grab index
index = None
if re.search('[0-9]+$', shadowSpot):
index = re.search('[0-9]+$', shadowSpot).group()[0]
# Save spotlight names
shadowLightName = ('shadowLight' + index)
shadowNegLightName = ('shadowNegLight' + index)
# Create spotlights
shadowLight = cmds.spotLight( name=shadowLightName )
shadowNegLight = cmds.spotLight( name=shadowNegLightName )
# Add spotlights to group
cmds.group( shadowLightName, shadowNegLightName, useAsGroup=shadowSpot )
# Create constraints
cmds.pointConstraint( shadowLightName, shadowNegLightName )
cmds.orientConstraint( shadowLightName, shadowNegLightName )
# Connect shape attributes
cmds.connectAttr( (shadowLight + '.coneAngle'), (shadowNegLight + '.coneAngle'), force=True )
cmds.connectAttr( (shadowLight + '.dropoff'), (shadowNegLight + '.dropoff'), force=True )
cmds.connectAttr( (shadowLight + '.penumbraAngle'), (shadowNegLight + '.penumbraAngle'), force=True )
# Create utility node
shadowSpotIntensity = cmds.shadingNode( 'multiplyDivide', asUtility=True, name=(shadowSpot + 'mdIntensity') )
cmds.connectAttr( (shadowLight + '.intensity'), (shadowSpotIntensity + '.input1X') )
cmds.setAttr ( (shadowSpotIntensity + '.input2X'), -1 )
cmds.connectAttr ( (shadowSpotIntensity + '.outputX'), (shadowNegLight + '.intensity') )
# Zero out shadow light attributes
cmds.setAttr ( (shadowNegLightName + ".useDepthMapShadows"), 0 )
cmds.setAttr ( (shadowNegLightName + ".useRayTraceShadows"), 0 )
# Lock attributes
for attr in negLightAttr:
cmds.setAttr ( (shadowNegLightName + "." + attr), lock=True, keyable=False )
# Lock and hide spotlight controls
for control in controls:
cmds.setAttr ( (shadowSpot + "." + control), lock=True, keyable=False )
cmds.setAttr ( (shadowNegLightName + "." + control), lock=True, keyable=False )
# Activate displayHandle
cmds.setAttr ( (shadowLightName + ".displayHandle"), 1 )
def rehook_constrain(self, *args):
group_sel = cmds.ls(sl=True, fl=True)
for dummy_group in group_sel:
locator_name = str(dummy_group) + '_constrain'
dummy_geo_list = cmds.listRelatives(dummy_group, c=True)
for dummy_geo in dummy_geo_list:
cmds.orientConstraint( locator_name, dummy_geo )
def createFKControls(part, FK_Joints): print "In Create FK Controls" # create circle controllers for the FK chain circleCtl = [] circleCtlGrp = [] x = 0 for eachJoint in FK_Joints: # set the name here FKname = str(FK_Joints[x])[:len(FK_Joints[x])-6] # create the controller circleCtl.append(cmds.circle(sections=8, ch=False, n=FKname + "_CTRL")) # rotates the joint 90 degrees in y and freeze transformations cmds.xform(r=True, ro=(0, 90, 0), s=(0.5, 0.5, 0.5)) cmds.makeIdentity(apply=True, t=True, r=True, s=True, n=False) # groups the controller to itself, and renames circleCtlGrp.append(cmds.group(n=FKname + "_CTRL_GRP")) #parent constrains the group to the joint to place it in the correct place, and deletes the constraint fk_pctemp = cmds.parentConstraint(FK_Joints[x], circleCtlGrp[x], mo = False) cmds.delete(fk_pctemp) # orient constrains the joint to the controller cmds.orientConstraint(circleCtl[x], FK_Joints[x], mo = True) x += 1 y = 0 # parents the controls and groups up the hierarchy for eachGroup in circleCtlGrp: cmds.parent(circleCtlGrp[y+1], circleCtl[y]) y += 1 if y == len(circleCtlGrp)-1: break x = 0 handCtl = [] handCtlGrp = [] return circleCtl
def install(self):
controlZroGrp = cmds.listConnections(cmds.listConnections(self.nodes['control']+".controlMetadata")[0] + ".zeroGroup")
if not cmds.objExists(self.nodes['switcher']):
utils_transforms.createZeroGroup(controlZroGrp, name=self.nodes['switcher'])
# translate Spaces
for space in self.translateSpaces:
spaceGrp = space + "_space"
attrName = self.nodes['control']+"_translateSpace"
if cmds.attributeQuery(attrName, n = self.customAttribute, exists=True):
enumName = cmds.addAttr(self.customAttribute +'.'+ attrName, q=True, enumName=True)
enumName = enumName + ":" + space
cmds.addAttr(self.customAttribute +'.'+ attrName, e=True, enumName=enumName, k=True)
else:
cmds.addAttr(self.customAttribute, at='enum', enumName = space, ln=attrName, k=len(self.translateSpaces) > 1)
## space locator
spaceLoc = self.nodes['control'] + "_AT_" + space
if not cmds.objExists(spaceLoc):
cmds.spaceLocator(name = spaceLoc)[0]
cmds.setAttr(spaceLoc+".visibility", 0)
cmds.delete(cmds.parentConstraint(self.nodes['switcher'], spaceLoc, maintainOffset=False))
cmds.parent(spaceLoc, spaceGrp , absolute=True)
pCon = cmds.pointConstraint(spaceLoc, self.nodes['switcher'], name = self.nodes['switcher'] + "_pointConst")[0]
transWeights = cmds.pointConstraint(pCon, q=True, wal=True)
pCondition = self.enumCondition(self.customAttribute + '.' + self.nodes['control'] + "_translateSpace", self.nodes['control']+"_AT_"+ space + "_translateSpace_condition")
cmds.connectAttr(pCondition+".outColorR", pCon + "." + transWeights[-1])
# orient Spaces
for space in self.orientSpaces:
spaceGrp = space + "_space"
attrName = self.nodes['control']+"_orientSpace"
if cmds.attributeQuery(attrName, n = self.customAttribute, exists=True):
enumName = cmds.addAttr(self.customAttribute +'.'+ attrName, q=True, enumName=True)
enumName = enumName + ":" + space
cmds.addAttr(self.customAttribute +'.'+ attrName, e=True, enumName=enumName, k=True)
else:
cmds.addAttr(self.customAttribute, at='enum', enumName = space, ln=attrName, k=len(self.orientSpaces) > 1)
## space locator
spaceLoc = self.nodes['control'] + "_AT_" + space
if not cmds.objExists(spaceLoc):
cmds.spaceLocator(name = spaceLoc)[0]
cmds.setAttr(spaceLoc+".visibility", 0)
cmds.delete(cmds.parentConstraint(self.nodes['switcher'], spaceLoc, maintainOffset=False))
cmds.parent(spaceLoc, spaceGrp , absolute=True)
oCon = cmds.orientConstraint(spaceLoc, self.nodes['switcher'], name = self.nodes['switcher'] + "_orientConst")[0]
orientWeights = cmds.orientConstraint(oCon, q=True, wal=True)
oCondition = self.enumCondition(self.customAttribute + '.' + self.nodes['control'] + "_orientSpace", self.nodes['control']+"_AT_"+space + "_orientSpace_condition")
cmds.connectAttr(oCondition+".outColorR", oCon + "." + orientWeights[-1])
return
def install(self):
cmds.select(d=True)
# Create Ik joints
self.rig_info['ikjnts']=utils.createJoint(self.module_info['ikjnts'], self.rig_info['positions'], self.instance)
# Create Fk joints
self.rig_info['fkjnts']=utils.createJoint(self.module_info['fkjnts'], self.rig_info['positions'], self.instance)
# Create Rig joints
self.rig_info['rigjnts']=utils.createJoint(self.module_info['rigjnts'], self.rig_info['positions'], self.instance)
# Create Ik Rig
# Ik handle
#"ikcontrols": ["ctrl_ik_arm, ikh_arm", "ctrl_pv_arm"
# Generate a name for the ik handle using self.instance
ikhname = self.module_info["ikcontrols"][1].replace('_s_', self.instance)
self.rig_info['ikh']=cmds.ikHandle(n=ikhname, sj=self.rig_info['ikjnts'][0], ee=self.rig_info['ikjnts'][2], sol='ikRPsolver', p=2, w=1 )
ikctrlname = self.module_info["ikcontrols"][0].replace('_s_', self.instance)
self.rig_info['ikcontrol']=utils.createControl([[self.rig_info['positions'][2], ikctrlname, 'HandControl.ma']])[0]
pvpos = utils.calculatePVPosition([self.rig_info['ikjnts'][0], self.rig_info['ikjnts'][1], self.rig_info['ikjnts'][2]])
self.rig_info['pvcontrol']=utils.createControl([[pvpos, self.module_info["ikcontrols"][2], 'RectangleControl.ma']])[0]
# Make a control for arm settings
self.rig_info['setcontrol']=utils.createControl([[self.rig_info['positions'][2], 'ctrl_settings', 'RectangleControl.ma']])[0]
cmds.addAttr(self.rig_info['setcontrol'][1], ln='IK_FK', at="enum", en="fk:ik:", k=True )
# Parent ikh to ctrl
cmds.parent(self.rig_info['ikh'][0], self.rig_info['ikcontrol'][1])
# PV constraint
cmds.poleVectorConstraint(self.rig_info['pvcontrol'][1], self.rig_info['ikh'][0])
# orient constrain arm ik_wrist to ctrl_arm
cmds.orientConstraint(self.rig_info['ikcontrol'][1], self.rig_info['ikjnts'][2], mo=True)
# Create FK rig
self.rig_info['fkcontrols'] = utils.createControl([[self.rig_info['positions'][0], self.module_info["fkcontrols"][0], 'RectangleControl.ma'],
[self.rig_info['positions'][1], self.module_info["fkcontrols"][1], 'RectangleControl.ma'],
[self.rig_info['positions'][2], self.module_info["fkcontrols"][2], 'RectangleControl.ma']])
# Parent fk controls
cmds.parent(self.rig_info['fkcontrols'][2][0], self.rig_info['fkcontrols'][1][1])
cmds.parent(self.rig_info['fkcontrols'][1][0], self.rig_info['fkcontrols'][0][1])
# Connect Ik and Fk to Rig joints
switchattr = self.rig_info['setcontrol'][1] + '.IK_FK'
utils.connectThroughBC(self.rig_info['ikjnts'], self.rig_info['fkjnts'], self.rig_info['rigjnts'], self.instance, switchattr )
# Constrain fk joints to controls.
[cmds.parentConstraint(self.rig_info['fkcontrols'][i][1], self.rig_info['fkjnts'][i], mo=True) for i in range(len(self.rig_info['fkcontrols']))]
# SetupIk/Fk match scriptJob
"""
def orientConstraintCmd(maintainOffset):
# Get selection Objects
selection = cmds.ls (sl = True)
# Error Checking
if len(selection) != 2:
raise Warning ("Please Select 2 Objects")
return
cmds.orientConstraint(selection[0], selection[1], maintainOffset=maintainOffset)
def build(self):
self.main_grp = cmds.group(empty=1, name=(self.name + "_base_grp"))
common.align(self.main_grp, self.target)
self.main_jnt = cmds.joint(name=(self.main_grp.replace("grp", "jnt")))
self.orient_jnt = cmds.joint(name=(self.main_jnt.replace("base", "orient")))
cmds.select(self.main_jnt)
self.reader_jnt = cmds.joint(name=(self.main_jnt.replace("base", "reader")))
cmds.setAttr(self.reader_jnt + ".t" + self.axis, 1.0)
cmds.parentConstraint(self.orient_jnt, self.reader_jnt, mo=1)
cmds.orientConstraint(self.target, self.orient_jnt)
def orient(self): """make a orient constraint between lists""" fromItems, toItems = self._getItemsInLists() maintainOffset = self.maintainOffset_chb.isChecked() if len( fromItems ) == 1: for toNode in toItems: mc.orientConstraint( fromItems[0].name, toNode.name, mo = maintainOffset ) else: for fromNode,toNode in zip( fromItems, toItems ): mc.orientConstraint( fromNode.name, toNode.name, mo = maintainOffset )
def constrain_geometry(self, *args):
run_list = cmds.ls(sl=True, fl=True)
for dummy_list in run_list:
dummy_geo_list = cmds.listRelatives(dummy_list, c=True)
dummy_locator = cmds.spaceLocator(n = dummy_list+'_constrain')
#dummy_logo = cmds.textCurves( f='Times-Roman|h-1|w-400|c0', o = True, t=dummy_list + '_control' )
#cmds.parent( dummy_logo, dummy_locator, add=True )
for dummy_geo in dummy_geo_list:
cmds.orientConstraint( dummy_locator, dummy_geo )
def CreateSpaceSwitchReverse(self, AfectedObject, SpaceObjects, ControlObject, Name = "spaceSwitch", constraintType = "parent", mo = True, sswtype = "enum"): #
'''
Creates a simple space Switch that uses a reverse for simple solution it can only hold 2 spaces
'''
if len(SpaceObjects) == 2:
if sswtype == "enum":
SpaceObjectShortName =[]
for eachObject in SpaceObjects:
SpaceObjectShortName.append(self.NameConv.RMGetAShortName(eachObject))
self.AddEnumParameters(SpaceObjectShortName, ControlObject, Name = Name)
else:
if Name=="":
index = 0
SwitchName = 'SW'
for eachString in SpaceObjects:
SwitchName = SwitchName + self.NameConv.RMGetAShortName(eachString).title()
index = index + 1
Name = SwitchName
self.AddNumericParameter( ControlObject, Name = Name)
reverse = cmds.shadingNode('reverse', asUtility=True, name = Name + "SWReverse")
multiply = cmds.shadingNode('multiplyDivide', asUtility=True, name = Name + "SWMultDiv")
#cmds.connectAttr(ControlObject + "." + Name, reverse + ".inputX")
cmds.connectAttr(ControlObject + "." + Name, multiply + ".input1X")
cmds.setAttr(multiply + ".input2X", 10)
cmds.setAttr(multiply + ".operation", 2)
cmds.connectAttr(multiply + ".outputX", reverse + ".inputX")
for eachObject in SpaceObjects:
if constraintType == "point":
parentConstraint = cmds.pointConstraint (eachObject, AfectedObject, mo = mo, name = AfectedObject + "SpaceSwitchConstraint")
WA = cmds.pointConstraint (parentConstraint, q = True, weightAliasList = True)
elif constraintType == "orient":
parentConstraint = cmds.orientConstraint (eachObject, AfectedObject, mo = mo, name = AfectedObject + "SpaceSwitchConstraint")
WA = cmds.orientConstraint (parentConstraint, q = True, weightAliasList = True)
elif constraintType == "parent":
parentConstraint = cmds.parentConstraint (eachObject, AfectedObject, mo = mo, name = AfectedObject + "SpaceSwitchConstraint")
WA = cmds.parentConstraint (parentConstraint, q = True, weightAliasList = True)
cmds.setAttr("%s.interpType"%parentConstraint[0] , 0)
if self.NameConv.RMIsNameInFormat (AfectedObject):
reverse = self.NameConv.RMRenameBasedOnBaseName(AfectedObject, reverse, NewName = reverse)
multiply = self.NameConv.RMRenameBasedOnBaseName(AfectedObject, multiply, NewName = multiply)
parentConstraint[0] = self.NameConv.RMRenameBasedOnBaseName (AfectedObject, parentConstraint[0], NewName = Name)
else:
reverse = self.NameConv.RMRenameNameInFormat(reverse)
multiply = self.NameConv.RMRenameNameInFormat(multiply)
parentConstraint[0] = self.NameConv.RMRenameNameInFormat ( parentConstraint[0])
cmds.connectAttr( multiply + ".outputX", parentConstraint[0] + "." + WA[1])
cmds.connectAttr( reverse + ".outputX", parentConstraint[0]+ "." + WA[0])
def hook(self):
"""Hooks up the arm module to the shoulder.
Sets up the space switching.
"""
hook = '%s_arm_shoulder_space_%s' % (self.side, self.nc.locator)
result_const = '%s_arm_result_const_%s' % (self.side, self.nc.group)
fk_const = '%s_arm_FK_const_%s' % (self.side, self.nc.group)
ik_const = '%s_arm_base_IK_const_%s' % (self.side, self.nc.group)
cmds.pointConstraint(hook, ik_const, mo=True, weight=1)
cmds.pointConstraint(hook, fk_const, mo=True, weight=1)
cmds.pointConstraint(hook, result_const, mo=True, weight=1)
# rotation spaces
body = '%s_arm_body_space_%s' % (self.side, self.nc.locator)
root = '%s_arm_root_space_%s' % (self.side, self.nc.locator)
self.c.snap_a_to_b(root, self.result_jnts[0])
self.c.snap_a_to_b(body, self.result_jnts[0])
fk_constr = cmds.orientConstraint(hook, body, root, fk_const, mo=True, weight=1)[0]
result_constr = cmds.orientConstraint(hook, body, root, result_const, mo=True, weight=1)[0]
cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=1)
cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=1)
cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=1)
cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=1)
cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=1)
cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0)
cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=1)
# rotation bleed fix
blend = cmds.shadingNode('blendColors', asUtility=True)
blend = cmds.rename(blend, '%s_arm_result_orient_BLD' % self.side)
cmds.connectAttr('%s.constraintRotate' % result_constr, '%s.color2' % blend, f=True)
cmds.setAttr('%s.color1R' % blend, 0)
cmds.disconnectAttr('%s.constraintRotateX' % result_constr, '%s.rotateX' % result_const)
cmds.disconnectAttr('%s.constraintRotateY' % result_constr, '%s.rotateY' % result_const)
cmds.disconnectAttr('%s.constraintRotateZ' % result_constr, '%s.rotateZ' % result_const)
cmds.connectAttr('%s.output' % blend, '%s.rotate' % result_const, f=True)
cmds.connectAttr('%s.FK_IK_Blend' % self.switch_control, '%s.blender' % blend, f=True)
# temporary fix for arm cycle problem
cmds.parent('%s_upperArmToElbowLengthStart_%s' % (self.side, self.nc.locator),
'%s_shoulderEnd_result_%s' % (self.side, self.nc.joint))
def orientConstraint(master, slave, mo=False, attrList=['rx', 'ry', 'rz']):
'''
Create a point constraint between the specifiec master and slave transforms.
Only constrains open, settable channels.
@param master: Constraint master transform.
@type master: str
@param slave: Constraint slave transform.
@type slave: str
@param mo: Maintain constraint offset
@type mo: bool
@param attrList: List of transform attributes to constrain.
@type attrList: list
'''
# ==========
# - Checks -
# ==========
# Check Target (Master)
if isinstance(master, types.StringTypes):
if not mc.objExists(master):
raise Exception('Constraint target "' + master +
'" does not exist!')
if not glTools.utils.transform.isTransform(master):
raise Exception('Constraint target "' + master +
'" is not a valid transform!')
elif isinstance(master, types.ListType):
for target in master:
if not mc.objExists(target):
raise Exception('Constraint target "' + target +
'" does not exist!')
if not glTools.utils.transform.isTransform(target):
raise Exception('Constraint target "' + target +
'" is not a valid transform!')
# Check Slave
if not mc.objExists(slave):
raise Exception('Constraint slave "' + slave + '" does not exist!')
if not glTools.utils.transform.isTransform(slave):
raise Exception('Constraint slave "' + slave +
'" is not a valid transform!')
# Check Settable Channels
sr = []
if not 'rx' in attrList or not mc.getAttr(slave + '.rx', se=True):
sr.append('x')
if not 'ry' in attrList or not mc.getAttr(slave + '.ry', se=True):
sr.append('y')
if not 'rz' in attrList or not mc.getAttr(slave + '.rz', se=True):
sr.append('z')
if not st: st = 'none'
# Skip All Check
if len(sr) == 3:
print('No axis to constrain! Unable to create constraint...')
return None
# =====================
# - Create Constraint -
# =====================
constraint = ''
try:
constraint = mc.orientConstraint(master, slave, sk=sr, mo=mo)[0]
except Exception, e:
raise Exception('Error creating constraint from "' + master +
'" to "' + slave + '"! Exception msg: ' + str(e))
def __init__(self,
prefix='new',
scale=1.0,
translateTo='',
rotateTo='',
parent='',
shape=1,
angle='y',
lockChannels=['s', 'v']):
###################################################################################################
# @param shape : 1 = circle
# @param shape : 2 = square
# @param shape : 2 = sphere
control_object = None
self.angle = angle
if shape == 1:
control_object = cmds.circle(n=prefix + '_CTL',
normal=[0, 1, 0],
ch=False,
radius=1.0)[0]
elif shape == 2:
control_object = cmds.curve(n=prefix + '_CTL',
d=1,
p=[(-1, 0, -1), (-1, 0, 1), (1, 0, 1),
(1, 0, -1), (-1, 0, -1)],
k=[0, 1, 2, 3, 4])
elif shape == 3:
control_object = cmds.circle(n=prefix + '_CTL',
ch=False,
normal=[1, 0, 0],
radius=1.0)[0]
add_shape = cmds.circle(n=prefix + '_CTL2',
ch=False,
normal=[0, 0, 1],
radius=1.0)[0]
cmds.parent(cmds.listRelatives(add_shape, shapes=True),
control_object,
r=True,
s=True)
cmds.delete(add_shape)
elif shape == 4:
control_object = cmds.circle(n=prefix + '_CTL',
ch=False,
normal=[1, 0, 0],
radius=1.0)[0]
add_shape_2 = cmds.circle(n=prefix + '_CTL3',
ch=False,
normal=[0, 1, 0],
radius=1.0)[0]
add_shape = cmds.circle(n=prefix + '_CTL2',
ch=False,
normal=[0, 0, 1],
radius=1.0)[0]
cmds.parent(cmds.listRelatives(add_shape, shapes=True),
control_object,
r=True,
s=True)
cmds.parent(cmds.listRelatives(add_shape_2, shapes=True),
control_object,
r=True,
s=True)
cmds.delete(add_shape)
cmds.delete(add_shape_2)
#
result = tools.create_groups(control_object)
cmds.scale(scale,
scale,
scale,
control_object + ".cv[*]",
relative=True)
# public members:
self.control = control_object
self.root = result[0]
self.auto = result[1]
self.lockChannels = lockChannels
self._angle = angle
# translate control
if cmds.objExists(translateTo):
cmds.delete(cmds.pointConstraint(translateTo, self.root))
# rotate control
if cmds.objExists(rotateTo):
cmds.delete(cmds.orientConstraint(rotateTo, self.root))
# parent control
if cmds.objExists(parent):
cmds.parent(self.root, parent)
# execute methods
self.overide_color()
self.lock_control_channels()
self.setAngle(self._angle)
def build(self):
'''
This is where the builds will happen.
'''
super(Brow, self).build()
# get all of the inputs to the node.
side = self.getAttributeByName("side").getValue()
anchor = self.getAttributeByName("anchor").getValue()
browInner = self.getAttributeByName("browInner").getValue().format(
side=side)
browMain = self.getAttributeByName("browMain").getValue().format(
side=side)
browPeak = self.getAttributeByName("browPeak").getValue().format(
side=side)
curve = self.getAttributeByName("curve").getValue().format(side=side)
browInnerJoint = self.getAttributeByName(
"browInnerJoint").getValue().format(browInner=browInner)
browMainJoint = self.getAttributeByName(
"browMainJoint").getValue().format(browMain=browMain)
browPeakJoint = self.getAttributeByName(
"browPeakJoint").getValue().format(browPeak=browPeak)
driverParent = self.getAttributeByName("driverParent").getValue()
geometry = self.getAttributeByName("geometry").getValue()
mc.parent(self.name, driverParent)
# going to create the control hierarchies.
browMainNul, browMainOrient, browMainCtrl = control.create(
name=browMain,
controlType="null",
hierarchy=['nul', 'ort'],
color=common.BLUE,
parent=anchor,
type='face')
browInnerNul, browInnerOrient, browInnerCtrl = control.create(
name=browInner,
controlType="null",
hierarchy=['nul', 'ort'],
color=common.BLUE,
parent=anchor,
type='face')
browPeakNul, browPeakOrient, browPeakCtrl = control.create(
name=browPeak,
controlType="null",
hierarchy=['nul', 'ort'],
color=common.BLUE,
parent=anchor,
type='face')
# Position the controls
#
# Main
mc.xform(browMainNul, ws=1, t=mc.xform(browMainJoint, q=1, ws=1, t=1))
con = mc.orientConstraint(browMainJoint, browMainOrient)[0]
if '_r_' in browMainJoint:
mc.setAttr(con + '.offsetZ', -180)
mc.setAttr(browMainNul + '.ry', -180)
mc.setAttr(browMainNul + '.sz', -1)
mc.delete(con)
# Inner
mc.xform(browInnerNul,
ws=1,
t=mc.xform(browInnerJoint, q=1, ws=1, t=1))
con = mc.orientConstraint(browInnerJoint, browInnerOrient)[0]
if '_r_' in browInnerJoint:
mc.setAttr(con + '.offsetZ', -180)
mc.setAttr(browInnerNul + '.ry', -180)
mc.setAttr(browInnerNul + '.sz', -1)
mc.delete(con)
mc.xform(browPeakNul, ws=1, t=mc.xform(browPeakJoint, q=1, ws=1, t=1))
con = mc.orientConstraint(browPeakJoint, browPeakOrient)[0]
if '_r_' in browPeakJoint:
mc.setAttr(con + '.offsetZ', -180)
mc.setAttr(browPeakNul + '.ry', -180)
mc.setAttr(browPeakNul + '.sz', -1)
mc.delete(con)
mc.parent(browInnerNul, browMainCtrl)
mc.parent(browPeakNul, browMainCtrl)
# create the driver nodes
browMainDriverNul = mc.createNode(
"transform",
name="{}_driver_nul".format(browMain),
parent=self.name)
browMainDriverOrt = mc.createNode(
"transform",
name="{}_driver_ort".format(browMain),
parent=browMainDriverNul)
browMainDriver = mc.createNode("joint",
name="{}_driver".format(browMain),
parent=browMainDriverOrt)
# position the driver
mc.xform(browMainDriverNul,
ws=True,
matrix=mc.xform(browMainNul, q=True, ws=True, matrix=True))
for attr in ['t', 'r', 's']:
mc.connectAttr("{}.{}".format(browMainOrient, attr),
"{}.{}".format(browMainDriverOrt, attr),
f=True)
mc.pointConstraint(browMainCtrl, browMainDriver)
# TX and TY isolated drivers
browMain_TX_driver = mc.duplicate(
browMainDriver, po=1, name="{}_TX_driver".format(browMain))[0]
browMain_TY_driver = mc.duplicate(
browMainDriver, po=1, name="{}_TY_driver".format(browMain))[0]
mc.connectAttr(browMainDriver + '.tx', browMain_TX_driver + '.tx')
mc.connectAttr(browMainDriver + '.ty', browMain_TY_driver + '.ty')
browInnerDriverNul = mc.createNode(
"transform",
name="{}_driver_nul".format(browInner),
parent=self.name)
browInnerDriverOrt = mc.createNode(
"transform",
name="{}_driver_ort".format(browInner),
parent=browInnerDriverNul)
browInnerDriver = mc.createNode("joint",
name="{}_driver".format(browInner),
parent=browInnerDriverOrt)
# position the driver
mc.xform(browInnerDriverNul,
ws=True,
matrix=mc.xform(browInnerNul, q=True, ws=True, matrix=True))
for attr in ['t', 'r', 's']:
mc.connectAttr("{}.{}".format(browInnerOrient, attr),
"{}.{}".format(browInnerDriverOrt, attr),
f=True)
mc.pointConstraint(browInnerCtrl, browInnerDriver)
# TX and TY isolated drivers
browInner_TX_driver = mc.duplicate(
browInnerDriver, po=1, name="{}_TX_driver".format(browInner))[0]
browInner_TY_driver = mc.duplicate(
browInnerDriver, po=1, name="{}_TY_driver".format(browInner))[0]
mc.connectAttr(browInnerDriver + '.tx', browInner_TX_driver + '.tx')
mc.connectAttr(browInnerDriver + '.ty', browInner_TY_driver + '.ty')
browPeakDriverNul = mc.createNode(
"transform",
name="{}_driver_nul".format(browPeak),
parent=self.name)
browPeakDriverOrt = mc.createNode(
"transform",
name="{}_driver_ort".format(browPeak),
parent=browPeakDriverNul)
browPeakDriver = mc.createNode("joint",
name="{}_driver".format(browPeak),
parent=browPeakDriverOrt)
# position the driver
mc.xform(browPeakDriverNul,
ws=True,
matrix=mc.xform(browPeakNul, q=True, ws=True, matrix=True))
for attr in ['t', 'r', 's']:
mc.connectAttr("{}.{}".format(browPeakOrient, attr),
"{}.{}".format(browPeakDriverOrt, attr),
f=True)
mc.pointConstraint(browPeakCtrl, browPeakDriver)
# create the set driven key nodes.
browMainSdkNul = mc.createNode("transform",
name="{}_sdk_nul".format(browMain),
parent=self.name)
browMainSdkDefAuto = mc.createNode(
"transform",
name="{}_sdk_def_auto".format(browMain),
parent=browMainSdkNul)
browMainSdkRotDefAuto = mc.createNode(
"transform",
name="{}_sdk_rot_def_auto".format(browMain),
parent=browMainSdkDefAuto)
browMainSdk = mc.createNode("transform",
name="{}_sdk".format(browMain),
parent=browMainSdkRotDefAuto)
# position the SDK nodes thanks
mc.xform(browMainSdkNul,
ws=True,
matrix=mc.xform(browMainDriverOrt,
q=True,
ws=True,
matrix=True))
# create the keys for the brow main sdk nodes
for attribute in ['x', 'y', 'z']:
mc.setDrivenKeyframe("{}.t{}".format(browMainSdkDefAuto,
attribute),
cd="{}.t{}".format(browMainDriver, attribute),
v=0,
dv=0)
mc.setDrivenKeyframe("{}.t{}".format(browMainSdkDefAuto,
attribute),
cd="{}.t{}".format(browMainDriver, attribute),
v=1,
dv=1)
mc.setDrivenKeyframe("{}.t{}".format(browMainSdkDefAuto,
attribute),
cd="{}.t{}".format(browMainDriver, attribute),
v=-1,
dv=-1)
mc.setDrivenKeyframe("{}.r{}".format(browMainSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browMainDriver, attribute),
v=0,
dv=0)
mc.setDrivenKeyframe("{}.r{}".format(browMainSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browMainDriver, attribute),
v=.1,
dv=1)
mc.setDrivenKeyframe("{}.r{}".format(browMainSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browMainDriver, attribute),
v=-.1,
dv=-1)
# create the set driven key nodes.
browInnerSdkNul = mc.createNode("transform",
name="{}_sdk_nul".format(browInner),
parent=self.name)
browInnerSdkDefAuto = mc.createNode(
"transform",
name="{}_sdk_def_auto".format(browInner),
parent=browInnerSdkNul)
browInnerSdkRotDefAuto = mc.createNode(
"transform",
name="{}_sdk_rot_def_auto".format(browInner),
parent=browInnerSdkDefAuto)
browInnerSdk = mc.createNode("transform",
name="{}_sdk".format(browInner),
parent=browInnerSdkRotDefAuto)
# position the SDK nodes
mc.xform(browInnerSdkNul,
ws=True,
matrix=mc.xform(browInnerDriverOrt,
q=True,
ws=True,
matrix=True))
# create the keys for the brow inner sdk nodes
for attribute in ['x', 'y', 'z']:
mc.setDrivenKeyframe("{}.t{}".format(browInnerSdkDefAuto,
attribute),
cd="{}.t{}".format(browInnerDriver,
attribute),
v=0,
dv=0)
mc.setDrivenKeyframe("{}.t{}".format(browInnerSdkDefAuto,
attribute),
cd="{}.t{}".format(browInnerDriver,
attribute),
v=1,
dv=1)
mc.setDrivenKeyframe("{}.t{}".format(browInnerSdkDefAuto,
attribute),
cd="{}.t{}".format(browInnerDriver,
attribute),
v=-1,
dv=-1)
mc.setDrivenKeyframe("{}.r{}".format(browInnerSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browInnerDriver,
attribute),
v=0,
dv=0)
mc.setDrivenKeyframe("{}.r{}".format(browInnerSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browInnerDriver,
attribute),
v=.1,
dv=1)
mc.setDrivenKeyframe("{}.r{}".format(browInnerSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browInnerDriver,
attribute),
v=-.1,
dv=-1)
# create the set driven key nodes.
browPeakSdkNul = mc.createNode("transform",
name="{}_sdk_nul".format(browPeak),
parent=self.name)
browPeakSdkDefAuto = mc.createNode(
"transform",
name="{}_sdk_def_auto".format(browPeak),
parent=browPeakSdkNul)
browPeakSdkRotDefAuto = mc.createNode(
"transform",
name="{}_sdk_rot_def_auto".format(browPeak),
parent=browPeakSdkDefAuto)
browPeakSdk = mc.createNode("transform",
name="{}_sdk".format(browPeak),
parent=browPeakSdkDefAuto)
# position the SDK nodes
mc.xform(browPeakSdkNul,
ws=True,
matrix=mc.xform(browPeakDriverOrt,
q=True,
ws=True,
matrix=True))
# create the keys for the brow peak sdk nodes
for attribute in ['x', 'y', 'z']:
mc.setDrivenKeyframe("{}.t{}".format(browPeakSdkDefAuto,
attribute),
cd="{}.t{}".format(browPeakDriver, attribute),
v=0,
dv=0)
mc.setDrivenKeyframe("{}.t{}".format(browPeakSdkDefAuto,
attribute),
cd="{}.t{}".format(browPeakDriver, attribute),
v=1,
dv=1)
mc.setDrivenKeyframe("{}.t{}".format(browPeakSdkDefAuto,
attribute),
cd="{}.t{}".format(browPeakDriver, attribute),
v=-1,
dv=-1)
mc.setDrivenKeyframe("{}.r{}".format(browPeakSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browPeakDriver, attribute),
v=0,
dv=0)
mc.setDrivenKeyframe("{}.r{}".format(browPeakSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browPeakDriver, attribute),
v=.1,
dv=1)
mc.setDrivenKeyframe("{}.r{}".format(browPeakSdkRotDefAuto,
attribute),
cd="{}.t{}".format(browPeakDriver, attribute),
v=-.1,
dv=-1)
# constrain the bind joints to the sdk nodes
for jnt, sdkNode in zip((browMainJoint, browInnerJoint, browPeakJoint),
(browMainSdk, browInnerSdk, browPeakSdk)):
mc.pointConstraint(sdkNode, jnt)
mc.orientConstraint(sdkNode, jnt)
# create the corrugator
corrugatorName = "brow_corrugator_{}".format(side)
cluster.create(geometry, name=corrugatorName, parent=browInnerCtrl)
# rename the cluster and control
mc.rename(corrugatorName, '{}_cluster'.format(corrugatorName))
mc.rename('{}_ctrl'.format(corrugatorName), corrugatorName)
mc.xform("{}_nul".format(corrugatorName),
ws=True,
matrix=mc.xform(browInnerCtrl, q=True, ws=True, matrix=True))
mc.setAttr("{}.displayHandle".format(corrugatorName), 1)
control.tagAsControl(corrugatorName, type='face')
# lock and hide scale and rotates for all of the brow controls
rigrepo.libs.attribute.lockAndHide(
[browMainCtrl, browInnerCtrl, browPeakCtrl, corrugatorName],
['r', 'rx', 'ry', 'rz', 's', 'sx', 'sy', 'sz'])
# Set driven keys to be post and pre infinity
driven_keys = mc.listConnections(browMainDriver, type='animCurveUA')
driven_keys += mc.listConnections(browMainDriver, type='animCurveUL')
driven_keys += mc.listConnections(browInnerDriver, type='animCurveUA')
driven_keys += mc.listConnections(browInnerDriver, type='animCurveUL')
driven_keys += mc.listConnections(browPeakDriver, type='animCurveUA')
driven_keys += mc.listConnections(browPeakDriver, type='animCurveUL')
for x in driven_keys:
mc.setAttr(x + '.preInfinity', 1)
mc.setAttr(x + '.postInfinity', 1)
mc.keyTangent(x, index=(0, 0), inTangentType='spline')
mc.keyTangent(x, index=(0, 0), outTangentType='spline')
mc.keyTangent(x, index=(2, 2), inTangentType='spline')
mc.keyTangent(x, index=(2, 2), outTangentType='spline')
# create the curve rig for the brows.
curveControlNames = [
'brow_bend_{}_{}'.format(index, side)
for index in range(len(mc.ls('{}.cv'.format(curve), fl=True)))
]
curveRig = rigrepo.libs.wire.buildCurveRig(
curve,
name='brow_bend_{}'.format(side),
ctrl_names=curveControlNames,
parent=self.rigGroup,
control_type='face',
control_color=rigrepo.libs.common.RED)
bindmeshGeometry, follicleList, controlHieracrchyList, jointList, baseCurveJointList = curveRig
for controlHieracrchy in controlHieracrchyList:
shapeNode = mc.listRelatives(controlHieracrchy[-1],
c=True,
shapes=True)[0]
mc.setAttr('{}.lodv'.format(shapeNode), 0)
# create the wire deformer.
# create the skinCluster for the curve
wireDeformer = mc.wire(geometry,
gw=False,
en=1.00,
ce=0.00,
li=0.00,
w=curve,
name="{}_wire".format(curve))[0]
# set the default values for the wire deformer
mc.setAttr("{}.rotation".format(wireDeformer), 0)
mc.setAttr("{}.dropoffDistance[0]".format(wireDeformer), 100)
# create skinCluster for the base wire
baseCurve = "{}BaseWire".format(curve)
baseCurveSkin = mc.skinCluster(*baseCurveJointList + mc.ls(baseCurve),
n="{}_skinCluster".format(baseCurve),
tsb=True)[0]
# parent the curves into the hiearchy.
mc.parent([curve, baseCurve], 'brow_bend_{}_grp'.format(side))
def createController(self):
# create controller
haindLegControllerName = controllerShape( self.IkHindLegJointList[3].replace( 'ball_JNT', 'hindLeg_CON' ), 'cube', 'blue' )
cmds.move( self.anklePos[0], self.anklePos[1], self.anklePos[2], haindLegControllerName )
hipControllerName = controllerShape( self.IkHindLegJointList[0].replace( 'JNT', 'CON' ), 'cube', 'blue' )
POsnap( hipControllerName, self.IkHindLegJointList[0] )
hipWorldControllerName = controllerShape( self.IkHindLegJointList[0].replace( 'JNT', 'world_CON' ), 'cube', 'blue' )
Psnap( hipWorldControllerName, self.IkHindLegJointList[0] )
kneePVContollerName = cmds.spaceLocator( n=self.IkHindLegJointList[1].replace( 'JNT', 'LOC' ) )[0]
kneePVPos = cmds.xform( self.IkHindLegJointList[0], t=True, ws=True, q=True )
cmds.move( kneePVPos[0], kneePVPos[1], kneePVPos[2] + 20, kneePVContollerName )
anklePVContollerName = controllerShape( self.IkHindLegJointList[2].replace( 'JNT', 'CON' ), 'sphere', 'blue' )
anklePVPos = cmds.xform( self.IkHindLegJointList[2], t=True, ws=True, q=True )
cmds.move( anklePVPos[0], anklePVPos[1], anklePVPos[2], anklePVContollerName )
# controller homeNull
homeNul( haindLegControllerName )
hipNul = homeNul( hipControllerName )
hipRotZNul = homeNul( hipControllerName, hipNul.replace( 'hip', 'hipRotZ' ) )
hipNulWorldNul = homeNul( hipWorldControllerName )
kneePVNul = homeNul( kneePVContollerName )
homeNul( anklePVContollerName )
# constraints & grouping
cmds.parent( self.pivotNulList[0], haindLegControllerName )
cmds.parent( kneePVNul, hipControllerName )
cmds.parent( hipNul, hipWorldControllerName )
if self.side != 'R' :
cmds.aimConstraint( haindLegControllerName, hipRotZNul, mo=True, weight=1, aimVector=[ 1, 0, 0 ], upVector=[ 0, 1, 0 ], worldUpType='none', skip=[ 'x', 'y' ] )
else :
cmds.aimConstraint( haindLegControllerName, hipRotZNul, mo=True, weight=1, aimVector=[ -1, 0, 0 ], upVector=[ 0, 1, 0 ], worldUpType='none', skip=[ 'x', 'y' ] )
cmds.pointConstraint( hipControllerName, self.IkHindLegJointList[0] )
cmds.pointConstraint( hipControllerName, self.subIkJointList[0] )
cmds.orientConstraint( hipControllerName, self.subIkJointList[0] )
cmds.poleVectorConstraint( anklePVContollerName, self.sRPsName )
cmds.poleVectorConstraint( kneePVContollerName, self.RPsName )
# addAttr & connection
cmds.addAttr( haindLegControllerName, longName='auto', at='enum', en='Angle', keyable=True )
cmds.setAttr( '%s.auto' % haindLegControllerName, lock=True )
cmds.addAttr( haindLegControllerName, longName='front', at='double', keyable=True, attributeType='float', min=0, max=1, dv=0.5 )
cmds.addAttr( haindLegControllerName, longName='subController', at='enum', en='Visibility', keyable=True )
cmds.setAttr( '%s.subController' % haindLegControllerName, lock=True )
cmds.addAttr( haindLegControllerName, longName='vis', at='bool', keyable=True )
cmds.setKeyframe( '%s.rz' % hipRotZNul )
cmds.disconnectAttr( 'pairBlend1_inRotateZ1.output', 'pairBlend1.inRotateZ1' )
cmds.delete( 'pairBlend1_inRotateZ1' )
cmds.rename( 'pairBlend1', hipRotZNul.replace( 'NUL', 'PBD' ) )
cmds.connectAttr ( '%s.front' % haindLegControllerName, '%s.blendAim1' % hipRotZNul )
# create foot controller
ankleRollCONT = controllerShape( self.anklePivotName.replace( 'PIVOT', 'CON' ), 'cube', 'yellow' )
cvNum = cmds.getAttr( '%s.spans' % ankleRollCONT ) + cmds.getAttr( '%s.degree' % ankleRollCONT )
cmds.select( '%s.cv[0:%s]' % ( ankleRollCONT, cvNum-1 ) )
cmds.scale( 0.5, 0.5, 0.5 )
cmds.select( cl=True )
cmds.parent( '%sShape' % ankleRollCONT, self.anklePivotName, r=True, s=True )
cmds.delete( ankleRollCONT )
ankleRollCON = cmds.rename( self.anklePivotName, self.anklePivotName.replace( 'PIVOT', 'CON' ) )
for x in range( len( self.pivotList ) ):
CONT = controllerShape( self.pivotList[x].replace( 'PIVOT', 'CON' ), 'cube', 'yellow' )
cvNum = cmds.getAttr( '%s.spans' % CONT ) + cmds.getAttr( '%s.degree' % CONT )
cmds.select( '%s.cv[0:%s]' % ( CONT, cvNum-1 ) )
cmds.scale( 0.5, 0.5, 0.5 )
cmds.select( cl=True )
cmds.parent( '%sShape' % CONT, self.pivotList[x], r=True, s=True )
cmds.delete( CONT )
ankleRollCON = cmds.rename( self.pivotList[x], self.pivotList[x].replace( 'PIVOT', 'CON' ) )
cmds.connectAttr( '%s.vis' % haindLegControllerName, '%s.visibility' % self.pivotNulList[0] )
def constrainSelected(copyBreakdowns=True,
frameRange=False,
nodeList=None,
info=True,
skipUD=True,
keyLocOnEveryFrame=True,
bakeGrp='ConstraintLocators_grp',
smartKey=True):
"""
"""
print 'info = {0}'.format(info)
print 'keyLocOnEveryFrame = {0}'.format(keyLocOnEveryFrame)
print 'frameRange = {0}'.format(frameRange)
locDescriptor = 'Constraint'
locSuffix = '_loc'
cmds.refresh(suspend=True)
locList = []
currTime = cmds.currentTime(q=True)
if frameRange:
timeMin = cmds.playbackOptions(q=1, min=1)
timeMax = cmds.playbackOptions(q=1, max=1)
if info:
print('timeMin = ' + str(timeMin))
print('timeMax = ' + str(timeMax))
nodeList = nodeList or cmds.ls(sl=True)
try:
cmds.undoInfo(openChunk=True)
if info: print('nodeList = ' + str(nodeList))
if not len(nodeList):
raise Exception()
if not cmds.objExists(bakeGrp):
cmds.createNode('transform', n=bakeGrp)
keyFrameInfo = {}
for (i, each) in enumerate(nodeList):
print each, '(', i + 1, '/', len(nodeList), ')'
keyFrameInfo[each] = {}
# Query keyframe info
udList = cmds.listAttr(each, ud=1)
if info: print('udList = ' + str(udList))
keyframes = cmds.keyframe(each, query=True, name=True)
keyFrameInfo[each]['keyframes'] = keyframes
if keyframes:
timeList = sorted(
list(
set(
cmds.keyframe(keyframes,
query=True,
timeChange=True))))
else:
timeList = [cmds.currentTime(q=1)]
keyFrameInfo[each]['timeList'] = timeList
keyFrameInfo[each]['udList'] = udList
if info: print('timeList = ' + str(timeList))
locName = '{}{}{}'.format(each, locDescriptor, locSuffix)
if cmds.objExists(locName):
foo = 0
if info:
print('locName "' + str(locName) + '" already exists...')
while cmds.objExists(locName):
foo += 1
locName = '{}{}{}{}'.format(each, locDescriptor, foo,
locSuffix)
if info: print('new locName = "' + str(locName) + '" ')
conLoc = cmds.spaceLocator(n=locName)[0]
keyFrameInfo[each]['conLoc'] = conLoc
if info: print('Created Constraint Locator "' + str(conLoc) + '"')
cmds.addAttr(conLoc, at='message', ln=MESSAGEATTR)
cmds.connectAttr('{0}.message'.format(each),
'{0}.{1}'.format(conLoc, MESSAGEATTR))
locList.append(conLoc)
cmds.parent(conLoc, bakeGrp)
# Gather the earliest start frame
frameList = []
for each in keyFrameInfo:
timeList = keyFrameInfo[each]['timeList']
if keyLocOnEveryFrame:
if info: print('keyLocOnEveryFrame')
keyLocEveryFrameMin = timeMin if frameRange else timeList[0]
if info:
print('keyLocEveryFrameMin = {0}'.format(
keyLocEveryFrameMin))
keyLocEveryFrameMax = timeMax if frameRange else timeList[-1]
if info:
print('keyLocEveryFrameMax = {0}'.format(
keyLocEveryFrameMax))
timeList = range(int(keyLocEveryFrameMin),
int(keyLocEveryFrameMax + 1))
if info: print '"{0}" timeList = {1}'.format(each, timeList)
keyFrameInfo[each]['timeList'] = timeList
frameList = frameList + timeList
frameList = sorted(set(frameList))
if info: print 'frameList = {0}'.format(frameList)
if info: print 'keyFrameInfo = {0}'.format(keyFrameInfo)
if frameRange:
frameListCopy = copy.copy(frameList)
frameList = []
for frame in frameListCopy:
if frame < timeMin:
continue
if frame > timeMax:
break
frameList.append(frame)
# Iterate through each frame
pacList = []
gMainProgressBar = mel.eval('$tmp = $gMainProgressBar')
cmds.progressBar(gMainProgressBar,
edit=True,
beginProgress=True,
isInterruptable=True,
status='querying frames...',
maxValue=len(frameList))
progressBarCancelled = False
for frame in frameList:
if cmds.progressBar(gMainProgressBar, query=True,
isCancelled=True):
progressBarCancelled = True
break
cmds.progressBar(gMainProgressBar,
edit=True,
step=1,
status='frame {0}'.format(frame))
cmds.currentTime(frame)
if info: print '\n========================'
if info: print 'frame: {0}'.format(frame)
for each in keyFrameInfo:
if info: print '{}'.format(each)
# check if the current frame is in each timelist
if not frame in keyFrameInfo[each]['timeList']:
# continue on if it's not
continue
conLoc = keyFrameInfo[each]['conLoc']
keyframes = keyFrameInfo[each]['keyframes']
# check if we've already connected the locator for baking
if not 'startFrame' in keyFrameInfo[each]:
if info:
print '"startFrame" not in keyFrameInfo["{0}"], defining...'.format(
each)
# store the start frame if we haven't
keyFrameInfo[each]['startFrame'] = frame
# Setup constraint to constraint locator
# with an initial keyframe, so that when
# the constraint is made we get a pairblend
cmds.delete(cmds.parentConstraint(each, conLoc))
cmds.setKeyframe(conLoc)
pacList.append(cmds.parentConstraint(each, conLoc)[0])
# Query additional information for breakdowns settings
if copyBreakdowns:
if info:
print('copyBreakdowns = ' + str(copyBreakdowns))
roVal = cmds.getAttr('{0}.ro'.format(each))
cmds.setAttr('{0}.ro'.format(conLoc), roVal)
# query associated attributes
keyFrameInfo[each]['keyable'] = {}
for keyframe in keyframes:
connections = cmds.listConnections(keyframe,
plugs=1,
s=0,
d=1)
xAttr = connections[0].split('.')[1]
if udList:
if skipUD and xAttr in keyFrameInfo[each][
'udList']:
if info:
print 'xAttr "{0}" in udList, skipping...'.format(
xAttr)
continue
keyFrameInfo[each]['keyable'][keyframe] = {}
keyFrameInfo[each]['keyable'][keyframe][
'attr'] = xAttr
if info:
print(
'keyFrameInfo["{0}"]["{1}"][\'attr\'] = {2}'
.format(
each, keyframe, keyFrameInfo[each]
['keyable'][keyframe]['attr']))
keyFrameInfo[each]['keyable'][keyframe][
'tList'] = cmds.keyframe(keyframe,
query=1,
timeChange=1)
keyFrameInfo[each]['keyable'][keyframe][
'vList'] = cmds.keyframe(keyframe,
query=1,
valueChange=1)
# set keys
if keyLocOnEveryFrame:
if info: print 'keyLocOnEveryFrame'
cmds.setKeyframe(conLoc)
elif copyBreakdowns:
if info: print 'copyBreakdowns'
for keyframe in keyFrameInfo[each]['keyable']:
if info: print 'keyframe = "{0}"'.format(keyframe)
'''
if not keyframe in keyFrameInfo[each]['keyable']:
if info: print 'not "{0}" in {1}'.format(keyframe, keyFrameInfo[each]['keyable'])
continue
'''
if not frame in keyFrameInfo[each]['keyable'][
keyframe]['tList']:
if info:
print('not "{}" in {}'.format(
frame, keyFrameInfo[each]['keyable']
[keyframe]['tList']))
if smartKey:
cmds.setKeyframe(conLoc,
attribute=keyFrameInfo[each]
['keyable'][keyframe]['attr'])
continue
index = keyFrameInfo[each]['keyable'][keyframe][
'tList'].index(frame)
breakdown = cmds.keyframe(keyframe,
query=1,
index=(index, index),
breakdown=1)
bd = True if breakdown else False
cmds.setKeyframe(conLoc,
attribute=keyFrameInfo[each]
['keyable'][keyframe]['attr'],
breakdown=bd)
if info: print('setKeyframe("{}")'.format(conLoc))
else:
if info: print 'not keyLocOnEveryFrame or copyBreakdowns'
cmds.setKeyframe(conLoc)
# clean up
cmds.delete(pacList)
# Now attach destination nodes to constraint locators
if not progressBarCancelled:
for each in keyFrameInfo:
conLoc = keyFrameInfo[each]['conLoc']
constrainMulti = False
try:
cmds.orientConstraint(conLoc, each)
constrainMulti = True
print 'could orient constrain'
except:
pass
try:
cmds.pointConstraint(conLoc, each)
constrainMulti = True
print 'could point constrain'
except:
pass
if not constrainMulti:
channels = ['x', 'y', 'z']
for channel in channels:
channelList = copy.copy(channels)
channelList.pop(channelList.index(channel))
try:
cmds.orientConstraint(conLoc,
each,
skip=channelList)
print 'could orient constrain ', channel
except:
pass
try:
cmds.pointConstraint(conLoc,
each,
skip=channelList)
print 'could point constrain ', channel
except:
pass
else:
cmds.warning(
'constrain selected cancelled, skipping constraining to locators...'
)
except Exception as E:
traceback.print_exc(file=sys.stderr)
cmds.progressBar(gMainProgressBar, edit=True, endProgress=True)
cmds.refresh(suspend=False)
cmds.undoInfo(closeChunk=True)
cmds.progressBar(gMainProgressBar, edit=True, endProgress=True)
cmds.refresh(suspend=False)
cmds.currentTime(currTime)
cmds.select(nodeList)
cmds.undoInfo(closeChunk=True)
def setupControl(self,*args):
#Load variables
name = cmds.textFieldButtonGrp(self.nameField,q=True,text=True)
control = cmds.textFieldButtonGrp(self.controlField,q=True,text=True)
rivet = cmds.textFieldButtonGrp(self.rivetField,q=True,text=True)
constObj = cmds.textFieldButtonGrp(self.jointField,q=True,text=True)
#Load selection
verts = cmds.ls(sl=True,fl=True)
#Create Cluster
clusterName,clusterHandle = cmds.cluster(rel=True,n=name+'_clstr')
#Delete Rivet's aim constraint because it causes flipping if the rivets lofted nurbs plane flips.
#Add parent constraint to object.(constObj)
try:
temp = cmds.listConnections(rivet)
cmds.delete(temp[1])
except:
# No constraint to delete on rivet
pass
#Rivet WS location
rivetLocation = cmds.xform(rivet,q=True,ws=True,t=True)
#Snap Cluster pivots to rivetLocation
self.move(clusterHandle, rivetLocation,t=False,sp=True,rp=True)
#Snap Controls pivots to rivetLocation
self.move(control, rivetLocation,t=False,sp=True,rp=True)
#Group Cluster
clusterGrp = cmds.group(clusterHandle)
clusterGrp = cmds.rename(clusterGrp, name + 'Cluster_' + clusterHandle)
#Create over ride group
or_grp = cmds.group(em=True,name=name+"OR1")
or2_grp = cmds.group(em=True,name=name+"OR2")
#Parent override group to rivet
cmds.parent(or_grp,or2_grp)
cmds.parent(or2_grp,rivet)
#Freeze transforms on override group
cmds.makeIdentity(or_grp,apply=True,t=True,r=True,s=True,n=True)
#Zero Control
zeroNode = cmds.group(em=True,n=name + "nullGrp")
pos = cmds.xform( control, q=1, ws=True, t=1)
cmds.xform( zeroNode, ws=True, t=[pos[0], pos[1], pos[2]])
rot = cmds.xform( control, q=1, ws=True, ro=1)
cmds.xform( zeroNode, ws=True, ro=[rot[0], rot[1], rot[2]])
scale = cmds.xform( control, q=1, r=1, s=1)
cmds.xform( zeroNode, ws=True, s=[scale[0], scale[1], scale[2]])
#Snap zeroNode pivot to control
controlLocation = cmds.xform(control,q=True,ws=True,rp=True)
self.move(zeroNode, controlLocation, t=False, sp=True, rp=True)
#parent control to OverRide group
cmds.parent(control, zeroNode, a=True)
cmds.parent(zeroNode,or_grp)
#Connect control t,r,s to cluster, then hide the cluster and rivet group
cmds.connectAttr(control + ".translate", clusterHandle + ".translate")
cmds.connectAttr(control + ".rotate", clusterHandle + ".rotate")
cmds.connectAttr(control + ".scale", clusterHandle + ".scale")
#Create utility node and negate double transform
#by reversing the transformation of or_grp <---- Cause of double transforms
mdNode = cmds.createNode("multiplyDivide")
nodeName = name + "_MD"
cmds.rename(mdNode,nodeName)
mdNode = nodeName
#Unparent control
cmds.parent(zeroNode,w=True)
#Set up the MD node
cmds.setAttr( "%s.input2X"%mdNode, -1)
cmds.setAttr( "%s.input2Y"%mdNode, -1)
cmds.setAttr( "%s.input2Z"%mdNode, -1)
#Connect the nodes
# control ---> mdNode
cmds.connectAttr("%s.translateX"%control,"%s.input1X"%mdNode,f=True)
cmds.connectAttr("%s.translateY"%control,"%s.input1Y"%mdNode,f=True)
cmds.connectAttr("%s.translateZ"%control,"%s.input1Z"%mdNode,f=True)
#mdNode ---> or_grp
cmds.connectAttr("%s.outputX"%mdNode,"%s.translateX"%or_grp,f=True)
cmds.connectAttr("%s.outputY"%mdNode,"%s.translateY"%or_grp,f=True)
cmds.connectAttr("%s.outputZ"%mdNode,"%s.translateZ"%or_grp,f=True)
#Reparent control
cmds.parent(zeroNode,or_grp)
#Get mesh name
# ex. "meshName.vtx[35]"
mesh = verts[0].split('.')[0]
#Get meshDeformer
meshDeformer = mel.eval('findRelatedSkinCluster("%s");'%mesh)
"""
history = cmds.listHistory(mesh)
for each in history:
#print " History: " + each
if("skinCluster" in str(each)):
#Possible match for meshDeformer
if("Group" not in str(each)):
meshDeformer = each
if("cMuscleSystem" in str(each)):
if("Group" not in str(each)):
meshDeformer = each
"""
#Reorder deformer nodes
#Move cluster + meshDeformer to top of deformer stack
cmds.reorderDeformers(clusterHandle,meshDeformer,mesh)
#Move meshDeformer to top of deformer stack
cmds.reorderDeformers(meshDeformer,clusterHandle,mesh)
#Create final group
topGrp = cmds.group(em=True,name=name+"_followCnt_grp")
cmds.parent(clusterGrp,rivet,topGrp)
#Orient constrain rivet to constrain object
cmds.orientConstraint(constObj,rivet,mo=True)
#Hide cluster grp
cmds.setAttr(clusterGrp + ".visibility",0)
#Hide the rivet
rivetShape = cmds.listRelatives(rivet,shapes=True)
cmds.setAttr(rivetShape[0] + ".visibility",0)
#Clear selection
cmds.select(clear=True)
def setIK(self, *jnt):
buffer = []
copied = []
crv = ''
tmp = cmds.listRelatives(jnt[0], c=1, ad=1)
c = jnt[0]
buffer.append(c)
for i in range(len(tmp)):
if jnt[-1] in c:
break
else:
c = cmds.listRelatives(c, c=True)
buffer.append(c[0])
#조인트 복사 및 중복된 네임 정리
for e in buffer:
name = e.split('_')[0] + '_IK_' + e.split('_')[2]
dup = cmds.duplicate(e, n=name, rr=True, rc=True)
tmp = setUniqueName(dup[0], 'JNT')
par = cmds.listRelatives(tmp, p=True, typ='joint')
chi = cmds.listRelatives(tmp, c=True, typ='joint')
if par is not None:
if len(copied) is not 0:
cmds.parent(tmp, copied[-1])
if cmds.connectionInfo(tmp + '.inverseScale',
id=True) is False:
cmds.connectAttr(copied[-1] + '.scale',
tmp + '.inverseScale',
f=True)
if chi is not None:
cmds.delete(chi)
copied.append(tmp)
#커브 그리기
for i in range(len(copied)):
pos = cmds.xform(copied[i], q=True, ws=True, t=True)
if i is 0:
continue
elif copied[i] is copied[1]:
tmp = cmds.curve(n='C_IK_spineCurve', d=3, p=pos)
crv = setUniqueName(tmp, 'CRV')
else:
cmds.curve(crv, a=True, p=pos)
cmds.parent(copied[0], 'IKJoint_GRP')
tmp = ikHandleMaker(copied[1], copied[-1], 'ikSplineSolver', crv)
hdl = cmds.rename(tmp[0], copied[0].replace('JNT', 'HDL'))
cmds.parent(crv, hdl, 'auxillary_GRP')
#컨트롤러 생성 / 스플라인 커브 컨트롤 셋
cons = splineControllerMaker(crv, hdl)
#스플라인 스트레치 연결
st = splineStretchy()
st.stretchy(cons[1], crv, copied[1], copied[2], copied[3])
#힙 컨트롤러 생성
buf = controllerShape('C_IK_hip', 'square', 'yellow')
hip = setUniqueName(buf, 'CON')
hipNul = homeNul(hip)
cmds.delete(cmds.parentConstraint(cons[0], hipNul, w=True))
cmds.parentConstraint(hip, copied[0], mo=True)
cmds.parent(hipNul, cons[0])
cmds.orientConstraint(cons[1], copied[-1], mo=True)
#루트 컨트롤러 생성
cmds.delete(cmds.parentConstraint(cons[0], 'root_NUL', w=True))
cons.append(hip)
#return control curves
return cons
def chain_create(self, objs = None,
fwd = None, up=None,
name = None,
upSetup = "guess",
extendStart = None,
extendEnd = True,
mNucleus=None,
upControl = None,
aimUpMode = None,
**kws):
_str_func = 'chain_create'
if not objs:
_sel = mc.ls(sl=1)
if _sel:objs = _sel
ml = cgmMeta.asMeta( objs, noneValid = True )
ml_baseTargets = copy.copy(ml)
if not ml:
return log.warning("No objects passed. Unable to chain_create")
if not name:
name = ml[-1].p_nameBase
_idx = self.get_nextIdx()
#Make our sub group...
mGrp = self.doCreateAt(setClass=1)
mGrp.p_parent = self
mGrp.rename("chain_{0}_grp".format(name))
mGrp.dagLock()
self.connectChildNode(mGrp.mNode,'chain_{0}'.format(_idx),'owner')
#holders and dat...
ml_targets = []
ml_posLocs = []
ml_aim_locs = []
fwd = fwd or self.fwd
up = up or self.up
upSetup = upSetup or self.upSetup
extendStart = extendStart or self.extendStart
extendEnd = extendEnd or self.extendEnd
upControl = upControl or self.upControl
aimUpMode = aimUpMode or self.aimUpMode
#fwdAxis = simpleAxis(fwd)
#upAxis = simpleAxis(up)
fwdAxis = TRANS.closestAxisTowardObj_get(ml[0], ml[1])
upAxis = TRANS.crossAxis_get(fwdAxis)
mGrp.doStore('fwd', fwdAxis.p_string)
mGrp.doStore('up', upAxis.p_string)
#Curve positions...
l_pos = []
if upSetup == 'manual':
if len(ml) < 2:
log.debug(cgmGEN.logString_msg(_str_func, 'Single count. Adding extra handle.'))
mLoc = ml[0].doLoc()
mLoc.rename("chain_{0}_end_loc".format(name))
_size = DIST.get_bb_size(ml[0],True,'max')
mLoc.p_position = ml[0].getPositionByAxisDistance(fwdAxis.p_string,_size)
ml.append(mLoc)
mLoc.p_parent = mGrp
for obj in ml:
l_pos.append(obj.p_position)
_v_baseDist = DIST.get_distance_between_points(l_pos[-1],l_pos[-2])
_v_baseDist = MATHUTILS.Clamp(_v_baseDist, .5,None)
_p_baseExtend = DIST.get_pos_by_axis_dist(ml[-1],
fwdAxis.p_string,
_v_baseDist)
if extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...'))
extendEnd = VALID.valueArg(extendEnd)
if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd):
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess'))
l_pos.append(_p_baseExtend)
elif extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | {0}'.format(extendEnd)))
l_pos.append( DIST.get_pos_by_axis_dist(ml[-1],
fwdAxis.p_string,
extendEnd ))
else:
l_pos.append( _p_baseExtend)
if extendStart:
f_extendStart = VALID.valueArg(extendStart)
if f_extendStart:
l_pos.insert(0, DIST.get_pos_by_axis_dist(ml[0],
fwdAxis.inverse.p_string,
f_extendStart ))
else:
log.debug(cgmGEN.logString_msg(_str_func, 'Resolving aim'))
if len(ml) < 2:
return log.error(cgmGEN.logString_msg(_str_func, 'Single count. Must use manual upSetup and aim/up args'))
for obj in ml:
l_pos.append(obj.p_position)
_vecEnd = MATHUTILS.get_vector_of_two_points(l_pos[-2],l_pos[-1])
if extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...'))
extendEnd = VALID.valueArg(extendEnd)
if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd):
log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess'))
l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd,
(DIST.get_distance_between_points(l_pos[-2],l_pos[-1])/2)))
elif extendEnd:
log.debug(cgmGEN.logString_msg(_str_func, 'extendStart | {0}'.format(extendEnd)))
l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd,
extendEnd))
if extendStart:
f_extendStart = VALID.valueArg(extendStart)
if f_extendStart:
log.debug(cgmGEN.logString_msg(_str_func, 'extendStart...'))
_vecStart = MATHUTILS.get_vector_of_two_points(l_pos[1],l_pos[0])
l_pos.insert(0, DIST.get_pos_by_vec_dist(l_pos[0],
_vecStart,
f_extendStart))
#pprint.pprint(l_pos)
#for i,p in enumerate(l_pos):
# LOC.create(position=p,name='p_{0}'.format(i))
crv = CORERIG.create_at(create='curve',l_pos= l_pos, baseName = name)
mInCrv = cgmMeta.asMeta(crv)
mInCrv.rename("{0}_inCrv".format(name))
mGrp.connectChildNode(mInCrv.mNode,'mInCrv')
mc.select(cl=1)
# make the dynamic setup
log.debug(cgmGEN.logString_sub(_str_func,'dyn setup'))
b_existing = False
b_existing_nucleus = False
mHairSys = self.getMessageAsMeta('mHairSysShape')
if mHairSys:
mHairSysDag = mHairSys.getTransform(asMeta=1)
log.info(cgmGEN.logString_msg(_str_func,'Using existing system: {0}'.format(mHairSys.mNode)))
mc.select(mHairSysDag.mNode, add=True)
b_existing = True
if self.useExistingNucleus or mNucleus:
mNucleus = self.get_nucleus(mNucleus)
if mNucleus:
#mc.select(mNucleus.mNode,add=1)
b_existing_nucleus = True
log.info(cgmGEN.logString_msg(_str_func,'Using existing nucleus: {0}'.format(mNucleus.mNode)))
self.connectChildNode(mNucleus.mNode,'mNucleus')
mc.select(mInCrv.mNode,add=True)
mel.eval('makeCurvesDynamic 2 { "0", "0", "1", "1", "0" }')
# get relevant nodes
follicle = mc.listRelatives(mInCrv.mNode,parent=True)[0]
mFollicle = cgmMeta.asMeta(follicle)
mFollicle.rename("{0}_foll".format(name))
parent = mFollicle.getParent(asMeta=1)
mFollicle.p_parent = mGrp
mFollicleShape = mFollicle.getShapes(1)[0]
mc.delete(parent.mNode)
_follicle = mFollicle.mNode
mGrp.connectChildNode(mFollicle.mNode,'mFollicle','group')
follicleShape = mFollicleShape.mNode#mc.listRelatives(mFollicle.mNode, shapes=True)[0]
_hairSystem = mc.listRelatives( mc.listConnections('%s.currentPosition' % follicleShape)[0],
shapes=True)[0]
if not b_existing:
mHairSys = cgmMeta.asMeta(_hairSystem)
mHairSysDag = mHairSys.getTransform(asMeta=1)
mHairSysDag.rename("{0}_hairSys".format(self.baseName))
self.connectChildNode(mHairSysDag.mNode,'mHairSysDag','owner')
self.connectChildNode(mHairSys.mNode,'mHairSysShape','owner')
mHairSysDag.p_parent = self
_hairSystem = mHairSys.mNode
outCurve = mc.listConnections('%s.outCurve' % _follicle)[0]
mCrv = cgmMeta.asMeta(outCurve)
parent = mCrv.getParent(asMeta=1)
outCurveShape = mc.listRelatives(mCrv.mNode, shapes=True)[0]
mCrv.p_parent = mGrp.mNode
mc.delete(parent.mNode)
_nucleus = mc.listConnections( '%s.currentState' % mHairSys.mNode )[0]
if not b_existing_nucleus:
mNucleus = cgmMeta.asMeta(_nucleus)
mNucleus.rename("cgmDynFK_nucleus")
#self.connectChildNode(mNucleus.mNode,'mNucleus','owner')
self.connectChildNode(mNucleus.mNode,'mNucleus')
if self.startFrame is not None:
mNucleus.startFrame = self.startFrame
else:
#Because maya is crappy we gotta manually wire the existing nucleus
##startFrame out to startFrame in
##outputObjects[x] - nextState
##shape.currentState>inputActive[x]
##shape.startState>inputActiveStart[x]
if cgmMeta.asMeta(_nucleus).mNode != mNucleus.mNode:
mc.delete(_nucleus)
_useNucleus = mNucleus.mNode
"""
_useIdx = ATTR.get_nextCompoundIndex(mNucleus.mNode,'outputObjects')
log.info("useIdx: {0}".format(_useIdx))
ATTR.connect('{0}.outputObjects[{1}]'.format(_useNucleus,_useIdx),'{0}.nextState'.format(_hairSystem))
ATTR.connect('{0}.currentState'.format(_hairSystem),'{0}.inputActive[{1}]'.format(_useNucleus,_useIdx))
ATTR.connect('{0}.startState'.format(_hairSystem),'{0}.inputActiveStart[{1}]'.format(_useNucleus,_useIdx))"""
mParent = ml[0].getParent(asMeta=1)
if not mParent:
mParent = ml[0].doGroup(1,1,
asMeta=True,
typeModifier = 'dynFKParent',
setClass='cgmObject')
#else:
#mParent.getParent(asMeta=1)
mGrp.connectChildNode(mCrv.mNode,'mOutCrv','group')
#self.follicles.append(follicle)
#self.outCurves.append(outCurve)
# set default properties
mFollicleShape.pointLock = 1
#mc.setAttr( '%s.pointLock' % follicleShape, 1 )
mc.parentConstraint(ml[0].getParent(), _follicle, mo=True)
# create locators on objects
locators = []
prs = []
ml_locs = []
ml_aims = []
ml_prts = []
_upVector = None
if upSetup == 'guess':
log.debug(cgmGEN.logString_msg(_str_func, 'Resolving up/aim'))
poci_base = CURVES.create_pointOnInfoNode(mInCrv.mNode,1)
mPoci_base = cgmMeta.asMeta(poci_base)
_upVector = mPoci_base.normalizedNormal
log.debug(cgmGEN.logString_msg(_str_func, "upVector: {0}".format(_upVector)))
#Let's make an up object as the parent of the root isn't good enough
mUp = ml[0].doCreateAt(setClass=1)
mUp.rename("chain_{0}_up".format(name))
mUp.p_parent = mGrp
if _upVector:
SNAP.aim_atPoint(mUp.mNode,
DIST.get_pos_by_vec_dist(mUp.p_position,
_upVector,
10),aimAxis='y+',upAxis='z+')
if upControl:
log.debug(cgmGEN.logString_msg(_str_func,'upControl'))
if len(ml_baseTargets)>1:
sizeControl = DIST.get_distance_between_targets([mObj.mNode for mObj in ml_baseTargets],True)
else:
sizeControl = DIST.get_bb_size(ml[0],True,'max')
crv = CURVES.create_controlCurve(mUp.mNode,'arrowSingle', size= sizeControl, direction = 'y+')
CORERIG.shapeParent_in_place(mUp.mNode, crv, False)
mUpGroup = mUp.doGroup(True,True,
asMeta=True,
typeModifier = 'master',
setClass='cgmObject')
mc.parentConstraint(ml[0].getParent(), mUpGroup.mNode, mo=True)
else:
mc.parentConstraint(ml[0].getParent(), mUp.mNode, mo=True)
# create control joint chain
mc.select(cl=True)
chain = []
for obj in ml:
if len(chain) > 0:
mc.select(chain[-1])
jnt = mc.joint(name='%s_%s_jnt' % (name, obj.p_nameBase))
SNAP.matchTarget_set(jnt, obj.mNode)
mObj = cgmMeta.asMeta(jnt)
mObj.doSnapTo(mObj.getMessageAsMeta('cgmMatchTarget'))
chain.append(jnt)
mc.parent(chain[0], _follicle)
mInCrv.p_parent = mGrp
mc.bindSkin(mInCrv.mNode, chain[0], ts=True)
log.debug(cgmGEN.logString_msg(_str_func,'aimUpMode: {0}'.format(aimUpMode)))
for i, mObj in enumerate(ml):
if not i:
mUpUse = mUp
else:
mUpUse = ml_locs[-1]
mLoc = cgmMeta.asMeta( LOC.create(mObj.getNameLong()) )
loc = mLoc.mNode
ml_locs.append(mLoc)
#loc = LOC.create(mObj.getNameLong())
mAim = mLoc.doGroup(False,False,
asMeta=True,
typeModifier = 'aim',
setClass='cgmObject')
ml_aims.append(mAim)
#aimNull = mc.group(em=True)
#aimNull = mc.rename('%s_aim' % mObj.getShortName())
poc = CURVES.create_pointOnInfoNode(outCurveShape)
#mc.createNode('pointOnCurveInfo', name='%s_pos' % loc)
mPoci_obj = cgmMeta.asMeta(poc)
mPoci_obj.rename('%s_pos' % loc)
pocAim = CURVES.create_pointOnInfoNode(outCurveShape)
#mc.createNode('pointOnCurveInfo', name='%s_aim' % loc)
pr = CURVES.getUParamOnCurve(loc, outCurve)
mPoci_obj.parameter = pr
#mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % poc, f=True )
#mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % pocAim, f=True )
#mc.setAttr( '%s.parameter' % poc, pr )
if i < len(ml)-1:
nextpr = CURVES.getUParamOnCurve(ml[i+1], outCurve)
mc.setAttr('%s.parameter' % pocAim, (nextpr))# + pr))# * .5)
else:
if extendStart:
mc.setAttr( '%s.parameter' % pocAim, len(ml)+1 )
else:
mc.setAttr( '%s.parameter' % pocAim, len(ml) )
mLocParent = mLoc.doGroup(False,False,
asMeta=True,
typeModifier = 'pos',
setClass='cgmObject')
ml_prts.append(mLocParent)
#locParent = mc.group(em=True)
#locParent = mc.rename( '%s_pos' % mObj.getShortName() )
mc.connectAttr( '%s.position' % mPoci_obj.mNode, '%s.translate' % mLocParent.mNode)
mc.connectAttr( '%s.position' % pocAim, '%s.translate' % mAim.mNode)
if aimUpMode == 'master':
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "objectrotation",
worldUpVector = upAxis.p_vector,
worldUpObject = mUp.mNode )
elif aimUpMode == 'orientToMaster':
mc.orientConstraint( mUp.mNode,
mLocParent.mNode,
maintainOffset = 1)
elif aimUpMode == 'sequential':
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "objectrotation",
worldUpVector = upAxis.p_vector,
worldUpObject = mUpUse.mNode )
elif aimUpMode == 'joint':
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "objectrotation",
worldUpVector = upAxis.p_vector,
worldUpObject = chain[i] )
elif aimUpMode == 'curveNormal':
mUpLoc = mLoc.doGroup(False,False,
asMeta=True,
typeModifier = 'up',
setClass='cgmObject')
mUpLoc.p_parent = mLocParent
aimConstraint = mc.aimConstraint( mAim.mNode,
mLocParent.mNode,
aimVector=fwdAxis.p_vector,
upVector = upAxis.p_vector,
worldUpType = "object")
mPlusMinusAverage = cgmMeta.cgmNode(name="{0}_pma".format(mObj.p_nameBase),
nodeType = 'plusMinusAverage')
mPlusMinusAverage.operation = 3
mPoci_obj.doConnectOut('position','{0}.input3D[0]'.format(mPlusMinusAverage.mNode))
mPoci_obj.doConnectOut('normalizedNormal','{0}.input3D[1]'.format(mPlusMinusAverage.mNode))
mUpLoc.doConnectIn('translate','{0}.output3D'.format(mPlusMinusAverage.mNode))
mLoc.p_parent = mLocParent
mAim.p_parent = mGrp
mLocParent.p_parent = mGrp
#mc.parent(loc, locParent)
mCrv.rename("{0}_outCrv".format(name))
mCrvParent = mCrv.getParent(asMeta=1)
mCrvParent.p_parent = mGrp
mGrp.msgList_connect('mLocs',ml_locs)
mGrp.msgList_connect('mAims',ml_aims)
mGrp.msgList_connect('mParents',ml_prts)
mGrp.msgList_connect('mTargets',ml)
mGrp.msgList_connect('mBaseTargets',ml_baseTargets)
mGrp.msgList_connect('mObjJointChain',chain)
mGrp.doStore('cgmName', name)
mNucleus.doConnectOut('startFrame',"{0}.startFrame".format(mHairSys.mNode))
def switchConstraint(attachType,
transform,
targetList,
aliasList=[],
createTarget=True,
switchCtrl=None,
switchAttr=None,
prefix=''):
"""
Setup a single or multi target switchable constraint based on the input arguments
@param attachType: Attach constraint type. Accepted types are "point", "orient", "parent", "scale" and "all".
@type attachType: str
@param transform: The transform that will be the slave of the attach constraint.
@type transform: str
@param targetList: A list of transforms that will be the parent/master of the attach constraint.
@type targetList: list
@param aliasList: A list of name alias' for each item in targetList. Uses to populate the enum attr for constraint target switching.
@type aliasList: list
@param createTarget: If True, create a new null transform under the current target that will result in a zero offset constraint. If False, use the transform specified in targetList.
@type createTarget: bool
@param switchCtrl: The control object that will hold the constraint target switch attribute.
@type switchCtrl: str
@param switchAttr: Name of the constraint target switch attribute.
@type switchAttr: str
@param prefix: Name prefix for new nodes.
@type prefix: str
"""
# ==========
# - Checks -
# ==========
# Attach Type
if not attachType in ['point', 'orient', 'parent', 'scale', 'all']:
raise Exception('Invalid attach type! ("' + attachType + '")')
# Prefix
if not prefix: prefix = transform
# Transform
if not cmds.objExists(transform):
raise Exception('Transform "' + transform + '" does not exist!')
# Target
for target in targetList:
if not cmds.objExists(target):
raise Exception('Target transform "' + target +
'" does not exist!')
# Target Alias List
if not aliasList: aliasList = targetList
# Switch Control
if switchCtrl and not cmds.objExists(switchCtrl):
raise Exception('Switch control "' + switchCtrl + '" does not exist!')
# =====================
# - Switch Attributes -
# =====================
# Create Switch Attribute
if switchCtrl:
if not cmds.objExists(switchCtrl + '.' + switchAttr):
cmds.addAttr(switchCtrl,
ln=switchAttr,
at='enum',
en=':'.join(aliasList),
k=True)
# ============================
# - Create Target Transforms -
# ============================
# Initialize new target list
if createTarget:
# For Each Target
cTargetList = []
for t in range(len(targetList)):
# Duplicate transform to generate new target
cTarget = cmds.createNode('transform',
n=prefix + '_' + aliasList[t] +
'_target')
glTools.utils.transform.match(cTarget, transform)
# Parent Control Target to Current Constraint Target
try:
cTarget = cmds.parent(cTarget, targetList[t])[0]
except:
raise Exception('Unable to parent target null "' + cTarget +
'" to target transform "' + targetList[t] +
'"!')
# Target Display Override
glTools.utils.base.displayOverride(cTarget,
overrideEnable=1,
overrideDisplay=2)
# Append to Target List
cTargetList.append(cTarget)
# Update target list
targetList = cTargetList
# Set Channel States
chStateUtil = glTools.utils.channelState.ChannelState()
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
objectList=targetList)
# =====================
# - Create Constraint -
# =====================
# Initialize scale constraint valiables ("all" only)
scaleConstraint = None
scaleWtAlias = []
if attachType == 'point':
constraint = cmds.pointConstraint(targetList,
transform,
mo=False,
n=prefix + '_pointConstraint')[0]
wtAlias = cmds.pointConstraint(constraint, q=True, wal=True)
if attachType == 'orient':
constraint = cmds.orientConstraint(targetList,
transform,
mo=False,
n=prefix + '_orientConstraint')[0]
wtAlias = cmds.orientConstraint(constraint, q=True, wal=True)
if attachType == 'parent':
constraint = cmds.parentConstraint(targetList,
transform,
mo=False,
n=prefix + '_parentConstraint')[0]
wtAlias = cmds.parentConstraint(constraint, q=True, wal=True)
if attachType == 'scale':
constraint = cmds.scaleConstraint(targetList,
transform,
mo=False,
n=prefix + '_scaleConstraint')[0]
wtAlias = cmds.parentConstraint(constraint, q=True, wal=True)
if attachType == 'all':
constraint = cmds.parentConstraint(targetList,
transform,
mo=False,
n=prefix + '_parentConstraint')[0]
wtAlias = cmds.parentConstraint(constraint, q=True, wal=True)
scaleConstraint = cmds.scaleConstraint(targetList,
transform,
mo=False,
n=prefix +
'_scaleConstraint')[0]
scaleWtAlias = cmds.scaleConstraint(scaleConstraint, q=True, wal=True)
# =============================
# - Connect to Switch Control -
# =============================
if switchCtrl:
# Initialize switch list
switchNodes = []
for i in range(len(targetList)):
# Create Switch Node
switchNode = cmds.createNode('condition',
n=prefix + '_' + wtAlias[i] +
'_condition')
# Connect to switch attr
cmds.connectAttr(switchCtrl + '.' + switchAttr,
switchNode + '.firstTerm',
f=True)
cmds.setAttr(switchNode + '.secondTerm', i)
cmds.setAttr(switchNode + '.operation', 0) # Equal
cmds.setAttr(switchNode + '.colorIfTrue', 1, 0, 0)
cmds.setAttr(switchNode + '.colorIfFalse', 0, 1, 1)
# Connect to constraint target weight
cmds.connectAttr(switchNode + '.outColorR',
constraint + '.' + wtAlias[i])
# Connect to scale constraint, if necessary ("all" only)
if scaleConstraint:
cmds.connectAttr(switchNode + '.outColorR',
scaleConstraint + '.' + scaleWtAlias[i])
# Append switch list
switchNodes.append(switchNode)
# =================
# - Return Result -
# =================
return constraint
def build(inputJoints=None):
"""
create Slave joints for given joints list.
if inputJoints = None, create slave joints for all joints in the scene without end joint in the joint chain
:param inputJoints: str list, target joints list for create Slave joints
:return: None
"""
if inputJoints:
targetJoints = inputJoints
else:
targetJoints = []
# list all selected inputJoints without end inputJoints
allJoints = cmds.ls(type='joint')
for joint in allJoints:
if cmds.attributeQuery('slaveJoint', node=joint, exists=1):
targetJoints.append(joint)
cmds.select(cl=1)
# 1. generate slave joint for each target joint
if targetJoints:
for joint in targetJoints:
slaveJoint = cmds.joint(n='Slave_' + joint)
cmds.select(cl=1)
cmds.delete(cmds.parentConstraint(joint, slaveJoint, mo=0))
cmds.makeIdentity(slaveJoint, apply=1, t=1, r=1, s=1)
if not cmds.attributeQuery('slaveJoint', node=slaveJoint,
exists=1):
cmds.addAttr(slaveJoint, ln='slaveJoint', at='message')
cmds.connectAttr(joint + '.slaveJoint',
slaveJoint + '.slaveJoint',
f=1)
cmds.select(cl=1)
# 2. parenting
if targetJoints:
for joint in targetJoints:
slaveJoint = cmds.listConnections(joint + '.slaveJoint',
destination=1,
source=0,
type='joint')[0]
if cmds.attributeQuery('slaveParent', node=joint, exists=1):
parent = cmds.getAttr(joint + '.slaveParent')
if cmds.attributeQuery('slaveJoint', node=parent, exists=1):
parentSlave = cmds.listConnections(parent + '.slaveJoint',
source=0,
destination=1,
type='joint')[0]
if parentSlave:
cmds.parent(slaveJoint, parentSlave)
else:
parent = cmds.listRelatives(joint,
c=0,
p=1,
s=0,
type='joint',
path=1)
if parent:
if cmds.attributeQuery('slaveJoint',
node=parent[0],
exists=1):
parentSlave = cmds.listConnections(parent[0] +
'.slaveJoint',
source=0,
destination=1,
type='joint')
if parentSlave:
cmds.parent(slaveJoint, parentSlave[0])
cmds.select(cl=1)
# 3. Constraint slave joint
if targetJoints:
for joint in targetJoints:
slaveJoint = cmds.listConnections(joint + '.slaveJoint',
destination=1,
source=0,
type='joint')[0]
if cmds.attributeQuery('slavePointConst', node=joint, exists=1):
pointConst = cmds.getAttr(joint + '.slavePointConst')
if pointConst:
cmds.pointConstraint(pointConst, slaveJoint, mo=0)
else:
cmds.pointConstraint(joint, slaveJoint, mo=0)
cmds.orientConstraint(joint, slaveJoint, mo=0)
cmds.scaleConstraint(joint, slaveJoint, mo=0)
cmds.select(cl=1)
def main(templateFile=None,
inheritTemplateRotations=False,
controlShapes=None,
oglControlShapes=None,
fbx=False,
scale=1,
radius=1,
numTwistJoints=4,
ikShape="cube"):
template(filepath=templateFile, scale=scale)
root.main(name="assembly", position="spine1", fbx=fbx, radius=radius)
#
# spine and head
#
spine.main(
positions=["spine1", "spine2", "spine3", "spine4", "spine5", "spine6"],
radius=radius)
mc.parent("spine", "pelvis_ctrl")
mc.parentConstraint("body_ctrl", "spine_ik2_ctrl_grp", mo=True)
mc.setAttr("spine_ik1_ctrlShape.lodVisibility", False)
mc.connectAttr("assembly.joints", "spine_ik1_ctrl.joints")
mc.setAttr("spine_ik1_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "spine_ik1_ctrl.editJoints")
mc.setAttr("spine_ik1_ctrl.editJoints", k=False)
head.main(control="spine_ik6_ctrl",
parent="spine_jnt6",
positions=["jaw", "eye_lf", "eye_rt"],
radius=radius,
ikShape=ikShape)
mc.connectAttr("assembly.joints", "spine_ik6_ctrl.joints")
mc.setAttr("spine_ik6_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "spine_ik6_ctrl.editJoints")
mc.setAttr("spine_ik6_ctrl.editJoints", k=False)
#
# legs
#
leg.main(name="leg_lf",
positions=[
"leg_lf1", "leg_lf2", "leg_lf3", "leg_lf4", "leg_lf5",
"leg_lf6"
],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("leg_lf", "cog_ctrl")
mc.parentConstraint("pelvis_ctrl", "leg_lf_ik1_grp", mo=True)
mc.connectAttr("assembly.joints", "leg_lf_ik1_ctrl.joints")
mc.setAttr("leg_lf_ik1_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "leg_lf_ik1_ctrl.editJoints")
mc.setAttr("leg_lf_ik1_ctrl.editJoints", k=False)
mc.setAttr("leg_lf_ik1_ctrl.fkControls", False)
leg.main(name="leg_rt",
positions=[
"leg_rt1", "leg_rt2", "leg_rt3", "leg_rt4", "leg_rt5",
"leg_rt6"
],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("leg_rt", "cog_ctrl")
mc.parentConstraint("pelvis_ctrl", "leg_rt_ik1_grp", mo=True)
mc.connectAttr("assembly.joints", "leg_rt_ik1_ctrl.joints")
mc.setAttr("leg_rt_ik1_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "leg_rt_ik1_ctrl.editJoints")
mc.setAttr("leg_rt_ik1_ctrl.editJoints", k=False)
mc.setAttr("leg_rt_ik1_ctrl.fkControls", False)
#
# arms
#
arm.main(name="arm_lf",
positions=["arm_lf1", "arm_lf2", "arm_lf3", "arm_lf4"],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("arm_lf", "body_ctrl")
mc.parentConstraint("spine_jnt3", "arm_lf", mo=True)
mc.connectAttr("assembly.joints", "arm_lf_ik2_ctrl.joints")
mc.setAttr("arm_lf_ik2_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "arm_lf_ik2_ctrl.editJoints")
mc.setAttr("arm_lf_ik2_ctrl.editJoints", k=False)
mc.setAttr("arm_lf_ik2_ctrl.fkControls", False)
arm.main(name="arm_rt",
positions=["arm_rt1", "arm_rt2", "arm_rt3", "arm_rt4"],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("arm_rt", "body_ctrl")
mc.parentConstraint("spine_jnt3", "arm_rt", mo=True)
mc.connectAttr("assembly.joints", "arm_rt_ik2_ctrl.joints")
mc.setAttr("arm_rt_ik2_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "arm_rt_ik2_ctrl.editJoints")
mc.setAttr("arm_rt_ik2_ctrl.editJoints", k=False)
mc.setAttr("arm_rt_ik2_ctrl.fkControls", False)
#
# hands and fingers
#
positions = []
l = mc.ls("finger_lf*_1", typ="joint") or []
for n in l:
l2 = mc.listRelatives(n, pa=True, ad=True) or []
positions.append(sorted([n] + l2))
hand.main(name="hand",
side="lf",
control="arm_lf_ik2_ctrl",
parent="arm_lf_fk4_ctrl",
radius=radius,
positions=positions,
inheritTemplateRotations=inheritTemplateRotations)
mc.setAttr("arm_lf_ik2_ctrl.fingerControls", False)
positions = []
l = mc.ls("finger_rt*_1", typ="joint") or []
for n in l:
l2 = mc.listRelatives(n, pa=True, ad=True) or []
positions.append(sorted([n] + l2))
hand.main(name="hand",
side="rt",
control="arm_rt_ik2_ctrl",
parent="arm_rt_fk4_ctrl",
radius=radius,
positions=positions,
inheritTemplateRotations=inheritTemplateRotations)
mc.setAttr("arm_rt_ik2_ctrl.fingerControls", False)
#
# delete template
#
mc.delete("template")
#
# twist joints
#
if numTwistJoints:
twist.main(name="leg_lf_up",
control="leg_lf_ik1_ctrl",
parent="leg_lf_ik1_grp",
count=numTwistJoints,
stable="leg_lf_fk1_ctrl",
_twist="leg_lf_fk2_ctrl",
scale="leg_lf_ik1",
wu=(1, 0, 0),
wuo="leg_lf")
mc.delete("leg_lf_jnt1")
twist.main(name="leg_rt_up",
control="leg_rt_ik1_ctrl",
parent="leg_rt_ik1_grp",
count=numTwistJoints,
stable="leg_rt_fk1_ctrl",
_twist="leg_rt_fk2_ctrl",
scale="leg_rt_ik1",
wu=(1, 0, 0),
wuo="leg_rt")
mc.delete("leg_rt_jnt1")
twist.main(name="leg_lf_lo",
control="leg_lf_ik1_ctrl",
parent="leg_lf_fk2_ctrl",
count=numTwistJoints,
stable="leg_lf_fk2_ctrl",
_twist="leg_lf_fk3_ctrl",
scale="leg_lf_ik1")
mc.delete("leg_lf_jnt2")
twist.main(name="leg_rt_lo",
control="leg_rt_ik1_ctrl",
parent="leg_rt_fk2_ctrl",
count=numTwistJoints,
stable="leg_rt_fk2_ctrl",
_twist="leg_rt_fk3_ctrl",
scale="leg_rt_ik1")
mc.delete("leg_rt_jnt2")
twist.main(name="arm_lf_up",
control="arm_lf_ik2_ctrl",
parent="arm_lf_fk1_ctrl",
count=numTwistJoints,
stable="arm_lf_fk2_ctrl",
_twist="arm_lf_fk3_ctrl",
scale="arm_lf_ik2")
mc.delete("arm_lf_jnt2")
twist.main(name="arm_rt_up",
control="arm_rt_ik2_ctrl",
parent="arm_rt_fk1_ctrl",
count=numTwistJoints,
stable="arm_rt_fk2_ctrl",
_twist="arm_rt_fk3_ctrl",
scale="arm_rt_ik2",
aim=(-1, 0, 0))
mc.delete("arm_rt_jnt2")
twist.main(name="arm_lf_lo",
control="arm_lf_ik2_ctrl",
parent="arm_lf_fk3_ctrl",
count=numTwistJoints,
stable="arm_lf_fk3_ctrl",
_twist="arm_lf_fk4_ctrl",
scale="arm_lf_ik2")
mc.delete("arm_lf_jnt3")
twist.main(name="arm_rt_lo",
control="arm_rt_ik2_ctrl",
parent="arm_rt_fk3_ctrl",
count=numTwistJoints,
stable="arm_rt_fk3_ctrl",
_twist="arm_rt_fk4_ctrl",
scale="arm_rt_ik2",
aim=(-1, 0, 0))
mc.delete("arm_rt_jnt3")
#
# transformation spaces for some controls
#
common.space("leg_lf_ik1_ctrl",
"leg_lf_ik1_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_lf_ik1_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_lf_ik1_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("leg_lf_ik1_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("leg_rt_ik1_ctrl",
"leg_rt_ik1_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_rt_ik1_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_rt_ik1_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("leg_rt_ik1_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("leg_lf_pv_ctrl",
"leg_lf_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_lf_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_lf_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("leg_lf_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("leg_rt_pv_ctrl",
"leg_rt_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_rt_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_rt_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("leg_rt_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("spine_ik3_ctrl",
"spine_ik3_ctrl_grp",
constraint="parent",
name="local")
common.space("spine_ik3_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("spine_ik3_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("spine_ik3_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("arm_lf_pv_ctrl",
"arm_lf_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_lf_pv_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_lf_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_lf_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("arm_lf_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_lf_pv_ctrl.space", 3)
common.space("arm_rt_pv_ctrl",
"arm_rt_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_rt_pv_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_rt_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_rt_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("arm_rt_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_rt_pv_ctrl.space", 3)
common.space("arm_lf_ik2_ctrl",
"arm_lf_ik2_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_lf_ik2_ctrl",
"spine_jnt6",
constraint="parent",
name="head")
common.space("arm_lf_ik2_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_lf_ik2_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_lf_ik2_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("arm_lf_ik2_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_lf_ik2_ctrl.space", 4)
common.space("arm_rt_ik2_ctrl",
"arm_rt_ik2_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_rt_ik2_ctrl",
"spine_jnt6",
constraint="parent",
name="head")
common.space("arm_rt_ik2_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_rt_ik2_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_rt_ik2_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("arm_rt_ik2_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_rt_ik2_ctrl.space", 4)
common.space("spine_ik6_ctrl",
"spine_ik6_ctrl_grp",
constraint="orient",
name="local")
common.space("spine_ik6_ctrl",
"spine_jnt3",
constraint="orient",
name="chest")
common.space("spine_ik6_ctrl",
"body_ctrl",
constraint="orient",
name="body")
common.space("spine_ik6_ctrl", "cog_ctrl", constraint="orient", name="cog")
common.space("spine_ik6_ctrl",
"world_ctrl",
constraint="orient",
name="world")
mc.setAttr("spine_ik6_ctrl.space", 3)
common.space("head_eyes_ik_ctrl",
"spine_ik6_ctrl",
constraint="parent",
name="local")
common.space("head_eyes_ik_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("head_eyes_ik_ctrl.space", 1)
#
# global switch for control visibility
#
for n in ["fk_controls_set", "ik_controls_set"]:
for n2 in mc.sets(n, q=True):
if mc.nodeType(n2) == "objectSet": l = mc.sets(n2, q=True)
else: l = [n2]
for n3 in l:
n3 = mc.listRelatives(n3, pa=True, s=True)[0]
mc.setAttr(n3 + ".overrideEnabled", True)
try:
mc.connectAttr("assembly.controls",
n3 + ".overrideVisibility")
except:
pass
#
# fbx skeleton
#
if fbx:
mc.createNode("joint", n="root_fbx", p="skeleton_fbx")
mc.setAttr("root_fbx.radius", radius * 0.25)
c = mc.pointConstraint("pelvis_ctrl", "root_fbx", sk=["y"])[0]
mc.parent(c, "constraints_fbx")
c = mc.orientConstraint("pelvis_ctrl", "root_fbx", sk=["x", "z"])[0]
mc.parent(c, "constraints_fbx")
c = mc.scaleConstraint("pelvis_ctrl", "root_fbx")[0]
mc.parent(c, "constraints_fbx")
l = [
None, "pelvis_ctrl", "spine_jnt1", "spine_jnt2", "spine_jnt3",
"spine_jnt4", "spine_jnt5", "spine_jnt6", "jaw_jnt"
]
l2 = [
"root_fbx", "pelvis_fbx", "spine_fbx1", "spine_fbx2", "spine_fbx3",
"spine_fbx4", "spine_fbx5", "spine_fbx6", "jaw_fbx"
]
for i in range(1, len(l)):
mc.createNode("joint", n=l2[i], p=l2[i - 1])
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.pointConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
c = mc.orientConstraint(l[i], l2[i], mo=True)[0]
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(c + ".o", -r[0], -r[1], -r[2])
mc.parent(c, "constraints_fbx")
for side in ["lf", "rt"]:
mc.createNode("joint", n="eye_" + side + "_fbx", p="spine_fbx6")
mc.setAttr("eye_" + side + "_fbx" + ".radius", radius * 0.25)
mc.delete(
mc.parentConstraint("eye_" + side + "_jnt",
"eye_" + side + "_fbx"))
r = mc.getAttr("eye_" + side + "_fbx.r")[0]
mc.setAttr("eye_" + side + "_fbx.jo", r[0], r[1], r[2])
mc.setAttr("eye_" + side + "_fbx.r", 0, 0, 0)
c = mc.parentConstraint("eye_" + side + "_jnt",
"eye_" + side + "_fbx",
mo=True)[0]
mc.parent(c, "constraints_fbx")
mc.duplicate("eye_" + side + "_fbx")
mc.parent("eye_" + side + "_fbx1", "eye_" + side + "_fbx")
mc.duplicate("eye_" + side + "_fbx1")
mc.parent("eye_" + side + "_fbx2", "eye_" + side + "_fbx1")
if numTwistJoints:
l = [
"leg_" + side + "_up_twr1", "leg_" + side + "_up_tw1",
"leg_" + side + "_up_tw2", "leg_" + side + "_up_tw3",
"leg_" + side + "_lo_twr1", "leg_" + side + "_lo_tw1",
"leg_" + side + "_lo_tw2", "leg_" + side + "_lo_tw3",
"leg_" + side + "_jnt3", "leg_" + side + "_jnt4"
]
l2 = [
"leg_" + side + "_tw_fbx1", "leg_" + side + "_tw_fbx2",
"leg_" + side + "_tw_fbx3", "leg_" + side + "_tw_fbx4",
"leg_" + side + "_tw_fbx5", "leg_" + side + "_tw_fbx6",
"leg_" + side + "_tw_fbx7", "leg_" + side + "_tw_fbx8",
"leg_" + side + "_fbx1", "leg_" + side + "_fbx4"
]
last_good = "pelvis_fbx"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
l = [
"arm_" + side + "_jnt1", "arm_" + side + "_up_twr1",
"arm_" + side + "_up_tw1", "arm_" + side + "_up_tw2",
"arm_" + side + "_up_tw3", "arm_" + side + "_lo_twr1",
"arm_" + side + "_lo_tw1", "arm_" + side + "_lo_tw2",
"arm_" + side + "_lo_tw3", "arm_" + side + "_jnt4"
]
l2 = [
"arm_" + side + "_fbx1", "arm_" + side + "_tw_fbx1",
"arm_" + side + "_tw_fbx2", "arm_" + side + "_tw_fbx3",
"arm_" + side + "_tw_fbx4", "arm_" + side + "_tw_fbx5",
"arm_" + side + "_tw_fbx6", "arm_" + side + "_tw_fbx7",
"arm_" + side + "_tw_fbx8", "arm_" + side + "_fbx4"
]
last_good = "spine_fbx3"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
else:
l = [
"leg_" + side + "_jnt1", "leg_" + side + "_jnt2",
"leg_" + side + "_jnt3", "leg_" + side + "_jnt4"
]
l2 = [
"leg_" + side + "_fbx1", "leg_" + side + "_fbx2",
"leg_" + side + "_fbx3", "leg_" + side + "_fbx4"
]
last_good = "pelvis_fbx"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
l = [
"arm_" + side + "_jnt1", "arm_" + side + "_jnt2",
"arm_" + side + "_jnt3", "arm_" + side + "_jnt4"
]
l2 = [
"arm_" + side + "_fbx1", "arm_" + side + "_fbx2",
"arm_" + side + "_fbx3", "arm_" + side + "_fbx4"
]
last_good = "spine_fbx3"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
for i in range(1, 6):
l = [None] + mc.ls("finger_" + side + str(i) + "_jnt*",
typ="joint") or []
l2 = ["arm_" + side + "_fbx4"] + [
"finger_" + side + str(i) + "_fbx" + str(j + 1)
for j in range(len(l) - 1)
]
for j in range(1, len(l)):
mc.createNode("joint", n=l2[j], p=l2[j - 1])
mc.setAttr(l2[j] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[j], l2[j]))
r = mc.getAttr(l2[j] + ".r")[0]
mc.setAttr(l2[j] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[j] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[j], l2[j], mo=True)[0]
mc.parent(c, "constraints_fbx")
mc.createNode("joint",
n="props_" + side + "_fbx",
p="arm_" + side + "_fbx4")
mc.setAttr("props_" + side + "_fbx.radius", radius * 0.25)
if side == "lf": mc.setAttr("props_" + side + "_fbx.ty", scale)
else: mc.setAttr("props_" + side + "_fbx.ty", -scale)
common.control(name="props_"+side, parent="arm_"+side+"_fk4_ctrl", \
position="props_"+side+"_fbx", rotation="props_"+side+"_fbx", \
normal=(0,1,0), color=13, radius=radius*0.5, hideAttr=["v"])
mc.addAttr("arm_" + side + "_ik2_ctrl",
ln="propsControls",
at="bool",
k=True)
mc.connectAttr("arm_" + side + "_ik2_ctrl.propsControls",
"props_" + side + "_ctrl.v")
mc.delete(
mc.parentConstraint("props_" + side + "_ctrl",
"props_" + side + "_fbx"))
r = mc.getAttr("props_" + side + "_fbx.r")[0]
mc.setAttr("props_" + side + "_fbx.jo", r[0], r[1], r[2])
mc.setAttr("props_" + side + "_fbx.r", 0, 0, 0)
c = mc.parentConstraint("props_" + side + "_ctrl",
"props_" + side + "_fbx",
mo=True)[0]
c = mc.rename(c, "props_" + side + "_fbx_parcon")
mc.parent(c, "constraints_fbx")
#
# rename controls for nice
#
mc.rename("leg_lf_ik1_ctrl", "leg_lf_ik_ctrl")
mc.rename("leg_lf_fk1_ctrl", "leg_up_lf_fk_ctrl")
mc.rename("leg_lf_fk2_ctrl", "leg_lo_lf_fk_ctrl")
mc.rename("leg_lf_fk3_ctrl", "ankle_lf_fk_ctrl")
mc.rename("leg_lf_fk4_ctrl", "toes_lf_fk_ctrl")
mc.rename("leg_rt_ik1_ctrl", "leg_rt_ik_ctrl")
mc.rename("leg_rt_fk1_ctrl", "leg_up_rt_fk_ctrl")
mc.rename("leg_rt_fk2_ctrl", "leg_lo_rt_fk_ctrl")
mc.rename("leg_rt_fk3_ctrl", "ankle_rt_fk_ctrl")
mc.rename("leg_rt_fk4_ctrl", "toes_rt_fk_ctrl")
mc.rename("spine_ik2_ctrl", "waist_ctrl")
mc.rename("spine_ik3_ctrl", "chest_ctrl")
mc.rename("spine_ik5_ctrl", "neck_ctrl")
mc.rename("spine_ik6_ctrl", "head_ctrl")
mc.rename("arm_lf_ik1_ctrl", "shoulder_lf_ik_ctrl")
mc.rename("arm_lf_ik2_ctrl", "arm_lf_ik_ctrl")
mc.rename("arm_lf_fk1_ctrl", "shoulder_lf_fk_ctrl")
mc.rename("arm_lf_fk2_ctrl", "arm_up_lf_fk_ctrl")
mc.rename("arm_lf_fk3_ctrl", "arm_lo_lf_fk_ctrl")
mc.rename("arm_lf_fk4_ctrl", "wrist_lf_fk_ctrl")
mc.rename("arm_rt_ik1_ctrl", "shoulder_rt_ik_ctrl")
mc.rename("arm_rt_ik2_ctrl", "arm_rt_ik_ctrl")
mc.rename("arm_rt_fk1_ctrl", "shoulder_rt_fk_ctrl")
mc.rename("arm_rt_fk2_ctrl", "arm_up_rt_fk_ctrl")
mc.rename("arm_rt_fk3_ctrl", "arm_lo_rt_fk_ctrl")
mc.rename("arm_rt_fk4_ctrl", "wrist_rt_fk_ctrl")
#
# load control shapes
#
if controlShapes:
if os.path.isfile(THIS_DIR + "/" + controlShapes):
common.loadControlShapes(THIS_DIR + "/" + controlShapes)
elif os.path.isfile(controlShapes):
common.loadControlShapes(controlShapes)
#
# load OpenGL shapes
#
if oglControlShapes:
f = None
if os.path.isfile(THIS_DIR + "/" + oglControlShapes):
f = THIS_DIR + "/" + oglControlShapes
elif os.path.isfile(oglControlShapes):
f = oglControlShapes
if f:
# delete wire control shapes
l = []
for t in ["fk", "ik"]:
for n in mc.sets(t + "_controls_set", q=True):
if mc.nodeType(n) != "objectSet": l.append(n)
else: l += mc.sets(n, q=True)
for n in l:
mc.delete(mc.listRelatives(n, pa=True, s=True))
# create OpenGL control shapes
f2 = open(f)
s = f2.read()
f2.close()
mm.eval(s)
# connect OpenGL shape visibility attributes to rig parameters
f = mc.internalVar(userScriptDir=True) + "/icons.cfg"
for n in l:
try:
n2 = mc.listRelatives(n, pa=True, s=True)[0]
except:
continue
mc.setAttr(n2 + ".overrideEnabled", True)
mc.connectAttr("assembly.controls", n2 + ".overrideVisibility")
mc.setAttr(n + ".iconsConfigFile", f, typ="string")
mc.setAttr(n + ".reloadIconsData", True)
for side in ["lf", "rt"]:
for n in [
"shoulder_" + side + "_fk_ctrl",
"arm_up_" + side + "_fk_ctrl",
"arm_lo_" + side + "_fk_ctrl",
"wrist_" + side + "_fk_ctrl"
]:
mc.connectAttr("arm_" + side + "_ik_ctrl.fkControls",
n + "Shape.v")
for n in [
"shoulder_" + side + "_ik_ctrl",
"arm_" + side + "_pv_ctrl", "lines_arm_" + side
]:
mc.connectAttr("arm_" + side + "_ik_ctrl.ikControls",
n + "Shape.v")
for i in ["1", "2", "3", "4", "5"]:
for j in ["1", "2", "3"]:
mc.connectAttr(
"arm_" + side + "_ik_ctrl.fingerControls",
"finger_" + side + i + "_fk" + j + "_ctrlShape.v")
for n in [
"leg_up_" + side + "_fk_ctrl",
"leg_lo_" + side + "_fk_ctrl",
"ankle_" + side + "_fk_ctrl",
"toes_" + side + "_fk_ctrl"
]:
mc.connectAttr("leg_" + side + "_ik_ctrl.fkControls",
n + "Shape.v")
for n in ["leg_" + side + "_pv_ctrl", "lines_leg_" + side]:
mc.connectAttr("leg_" + side + "_ik_ctrl.ikControls",
n + "Shape.v")
for n in ["lines_arm_" + side, "lines_leg_" + side]:
mc.connectAttr("assembly.controls",
n + "Shape.overrideVisibility")
for n in [
"head_jaw_fk_ctrl", "head_eye_rt_fk_ctrl",
"head_eye_lf_fk_ctrl"
]:
mc.connectAttr("head_ctrl.fkControls", n + "Shape.v")
mc.connectAttr("head_ctrl.ikControls", "head_eyes_ik_ctrlShape.v")
mc.connectAttr("head_ctrl.ikControls", "lines_eyesShape.v")
mc.connectAttr("assembly.controls",
"lines_eyesShape.overrideVisibility")
mc.connectAttr("assembly.controls",
"lines_spineShape.overrideVisibility")
mc.parent("lines", "lines_arm_lf", "lines_arm_rt", "lines_leg_lf",
"lines_leg_rt", "lines_eyes", "lines_spine", "assembly")
mc.setAttr("assembly.joints", False)
try:
mc.setAttr("assembly.fbxJoints", False)
except:
pass
mc.select(cl=True)
mc.dgdirty(a=True)
def go():
project = Project()
environment = Environment()
# Create a global position locator which will grab Jampa's position despite his scaled translations
mc.currentTime(0)
globalPos = mc.spaceLocator(p=[0,0,0])
globPos = mc.rename(globalPos, "jampaGlobalPos")
mc.select("jampa_rig_main_global_cc_01")
mc.select(globPos, add=True)
mc.pointConstraint(offset=[0,0,0], weight=1)
mc.orientConstraint(offset=[0,0,0], weight=1)
# Get transformation variables from globPos locator
tx = mc.getAttr(globPos+".translateX")
ty = mc.getAttr(globPos+".translateY")
tz = mc.getAttr(globPos+".translateZ")
rx = mc.getAttr(globPos+".rotateX")
ry = mc.getAttr(globPos+".rotateY")
rz = mc.getAttr(globPos+".rotateZ")
# get alembic filepath for scene's animation (requires prior export)
src = mc.file(q=True, sceneName=True)
src_dir = os.path.dirname(src)
checkout_element = project.get_checkout_element(src_dir)
checkout_body_name = checkout_element.get_parent()
body = project.get_body(checkout_body_name)
element = body.get_element(Department.ANIM)
cache_file = os.path.join(element.get_dir(), "cache", "jampa_rig_main.abc")
# checkout cfx scene for corresponding shot number
current_user = environment.get_current_username()
element = body.get_element(Department.CFX)
cfx_filepath = element.checkout(current_user)
#open cfx file
if cfx_filepath is not None:
if not mc.file(q=True, sceneName=True) == '':
mc.file(save=True, force=True) #save file
if not os.path.exists(cfx_filepath):
mc.file(new=True, force=True)
mc.file(rename=cfx_filepath)
mc.file(save=True, force=True)
else:
mc.file(cfx_filepath, open=True, force=True)
# import alembic
command = "AbcImport -mode import \"" + cache_file + "\""
maya.mel.eval(command)
# delete all geo except jampa skin and rename
geometry = mc.ls(geometry=True)
transforms = mc.listRelatives(geometry, p=True, path=True)
mc.select(transforms, r=True)
for geo in mc.ls(sl=True):
if(geo != "jampa_rig_main_jampa_geo_body"):
mc.delete(geo)
collide = "JAMPA_COLLIDE"
mc.rename("jampa_rig_main_jampa_geo_body", collide)
# reference robe
body = project.get_body("jampa_robe")
element = body.get_element(Department.MODEL)
robe_file = element.get_app_filepath()
mc.file(robe_file, reference=True)
# set robe transforms to variables above
mc.setAttr("jampa_robe_model_main_jampa_robe_sim.translateX", tx)
mc.setAttr("jampa_robe_model_main_jampa_robe_sim.translateY", ty)
mc.setAttr("jampa_robe_model_main_jampa_robe_sim.translateZ", tz)
mc.setAttr("jampa_robe_model_main_jampa_robe_sim.rotateX", rx)
mc.setAttr("jampa_robe_model_main_jampa_robe_sim.rotateY", ry)
mc.setAttr("jampa_robe_model_main_jampa_robe_sim.rotateZ", rz)
# make jampa skin a passive collider
mc.select(collide)
command = "makeCollideNCloth"
maya.mel.eval(command)
rigid_shape = "nRigid_jampa"
mc.rename("nRigid1", rigid_shape)
mc.setAttr(rigid_shape+".stickiness", 0.2)
mc.setAttr(rigid_shape+".friction", 0.5)
# make cloth objects and display layers of each robe piece
jampa_torso = "jampa_robe_model_main_robe_torso_01"
jampa_sash = "jampa_robe_model_main_robe_sash_01"
jampa_skirt = "jampa_robe_model_main_robe_skirt_01"
cloth_pieces = {jampa_torso, jampa_sash, jampa_skirt}
command = "createNCloth 0"
for cp in cloth_pieces:
mc.select(cp)
maya.mel.eval(command)
mc.rename("nCloth1", "nCloth_"+cp)
mc.select(cp)
layername = "cloth_"+cp[:-3].replace("robe_model_main_robe_", "")
mc.createDisplayLayer(name=layername.upper(), number=1, noRecurse=True)
# set appropriate values in nucleus node
nucleus = "nucleus_jampa"
mc.rename("nucleus1", nucleus)
mc.setAttr(nucleus+".subSteps", 30)
mc.setAttr(nucleus+".startFrame", -30)
mc.setAttr(nucleus+".spaceScale", 0.23)
mc.currentTime(-50)
def CreateProxies(self):
thumbsOn = True
fingersNum = 4
toesNum = 1
spineNum = 4
neckNum = 2
self.Main = "Proxies_Main"
self.Proxies_Root = "Proxies_Root"
self.Proxies_SpineTop = "Proxies_SpineTop"
self.Proxies_Head = "Proxies_Head"
self.Proxies_Jaw = "Proxies_Jaw"
self.Proxies_JawTip = "Proxies_JawTip"
self.Proxies_HeadTip = "Proxies_HeadTip"
self.Proxies_L_Eye = "Proxies_L_Eye"
self.Proxies_R_Eye = "Proxies_R_Eye"
self.Proxies_SpineOrientLocator = "Proxies_SpineOrientLocator"
self.Proxies_NeckOrientLocator = "Proxies_NeckOrientLocator"
# todo : SET UNITS TO CENTIMETERS
# todo : Close NODE EDITOR
# Joint Base
Main = cmds.circle(n=self.Main, c=(0, 0, 0), nr=(0, 1, 0), sw=360, r=8, d=3, ut=0, tol=0.01, s=8, ch=0)
# Root
self.CreatePrixyNode(name=self.Proxies_Root,
mScale=[1.6, 1.6, 1.6],
mMvoe=[0, 15.25, 0],
lScale=[0.4, 0.4, 0.4])
# Top
self.CreatePrixyNode(name=self.Proxies_SpineTop,
PC=self.Proxies_Root,
mScale=[1.6, 1.6, 1.6],
mMvoe=[0, 6.6, 0],
lScale=[0.4, 0.4, 0.4])
# Aim Locator
loc = cmds.spaceLocator(n=self.Proxies_SpineOrientLocator)
cmds.parent(self.Proxies_SpineOrientLocator, self.Main)
cmds.pointConstraint(self.Proxies_Root, self.Proxies_SpineOrientLocator)
cmds.aimConstraint(self.Proxies_SpineTop, self.Proxies_SpineOrientLocator, aimVector=[0, 1, 0],
upVector=[1, 0, 0], worldUpType="vector", worldUpVector=[1, 0, 0])
cmds.setAttr("%s.visibility" % self.Proxies_SpineOrientLocator, 0)
# Spline
self.spineProxies = []
i2 = spineNum - 1
nPad = "0"
for i in range(1, spineNum):
self.ProxyBase("Proxies_Spine_%s%s" % (nPad, i))
cmds.group("Proxies_Spine_%s%s" % (nPad, i), n="Proxies_Spine_%s%s_GRP" % (nPad, i))
cmds.xform(os=True, piv=[0, 0, 0])
cmds.makeIdentity("Proxies_Spine_%s%s_GRP" % (nPad, i), apply=True, t=1, r=1, s=1)
cmds.pointConstraint(self.Proxies_Root, self.Proxies_SpineTop, "Proxies_Spine_%s%s_GRP" % (nPad, i))
cmds.orientConstraint(self.Proxies_SpineOrientLocator, "Proxies_Spine_%s%s_GRP" % (nPad, i))
cmds.setAttr("Proxies_Spine_%s%s_GRP_pointConstraint1.Proxies_RootW0" % (nPad, i), i2)
cmds.setAttr("Proxies_Spine_%s%s_GRP_pointConstraint1.Proxies_SpineTopW1" % (nPad, i), i)
self.spineProxies.append("Proxies_Spine_%s%s" % (nPad, i))
# CONNECTORS
if i == 1:
self.ProxyConnectors(self.Proxies_Root, "Proxies_Spine_%s%s" % (nPad, i))
else:
self.ProxyConnectors("Proxies_Spine_%s%s" % (nPad, i), "Proxies_Spine_%s%s" % (nPad, i - 1))
i2 = i2 - 1
self.ProxyConnectors("Proxies_Spine_%s%s" % (nPad, spineNum - 1), self.Proxies_SpineTop)
cmds.select(self.spineProxies)
cmds.pickWalk(d="up")
spineProxiesG = cmds.ls(sl=True)
# Head
self.CreatePrixyNode(name=self.Proxies_Head,
PC=self.Proxies_SpineTop,
mMvoe=[0, 2, 0],
mScale=[1.25, 1.25, 1.25])
# CREATE AIM LOCATOR TO ORIENT NECK PROXIES
cmds.spaceLocator(n=self.Proxies_NeckOrientLocator)
cmds.parent(self.Proxies_NeckOrientLocator, self.Main)
cmds.pointConstraint(self.Proxies_SpineTop, self.Proxies_NeckOrientLocator)
cmds.aimConstraint(self.Proxies_Head, self.Proxies_NeckOrientLocator, aimVector=[0, 1, 0],
upVector=[1, 0, 0], worldUpType="vector", worldUpVector=[1, 0, 0])
cmds.setAttr("%s.visibility" % self.Proxies_NeckOrientLocator, 0)
# Neck
self.neckProxies = []
i2 = neckNum - 1
nPad = "0"
for i in range(1, neckNum):
self.ProxyBase("Proxies_Neck_%s%s" % (nPad, i))
cmds.scale(0.8, 0.8, 0.8, "Proxies_Neck_%s%s" % (nPad, i), r=True)
cmds.makeIdentity("Proxies_Neck_%s%s" % (nPad, i), apply=True, t=1, r=1, s=1)
cmds.group("Proxies_Neck_%s%s" % (nPad, i), n="Proxies_Neck_%s%s_GRP" % (nPad, i))
cmds.xform(os=True, piv=[0, 0, 0])
cmds.makeIdentity("Proxies_Neck_%s%s_GRP" % (nPad, i), apply=True, t=1, r=1, s=1)
cmds.pointConstraint(self.Proxies_SpineTop, self.Proxies_Head, "Proxies_Neck_%s%s_GRP" % (nPad, i))
cmds.orientConstraint(self.Proxies_NeckOrientLocator, "Proxies_Neck_%s%s_GRP" % (nPad, i))
cmds.setAttr("Proxies_Neck_%s%s_GRP_pointConstraint1.Proxies_SpineTopW0" % (nPad, i), i2)
cmds.setAttr("Proxies_Neck_%s%s_GRP_pointConstraint1.Proxies_HeadW1" % (nPad, i), i)
self.neckProxies.append("Proxies_Neck_%s%s" % (nPad, i))
if i == 1:
self.ProxyConnectors(self.Proxies_SpineTop, "Proxies_Neck_%s%s" % (nPad, i))
else:
self.ProxyConnectors("Proxies_Neck_%s%s" % (nPad, i), "Proxies_Neck_%s%s" % (nPad, i - 1))
i2 = i2 - 1
cmds.select(self.neckProxies)
cmds.pickWalk(d="up")
neckProxiesG = cmds.ls(sl=True)
self.ProxyConnectors("Proxies_Neck_%s%s" % (nPad, neckNum - 1), self.Proxies_Head)
# Jaw
self.CreatePrixyNode(self.Proxies_Jaw,
PC=self.Proxies_Head,
mMvoe=[0, 0.83, 0.38],
isConnect=True)
self.CreatePrixyNode(self.Proxies_JawTip,
PC=self.Proxies_Jaw,
mMvoe=[0, -0.83, 1.52],
isConnect=True)
self.CreatePrixyNode(self.Proxies_HeadTip,
PC=self.Proxies_Head,
mMvoe=[0, 3.38, 0],
isConnect=True)
# Eye
self.CreatePrixyNode(self.Proxies_L_Eye,
PC=self.Proxies_Head,
mMvoe=[0.57, 1.53, 1.64],
isConnect=True)
self.CreatePrixyNode(self.Proxies_R_Eye,
PC=self.Proxies_Head,
mMvoe=[-0.57, 1.53, 1.64],
isConnect=True)
# Arms
armLoop = 1
armPrefx = "_L"
armMultiplier = 1.0
while armLoop <= 2:
Clavicle = "Proxies" + armPrefx + "_Clavicle"
self.CreatePrixyNode(Clavicle,
PC=self.Proxies_SpineTop,
mMvoe=[armMultiplier * 1.25, 0.5, 0],
isConnect=True,
isParent=True)
Shoulder = "Proxies" + armPrefx + "_Shoulder"
self.CreatePrixyNode(Shoulder,
PC=Clavicle,
mMvoe=[armMultiplier * 1.7, 0, 0],
isConnect=True,
isParent=True)
Elbow = "Proxies" + armPrefx + "_Elbow"
self.CreatePrixyNode(Elbow,
PC=Shoulder,
mMvoe=[armMultiplier * 3.5, 0, 0],
isConnect=True)
Wrist = "Proxies" + armPrefx + "_Wrist"
self.CreatePrixyNode(Wrist,
PC=Elbow,
mMvoe=[armMultiplier * 3.5, 0, 0],
isConnect=True)
ElbowG = "Proxies" + armPrefx + "_Elbow_GRP"
cmds.group(n=ElbowG, em=True)
PCons = cmds.pointConstraint(Elbow, ElbowG)
cmds.delete(PCons)
cmds.parent(Elbow, ElbowG)
cmds.makeIdentity(ElbowG, apply=True, t=1, r=1, s=1)
cmds.move(0, 0, 0.001, "%s.scalePivot" % ElbowG, "%s.rotatePivot" % ElbowG, r=True)
cmds.pointConstraint(Shoulder, Wrist, ElbowG, mo=True)
cmds.parent(ElbowG, Wrist, self.Main)
Palm = "Proxies" + armPrefx + "_Palm"
self.CreatePrixyNode(Palm,
PC=Wrist,
mMvoe=[armMultiplier * 0.7, 0, 0],
mScale=[0.7, 0.7, 0.7],
lScale=[0.175, 0.175, 0.175],
isConnect=True,
isParent=True)
if thumbsOn:
ThumbJ1 = "Proxies" + armPrefx + "_ThumbJ1"
self.CreatePrixyNode(ThumbJ1,
PC=Wrist,
mMvoe=[armMultiplier * 0.45, 0, 0.51],
mScale=[0.75, 0.75, 0.75],
lScale=[0.1875, 0.1875, 0.1875],
isConnect=True,
isParent=True)
ThumbJ2 = "Proxies" + armPrefx + "_ThumbJ2"
self.CreatePrixyNode(ThumbJ2,
PC=ThumbJ1,
mMvoe=[armMultiplier * 0, 0, 0.75],
mScale=[0.75, 0.75, 0.75],
lScale=[0.1875, 0.1875, 0.1875],
isConnect=True,
isParent=True)
ThumbJ3 = "Proxies" + armPrefx + "_ThumbJ3"
self.CreatePrixyNode(ThumbJ3,
PC=ThumbJ2,
mMvoe=[armMultiplier * 0, 0, 0.75],
mScale=[0.75, 0.75, 0.75],
lScale=[0.1875, 0.1875, 0.1875],
isConnect=True,
isParent=True)
ThumbJTip = "Proxies" + armPrefx + "_ThumbJTip"
self.CreatePrixyNode(ThumbJTip,
PC=ThumbJ3,
mMvoe=[armMultiplier * 0, 0, 0.75],
mScale=[0.75, 0.75, 0.75],
lScale=[0.1875, 0.1875, 0.1875],
isConnect=True,
isParent=True)
fingerIndex = 1
while fingerIndex <= fingersNum:
FingerJ1 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_J1"
if fingerIndex == 1:
self.ProxyBase(FingerJ1)
PCons = cmds.pointConstraint(Wrist, FingerJ1)
cmds.delete(PCons)
cmds.move(armMultiplier * 1.47, 0, 0, FingerJ1, r=True, os=True, wd=True)
if fingersNum == 2:
cmds.move(0, 0, 0.25, FingerJ1, r=True)
cmds.makeIdentity(FingerJ1, apply=True, t=1, r=1, s=1)
elif fingersNum >= 3:
cmds.move(0, 0, 0.5, FingerJ1, r=True)
cmds.makeIdentity(FingerJ1, apply=True, t=1, r=1, s=1)
else:
FingerJ0 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex - 1) + "_J1"
self.ProxyBase(FingerJ1)
PCons = cmds.pointConstraint(FingerJ0, FingerJ1)
cmds.delete(PCons)
cmds.move(0, 0, -0.4, FingerJ1, r=True, os=True, wd=True)
cmds.scale(0.62, 0.62, 0.62, FingerJ1)
cmds.makeIdentity(FingerJ1, apply=True, t=1, r=1, s=1)
cmds.setAttr("%sSnapShape.localScaleX" % FingerJ1, 0.155)
cmds.setAttr("%sSnapShape.localScaleY" % FingerJ1, 0.155)
cmds.setAttr("%sSnapShape.localScaleZ" % FingerJ1, 0.155)
cmds.parent(FingerJ1, Palm)
self.ProxyConnectors(Palm, FingerJ1)
FingerJ2 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_J2"
self.CreatePrixyNode(FingerJ2,
PC=FingerJ1,
mMvoe=[armMultiplier * 0.61, 0, 0],
mScale=[0.62, 0.62, 0.62],
lScale=[0.155, 0.155, 0.155],
isConnect=True,
isParent=True)
FingerJ3 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_J3"
self.CreatePrixyNode(FingerJ3,
PC=FingerJ2,
mMvoe=[armMultiplier * 0.61, 0, 0],
mScale=[0.62, 0.62, 0.62],
lScale=[0.155, 0.155, 0.155],
isConnect=True,
isParent=True)
FingerJTip = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_JTip"
self.CreatePrixyNode(FingerJTip,
PC=FingerJ3,
mMvoe=[armMultiplier * 0.61, 0, 0],
mScale=[0.62, 0.62, 0.62],
lScale=[0.155, 0.155, 0.155],
isConnect=True,
isParent=True)
fingerIndex += 1
cmds.makeIdentity(Wrist, apply=True, t=1, r=1, s=1)
armPrefx = "_R"
armMultiplier = -1.0
armLoop += 1
# Legs
legLoop = 1
legPrefx = "_L"
legMultiplier = 1.0
while legLoop <= 2:
Hip = "Proxies" + legPrefx + "_Hip"
self.CreatePrixyNode(Hip,
PC=self.Proxies_Root,
mMvoe=[legMultiplier * 1.72, -0.8, 0],
isConnect=True,
isParent=True)
Knee = "Proxies" + legPrefx + "_Knee"
self.CreatePrixyNode(Knee,
PC=Hip,
mMvoe=[0, -6.4, 0],
mRotate=[0, 180, 90],
isConnect=True,
isParent=True)
Ankle = "Proxies" + legPrefx + "_Ankle"
self.CreatePrixyNode(Ankle,
PC=Knee,
mMvoe=[0, -6.4, 0],
isConnect=True,
isParent=True)
KneeG = "Proxies" + legPrefx + "_Knee_GRP"
cmds.group(n=KneeG, em=True)
PCons = cmds.pointConstraint(Knee, KneeG)
cmds.delete(PCons)
cmds.parent(Knee, KneeG)
cmds.makeIdentity(KneeG, apply=True, t=1, r=1, s=1)
# cmds.move(0,0,0.001,"%s.scalePivot" % KneeG,"%s.rotatePivot" % KneeG ,r=True)
cmds.pointConstraint(Hip, Ankle, KneeG, mo=True)
cmds.parent(KneeG, Ankle, self.Main)
Ball = "Proxies" + legPrefx + "_Ball"
self.CreatePrixyNode(Ball,
PC=Ankle,
mMvoe=[0, -1.65, 2.26],
isConnect=True,
isParent=True)
Toe = "Proxies" + legPrefx + "_Toe"
self.CreatePrixyNode(Toe,
PC=Ball,
mMvoe=[0, 0, 1.7])
if toesNum == 1:
self.ProxyConnectors(Ball, Toe)
BallG = "Proxies" + legPrefx + "_Ball_GRP"
cmds.group(n=BallG, em=True)
cmds.parent(BallG, Ball)
cmds.parent(Toe, BallG)
KneeLocator = "Proxies" + legPrefx + "_KneeLocator"
cmds.spaceLocator(n=KneeLocator)
PCons = cmds.pointConstraint(Knee, KneeLocator)
cmds.delete(PCons)
cmds.parent(KneeLocator, Knee)
cmds.move(0, 0, 1.5, KneeLocator, r=True)
cmds.setAttr("%s.v" % KneeLocator, 0)
# toe num
cmds.makeIdentity(Ball, apply=True, t=1, r=1, s=1)
legLoop += 1
legPrefx = "_R"
legMultiplier = -1.0
# PARENT CONTROLS
cmds.parent(self.Proxies_Root, spineProxiesG, self.Proxies_SpineTop, neckProxiesG, self.Proxies_Head, self.Main)
cmds.parent(self.Proxies_Jaw, self.Proxies_HeadTip, self.Proxies_L_Eye, self.Proxies_R_Eye,
self.Proxies_Head)
cmds.parent(self.Proxies_JawTip, self.Proxies_Jaw)
# INDICATOR
self.ElbowIndicator("L")
self.ElbowIndicator("R")
self.KneeIndicator("L")
self.KneeIndicator("R")
# LOCATORS FOR FOOT TILT
self.FootTilt("L")
self.FootTilt("R")
self.LimitAndLock()
# CREATE LAYER
cmds.select(self.Main)
layer = cmds.objExists("ProxiesLayer")
if layer is not None:
cmds.createDisplayLayer(n="ProxiesLayer", number=1, nr=True)
else:
cmds.editDisplayLayerMembers("ProxiesLayer", self.Main, noRecurse=True)
cmds.select(clear=True)
# menber
self.Main = "Proxies_Main"
self.Proxies_Root = "Proxies_Root"
self.Proxies_SpineTop = "Proxies_SpineTop"
self.Proxies_Head = "Proxies_Head"
self.Proxies_Jaw = "Proxies_Jaw"
self.Proxies_JawTip = "Proxies_JawTip"
self.Proxies_HeadTip = "Proxies_HeadTip"
self.Proxies_L_Eye = "Proxies_L_Eye"
self.Proxies_R_Eye = "Proxies_R_Eye"
self.Proxies_L_Clavicle = "Proxies_L_Clavicle"
self.Proxies_L_Shoulder = "Proxies_L_Shoulder"
self.Proxies_L_Wrist = "Proxies_L_Wrist"
self.Proxies_L_Palm = "Proxies_L_Palm"
self.Proxies_L_Hip = "Proxies_L_Hip"
self.Proxies_L_Ankle = "Proxies_L_Ankle"
self.Proxies_L_Elbow = "Proxies_L_Elbow"
self.Proxies_L_Knee = "Proxies_L_Knee"
self.Proxies_L_Ball = "Proxies_L_Ball"
self.Proxies_L_Toe = "Proxies_L_Toe"
self.Proxies_R_Clavicle = "Proxies_R_Clavicle"
self.Proxies_R_Shoulder = "Proxies_R_Shoulder"
self.Proxies_R_Wrist = "Proxies_R_Wrist"
self.Proxies_R_Palm = "Proxies_R_Palm"
self.Proxies_R_Hip = "Proxies_R_Hip"
self.Proxies_R_Ankle = "Proxies_R_Ankle"
self.Proxies_R_Elbow = "Proxies_R_Elbow"
self.Proxies_R_Knee = "Proxies_R_Knee"
self.Proxies_R_Ball = "Proxies_R_Ball"
self.Proxies_R_Toe = "Proxies_R_Toe"
pass
def makeArm(self, isLeft, leftRight, jntArmArray, jntClavicle, jntScapula,
colourTU, jntShoulderRoot, ctrlFKIK, ctrlFKIKAttr, jntSpine6,
checkboxTwists, checkboxSpine, checkGeo, checkboxSwitch,
ctrlIKChest, ctrlCOG, grpFollow, geoJntArray, *args):
# Adding the twist joints
if checkboxTwists:
# xprNameTwist, twistExpression, geoJntArray = self.makeTwists(3, leftRight, jntArmArray, geoJntArray, makeExpression)
xprNameTwist, twistExpression, geoJntArray = self.makeTwists(
3, leftRight, jntArmArray, geoJntArray)
# NOTE: I use a slightly different order than the originals, leaving the SetGeo section to the lat
# Creating FK and IK Joints
bndJnts, fkJnts, ikJnts = self.getBndFkIkJnts(jntArmArray)
fkLen = len(fkJnts)
ikLen = len(ikJnts)
bndLen = len(bndJnts)
if bndLen != fkLen or bndLen != ikLen:
mc.warning("Your arm joints are somehow not equal")
return
else:
ikFkJntConstraints = []
for i in range(bndLen):
temp = mc.orientConstraint(fkJnts[i], ikJnts[i], bndJnts[i])[0]
ikFkJntConstraints.append(temp)
for i in range(len(ikFkJntConstraints)):
self.tgpSetDriverArmFKIKSwitch(ctrlFKIK, ctrlFKIKAttr,
ikFkJntConstraints[i])
# we want to create FK controls for the limbs except the end
armLength, fkJntOffsetCtrls = self.createArmFKs(fkJnts, colourTU)
# create the shoulder control
shoulderOffsetCtrl = self.setupShoulder(jntShoulderRoot, bndJnts,
fkJntOffsetCtrls, colourTU)
# create the clavicle
if jntClavicle:
clavicleOffsetCtrl = self.setupClavicle(jntClavicle, colourTU,
leftRight,
shoulderOffsetCtrl,
jntArmArray)
# create the scapula
if jntScapula:
scapulaOffsetCtrl = self.setupScapula(
jntScapula,
colourTU,
leftRight,
shoulderOffsetCtrl,
)
# for testing purposes only, setting the IK to active:
mc.setAttr("{0}.{1}".format(ctrlFKIK, ctrlFKIKAttr), 0.5)
# Setting up the IK Arm
ikOffsetCtrl, ikArms, ikJntsDrive, ikSide = self.createArmIK(
ikJnts, leftRight, colourTU, isLeft)
# create the twists
self.setupIkElblowArmTwist(ikOffsetCtrl, ikJnts, ikArms, isLeft)
# change the rotation order
rotationChange = [
ikJnts[1], jntArmArray[1], fkJnts[1], ikJntsDrive[1],
fkJntOffsetCtrls[1][1]
]
CRU.changeRotateOrder(rotationChange, "YZX")
# Adding the Elbow Control
elbowOffsetCtrl = self.createElbow(
ikJntsDrive,
leftRight,
armLength,
ikArms,
isLeft,
colourTU,
)
# Adding Space Switching
# NOTE: This is something I added from the finalizing section
if checkboxSwitch:
# self.makeArmSwitch(ctrlLimb, ctrlShoulder, ctrlChest, ctrlCOG, grpFollow, leftRight, colourTU)
self.makeArmSwitch(fkJntOffsetCtrls[0][1], shoulderOffsetCtrl[1],
ctrlIKChest, ctrlCOG, grpFollow, leftRight,
colourTU)
# Organize the rig
self.armCleanUp(fkJnts, ikJnts, ikJntsDrive, bndJnts, jntShoulderRoot,
jntScapula, jntClavicle, checkboxSpine,
shoulderOffsetCtrl, scapulaOffsetCtrl,
clavicleOffsetCtrl, ikOffsetCtrl, elbowOffsetCtrl,
ikArms, jntSpine6, ikSide, fkJntOffsetCtrls, ctrlFKIK,
ctrlFKIKAttr)
if checkGeo:
CRU.tgpSetGeo(geoJntArray, setLayer=True)
def createArm(uparmJnts=8, lowarmJnts=8):
"""""" """""" """""" """""" """""" """
El reto del brazo comienza. Enfrentate a el
con denuedo y determinacion. Confia en ti mismo y todo saldra
a pedir de Yume
Notas:
rotacion Z -58.251
Ha habido un problema con la orientacion del pole del arm_l_skn. Lo he arreglado seteand
atributos pero no garantiza que eso vaya a ser estable. OJO
hay que cambiar los skn por jnts para no confundirlos de los skn en el twist
Lista de locators que vas a necesitar:
clavicle_loc_END_autoRig
lowerArm_loc_autoRig
hand_loc_autoRig
ARM~~ARM~~ARM
""" """""" """""" """""" """""" """"""
brazo = ['shoulder', 'hand', 'elbow']
generalC = "general_c_ctr"
tw = 'twist'
Tv = 'twistValue'
Nr = 'nonRoll'
vectores = ['X', 'Y', 'Z']
shoulderLocPos = cmds.getAttr('clavicle_l_loc_END_autoRig.translate')
elbowLocPos = cmds.getAttr('lowerArm_l_loc_autoRig.translate')
handLocPos = cmds.getAttr('hand_loc_autoRig.translate')
cmds.joint(n='shoulder_l_skn', rad=0.1)
cmds.select(cl=True)
cmds.joint(n='elbow_l_skn', rad=0.1)
cmds.select(cl=True)
cmds.joint(n='elbow_l_End', rad=0.1)
cmds.xform('shoulder_l_skn', t=shoulderLocPos[0])
cmds.xform('elbow_l_skn', t=elbowLocPos[0])
cmds.xform('elbow_l_End', t=handLocPos[0])
cmds.parent('elbow_l_skn', 'shoulder_l_skn')
cmds.parent('elbow_l_End', 'elbow_l_skn')
side = ['l', 'r']
uA = 'shoulder_{}_skn'.format(side[0])
lA = 'elbow_{}_skn'.format(side[0])
cmds.mirrorJoint(uA, myz=True, mb=True, sr=['_l_', '_r_'])
cmds.joint(oj='xyz', sao='yup', e=True, ch=True)
hands = ['elbow_r_End', 'elbow_l_End']
for side in 'rl':
hnd = cmds.duplicate('elbow_{}_End'.format(side),
n='hand_{}_skn'.format(side),
po=True)
cmds.parent(hnd, w=True)
end = cmds.joint(n='hand_{}_End'.format(side), rad=0.05)
if side == 'l':
cmds.xform(end, t=(+0.25, 0, 0))
else:
cmds.xform(end, t=(-0.25, 0, 0))
cmds.joint(hnd, oj='xyz', sao='yup', e=True, ch=True)
cmds.pointConstraint('elbow_{}_End'.format(side), hnd)
#####################EQUACION DE LA ANTIVIDA PARA AGRUPAR###############
toGroup = ['hand_l_skn', 'hand_r_skn', 'shoulder_r_skn', 'shoulder_l_skn']
for element in toGroup:
pos = cmds.getAttr('{}.translate'.format(element))
grp = cmds.group(n='{}_offset'.format(str(element)), em=True)
cmds.xform(grp, t=pos[0], r=True)
cmds.parent(element, grp)
cmds.parent(grp, 'skeleton_c_grp')
#6.2. Creacion del ikHandle de la cadena principal
for side in 'rl':
cmds.select('shoulder_{}_skn'.format(side))
cmds.select('elbow_{}_End'.format(side), add=True)
ikH = cmds.ikHandle(n='arm_{}_ikHandle'.format(side),
sol='ikRPsolver',
s='sticky')
cmds.group(n='rig_arm_{}_grp'.format(side))
polX = cmds.getAttr('arm_r_ikHandle.poleVectorX')
polY = cmds.getAttr('arm_r_ikHandle.poleVectorY')
polZ = cmds.getAttr('arm_r_ikHandle.poleVectorZ')
cmds.setAttr('arm_l_ikHandle.poleVectorX', polX)
cmds.setAttr('arm_l_ikHandle.poleVectorY', polY)
cmds.setAttr('arm_l_ikHandle.poleVectorZ', polZ)
'''''' '''''' '''''' ''''
6.3. Configuracion de los sistemas nonRoll
6.3.1 Configuracion de la cadena NonRoll del Shoulde
'''
arms = ['shoulder_l_skn', 'shoulder_r_skn']
for side in 'rl':
arm = 'shoulder_{}_skn'.format(side)
nonRoll = cmds.duplicate(arm,
n='shoulder_{}_nonRoll'.format(side),
rc=True)
rollList = cmds.listRelatives(nonRoll, allDescendents=True)
cmds.delete(rollList[:2])
cmds.parent('shoulder_{}_nonRoll'.format(side), w=True)
cmds.rename(rollList[-1], 'shoulder_{}_nonRoll_End'.format(side))
cmds.group(n='shoulder_{}_nonRoll_grp'.format(side), em=True)
cmds.parent('shoulder_{}_nonRoll'.format(side),
'shoulder_{}_nonRoll_grp'.format(side))
#Creacion del Ik
ik = 'shoulder_{}_nonRoll'.format(side)
cmds.select(ik)
cmds.select('shoulder_{}_{}_End'.format(side, Nr))
nRH = cmds.ikHandle(n='shoulder_{}_ikHandle_{}'.format(side, Nr),
sol='ikSCsolver',
s='sticky')
cmds.parent(nRH[0], 'shoulder_{}_{}_grp'.format(side, Nr))
for a in 'XYZ':
cmds.setAttr(
'shoulder_{}_ikHandle_{}.poleVector{}'.format(side, Nr, a), 0)
#Creacion del pointConstraint
cmds.pointConstraint(
'shoulder_{}_skn'.format(side),
ik,
n='pointConstraint_{}_shoulderToNonRoll'.format(side))
cmds.pointConstraint(
'elbow_{}_skn'.format(side),
'shoulder_{}_ikHandle_{}'.format(side, Nr),
n='pointConstraint_{}_elbowToikHandle'.format(side))
cmds.parent('shoulder_{}_nonRoll_grp'.format(side),
'rig_arm_{}_grp'.format(side))
p = cmds.group(n='shoulder_{}_rollSystem'.format(side), em=True)
cmds.parent(p, 'rig_arm_{}_grp'.format(side))
cmds.parent('shoulder_{}_nonRoll_grp'.format(side), p)
'''
6.3.2 Configuracion de la cadena NonRoll del Elbow
'''
elbow = ['elbow_l_skn', 'elbow_r_skn']
for arm in elbow:
nonRoll = cmds.duplicate(arm,
n='elbow_{}_nonRoll'.format(arm[6]),
rc=True)
rollList = cmds.listRelatives(nonRoll, allDescendents=True)
cmds.delete(rollList[1])
cmds.parent('elbow_{}_nonRoll'.format(arm[6]), w=True)
cmds.rename(rollList[0], 'elbow_{}_nonRoll_End'.format(arm[6]))
cmds.group(n='elbow_l_nonRoll_grp', em=True)
cmds.parent('elbow_l_nonRoll', 'elbow_l_nonRoll_grp')
cmds.group(n='elbow_r_nonRoll_grp', em=True)
cmds.parent('elbow_r_nonRoll', 'elbow_r_nonRoll_grp')
ik2 = ['elbow_r_nonRoll', 'elbow_l_nonRoll']
for i in ik2: #Creacion del Ik
cmds.select(i)
cmds.select('elbow_{}_nonRoll_End'.format(i[6]))
nRH = cmds.ikHandle(n='elbow_{}_ikHandle_{}'.format(i[6], Nr),
sol='ikSCsolver',
s='sticky')
cmds.parent(nRH[0], 'elbow_{}_{}_grp'.format(i[6], Nr))
for a in vectores:
cmds.setAttr(
'elbow_{}_ikHandle_{}.poleVector{}'.format(i[6], Nr, a), 0)
for i in ik2: #Creacion del pointConstraint
cmds.pointConstraint(
'elbow_{}_skn'.format(i[6]),
i,
n='pointConstraint_{}_shoulderENDToNonRoll'.format(i[6]))
cmds.pointConstraint('hand_{}_skn'.format(i[6]),
'elbow_{}_ikHandle_nonRoll'.format(i[6]),
n='pointConstraint_{}_elbowENDToikHandle'.format(
i[6]))
'''''' '''
Global Sclae a los Non Roll
grupos de rollSystem de elbow
''' ''''''
for side in 'rl':
k = cmds.group(n='elbow_{}_rollSystem'.format(side), em=True)
cmds.parent(k, 'rig_arm_{}_grp'.format(side))
cmds.parent('elbow_{}_{}_grp'.format(side, Nr), k)
nonRollArm = [
'shoulder_l_rollSystem', 'elbow_l_rollSystem', 'shoulder_r_rollSystem',
'elbow_r_rollSystem'
]
for r in nonRollArm:
for a in vectores:
cmds.connectAttr('general_c_ctr.GlobalScale',
'{}.scale{}'.format(r, a))
#TwistValue
cmds.duplicate('shoulder_l_nonRoll_End', n='elbow_l_twistValue')
tvL = 'elbow_l_twistValue'
cmds.setAttr('elbow_l_twistValue.jointOrientX', 0)
cmds.parent(tvL, 'elbow_l_skn')
cmds.duplicate('shoulder_r_nonRoll_End', n='elbow_r_twistValue')
tvR = 'elbow_r_twistValue'
cmds.parent(tvR, 'elbow_r_skn')
tiwstValues = [tvL, tvR]
for indent in 'rl':
cmds.aimConstraint('hand_{}_skn'.format(indent),
'elbow_{}_twistValue'.format(indent),
aim=[1, 0, 0],
u=[0, 1, 0],
wu=[0, 1, 0],
n='elbow_{}_twistValue_elbowToHand'.format(indent),
wuo='elbow_{}_nonRoll'.format(indent),
wut="objectrotation",
mo=True)
cmds.parentConstraint(
'shoulder_r_nonRoll',
'elbow_r_nonRoll_grp',
mo=True,
n='parentConstraint_r_nonRoll_shoulderToelbowNonRollGrp')
cmds.parentConstraint(
'shoulder_l_nonRoll',
'elbow_l_nonRoll_grp',
mo=True,
n='parentConstraint_l_nonRoll_shoulderToelbowNonRollGrp')
'''
6.3.3 Configuracion de la cadena NonRoll del Hand
'''
for side in 'rl':
handNonRoll = cmds.duplicate('hand_{}_skn'.format(side),
n='hand_{}_nonRoll'.format(side),
rc=True)
handNonRollList = cmds.listRelatives(handNonRoll)
cmds.rename(handNonRollList[0], 'hand_{}_nonRoll_End'.format(side))
cmds.delete(handNonRollList[1])
cmds.group(n='hand_{}_nonRoll_grp'.format(side), em=True, w=True)
cmds.parent('hand_{}_nonRoll'.format(side),
'hand_{}_nonRoll_grp'.format(side))
cmds.parent('hand_{}_nonRoll_grp'.format(side),
'elbow_{}_rollSystem'.format(side))
cmds.select('hand_{}_nonRoll'.format(side))
cmds.select('hand_{}_{}_End'.format(side, Nr))
nRH = cmds.ikHandle(n='hand_{}_ikHandle_{}'.format(side, Nr),
sol='ikSCsolver',
s='sticky')
cmds.parent(nRH[0], 'hand_{}_{}_grp'.format(side, Nr))
for a in vectores:
cmds.setAttr(
'hand_{}_ikHandle_{}.poleVector{}'.format(side, Nr, a), 0)
cmds.pointConstraint(
'hand_{}_skn'.format(side),
'hand_{}_{}'.format(side, Nr),
n='pointConstraint_{}_handNonRollToHandSkn'.format(side))
cmds.pointConstraint(
'hand_{}_End'.format(side),
'hand_{}_ikHandle_{}'.format(side, Nr),
n='pointConstraint_{}_handENDToHandikHandle'.format(side))
#twistValue
h = cmds.duplicate('hand_{}_skn'.format(side),
n='hand_{}_{}'.format(side, Tv),
rc=True)
handList = cmds.listRelatives(h)
cmds.delete(handList[0])
cmds.delete(handList[1])
cmds.parent('hand_{}_{}'.format(side, Tv), 'hand_{}_skn'.format(side))
cmds.aimConstraint(
'hand_{}_End'.format(side),
'hand_{}_{}'.format(side, Tv),
n='aimConstraint_{}_twistValue_handTohandTwistValue'.format(side),
wuo='hand_{}_nonRoll'.format(side),
wut="objectrotation",
mo=False)
###
cmds.parentConstraint(
'elbow_{}_skn'.format(side),
'hand_{}_nonRoll_grp'.format(side),
mo=True,
n='eseParentQueNosCostoEncontratTanto_{}_pc'.format(side))
'''
~~~~CADENA TWIST JOINTS~~~~
1) upperARM
a)jointChain
i) Left
ii) Right
b)ikSpline
i) Left
ii) Right
2) foreARM
a)jointChain
i) Left
ii) Right
b)ikSpline
i) Left
ii) Right
'''
cmds.select(cl=True)
# upperARM - jointChain - LEFT
def upperArmJointLeft(cantidad, nombre, chin, radio):
inicio = 'clavicle_l_loc_END_autoRig'
fin = 'lowerArm_l_loc_autoRig'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
upperArmJointLeft(uparmJnts, 'upperArm_l_skn', chin=True, radio=0.1)
cmds.rename('upperArm_l_skn0', 'upperArm_l_skn')
foreArmJointList = cmds.listRelatives('upperArm_l_skn',
allDescendents=True)
foreArmJointList.append('upperArm_l_skn')
cmds.rename(foreArmJointList[0], 'upperArm_l_End')
cmds.select(cl=True)
# upperARM - jointChain - RIGHT
def upperArmJointRight(cantidad, nombre, chin, radio):
inicio = 'shoulder_r_nonRoll'
fin = 'elbow_r_nonRoll'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
upperArmJointRight(uparmJnts, 'upperArm_r_skn', chin=True, radio=0.1)
cmds.rename('upperArm_r_skn0', 'upperArm_r_skn')
foreArmJointList = cmds.listRelatives('upperArm_r_skn',
allDescendents=True)
foreArmJointList.append('upperArm_r_skn')
cmds.rename(foreArmJointList[0], 'upperArm_r_End')
# upperARM - ikSpline - LEFT
def upperArmIkSplineLeft():
cmds.ikHandle(n='upperArm_l_ikHandle_{}'.format(tw),
sj='upperArm_l_skn',
ee='upperArm_l_End',
sol='ikSplineSolver')
c = cmds.rename('curve1', 'upperArm_l_ikHandle_curve_{}'.format(tw))
cmds.parent('upperArm_l_ikHandle_curve_{}'.format(tw), 'rig_arm_l_grp')
cmds.parent('upperArm_l_ikHandle_{}'.format(tw),
'shoulder_l_rollSystem')
upperArmIkSplineLeft()
cmds.parent('upperArm_l_skn', 'shoulder_l_rollSystem')
# upperARM - ikSpline - RIGHT
def upperArmIkSplineRight():
cmds.ikHandle(n='upperArm_r_ikHandle_{}'.format(tw),
sj='upperArm_r_skn',
ee='upperArm_r_End',
sol='ikSplineSolver')
cmds.rename('curve1', 'upperArm_r_ikHandle_curve_{}'.format(tw))
cmds.parent('upperArm_r_ikHandle_curve_{}'.format(tw), 'rig_arm_r_grp')
cmds.parent('upperArm_r_ikHandle_{}'.format(tw),
'shoulder_r_rollSystem')
upperArmIkSplineRight()
cmds.parent('upperArm_r_skn', 'shoulder_r_rollSystem')
cmds.select(cl=True)
# foreARM - jointChain - LEFT
def foreArmJointLeft(cantidad, nombre, chin, radio):
inicio = 'lowerArm_l_loc_autoRig'
fin = 'hand_loc_autoRig'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
foreArmJointLeft(lowarmJnts, 'foreArm_l_skn', chin=True, radio=0.1)
cmds.rename('foreArm_l_skn0', 'foreArm_l_skn')
foreArmJointList = cmds.listRelatives('foreArm_l_skn', allDescendents=True)
foreArmJointList.append('foreArm_l_skn')
cmds.rename(foreArmJointList[0], 'foreArm_l_End')
cmds.parent('foreArm_l_skn', 'elbow_l_skn')
# foreARM - jointChain - RIGHT
cmds.select(cl=True)
def foreArmJointRight(cantidad, nombre, chin, radio):
inicio = 'elbow_r_nonRoll'
fin = 'hand_r_nonRoll'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
foreArmJointRight(lowarmJnts, 'foreArm_r_skn', chin=True, radio=0.1)
cmds.rename('foreArm_r_skn0', 'foreArm_r_skn')
foreArmJointList = cmds.listRelatives('foreArm_r_skn', allDescendents=True)
foreArmJointList.append('foreArm_r_skn')
cmds.rename(foreArmJointList[0], 'foreArm_r_End')
cmds.parent('foreArm_r_skn', 'elbow_r_skn')
# foreARM - ikSpline - LEFT
def foreArmIkSplineLeft():
cmds.ikHandle(n='foreArm_l_ikHandle_{}'.format(tw),
sj='foreArm_l_skn',
ee='foreArm_l_End',
sol='ikSplineSolver')
cmds.rename('curve1', 'foreArm_l_ikHandle_curve_{}'.format(tw))
cmds.parent('foreArm_l_ikHandle_curve_{}'.format(tw), 'rig_arm_l_grp')
cmds.parent('foreArm_l_ikHandle_{}'.format(tw), 'elbow_l_rollSystem')
foreArmIkSplineLeft()
# foreARM - ikSpline - RIGHT
side = 'rl'
def foreArmIkSplineRight():
cmds.ikHandle(n='foreArm_r_ikHandle_{}'.format(tw),
sj='foreArm_r_skn',
ee='foreArm_r_End',
sol='ikSplineSolver')
cmds.rename('curve1', 'foreArm_r_ikHandle_curve_{}'.format(tw))
cmds.parent('foreArm_r_ikHandle_curve_{}'.format(tw), 'rig_arm_r_grp')
cmds.parent('foreArm_r_ikHandle_{}'.format(tw), 'elbow_r_rollSystem')
foreArmIkSplineRight()
# twistUpperArm - nodos
def twistUpperArm():
for i in side:
elbowValeu = 'elbow_{}_{}'.format(i, Tv)
shoulderHandle = 'upperArm_{}_ikHandle_twist'.format(i)
multMenusUno = cmds.shadingNode('multDoubleLinear',
n='{}_{}_{}_multMenusUno'.format(
'Shoulder', Tv, i),
au=True)
cmds.connectAttr('{}.rotateX'.format(elbowValeu),
'{}.input1'.format(multMenusUno))
cmds.setAttr('{}.input2'.format(multMenusUno), -1)
cmds.connectAttr('{}.output'.format(multMenusUno),
'{}.twist'.format(shoulderHandle))
twistUpperArm()
def twistForeArm():
for i in side:
handValeu = 'hand_{}_{}'.format(i, Tv)
shandHandle = 'foreArm_{}_ikHandle_twist'.format(i)
multMenusUno = cmds.shadingNode('multDoubleLinear',
n='{}_{}_{}_multMenusUno'.format(
'Elbow', Tv, i),
au=True)
cmds.connectAttr('{}.rotateX'.format(handValeu),
'{}.input1'.format(multMenusUno))
cmds.setAttr('{}.input2'.format(multMenusUno), -1)
cmds.connectAttr('{}.output'.format(multMenusUno),
'{}.twist'.format(shandHandle))
twistForeArm()
'''
Colocacion de controles:
Hand_l_IK
FKs
Pole
'''
for i in 'rl':
ikOff = 'handIKCtr_{}_offset'.format(i)
handOff = 'handFKCtr_{}_offset'.format(i)
shoulderOff = 'shoulderFKCtr_{}_offset'.format(i)
elbowOff = 'elbowFKCtr_{}_offset'.format(i)
armSettingsOff = 'armSettingsCtr_{}_offset'.format(i)
handPos = cmds.xform('hand_{}_nonRoll'.format(i),
ws=True,
q=True,
t=True)
shouldePos = cmds.xform('shoulder_{}_nonRoll'.format(i),
ws=True,
q=True,
t=True)
elbowPos = cmds.xform('elbow_{}_nonRoll'.format(i),
ws=True,
q=True,
t=True)
cmds.xform(ikOff, ws=True, t=handPos)
cmds.xform(handOff, ws=True, t=handPos)
cmds.xform(shoulderOff, ws=True, t=shouldePos)
cmds.xform(elbowOff, ws=True, t=elbowPos)
cmds.parent(armSettingsOff, 'hand_{}_nonRoll_End'.format(i))
for a in vectores:
cmds.setAttr('{}.translate{}'.format(armSettingsOff, a), 0)
if i == 'l':
cmds.setAttr('{}.translateX'.format(armSettingsOff), 30)
else:
cmds.setAttr('{}.translateX'.format(armSettingsOff), -30)
cmds.parentConstraint('hand_{}_skn'.format(i),
armSettingsOff,
mo=True,
n='parentConstraint_{}_ArmSettingsParent')
####
def poleLocation():
from maya import cmds, OpenMaya
import math
for i in side:
start = cmds.xform('shoulder_{}_skn'.format(i), q=1, ws=1, t=1)
mid = cmds.xform('elbow_{}_skn'.format(i), q=1, ws=1, t=1)
end = cmds.xform('elbow_{}_End'.format(i), q=1, ws=1, t=1)
startV = OpenMaya.MVector(start[0], start[1], start[2])
midV = OpenMaya.MVector(mid[0], mid[1], mid[2])
endV = OpenMaya.MVector(end[0], end[1], end[2])
startEnd = endV - startV
startMid = midV - startV
dotP = startMid * startEnd
proj = float(dotP) / float(startEnd.length())
startEndN = startEnd.normal()
projV = startEndN * proj
arrowV = startMid - projV
arrowV *= 0.5
finalV = arrowV + midV
cross1 = startEnd ^ startMid
cross1.normalize()
cross2 = cross1 ^ arrowV
cross2.normalize()
arrowV.normalize()
matrixV = [
arrowV.x, arrowV.y, arrowV.z, 0, cross1.x, cross1.y, cross1.z,
0, cross2.x, cross2.y, cross2.z, 0, 0, 0, 0, 1
]
matrixM = OpenMaya.MMatrix()
OpenMaya.MScriptUtil.createMatrixFromList(matrixV, matrixM)
matrixFn = OpenMaya.MTransformationMatrix(matrixM)
rot = matrixFn.eulerRotation()
loc = 'armPoleCtr_{}_offset'.format(i)
cmds.xform(loc, ws=1, t=(finalV.x, finalV.y, finalV.z))
cmds.xform(loc,
ws=1,
rotation=((rot.x / math.pi * 180.0),
(rot.y / math.pi * 180.0),
(rot.z / math.pi * 180.0)))
poleLocation()
'''
Parent de Controles:
PACs
Parent Constrains
PoleVector Constraints
Orient Cosntraints (FK)
'''
for i in 'rl':
for partes in brazo:
PAC = cmds.duplicate('{}_{}_skn'.format(partes, i),
n='{}_{}_skn_PAC'.format(partes, i),
rc=True)
PAClist = cmds.listRelatives(PAC, ad=True)
for huesoDeParent in PAClist:
cmds.delete(huesoDeParent)
cmds.parent('{}_{}_skn_PAC'.format(partes, i),
'{}FK_{}_ctr'.format(partes, i))
PACdeIK = cmds.duplicate('hand_{}_skn_PAC'.format(i),
n='hand_IK_{}_skn_PAC'.format(i))
cmds.parent(PACdeIK, 'handIK_{}_ctr'.format(i))
cmds.pointConstraint(PACdeIK,
'arm_{}_ikHandle'.format(i),
n='pointConstraint_{}_PACofTheArmIK'.format(i))
cmds.poleVectorConstraint(
'armPole_{}_ctr'.format(i),
'arm_{}_ikHandle'.format(i),
n='poleVectorConstraint_{}_PoleofTheArmIK'.format(i))
for partes in brazo:
if partes != 'hand':
cmds.orientConstraint(
'{}_{}_skn_PAC'.format(partes, i),
'{}_{}_skn'.format(partes, i),
n='orientConstraint_{}_{}PACto{}sknFK'.format(
i, partes, partes))
else:
cmds.orientConstraint(
'{}_{}_skn_PAC'.format(partes, i),
'{}_IK_{}_skn_PAC'.format(partes, i),
'{}_{}_skn'.format(partes, i),
n='orientConstraint_{}_{}PACto{}sknFKandIK'.format(
i, partes, partes))
'''
Nodos:
Switch FK/IK
'''
for i in 'rl':
armSettings = 'armSettings_{}_ctr'.format(i)
ikH = 'arm_{}_ikHandle'.format(i)
cmds.connectAttr('{}.Arm_IK'.format(armSettings),
'{}.ikBlend'.format(ikH))
reverse = cmds.shadingNode('reverse',
au=True,
n='armSettings_{}_reverse'.format(i))
cmds.connectAttr('{}.Arm_IK'.format(armSettings),
'{}.inputY'.format(reverse))
cmds.connectAttr(
'{}.outputY'.format(reverse),
'orientConstraint_{}_handPACtohandsknFKandIK.hand_{}_skn_PACW0'.
format(i, i))
cmds.connectAttr(
'{}.Arm_IK'.format(armSettings),
'orientConstraint_{}_handPACtohandsknFKandIK.hand_IK_{}_skn_PACW1'.
format(i, i))
cmds.connectAttr('{}.Arm_IK'.format(armSettings),
'handIK_{}_ctr.visibility'.format(i))
for segmentos in brazo:
cmds.connectAttr('{}.outputY'.format(reverse),
'{}FK_{}_ctr.visibility'.format(segmentos, i))
'''
Nodos:
Stretch
'''
for i in 'rl':
for partes in brazo:
loc = cmds.spaceLocator(n='stretch{}_{}_loc'.format(partes, i))
cmds.parent(loc, '{}_{}_skn'.format(partes, i))
for a in vectores:
cmds.setAttr('{}.translate{}'.format(loc[0], a), 0)
if partes == 'shoulder':
cmds.parent(loc, 'clavicle_{}_END'.format(i))
elif partes == 'elbow':
cmds.parent(loc, 'armPole_{}_ctr'.format(i))
else:
cmds.parent(loc, 'handIK_{}_ctr'.format(i))
def stretchArm():
for i in 'rl':
shoulder = 'stretchshoulder_{}_locShape'.format(i)
elbow = 'stretchelbow_{}_locShape'.format(i)
hand = 'stretchhand_{}_locShape'.format(i)
up = cmds.shadingNode('distanceBetween',
n='upArm_{}_distance'.format(i),
au=True)
entire = cmds.shadingNode('distanceBetween',
n='entireArm_{}_distance'.format(i),
au=True)
low = cmds.shadingNode('distanceBetween',
n='lowArm_{}_distance'.format(i),
au=True)
cmds.connectAttr('{}.worldPosition'.format(shoulder),
'{}.point1'.format(up))
cmds.connectAttr('{}.worldPosition'.format(elbow),
'{}.point2'.format(up))
cmds.connectAttr('{}.worldPosition'.format(shoulder),
'{}.point1'.format(entire))
cmds.connectAttr('{}.worldPosition'.format(hand),
'{}.point2'.format(entire))
cmds.connectAttr('{}.worldPosition'.format(elbow),
'{}.point1'.format(low))
cmds.connectAttr('{}.worldPosition'.format(hand),
'{}.point2'.format(low))
nod = [up, entire, low]
for o in nod:
div = cmds.shadingNode('multiplyDivide',
n='{}_{}_normalStretch'.format(
o[:-11], i),
au=True)
cmds.setAttr('{}.operation'.format(div), 2)
cmds.connectAttr('{}.distance'.format(o),
'{}.input1Y'.format(div))
dis = cmds.getAttr('{}.distance'.format(o))
cmds.setAttr('{}.input2Y'.format(div), dis)
clamp = cmds.shadingNode('clamp',
n='armStretch_{}_clamp'.format(i),
au=True)
cmds.setAttr('{}.maxG'.format(clamp), 999)
cmds.connectAttr(
'{}_{}_normalStretch.outputY'.format(entire[:-11], i),
'{}.inputG'.format(clamp))
cmds.connectAttr('general_c_ctr.GlobalScale',
'{}.minG'.format(clamp))
blen = cmds.shadingNode('blendColors',
n='armStretch_pinElbow_{}_blend'.format(i),
au=True)
blenF = cmds.shadingNode('blendColors',
n='armStretch_FINAL_{}_blend'.format(i),
au=True)
blenS = cmds.shadingNode(
'blendColors',
n='armStretch_stretchiness_{}_blend'.format(i),
au=True)
dive = cmds.shadingNode(
'multiplyDivide',
n='armStretch_stretchByGlobal_{}_div'.format(i),
au=True)
rever = 'armSettings_{}_reverse'.format(i)
#Blen
cmds.connectAttr(
'{}_{}_normalStretch.{}'.format('upArm', i, 'outputY'),
'{}.color1G'.format(blen))
cmds.connectAttr('{}.{}'.format(clamp, 'outputG'),
'{}.color2G'.format(blen))
cmds.connectAttr('{}.{}'.format(clamp, 'outputG'),
'{}.color2B'.format(blen))
cmds.connectAttr(
'{}_{}_normalStretch.{}'.format('lowArm', i, 'outputY'),
'{}.color1B'.format(blen))
#BlenF
cmds.connectAttr('{}.outputG'.format(blen),
'{}.color1G'.format(blenF))
cmds.connectAttr('{}.outputB'.format(blen),
'{}.color1B'.format(blenF))
cmds.connectAttr('armSettings_{}_ctr.Arm_IK'.format(i),
'{}.blender'.format(blenF))
#BlenS
cmds.connectAttr('{}.outputG'.format(blenF),
'{}.color1G'.format(blenS))
cmds.connectAttr('{}.outputB'.format(blenF),
'{}.color1B'.format(blenS))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.color2G'.format(blenS))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.color2B'.format(blenS))
#Dive
cmds.setAttr('{}.operation'.format(dive), 2)
cmds.connectAttr('{}.outputG'.format(blenS),
'{}.input1Y'.format(dive))
cmds.connectAttr('{}.outputB'.format(blenS),
'{}.input1Z'.format(dive))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Y'.format(dive))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Z'.format(dive))
cmds.connectAttr('{}.outputY'.format(dive),
'shoulder_{}_skn.scaleX'.format(i))
cmds.connectAttr('{}.outputZ'.format(dive),
'elbow_{}_skn.scaleX'.format(i))
############################## Conexion Control Blender de BlenS
plusMinus = cmds.shadingNode(
'plusMinusAverage',
n='arm_autoStretchOverride_{}_sum'.format(i),
au=True)
clampPlusMinus = cmds.shadingNode(
'clamp',
n='arm_autoStretchOverride_{}_clamp'.format(i),
au=True)
cmds.setAttr('{}.maxG'.format(clampPlusMinus), 1)
cmds.connectAttr('{}.outputY'.format(rever),
'{}.input2D[0].input2Dy'.format(plusMinus))
cmds.connectAttr('handIK_{}_ctr.AutoStretch'.format(i),
'{}.input2D[1].input2Dy'.format(plusMinus))
cmds.connectAttr('{}.output2Dy'.format(plusMinus),
'{}.inputG'.format(clampPlusMinus))
cmds.connectAttr('{}.outputG'.format(clampPlusMinus),
'{}.blender'.format(blenS))
############################## Conexion Control de ColorG y colorB de BlenF
multDivUp = cmds.shadingNode(
'multiplyDivide',
n='armShoulder_{}_StretchByGlobal_mult'.format(i),
au=True)
multDivLow = cmds.shadingNode(
'multiplyDivide',
n='armElbow_{}_StretchByGlobal_mult'.format(i),
au=True)
cmds.connectAttr('shoulderFK_{}_ctr.Stretch'.format(i),
'{}.input1Y'.format(multDivUp))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Y'.format(multDivUp))
cmds.connectAttr('elbowFK_{}_ctr.Stretch'.format(i),
'{}.input1Y'.format(multDivLow))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Y'.format(multDivLow))
cmds.connectAttr('{}.outputY'.format(multDivUp),
'{}.color2G'.format(blenF))
cmds.connectAttr('{}.outputY'.format(multDivLow),
'{}.color2B'.format(blenF))
######################## Blender Blen
multDivPin = cmds.shadingNode(
'multiplyDivide',
n='armShoulder_{}_PinElbow_mult'.format(i),
au=True)
cmds.connectAttr('armPole_{}_ctr.PinElbow'.format(i),
'{}.input1Y'.format(multDivPin))
cmds.connectAttr('armSettings_{}_ctr.Arm_IK'.format(i),
'{}.input2Y'.format(multDivPin))
cmds.connectAttr('{}.outputY'.format(multDivPin),
'{}.blender'.format(blen))
cmds.connectAttr('{}.outputY'.format(multDivPin),
'{}.input2D[2].input2Dy'.format(plusMinus))
stretchArm()
def stretchTwistArm():
for i in side:
cvUp = 'upperArm_{}_ikHandle_curve_twist'.format(i)
cvLow = 'foreArm_{}_ikHandle_curve_twist'.format(i)
cvInfUp = cmds.shadingNode(
'curveInfo',
n='upArm_stretchTwitch_{}_info'.format(i),
au=True)
cvInfLow = cmds.shadingNode(
'curveInfo',
n='lowArm_stretchTwitch_{}_info'.format(i),
au=True)
cmds.connectAttr('{}.worldSpace'.format(cvUp),
'{}.inputCurve'.format(cvInfUp))
cmds.connectAttr('{}.worldSpace'.format(cvLow),
'{}.inputCurve'.format(cvInfLow))
divUp = cmds.shadingNode('multiplyDivide',
n='lowArm_stretchTwitch_{}_div'.format(i),
au=True)
divGlobUp = cmds.shadingNode(
'multiplyDivide',
n='lowArm_stretchTwitchbuGlobal_{}_div'.format(i),
au=True)
divLow = cmds.shadingNode('multiplyDivide',
n='upArm_stretchTwitch_{}_div'.format(i),
au=True)
divGlobLow = cmds.shadingNode(
'multiplyDivide',
n='upArm_stretchTwitchbbyGlobal_{}_div'.format(i),
au=True)
u = [divUp, divGlobUp, divLow, divGlobLow]
for indent in u:
cmds.setAttr('{}.operation'.format(indent), 2)
lenghtUp = cmds.getAttr('{}.arcLength'.format(cvInfUp))
lengthLow = cmds.getAttr('{}.arcLength'.format(cvInfLow))
cmds.connectAttr('{}.arcLength'.format(cvInfUp),
'{}.input1Y'.format(divUp))
cmds.connectAttr('{}.arcLength'.format(cvInfLow),
'{}.input1Y'.format(divLow))
cmds.setAttr('{}.input2Y'.format(divUp), lenghtUp)
cmds.setAttr('{}.input2Y'.format(divLow), lengthLow)
cmds.connectAttr('{}.outputY'.format(divUp),
'{}.input1Y'.format(divGlobUp))
cmds.connectAttr('{}.outputY'.format(divLow),
'{}.input1Y'.format(divGlobLow))
cmds.connectAttr('{}.GlobalScale'.format('general_c_ctr'),
'{}.input2Y'.format(divGlobUp))
cmds.connectAttr('{}.GlobalScale'.format('general_c_ctr'),
'{}.input2Y'.format(divGlobLow))
k = ['upper', 'fore']
for part in k:
huesosTwist = cmds.listRelatives('{}Arm_{}_skn'.format(
part, i),
ad=True)
huesosTwist.append('{}Arm_{}_skn'.format(part, i))
for hueso in huesosTwist:
if part == 'upper':
cmds.connectAttr('{}.outputY'.format(divGlobUp),
'{}.scaleX'.format(hueso))
else:
cmds.connectAttr('{}.outputY'.format(divGlobLow),
'{}.scaleX'.format(hueso))
stretchTwistArm()
for side in 'rl':
cmds.pointConstraint(
'elbow_{}_skn'.format(side),
'elbowFKCtr_{}_offset'.format(side),
n='pointConstraint_{}_elbowStretchFK'.format(side))
cmds.pointConstraint('hand_{}_skn'.format(side),
'handFKCtr_{}_offset'.format(side),
n='pointConstraint_{}_handStretchFK'.format(side))
''''
ordenar el outliner
'''
cmds.parent('rig_arm_l_grp', 'rig_arm_r_grp', 'bodyRig_c_grp')
for side in 'rl':
PolePosition = cmds.getAttr(
'armPoleCtr_{}_offset.translateZ'.format(side))
cmds.setAttr('armPoleCtr_{}_offset.translateZ'.format(side),
(PolePosition - 1))
jntClavicle = 'clavicle_{}_skn'.format(side)
jntClavicleEnd = 'clavicle_{}_END'.format(side)
grpShoulderRollSystem = 'shoulder_{}_rollSystem'.format(side)
jntShoulderOffset = 'shoulder_{}_skn_offset'.format(side)
ctrShoulderFKOffset = 'shoulderFKCtr_{}_offset'.format(side)
fun.blendSystem(CurveU='upperArm_{}_ikHandle_curve_twist'.format(side),
CurveL='foreArm_{}_ikHandle_curve_twist'.format(side),
ClusterName='ClusterBlendSystem_Arm_{}_'.format(side),
upJnt='shoulder_{}_skn'.format(side),
middleJnt='elbow_{}_skn'.format(side),
upBlend='armUpBlend_{}_ctr'.format(side),
middleBlend='armMiddleBlend_{}_ctr'.format(side),
lowBlend='armLowBlend_{}_ctr'.format(side))
shoulderFKPcon = cmds.group(em=True,
n='shoulderFK_{}_pcon'.format(side))
pconShoulderMatrix = cmds.xform(ctrShoulderFKOffset,
q=True,
matrix=True,
ws=True)
cmds.xform(shoulderFKPcon, ws=True, matrix=pconShoulderMatrix)
cmds.parent(shoulderFKPcon, jntClavicleEnd)
cmds.parentConstraint(jntClavicle, grpShoulderRollSystem, mo=True)
cmds.pointConstraint(jntClavicleEnd, jntShoulderOffset, mo=False)
cmds.pointConstraint(shoulderFKPcon, ctrShoulderFKOffset, mo=False)
cmds.move(-50, 'armPoleCtr_{}_offset'.format(side), z=True)
cmds.connectAttr('armSettings_{}_ctr.Arm_IK'.format(side),
'armPole_{}_ctr.visibility'.format(side))
cmds.parent('armPoleCtr_{}_offset'.format(side), 'center_c_ctr')
cmds.rename('shoulder_{}_skn'.format(side),
'shoulder_{}_jnt'.format(side))
cmds.rename('elbow_{}_skn'.format(side), 'elbow_{}_jnt'.format(side))
cmds.parent('handFKCtr_{}_offset'.format(side),
'elbowFK_{}_ctr'.format(side))
cmds.parent('elbowFKCtr_{}_offset'.format(side),
'shoulderFK_{}_ctr'.format(side))
#Configuracion de los spaces
for side in 'rl':
pos = cmds.xform('handIK_{}_ctr'.format(side), ws=True, m=True, q=True)
w = cmds.group(em=True, n='handIK_{}_worldSpace'.format(side))
h = cmds.group(em=True, n='handIK_{}_headSpace'.format(side))
c = cmds.group(em=True, n='handIK_{}_chestSpace'.format(side))
p = cmds.group(em=True, n='handIK_{}_pelvisSpace'.format(side))
for i in [w, h, c, p]:
cmds.xform(i, ws=True, m=pos)
cmds.parent(w, 'general_c_ctr')
cmds.parent(h, 'head_c_ctr')
cmds.parent(c, 'chest_c_ctr')
cmds.parent(p, 'pelvis_c_ctr')
cmds.parentConstraint(w,
h,
c,
p,
'handIKCtr_{}_offset'.format(side),
mo=False,
n='spaceParentIKHand_{}_cns'.format(side))
cmds.connectAttr(
'handIK_{}_ctr.ChestSpace'.format(side),
'spaceParentIKHand_{}_cns.handIK_{}_chestSpaceW2'.format(
side, side))
cmds.connectAttr(
'handIK_{}_ctr.HeadSpace'.format(side),
'spaceParentIKHand_{}_cns.handIK_{}_headSpaceW1'.format(
side, side))
cmds.connectAttr(
'handIK_{}_ctr.HipSpace'.format(side),
'spaceParentIKHand_{}_cns.handIK_{}_pelvisSpaceW3'.format(
side, side))
clampSpace = fun.clampCreator(name='handIKSpace_{}_clamp'.format(side),
MaxR=1,
MinR=0)
fun.plusCreator(name='handIKSpace_{}_sum'.format(side),
InputX0='handIK_{}_ctr.ChestSpace'.format(side),
InputX1='handIK_{}_ctr.HeadSpace'.format(side),
InputX2='handIK_{}_ctr.HipSpace'.format(side),
OutputX='{}.inputR'.format(clampSpace))
reverseSpace = cmds.shadingNode('reverse',
au=True,
n='handIKSpace_{}_rev'.format(side))
cmds.connectAttr('{}.outputR'.format(clampSpace),
'{}.inputX'.format(reverseSpace))
cmds.connectAttr(
'{}.outputX'.format(reverseSpace),
'spaceParentIKHand_{}_cns.handIK_{}_worldSpaceW0'.format(
side, side))
#Correccion del fallo del twist del brazo
cmds.setAttr("elbow_l_twistValue_elbowToHand.offsetX", 0)
cmds.setAttr("elbow_l_twistValue.jointOrientX", 0)
cmds.parent('armMiddleBlendCtr_r_offset', 'skeleton_c_grp')
cmds.parent('armMiddleBlendCtr_l_offset', 'skeleton_c_grp')
cmds.parent('shoulderFKCtr_l_offset', 'handIKCtr_l_offset', 'center_c_ctr')
cmds.parent('shoulderFKCtr_r_offset', 'handIKCtr_r_offset', 'center_c_ctr')
for part in ['foreArm', 'upperArm']:
for side in 'rl':
foreArmList = cmds.listRelatives('{}_{}_skn'.format(part, side),
ad=True)
foreArmList.reverse()
i = 1
for element in foreArmList:
if 'skn' in element:
cmds.rename(element, '{}{}_{}_skn'.format(part, i, side))
i += 1
else:
pass
joints = cmds.ls(type='joint')
for jnt in joints:
if '_skn_PAC' in jnt:
newName = jnt.replace('_skn_PAC', '_PAC')
cmds.rename(jnt, newName)
else:
pass
def bicepJnts(side):
import maya.cmds as mc
# refer to the no roll attribute control
attrCtrl = "%s_arm_SW_ctrl" % side
rev = mc.createNode("reverse", n="%s_arm_01_no_twist_rev" % side)
mc.connectAttr("%s.%s_nr" % (attrCtrl, side), "%s.ix" % rev)
# refer to bicep joints
jnt1 = ("%s_arm_01_deform_ctrl_01" % side)
jnt2 = ("%s_arm_01_deform_ctrl_02" % side)
jnt3 = ("%s_arm_01_deform_ctrl_03" % side)
jnt4 = ("%s_arm_01_deform_ctrl_04" % side)
# refer to bicep nt joints
ntjnt1 = ("%s_arm_01_no_twist_ctrl_01" % side)
ntjnt2 = ("%s_arm_01_no_twist_ctrl_02" % side)
ntjnt3 = ("%s_arm_01_no_twist_ctrl_03" % side)
ntjnt4 = ("%s_arm_01_no_twist_ctrl_04" % side)
# controls
tempCrcl1 = mc.circle(n="%s_tempCircle1" % side)
mc.delete(tempCrcl1, ch=True)
mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl1[0], r=1)
mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl1[0], r=1)
mc.parent("%sShape" % tempCrcl1[0], ntjnt1, s=True, r=True)
mc.select(cl=True)
mc.delete(tempCrcl1[0])
oriConst1 = mc.orientConstraint(jnt1, ntjnt1, mo=True)
mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst1[0])
tempCrcl2 = mc.circle(n="%s_tempCircle2" % side)
mc.delete(tempCrcl2, ch=True)
mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl2[0], r=1)
mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl2[0], r=1)
mc.parent("%sShape" % tempCrcl2[0], ntjnt2, s=True, r=True)
mc.select(cl=True)
mc.delete(tempCrcl2[0])
oriConst2 = mc.orientConstraint(jnt2, ntjnt2, mo=True)
mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst2[0])
tempCrcl3 = mc.circle(n="%s_tempCircle3" % side)
mc.delete(tempCrcl3, ch=True)
mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl3[0], r=1)
mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl3[0], r=1)
mc.parent("%sShape" % tempCrcl3[0], ntjnt3, s=True, r=True)
mc.select(cl=True)
mc.delete(tempCrcl3[0])
oriConst3 = mc.orientConstraint(jnt3, ntjnt3, mo=True)
mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst3[0])
tempCrcl4 = mc.circle(n="%s_tempCircle4" % side)
mc.delete(tempCrcl4, ch=True)
mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl4[0], r=1)
mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl4[0], r=1)
mc.parent("%sShape" % tempCrcl4[0], ntjnt4, s=True, r=True)
mc.select(cl=True)
mc.delete(tempCrcl4[0])
oriConst4 = mc.orientConstraint(jnt4, ntjnt4, mo=True)
mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst4[0])
def createFKJointCtls(controlBaseGrp,
parentJntsArray,
lettersArray,
side="L",
jntPrefix="JNT",
grpPrefix="GRP",
ctlPrefix="CTL",
part="toe"):
#Get information
fkJntChains = parentJntsArray
curlGrps = [] #Contains curl offset groups for each ctl
rootCtlGrp = []
incre = -1 #For toe lettering
for jntChain in fkJntChains:
incre2 = 0 #For down chain numbering
incre = incre + 1
#Get all of a toes segments
parentAndChildJntChain = returnParentAndChildren(jntChain,
reverse=False)
#Remove the end joint from the list
del parentAndChildJntChain[len(parentAndChildJntChain) - 1]
#For each joint in each toe
for jnt in parentAndChildJntChain:
incre2 = incre2 + 1
#Duplicate the controlBaseGrp
newCtlGrp = ma.duplicate(controlBaseGrp)
#Rename grp and ctl and return both
newCtlGrp, newCtl = renameControl(
newCtlGrp[0], (side + "_" + part + lettersArray[incre] +
"FKCtl0" + str(incre2) + "_" + grpPrefix),
(side + "_" + part + lettersArray[incre] + "FK0" +
str(incre2) + "_" + ctlPrefix))
#Lock unwanted attributes (all but rotation)
for attr1 in (".translate", ".scale", ".visibility"):
if attr1 != ".visibility":
for attr2 in ("X", "Y", "Z"):
ma.setAttr(str(newCtl) + attr1 + attr2,
l=True,
k=False)
else:
ma.setAttr(str(newCtl) + attr1, l=True, k=False)
#point and orient to the current joint
pointAndOrientSelected(item1=jnt, item2=newCtlGrp)
#Duplicate point and orientated Grp for curl grp
curlGrp = ma.duplicate(
newCtlGrp,
po=True,
n=(side + "_" + part + lettersArray[incre] + "FKCurl0" +
str(incre2) + "_" + grpPrefix))
#parent group under original group then parent ctl under that
ma.parent(newCtl, curlGrp)
ma.parent(curlGrp, newCtlGrp)
newCtl = findLastChild(newCtlGrp)
#constrainCtlJnt to Ctl
ma.orientConstraint(newCtl, jnt)
if incre2 == 1:
rootCtlGrp.append(newCtlGrp)
parentCtl = newCtl
else:
#print str(newCtlGrp)+" "+str(parentCtl)
ma.parent(newCtlGrp, parentCtl)
parentCtl = findLastChild(parentCtl)
for rootJnt in rootCtlGrp:
toeHierach = returnParentAndChildren(rootJnt, reverse=False)
incre = 0
incre2 = 0
for jntTransform in toeHierach:
if incre2 == 1:
curlGrps.append(jntTransform)
incre2 = incre2 + 1
elif incre2 == 2:
if incre == 2:
curlGrps.append(jntTransform)
incre = 0
else:
incre = incre + 1
else:
incre2 = incre2 + 1
return rootCtlGrp, curlGrps #Return all the rootctlGrps, and curl offset grps
def _bakeCamera(sourceCamera = ''):
"""
Used for quickly baking out a camera into an existing CAM group.
Useful for checking in tracked cameras etc
"""
if sourceCamera == '':
sourceCamera = cmds.ls(sl=True)[0]
sourceCameraShape = cmds.listRelatives(sourceCamera, shapes = True)[0]
startFrame = int(cmds.playbackOptions(query = True, animationStartTime = True))
endFrame = int(cmds.playbackOptions(query = True, animationEndTime = True))
focallength = int(cmds.getAttr('%s.focalLength' % sourceCameraShape) )
camName = '%s_bake' % (sourceCamera)
newCam = cmds.camera(
name = camName,
centerOfInterest = 5,
focalLength = cmds.getAttr('%s.focalLength' % sourceCamera),
lensSqueezeRatio = 1,
cameraScale = cmds.getAttr('%s.cameraScale' % sourceCamera),
horizontalFilmAperture = cmds.getAttr('%s.horizontalFilmAperture' % sourceCamera),
horizontalFilmOffset = 0,
verticalFilmAperture = cmds.getAttr('%s.verticalFilmAperture' % sourceCamera),
verticalFilmOffset = 0,
filmFit = getFilmFit(cmds.getAttr('%s.filmFit' % sourceCamera)) ,
overscan = cmds.getAttr('%s.overscan' % sourceCamera),
motionBlur = 0,
shutterAngle = 144,
nearClipPlane = cmds.getAttr('%s.nearClipPlane' % sourceCamera),
farClipPlane = cmds.getAttr('%s.farClipPlane' % sourceCamera),
orthographic = 0,
orthographicWidth = 30,
panZoomEnabled = 0,
horizontalPan = 0,
verticalPan = 0,
zoom = 1,
dgm = True,
dr= True,
dsa = True
)
cmds.rename('%s1' % camName, camName)#stupid freaking maya can't create a new freaking node without putting a 1 at the end of it.
createTypeTag(camName, 'shotCam')
cmds.connectAttr('%s.focalLength' % sourceCameraShape, '%sShape.focalLength' % camName)
cmds.pointConstraint(sourceCamera, camName, n = 'TmpPoint', mo = False)
cmds.orientConstraint(sourceCamera, camName, n = 'TmpOrient', mo = False)
cmds.bakeResults(
camName,
simulation = True,
t = (startFrame,endFrame),
sampleBy = 1,
disableImplicitControl = True,
preserveOutsideKeys = False,
sparseAnimCurveBake = False,
removeBakedAttributeFromLayer = False,
bakeOnOverrideLayer = False,
controlPoints = False,
shape = True
)
cmds.delete('TmpPoint')
cmds.delete('TmpOrient')
try:
cmds.parent(camName, 'BAKE_CAM_hrc')
except TypeError:
cmds.group(n = 'BAKE_CAM_hrc', em = True)
cmds.parent(camName, 'BAKE_CAM_hrc')
except ValueError:
cmds.group(n = 'BAKE_CAM_hrc', em = True)
cmds.parent(camName, 'BAKE_CAM_hrc')
#get the imageplane and put it into the new camera.
try:
for input in cmds.listConnections('%s' % sourceCameraShape, source = True):
if 'imagePlane' in input:
cmds.shadingNode('imagePlane', asUtility = True , name = 'tempPlane')
cmds.connectAttr('%s.message' % input, '%sShape.imagePlane[0]' % camName)
cmds.delete('tempPlane')
except TypeError:
print 'No image plane found, skipping...'
return camName
def createIKLeg(side="L",
grpPrefix="GRP",
ctlPrefix="CTL",
ikhPrefix="IKH",
jntPrefix="JNT",
masterToe=1,
legStretchOffset=0.6):
#Get selected
sel = ma.ls(sl=True)
#I didn't know how to get alphabetical letters for toe ik handles nicely, sue me
#No one have this many toes on a single footJnt, but gotta be safe
letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
#List of floating point attributes to add to the ik control
IKfootJntAttrs = [
"toeEndTip", "toeEndSwivel", "toeUpperTip", "heelTip", "heelSwivel"
]
#Store variables
legStartJnt = sel[0]
legMidJnt = sel[1]
legEndJnt = sel[2]
footJnt = sel[3]
#IK Controls
footJntIKCtlGrp = sel[4]
footJntIKCtl = None
legPVCtlGrp = sel[5]
legPVCtl = None
#FK Controls
legFKUpperCtlGrp = sel[6]
legFKUpperCtl = None
legFKLowerCtlGrp = sel[7]
legFKLowerCtl = None
legFKHeelCtlGrp = sel[8]
legFKHeelCtl = None
legFKFootCtlGrp = sel[9]
legFKFootCtl = None
#FKIK switch
fkIKCtlGrp = sel[10]
fkIKCtl = None
fkToeCtlGrp = sel[11] # Control is duped for each toe joint control
toeStartEnd = [] # to hold all toe start and ends
toeIKHs = [] #To hold all toe ik handles
fkToeCtlGrps = [] #To hold all the fk toe controls
fkToeJnts = [] #To Hold all toe jnt roots to be given fk ctls
fkToeCurlGrps = [] #To hold the curl offset groups for the toes
### PREP FOR FK TOES
#Make duplicate toes parent old joints to new and get new start and end
toeStartEnd = dupAndParentChildChainStartEnd(footJnt, letters, side,
jntPrefix)
#### MAKE IK ####
#Create IK handle for leg itself
ma.select(cl=True)
ma.select((legStartJnt, legEndJnt))
legIK = ma.ikHandle(sol="ikRPsolver")
#Rename IK handle
legIKH = ma.rename(legIK[0], side + "_leg_" + ikhPrefix)
#Create IK handle for footJnt
ma.select(cl=True)
ma.select((legEndJnt, footJnt))
footJntIK = ma.ikHandle(sol="ikSCsolver")
footJntIKH = ma.rename(footJntIK[0], side + "_footJnt_" + ikhPrefix)
#Create IK handle for toe
ma.select(cl=True)
ma.select((footJnt, toeStartEnd[masterToe][0]))
toeIK = ma.ikHandle(sol="ikSCsolver")
toeIKH = ma.rename(toeIK[0], side + "_toe_" + ikhPrefix)
#Rename IK Control
footJntIKCtlGrp, footJntIKCtl = renameControl(
footJntIKCtlGrp, side + "_legIkCtl_" + grpPrefix,
side + "_legIk_" + ctlPrefix)
#Rename IK PV Control
legPVCtlGrp, legPVCtl = renameControl(legPVCtlGrp,
side + "_legPVCtl_" + grpPrefix,
side + "_legPV_" + ctlPrefix)
#lock and hide unwanted attributes on ikctl and pvCtl
for fkCtlAttr in ("X", "Y", "Z"):
ma.setAttr(footJntIKCtl + ".scale" + fkCtlAttr, l=True, k=False)
ma.setAttr(legPVCtl + ".scale" + fkCtlAttr, l=True, k=False)
ma.setAttr(legPVCtl + ".rotate" + fkCtlAttr, l=True, k=False)
ma.setAttr(footJntIKCtl + ".visibility", l=True, k=False)
ma.setAttr(legPVCtl + ".visibility", l=True, k=False)
#Move IK Contol
pointConTemp = ma.pointConstraint(legEndJnt, footJntIKCtlGrp)
ma.delete(pointConTemp)
#Point contraint footJntIKH to footJntIKCtl
#ma.pointConstraint(footJntIKCtl, legIKH)
#Move PV Control
pointConTemp = ma.pointConstraint(legMidJnt, legPVCtlGrp)
ma.delete(pointConTemp)
ma.move(0, 0, 50, legPVCtlGrp, os=True, r=True)
#Create Pole Vector Constraint
ma.poleVectorConstraint(legPVCtl, legIKH)
##Create each toe IK and store handle in toeIKHs!
incr = -1
for toe in toeStartEnd:
incr = incr + 1
ma.select(cl=True)
ma.select(toe[0], toe[1])
ikTemp = ma.ikHandle(sol="ikSCsolver")
ikTemp = ma.rename(ikTemp[0],
side + "_toe" + letters[incr] + "IK_" + ikhPrefix)
ma.setAttr(toe[1] + ".visibility", 0)
toeIKHs.append(ikTemp)
#### Create FKIK Switch! ####
#Name IKFK CTL
fkIKCtlGrp, fkIKCtl = renameControl(fkIKCtlGrp,
side + "_legFKIKCtl_" + grpPrefix,
side + "_legFKIK_" + ctlPrefix)
#Move IKFK Ctl
pointConTemp = ma.pointConstraint(legEndJnt, fkIKCtlGrp)
ma.delete(pointConTemp)
#Add attribute to FKIK
ma.addAttr(fkIKCtl, ln="FKIK", min=0, max=1, dv=0, k=True)
#FK Toe visibility (for use later!)
ma.addAttr(fkIKCtl, ln="fkToeVisibility", min=0, max=1, dv=0, k=True)
#Connect attribute IKH ikblend attributes to FKIK
#leg, foot, toe
for hdl in (legIKH, footJntIKH, toeIKH):
ma.connectAttr(fkIKCtl + ".FKIK", hdl + ".ikBlend")
#toes
for hdl in toeIKHs:
ma.connectAttr(fkIKCtl + ".FKIK", hdl + ".ikBlend")
#### Reverse footJnt Setup! ####
#Create root joint reverse footJnt joint (Heel joint)
ma.select(cl=True)
rvHeelJnt = ma.joint(rad=0.5)
rvHeelJnt = ma.rename(rvHeelJnt, side + "_footJntRV01_" + jntPrefix)
#Move root reverse footJnt
pointConTemp = ma.pointConstraint(legEndJnt, rvHeelJnt)
ma.delete(pointConTemp)
ma.move(0, rvHeelJnt, y=True)
#make the rest of the reverse footJnt
#Get locations for the reverse footJnt joints
reversefootJntLocations = []
for rvLocation in (toeStartEnd[masterToe][1], toeStartEnd[masterToe][0],
footJnt, legEndJnt):
reversefootJntLocations.append(
tuple(ma.xform(rvLocation, q=True, ws=True, t=True)))
#Create the IK toe joints
rvJnts = createJointChainOnPos(reversefootJntLocations)
#Rename all joints
incr = len(rvJnts) + 2
for jnt in rvJnts:
incr = incr - 1
if incr == 2:
#If it is the second to last joint, parent it under the heel root
ma.parent(
ma.rename(jnt,
side + "_footJntRV0" + str(incr) + "_" + jntPrefix),
rvHeelJnt)
else:
ma.rename(jnt, side + "_footJntRV0" + str(incr) + "_" + jntPrefix)
#Re obtain all the now children of rvHeelJnt, these are the rvJnts
rvJnts = returnParentAndChildren(rvHeelJnt, reverse=False)
#parent toesIKHs under the toe jnt on reverse footJnt rig
for toeHandle in toeIKHs:
ma.parent(toeHandle, rvJnts[1])
#parent toeIKH under the first toe rvjnt
ma.parent(toeIKH, rvJnts[2])
#parent footJntIKH under footJnt rvjnt
ma.parent(footJntIKH, rvJnts[3])
#parent leg IKH under leg rvjnt
ma.parent(legIKH, rvJnts[4])
#Make custom attributes for footJnt IK control
for attr in IKfootJntAttrs:
ma.addAttr(footJntIKCtl, ln=attr, dv=0, k=True)
#Connect new attributes to their respective reverse footJnt joint attributes
ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[0],
rvJnts[1] + ".rotateX") #Toe End Tip
ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[1],
rvJnts[1] + ".rotateY") #Toe End End Swivel
ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[2],
rvJnts[2] + ".rotateX") #Toe Tip Upper
ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[3],
rvJnts[3] + ".rotateX") #Heel Tip
ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[4],
rvJnts[3] + ".rotateY") #Heel Swivel
#Parent Constrain the root Reverse footJnt to the ikCtl
ma.parentConstraint(footJntIKCtl, rvJnts[0], mo=True)
#hide the RV foot
ma.setAttr(rvJnts[0] + ".visibility", 0)
#### Attatching FK Leg Controls ####
#rename controls
legFKUpperCtlGrp, legFKUpperCtl = renameControl(
legFKUpperCtlGrp, side + "_legFK01Ctl_" + grpPrefix,
side + "_legFK01_" + ctlPrefix)
legFKLowerCtlGrp, legFKLowerCtl = renameControl(
legFKLowerCtlGrp, side + "_legFK02Ctl_" + grpPrefix,
side + "_legFK02_" + ctlPrefix)
legFKHeelCtlGrp, legFKHeelCtl = renameControl(
legFKHeelCtlGrp, side + "_legFK03Ctl_" + grpPrefix,
side + "_legFK03_" + ctlPrefix)
legFKFootCtlGrp, legFKFootCtl = renameControl(
legFKFootCtlGrp, side + "_legFK04Ctl_" + grpPrefix,
side + "_legFK04_" + ctlPrefix)
#position controls
for fkJnt, fkCtlGrp, fkCtl in zip(
(legStartJnt, legMidJnt, legEndJnt, footJnt),
(legFKUpperCtlGrp, legFKLowerCtlGrp, legFKHeelCtlGrp, legFKFootCtlGrp),
(legFKUpperCtl, legFKLowerCtl, legFKHeelCtl, legFKFootCtl)):
#Move ctls to joints
pointAndOrientSelected(item1=fkJnt, item2=fkCtlGrp)
#orientConstrain joints to ctls
ma.orientConstraint(fkCtl, fkJnt)
#Make an orient constraint group for each iktoe so that they have a default orient when not in ikblend 1
ikToesOrientGrpCns = []
incr = -1
for ikToeJnt in toeStartEnd:
incr = incr + 1
ikToeCnGrp = ma.createNode("transform",
n=side + "_ikToe" + letters[incr] +
"OrientCn_" + grpPrefix)
pointAndOrientSelected(item1=ikToeJnt[0], item2=ikToeCnGrp)
ma.orientConstraint(ikToeCnGrp, ikToeJnt[0])
ikToesOrientGrpCns.append(ikToeCnGrp)
#CreateToeOrientCnGrp to contain all toes orient constraint groups
ikToesCnGrpGrp = ma.createNode("transform",
n=side + "_ikToeOrientCnGrp_" + grpPrefix)
for cnGrp in ikToesOrientGrpCns:
ma.parent(cnGrp, ikToesCnGrpGrp)
#parent grpgrp under last FKlegCtl
ma.parent(ikToesCnGrpGrp, legFKFootCtl)
for toe in toeStartEnd:
fkToeJnts.append(ma.listRelatives(toe[0], f=True)[1])
#parent fk controls in hierachy
ma.parent(legFKFootCtlGrp, legFKHeelCtl)
ma.parent(legFKHeelCtlGrp, legFKLowerCtl)
ma.parent(legFKLowerCtlGrp, legFKUpperCtl)
#### FK TOES CREATION! ####
#Create FK toe ctls and curl offset grps
fkToeCtlGrps, fkToeCurlGrps = createFKJointCtls(fkToeCtlGrp, fkToeJnts,
letters, side, jntPrefix,
grpPrefix, ctlPrefix)
#Add attributes to FKIK Ctl
ma.addAttr(fkIKCtl, ln="toeScrunch", dv=0, k=True)
ma.addAttr(fkIKCtl, ln="toeSpread", dv=0, k=True)
#linking up to scrunch, rotate Z
incre = 0
#Create reverse node for toe scrunch
toeScrunchRVNode = ma.createNode("reverse", n=side + "_toeScrunch_RV")
ma.connectAttr(fkIKCtl + ".toeScrunch", toeScrunchRVNode + ".inputX")
for toeCurlGrp in fkToeCurlGrps:
if incre == 0:
incre = incre + 1
ma.connectAttr(fkIKCtl + ".toeScrunch",
toeCurlGrp + ".rotateZ") #Toe End Tip
elif incre == 2:
incre = 0
ma.connectAttr(toeScrunchRVNode + ".outputX",
toeCurlGrp + ".rotateZ")
else:
incre = incre + 1
ma.connectAttr(toeScrunchRVNode + ".outputX",
toeCurlGrp + ".rotateZ")
#Linking up rotate Y for toe spread attr
incre = 0
#Create toe spread reverse node
toeSpreadRVNode = ma.createNode("reverse", n=side + "_toeSpread_RV")
#Create divide nodes
toeSpreadRVDiv = ma.createNode("multiplyDivide",
n=side + "_toeSpreadRV_MDV")
toeSpreadDiv = ma.createNode("multiplyDivide", n=side + "_toeSpread_MDV")
#Set divide node input 2X
ma.setAttr(toeSpreadRVDiv + ".operation", 2)
ma.setAttr(toeSpreadDiv + ".operation", 2)
ma.setAttr(toeSpreadRVDiv + ".input2X", 2)
ma.setAttr(toeSpreadDiv + ".input2X", 2)
#Connect up divide and reverse nodes
ma.connectAttr(fkIKCtl + ".toeSpread", toeSpreadRVNode + ".inputX")
ma.connectAttr(fkIKCtl + ".toeSpread", toeSpreadDiv + ".input1X")
ma.connectAttr(toeSpreadRVNode + ".outputX", toeSpreadRVDiv + ".input1X")
#Attatch all the toe starts to spread
for toeCurlGrp in fkToeCurlGrps:
incre = incre + 1
if incre == 1:
ma.connectAttr(toeSpreadRVDiv + ".outputX",
toeCurlGrp + ".rotateY")
elif incre == 4:
ma.connectAttr(toeSpreadRVNode + ".outputX",
toeCurlGrp + ".rotateY")
elif incre == 7:
ma.connectAttr(toeSpreadRVDiv + ".outputX",
toeCurlGrp + ".rotateY")
elif incre == 10:
ma.connectAttr(toeSpreadDiv + ".outputX", toeCurlGrp + ".rotateY")
elif incre == 13:
ma.connectAttr(fkIKCtl + ".toeSpread", toeCurlGrp + ".rotateY")
else:
pass
#### SETTING VISIBILITY, PARENTING ####
#Create fkik reverse node and connect to fkik
fkikRV = ma.createNode("reverse", n=side + "_fkIK_RV")
ma.connectAttr(fkIKCtl + ".FKIK", fkikRV + ".inputX")
#set visibility of IK foot
#legFKUpperCtlGrp, footJntIKCtlGrp
ma.connectAttr(fkIKCtl + ".FKIK", footJntIKCtlGrp + ".visibility")
ma.connectAttr(fkIKCtl + ".FKIK", legPVCtlGrp + ".visibility")
ma.connectAttr(fkikRV + ".outputX", legFKUpperCtlGrp + ".visibility")
## Parent constrain fkIKCtlGrp to the legEndJnt
ma.parentConstraint(legEndJnt, fkIKCtlGrp, mo=True)
#Create fkToeCtls_GRP to contain all the toe ctls
fkToeCtlsGrp = ma.createNode("transform",
n=side + "_fkToeCtls_" + grpPrefix)
#parent constrain root toes toe their respective ik switching toe jnts
for toe, toeRootGrp in zip(toeStartEnd, fkToeCtlGrps):
ma.parentConstraint(toe[0], toeRootGrp)
ma.connectAttr(fkIKCtl + ".fkToeVisibility",
toeRootGrp + ".visibility")
# Parent all toeRootGrps under fkToeCtlsGrp
ma.parent(toeRootGrp, fkToeCtlsGrp)
#### CREATE STRETCHY LEGS! ####
#Create and name locators!
legStretchStartLoc = ma.spaceLocator(n=side + "_legStartStretch_LOC")
legStretchEndLoc = ma.spaceLocator(n=side + "_legEndStretch_LOC")
#point constrain locators to start and end
ma.pointConstraint(legStartJnt, legStretchStartLoc)
ma.pointConstraint(footJntIKCtl, legStretchEndLoc)
#Create a distance between node
legStretchDst = ma.createNode("distanceBetween",
n=side + "_legStretch_DST")
ma.connectAttr(legStretchStartLoc[0] + ".worldMatrix",
legStretchDst + ".inMatrix1")
ma.connectAttr(legStretchEndLoc[0] + ".worldMatrix",
legStretchDst + ".inMatrix2")
#Create a divide node!
legStretchDiv = ma.createNode("multiplyDivide",
n=side + "_legStretchValue_MDV")
ma.setAttr(legStretchDiv + ".operation", 2)
#Create worldscale divide node!
worldScaleMult = ma.createNode("multiplyDivide",
n=side + "_legWorldScale_MDV")
#Set input2X to default distance (leaving 1X open for the world scale)
ma.setAttr(worldScaleMult + ".input2X",
(ma.getAttr(legStretchDst + ".distance") + legStretchOffset))
ma.setAttr(worldScaleMult + ".input1X",
1) # This will need to be attatched to the world scale later!
#Connect distance node to input1X and worldScaleMult to input2X
ma.connectAttr(legStretchDst + ".distance", legStretchDiv + ".input1X")
ma.connectAttr(worldScaleMult + ".outputX", legStretchDiv + ".input2X")
#Create a condition node
legStretchCon = ma.createNode("condition", n=side + "_legStretch_CN")
#Create stretch attribute on ikfootctl
ma.addAttr(footJntIKCtl, ln="stretch", min=0, max=1, dv=0, k=True)
#Create stretchSwitchAttrMDV and stretchSwitchFKIK
legStretchSwitchMult = ma.createNode("multiplyDivide",
n=side + "_legStretchSwitch_MDV")
legStretchSwitchFKIKMult = ma.createNode("multiplyDivide",
n=side +
"_legStretchSwitchFKIK_MDV")
#Connect stretch attribute to legStretchSwitchMult input1X
ma.connectAttr(footJntIKCtl + ".stretch",
legStretchSwitchMult + ".input1X")
#Connect FKIK attribute to legStretchSwitchFKIKMult input1X
ma.connectAttr(fkIKCtl + ".FKIK", legStretchSwitchFKIKMult + ".input1X")
#Connect legStretchDiv to legStretchSwitchMult.input2X
ma.connectAttr(legStretchDiv + ".outputX",
legStretchSwitchMult + ".input2X")
#Connect legStretchSwitchMult to legStretchSwitchFKIKMult.input2X
ma.connectAttr(legStretchSwitchMult + ".outputX",
legStretchSwitchFKIKMult + ".input2X")
#Connect legStretchSwitchFKIKMult to firstTerm
ma.connectAttr(legStretchSwitchFKIKMult + ".outputX",
legStretchCon + ".firstTerm")
#Connect MDV to the colorIfTrue.colorIfTrueR
ma.connectAttr(legStretchDiv + ".outputX",
legStretchCon + ".colorIfTrue.colorIfTrueR")
#set second term and operation of legStretchCon
ma.setAttr(legStretchCon + ".secondTerm", 1)
ma.setAttr(legStretchCon + ".operation", 2)
#Connect condition nodes outColor.outColorR to scaleX on legStartJnt and legMidJnt
ma.connectAttr(legStretchCon + ".outColor.outColorR",
legStartJnt + ".scaleX")
ma.connectAttr(legStretchCon + ".outColor.outColorR",
legMidJnt + ".scaleX")
#Create a group to hold the two locators
legStretchGrp = ma.createNode("transform",
n=side + "_legStretch_" + grpPrefix)
ma.parent(legStretchStartLoc[0], legStretchGrp)
ma.parent(legStretchEndLoc[0], legStretchGrp)
import maya.cmds as cmds
def parentManips(side):
import maya.cmds as mc
blendelbFrnt = "%s_elbowFrnt_twist_choice_bta" % side
blendfrarm = "%s_forearm_twist_choice_bta" % side
blendwrist = "%s_wrist_twist_choice_bta" % side
attrControl = "%s_arm_SW_ctrl" % side
rev = mc.createNode("reverse", n="%s_arm_02_no_twist_rev" % side)
mc.connectAttr("%s.%s_nr" % (attrControl, side), "%s.ix" % rev)
ntJnt1 = "%s_arm_02_no_twist_ctrl_01" % side
ntJnt2 = "%s_arm_02_no_twist_ctrl_02" % side
ntJnt3 = "%s_arm_02_no_twist_ctrl_03" % side
ntJnt4 = "%s_arm_02_no_twist_ctrl_04" % side
Jnt1 = "%s_arm_02_deform_ctrl_01" % side
Jnt2 = "%s_arm_02_deform_ctrl_02" % side
Jnt3 = "%s_arm_02_deform_ctrl_03" % side
Jnt4 = "%s_arm_02_deform_ctrl_04" % side
svl1 = "%s_sleeve_01_pivot_top_ctrl" % side
svl2 = "%s_sleeve_02_pivot_top_ctrl" % side
svl3 = "%s_sleeve_03_pivot_top_ctrl" % side
svl4 = "%s_sleeve_04_pivot_top_ctrl" % side
svl5 = "%s_sleeve_05_pivot_top_ctrl" % side
elbow = mc.duplicate("%s_arm_02" % side,
n="%s_arm_02_no_twist" % side,
po=True)
mc.parent(elbow[0], "%s_arm_02" % side)
tempOriConst = mc.orientConstraint(ntJnt4, elbow[0])
mc.delete(tempOriConst)
tempConst1 = mc.pointConstraint(ntJnt4,
"%s_orig" % svl1,
sk=("y", "z"))
mc.delete(tempConst1)
tempConst2 = mc.pointConstraint(ntJnt3,
"%s_orig" % svl2,
sk=("y", "z"))
mc.delete(tempConst2)
tempConst3 = mc.pointConstraint(ntJnt2,
"%s_orig" % svl3,
sk=("y", "z"))
mc.delete(tempConst3)
tempConst4 = mc.pointConstraint(ntJnt1,
"%s_orig" % svl4,
sk=("y", "z"))
mc.delete(tempConst4)
grp1 = mc.group(em=True, n="%s_transform" % svl1, p=ntJnt4)
tempConst5 = mc.pointConstraint(ntJnt4, grp1)
mc.delete(tempConst5)
oriCnst1 = mc.orientConstraint(ntJnt4, elbow[0], grp1, mo=True)
mc.connectAttr("%s.%s_nr" % (attrControl, side),
"%s.w0" % oriCnst1[0])
mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst1[0])
mc.parent("%s_orig" % svl1, grp1)
grp5 = mc.group(em=True, n="%s_transform" % svl5, p=ntJnt4)
tempConst6 = mc.pointConstraint(ntJnt4, grp5, sk="x")
mc.delete(tempConst6)
oriCnst2 = mc.orientConstraint(ntJnt4, elbow[0], grp5, mo=True)
mc.connectAttr("%s.%s_nr" % (attrControl, side),
"%s.w0" % oriCnst2[0])
mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst2[0])
mc.parent("%s_orig" % svl5, grp5)
grp2 = mc.group(em=True, n="%s_transform" % svl2, p=ntJnt3)
tempConst7 = mc.pointConstraint(ntJnt3, grp2)
mc.delete(tempConst7)
oriCnst3 = mc.orientConstraint(ntJnt3, elbow[0], grp2, mo=True)
mc.connectAttr("%s.%s_nr" % (attrControl, side),
"%s.w0" % oriCnst3[0])
mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst3[0])
mc.parent("%s_orig" % svl2, grp2)
grp3 = mc.group(em=True, n="%s_transform" % svl3, p=ntJnt2)
tempConst8 = mc.pointConstraint(ntJnt2, grp3)
mc.delete(tempConst8)
oriCnst4 = mc.orientConstraint(ntJnt2, elbow[0], grp3, mo=True)
mc.connectAttr("%s.%s_nr" % (attrControl, side),
"%s.w0" % oriCnst4[0])
mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst4[0])
mc.parent("%s_orig" % svl3, grp3)
grp4 = mc.group(em=True, n="%s_transform" % svl4, p=ntJnt1)
tempConst9 = mc.pointConstraint(ntJnt1, grp4)
mc.delete(tempConst9)
oriCnst5 = mc.orientConstraint(ntJnt1, elbow[0], grp4, mo=True)
mc.connectAttr("%s.%s_nr" % (attrControl, side),
"%s.w0" % oriCnst5[0])
mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst5[0])
mc.parent("%s_orig" % svl4, grp4)
def createCtrlSys(crv,
rootCrv,
surface,
rootSurface,
name,
parameter=0.5,
iteration=1):
# Get surface shape
crv_shape = cmds.listRelatives(crv[0], type="shape")[0]
rootCrv_shape = cmds.listRelatives(rootCrv[0], type="shape")[0]
surface_shape = cmds.listRelatives(surface[0], type="shape")
rootSurface_shape = cmds.listRelatives(rootSurface[0], type="shape")
# create wire, cluster
wire = cmds.wire(surface,
gw=False,
en=1.0,
ce=0.0,
li=0.0,
dds=(0, 1000),
w=crv,
n=name + "_wire")[0]
newCluster = cmds.cluster(rootCrv[0] + '.cv[:]',
n="{}_{}_FreeSys_Crv_Clst".format(
name, iteration),
envelope=1)
# run dynamicClst script
cmds.select(rootCrv[0], r=1)
dynamicSys_data = tp_createDynamicClst()
cmds.select(cl=1)
# Get arc length
rootCrv_arcLength = cmds.arclen(rootCrv)
# Create control
ctrl_data = bd_buildCtrl(ctrl_type="sphere",
name="{}_{}".format(name, iteration),
sufix="_FreeSys_Ctrl",
offset=1)
# Create follicle on surface
follicle_data = createFollicle(inputSurface=rootSurface_shape,
name=name + '_FreeSys_Ctrl_Flc',
hide=0)
# Point constraint ctrl grp
cmds.pointConstraint(follicle_data[0],
ctrl_data[1],
offset=(0, 0, 0),
weight=1)
# Orient constroint ctrl
cmds.orientConstraint(follicle_data[0], ctrl_data[0], mo=1, weight=1)
# Create attributes on control - Division, Parameter, Twist, Interpotaion
cmds.addAttr(ctrl_data[0],
ln="customAttr",
nn="________",
at="enum",
en="Custom:",
keyable=True)
cmds.setAttr(ctrl_data[0] + ".customAttr", lock=1)
cmds.addAttr(ctrl_data[0],
ln="parameter",
nn="Parameter",
at="double",
min=0,
max=rootCrv_arcLength,
dv=(rootCrv_arcLength / 2),
keyable=True)
cmds.addAttr(ctrl_data[0],
ln="twist",
nn="Twist",
at="double",
min=-1000,
max=1000,
dv=0,
keyable=True)
cmds.addAttr(ctrl_data[0],
ln="interpolation",
nn="Interpolation",
at="long",
min=1,
max=6,
dv=4,
keyable=True)
cmds.connectAttr(ctrl_data[0] + ".interpolation",
dynamicSys_data[0] + ".interpolation")
# Create setRange for translate conversion 0 1
ctrl_setRange = cmds.shadingNode('setRange',
au=1,
n=name + '_ctrl_t_setRange')
cmds.setAttr(ctrl_setRange + '.max.maxX', 1)
cmds.setAttr(ctrl_setRange + '.oldMax.oldMaxX', rootCrv_arcLength)
cmds.connectAttr(ctrl_data[0] + '.parameter',
ctrl_setRange + '.value.valueX')
# Connect ctrl translate x to follicle uVlue
cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
follicle_data[1] + '.parameterU')
# Create set range for scale X, output max 0-1, control ramp falloff
scale_setRange = cmds.shadingNode('setRange',
au=1,
n=name + '_ctrl_scaleToFalloff_setRange')
cmds.setAttr(scale_setRange + '.oldMin.oldMinX', 0.2)
cmds.setAttr(scale_setRange + '.oldMax.oldMaxX', 5)
cmds.setAttr(scale_setRange + '.min.minX', 0.1)
cmds.setAttr(scale_setRange + '.max.maxX', 1)
cmds.connectAttr(ctrl_data[0] + '.scale.scaleX',
scale_setRange + '.value.valueX')
# Calcaulating start and end position
colorStart_mpDiv = cmds.shadingNode('multiplyDivide',
au=1,
n=name + '_scaleInvert_mpDivide')
colorStartEnd_plusMA = cmds.shadingNode('plusMinusAverage',
au=1,
n=name + '_falloffResult_plusMA')
# Invert Scale newRange value
cmds.setAttr(colorStart_mpDiv + '.input2.input2X', -1)
cmds.connectAttr(scale_setRange + '.outValue.outValueX',
colorStart_mpDiv + '.input1.input1X')
# Connect to plusMinusAvarege node
cmds.connectAttr(colorStart_mpDiv + '.output.outputX',
colorStartEnd_plusMA + '.input2D[0].input2Dx')
cmds.connectAttr(scale_setRange + '.outValue.outValueX',
colorStartEnd_plusMA + '.input2D[0].input2Dy')
cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
colorStartEnd_plusMA + '.input2D[1].input2Dx')
cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
colorStartEnd_plusMA + '.input2D[1].input2Dy')
# Create clamp setRange - Limiting calculation to 0 to 1
clamp_setRenge = cmds.shadingNode('setRange',
au=1,
n=name + '_resultClamp_setRange')
cmds.setAttr(clamp_setRenge + '.oldMax.oldMaxX', 1)
cmds.setAttr(clamp_setRenge + '.max.maxX', 1)
cmds.setAttr(clamp_setRenge + '.oldMax.oldMaxY', 1)
cmds.setAttr(clamp_setRenge + '.max.maxY', 1)
cmds.connectAttr(colorStartEnd_plusMA + '.output2D.output2Dx',
clamp_setRenge + '.value.valueX')
cmds.connectAttr(colorStartEnd_plusMA + '.output2D.output2Dy',
clamp_setRenge + '.value.valueY')
# Connect to ramp colors
# Connect and configure color 1 mid
cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
dynamicSys_data[0] + '.colorEntryList[0].position')
cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[0].color',
1,
1,
1,
type="double3")
# Connect and configure color 0 start
cmds.connectAttr(clamp_setRenge + '.outValue.outValueX',
dynamicSys_data[0] + '.colorEntryList[2].position')
cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[2].color',
0,
0,
0,
type="double3")
# Connect and configure color 2 end
cmds.connectAttr(clamp_setRenge + '.outValue.outValueY',
dynamicSys_data[0] + '.colorEntryList[1].position')
cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[1].color',
0,
0,
0,
type="double3")
# Connect ctrl to cluster
cmds.connectAttr(ctrl_data[0] + '.translate', newCluster[1] + '.translate')
# Create and connect dropoff locators
cmds.select("{}.u[{}]".format(crv[0], 0), r=True)
dropoffLoc1 = cmds.dropoffLocator(1.0, 1.0, wire)[0]
cmds.select("{}.u[{}]".format(crv[0], 0.1), r=True)
dropoffLoc2 = cmds.dropoffLocator(1.0, 1.0, wire)[0]
cmds.select("{}.u[{}]".format(crv[0], 0.2), r=True)
dropoffLoc3 = cmds.dropoffLocator(1.0, 1.0, wire)[0]
cmds.select(cl=1)
cmds.connectAttr(ctrl_data[0] + ".twist",
"{}.wireLocatorTwist[{}]".format(wire, 1))
cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
dropoffLoc2 + '.param')
cmds.connectAttr(clamp_setRenge + '.outValue.outValueX',
dropoffLoc1 + '.param')
cmds.connectAttr(clamp_setRenge + '.outValue.outValueY',
dropoffLoc3 + '.param')
lock_hide([ctrl_data[0]], [".rx", ".ry", ".rz"])
# Set control parameter of choice
ctrl_tergetPosition = rootCrv_arcLength * parameter
cmds.setAttr(ctrl_data[0] + '.parameter', ctrl_tergetPosition)
# Group everything or pass creations to master grouper
return newCluster[1], ctrl_data[1], follicle_data[0], ctrl_data[0]
def Spine_Create():
Scale_Guide = cmds.xform('Guide_Ctrl_Master', ws=True, q=True, s=True)[0]
rot_Guide_Pelvis = cmds.xform('Guide_Pelvis', ws=True, q=True, ro=True)
trans_Guide_Pelvis = cmds.xform('Guide_Pelvis', ws=True, q=True, t=True)
trans_Loc_End_Pelvis = cmds.xform('Loc_End_Pelvis',
ws=True,
q=True,
t=True)
trans_Guide_Spine_2 = cmds.xform('Guide_Spine_1', ws=True, q=True, t=True)
trans_Guide_Spine_3 = cmds.xform('Guide_Spine_2', ws=True, q=True, t=True)
trans_Guide_Spine_4 = cmds.xform('Guide_Spine_3', ws=True, q=True, t=True)
trans_Guide_Spine_5 = cmds.xform('Guide_Chest', ws=True, q=True, t=True)
#Joints_Spine#
Joint_Spine_1 = cmds.joint(p=trans_Guide_Pelvis,
n=('J_Spine_1'),
rad=.6 * Scale_Guide)
Joint_Spine_2 = cmds.joint(p=trans_Guide_Spine_2,
n=('J_Spine_2'),
rad=.6 * Scale_Guide)
Joint_Spine_3 = cmds.joint(p=trans_Guide_Spine_3,
n=('J_Spine_3'),
rad=.6 * Scale_Guide)
Joint_Spine_4 = cmds.joint(p=trans_Guide_Spine_4,
n=('J_Spine_4'),
rad=.6 * Scale_Guide)
Joint_Spine_5 = cmds.joint(p=trans_Guide_Spine_5,
n=('J_Spine_5'),
rad=.6 * Scale_Guide)
#OJ_Joints_Spine#
OJ_Joint_Spine_1 = cmds.joint(Joint_Spine_1,
e=True,
zso=True,
oj='yxz',
sao='xup')
OJ_Joint_Spine_2 = cmds.joint(Joint_Spine_2,
e=True,
zso=True,
oj='yxz',
sao='xup')
OJ_Joint_Spine_3 = cmds.joint(Joint_Spine_3,
e=True,
zso=True,
oj='yxz',
sao='xup')
OJ_Joint_Spine_4 = cmds.joint(Joint_Spine_4,
e=True,
zso=True,
oj='yxz',
sao='xup')
#JointOrient_Chest#
joX_Joint_Chest = cmds.setAttr("J_Spine_5.jointOrientX", 0)
joY_Joint_Chest = cmds.setAttr("J_Spine_5.jointOrientY", 0)
joZ_Joint_Chest = cmds.setAttr("J_Spine_5.jointOrientZ", 0)
rot_Joint_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, ro=True)
cmds.select(d=True)
#Create Ik Spline#
Select_Spine_1 = cmds.select(Joint_Spine_1, r=True)
Add_Select_Spine_5 = cmds.select(Joint_Spine_5, add=True)
IkHandle_Spine = cmds.ikHandle(n='IkSpline_Spine', sol='ikSplineSolver')
Rename_Cv = cmds.rename('curve1', 'CV_Spine_1')
cmds.select(d=True)
#Rot_Translate_J_Spine_4#
rot_J_Spine_4 = cmds.xform(Joint_Spine_4, ws=True, q=True, ro=True)
trans_J_Spine_4 = cmds.xform(Joint_Spine_4, ws=True, q=True, t=True)
emparentarTrans_J_Spine_4 = cmds.xform('P_M_SpineFK_01_CTL',
ws=True,
t=trans_J_Spine_4)
emparentarRot_J_Spine_4 = cmds.xform('P_M_SpineFK_01_CTL',
ws=True,
ro=rot_J_Spine_4)
#Grp_Offset_Spine#
rot_J_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, ro=True)
trans_J_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, t=True)
Grp_Z_J_Spine_1 = cmds.group(n='Z_J_Spine_1', em=True)
Grp_P_J_Spine_1 = cmds.group(n='P_J_Spine_1')
emparentarTrans = cmds.xform(Grp_P_J_Spine_1, ws=True, t=trans_J_Spine_1)
emparentarRot = cmds.xform(Grp_P_J_Spine_1, ws=True, ro=rot_J_Spine_1)
P_J_Pelvis_Z_J_Pelvis = cmds.parent('J_Spine_1', 'Z_J_Spine_1')
cmds.select(d=True)
#Pelvis#
translate_Guide_Pelvis = cmds.xform('Guide_Pelvis',
ws=True,
q=True,
t=True)
rot_Guide_Pelvis = cmds.xform('Guide_Pelvis', ws=True, q=True, ro=True)
J_Pelvis = cmds.joint(n=('J_Pelvis'), rad=.7 * Scale_Guide)
Z_J_Pelvis = cmds.group(n=("Z_J_Pelvis"))
emparentarTrans_J_Pelvis = cmds.xform(Z_J_Pelvis,
ws=True,
t=translate_Guide_Pelvis)
emparentarRot_J_Pelvis = cmds.xform(Z_J_Pelvis,
ws=True,
ro=rot_Guide_Pelvis)
J_End_Pelvis = cmds.joint(p=trans_Loc_End_Pelvis,
n=('J_End_Pelvis'),
rad=.5 * Scale_Guide)
cmds.parent('J_End_Pelvis', 'J_Pelvis')
#M_Pelvis_CTL#
Position_Ctrl_Pelvis = cmds.xform("P_M_Pelvis_CTL",
ws=True,
t=trans_J_Spine_1)
Parent_Constraint_Chest = cmds.parentConstraint('M_Pelvis_CTL',
'J_Pelvis',
mo=True)
cmds.select(d=True)
#COG#
J_COG = cmds.joint(n=('J_COG'), rad=1 * Scale_Guide)
Grp_J_COG = cmds.group(n='Z_J_COG')
emparentarTrans_J_Pelvis = cmds.xform(Grp_J_COG,
ws=True,
t=translate_Guide_Pelvis)
emparentarRot_J_Pelvis = cmds.xform(Grp_J_COG,
ws=True,
ro=rot_Guide_Pelvis)
#M_Cog_CTL#
Position_Ctrl_Pelvis = cmds.xform("P_M_Cog_CTL",
ws=True,
t=trans_J_Spine_1)
Parent_Constraint_Chest = cmds.parentConstraint('M_Cog_CTL',
'J_COG',
mo=True)
cmds.select(d=True)
#Create Joints_CV_Spine
trans_CV_Ctrl_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, t=True)
rot_CV_Ctrl_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, ro=True)
J_CV_Ctrl_Spine_1 = cmds.joint(n=('J_Ctrl_Spine_1'))
ZJ_CV_Ctrl_Spine_1 = cmds.group(n=("Z_J_Ctrl_Spine_1"))
emp_trans_CV_Ctrl_Spine_1 = cmds.xform(ZJ_CV_Ctrl_Spine_1,
ws=True,
t=trans_CV_Ctrl_Spine_1)
emp_rot_CV_Ctrl_Spine_1 = cmds.xform(ZJ_CV_Ctrl_Spine_1,
ws=True,
ro=rot_CV_Ctrl_Spine_1)
cmds.select(d=True)
#CV_Spine_Mid#
trans_CV_Ctrl_Spine_Mid = cmds.xform('J_Spine_3', ws=True, q=True, t=True)
rot_CV_Ctrl_Spine_Mid = cmds.xform('J_Spine_3', ws=True, q=True, ro=True)
J_CV_Ctrl_Spine_Mid = cmds.joint(n=('J_Ctrl_Spine_Mid'))
ZJ_CV_Ctrl_Spine_Mid = cmds.group(n=("Z_J_Ctrl_Spine_Mid"))
emp_trans_J_Spine_2 = cmds.xform(ZJ_CV_Ctrl_Spine_Mid,
ws=True,
t=trans_CV_Ctrl_Spine_Mid)
emp_rot_J_Spine_2 = cmds.xform(ZJ_CV_Ctrl_Spine_Mid,
ws=True,
ro=rot_CV_Ctrl_Spine_Mid)
cmds.select(d=True)
#CV_Spine_Chest#
trans_CV_Ctrl_Spine_Chest = cmds.xform('J_Spine_5',
ws=True,
q=True,
t=True)
rot_CV_Ctrl_Spine_Chest = cmds.xform('J_Spine_5', ws=True, q=True, ro=True)
J_CV_Ctrl_Spine_Chest = cmds.joint(n=('J_Ctrl_Spine_Chest'))
ZJ_CV_Ctrl_Spine_Chest = cmds.group(n=("Z_J_Ctrl_Spine_Chest"))
emp_trans_J_Spine_3 = cmds.xform(ZJ_CV_Ctrl_Spine_Chest,
ws=True,
t=trans_CV_Ctrl_Spine_Chest)
emp_rot_J_Spine_2 = cmds.xform(ZJ_CV_Ctrl_Spine_Chest,
ws=True,
ro=rot_CV_Ctrl_Spine_Chest)
cmds.select(d=True)
#SKIN_CV
Select_Joints_CV_1 = cmds.select(J_CV_Ctrl_Spine_1, r=True)
Select_Joints_CV_3 = cmds.select(J_CV_Ctrl_Spine_Mid, add=True)
Select_Joints_CV_5 = cmds.select(J_CV_Ctrl_Spine_Chest, add=True)
Seelct_CV = cmds.select('CV_Spine_1', add=True)
Skin_CV = cmds.skinCluster('J_Ctrl_Spine_1',
'J_Ctrl_Spine_Mid',
'J_Ctrl_Spine_Chest',
'CV_Spine_1',
dr=4)[0]
#M_SpineFK_00_CTL#
translate = cmds.xform('J_Spine_2', ws=True, q=True, t=True)
rot = cmds.xform('J_Spine_2', ws=True, q=True, ro=True)
Position = cmds.xform('P_M_SpineFK_00_CTL', ws=True, t=translate)
Rotation = cmds.xform('P_M_SpineFK_00_CTL', ws=True, ro=rot)
#SpineMidAJUSTE#
translateCtrl_Spine_Mid = cmds.xform('J_Ctrl_Spine_Mid',
ws=True,
q=True,
t=True)
rotCtrl_Spine_Mid = cmds.xform('J_Ctrl_Spine_Mid',
ws=True,
q=True,
ro=True)
Position = cmds.xform('P_M_SpineAdj_CTL',
ws=True,
t=translateCtrl_Spine_Mid)
Rotation = cmds.xform('P_M_SpineAdj_CTL', ws=True, ro=rotCtrl_Spine_Mid)
cmds.select(d=True)
#Create_J_Chest#
trans_Guide_Chest = cmds.xform('Guide_Chest', ws=True, q=True, t=True)
rot_Guide_Chest = cmds.xform('Guide_Chest', ws=True, q=True, ro=True)
Joint_Chest = cmds.joint(n=('J_Chest'), rad=1 * Scale_Guide)
Grp_J_Chest = cmds.group(n='Z_J_Chest')
emparentarTrans_J_Chest = cmds.xform(Grp_J_Chest,
ws=True,
t=trans_Guide_Chest)
emparentarRot_J_Chest = cmds.xform(Grp_J_Chest,
ws=True,
ro=rot_Guide_Chest)
#M_Chest_CTL#
translate_J_Chest = cmds.xform('Z_J_Chest', ws=True, q=True, t=True)
rotate_J_Chest = cmds.xform('Z_J_Chest', ws=True, q=True, ro=True)
Position_Chest = cmds.xform("P_M_Chest_CTL", ws=True, t=translate_J_Chest)
Orientation_Chest = cmds.xform("P_M_Chest_CTL", ws=True, ro=rotate_J_Chest)
Parent_Constraint_Chest = cmds.parentConstraint('M_Chest_CTL',
'J_Chest',
mo=True)
#Constraints#
Orient_J_Ctrl_Spine_1_Ctrl_Spine_1 = cmds.orientConstraint(
'M_SpineFK_00_CTL', ZJ_CV_Ctrl_Spine_1, mo=True)
Parent_J_Ctrl_Spine_Mid_Ctrl_Spine_Mid = cmds.parentConstraint(
'M_SpineAdj_CTL', J_CV_Ctrl_Spine_Mid, mo=True)
Parent_J_Ctrl_Spine_Chest_Ctrl_Spine_Chest = cmds.parentConstraint(
"M_Chest_CTL", J_CV_Ctrl_Spine_Chest, mo=True)
Point_Ctrl_Pelvis_J_CV_Ctrl_Spine_1 = cmds.pointConstraint(
'M_Pelvis_CTL', J_CV_Ctrl_Spine_1)
#Herarchy_Spine#
Parent_Ctrl_Spine_Mid_Ctrl_Spine_Mid2 = cmds.parent(
"P_M_SpineFK_01_CTL", "M_SpineFK_00_CTL")
Parent_Ctrl_Spine_Fk_2_Ctrl_Chest = cmds.parent("P_M_Chest_CTL",
"M_SpineFK_01_CTL")
#Squash_Stretch#
#Arclen#
Cv_Info = cmds.arclen('CV_Spine_1', ch=True)
Valor = cmds.getAttr('curveInfo1.arcLength')
#MultiplyDivide_Stretch#
NodeMultiplyDivide_Stretch_Spine = cmds.shadingNode('multiplyDivide',
au=True,
n="MD_Stretch_Spine")
Operation_NodeMultiplyDivide_Stretch_Spine = cmds.setAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".operation", 2)
Set_Input2X_MD_Stretch = cmds.setAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".input2X", Valor)
#MultiplyDivide_MASS_LOSS#
NodeMultiplyDivide_MASS_LOSS_Spine = cmds.shadingNode(
'multiplyDivide', au=True, n="MD_MASS_LOSS_Spine")
Operation_NodeMultiplyDivide_MASS_LOSS_Spine = cmds.setAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".operation", 2)
Set_Input2X_MD_MASS_LOSS = cmds.setAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".input1X", Valor)
#Average_Spine_Mass_Loss#
NodeplusMinusAverage = cmds.shadingNode('plusMinusAverage',
au=True,
n='AV_Spine_Mass_Loss')
Set_Operation_Average = cmds.setAttr(NodeplusMinusAverage + ".operation",
3)
#Conect Arclen_MD_STRETCH#
ConectArclen_MD_Stretch = cmds.connectAttr(
(Cv_Info) + ".arcLength",
(NodeMultiplyDivide_Stretch_Spine) + ".input1X")
#Conect Arclen_MASS_LOSS_STRETCH#
ConectArclen_MD_MASS_LOSS = cmds.connectAttr(
(Cv_Info) + ".arcLength",
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".input2X")
#Conect_MD_Stretch_Joints#
Conect_MD_Stretch_J1 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_1.scaleY")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_2.scaleY")
Conect_MD_Stretch_J3 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_3.scaleY")
Conect_MD_Stretch_J4 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_4.scaleY")
#Conect_MD_MASS_LOSS_Joints#
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_2.scaleX")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_2.scaleZ")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_3.scaleX")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_3.scaleZ")
Connect_MD_MASS_LOSS_AV_0_Spine = cmds.connectAttr(
NodeMultiplyDivide_MASS_LOSS_Spine + '.outputX',
NodeplusMinusAverage + '.input3D[0].input3Dx',
f=True)
Connect_MD_MASS_LOSS_AV_1_Spine = cmds.connectAttr(
NodeMultiplyDivide_MASS_LOSS_Spine + '.outputX',
NodeplusMinusAverage + '.input3D[1].input3Dx',
f=True)
Disconnect_MD_AV = cmds.disconnectAttr(
NodeMultiplyDivide_MASS_LOSS_Spine + '.outputX',
NodeplusMinusAverage + '.input3D[1].input3Dx')
Connect_AV_J_Spine_1_X = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_1.scaleX',
f=True)
Connect_AV_J_Spine_1_Z = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_1.scaleZ',
f=True)
Connect_AV_J_Spine_4_X = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_4.scaleX',
f=True)
Connect_AV_J_Spine_4_Z = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_4.scaleZ',
f=True)
##Herarchy_Ctrl_Clavicle_L_Ctrl_Chest
Parent_Ctrl_Clavicle_L_Ctrl_Chest = cmds.parent("P_L_Clavicle_CTL",
"M_Chest_CTL")
##Herarchy_Ctrl_Clavicle_R_Ctrl_Chest
Parent_Ctrl_Clavicle_R_Ctrl_Chest = cmds.parent("P_R_Clavicle_CTL",
"M_Chest_CTL")
#Grp_HiddenSpine
Grp_Hidden_Spine = cmds.group(em=True, name='Hidden_Spine')
Parent_CV_Spine_Group = cmds.parent('CV_Spine_1', 'Hidden_Spine')
Parent_Ik_Spline_Spine_Group = cmds.parent('IkSpline_Spine',
'Hidden_Spine')
Hidde_IK_Handle_Arm_L = cmds.hide(Grp_Hidden_Spine)
cmds.select(d=True)
#Loc_Follow_Spine_Mid
Loc_Follow_Spine_Mid = cmds.spaceLocator(n='Loc_Follow_Spine_Mid',
p=(0, 0, 0))
Grp_Loc_Follow_Spine_Mid = cmds.group(n='Z_Loc_Follow_Spine_Mid')
ZGrp_Loc_Follow_Spine_Mid = cmds.group(n='P_Loc_Follow_Spine_Mid')
cmds.select(d=True)
#Loc_Follow_Spine_Pelvis
Loc_Follow_Spine_Pelvis = cmds.spaceLocator(n='Loc_Follow_Spine_Pelvis',
p=(0, 0, 0))
Grp_Loc_Follow_Spine_Pelvis = cmds.group(n='Z_Loc_Follow_Spine_Pelvis')
ZGrp_Loc_Follow_Spine_Pelvis = cmds.group(n='P_Loc_Follow_Spine_Pelvis')
Position_Loc_Follow_Spine_Pelvis = cmds.xform(ZGrp_Loc_Follow_Spine_Pelvis,
ws=True,
t=translate_Guide_Pelvis)
Rotation_Loc_Follow_Spine_Pelvis = cmds.xform(ZGrp_Loc_Follow_Spine_Pelvis,
ws=True,
ro=rot_Guide_Pelvis)
cmds.select(d=True)
#Loc_Follow_Spine_Chest
Loc_Follow_Spine_Chest = cmds.spaceLocator(n='Loc_Follow_Spine_Chest',
p=(0, 0, 0))
Grp_Loc_Follow_Spine_Chest = cmds.group(n='Z_Loc_Follow_Spine_Chest')
ZGrp_Loc_Follow_Spine_Chest = cmds.group(n='P_Loc_Follow_Spine_Chest')
Position_Loc_Follow_Spine_Chest = cmds.xform(ZGrp_Loc_Follow_Spine_Chest,
ws=True,
t=translate_J_Chest)
Rotation_Loc_Follow_Spine_Chest = cmds.xform(ZGrp_Loc_Follow_Spine_Chest,
ws=True,
ro=rotate_J_Chest)
cmds.select(d=True)
Position_Loc_Follow_Spine_Mid = cmds.xform(ZGrp_Loc_Follow_Spine_Mid,
ws=True,
t=translateCtrl_Spine_Mid)
Rotation_Loc_Follow_Spine_Mid = cmds.xform(ZGrp_Loc_Follow_Spine_Mid,
ws=True,
ro=rotCtrl_Spine_Mid)
NodeBColors_Follow_Ctrl_Spine_Mid = cmds.shadingNode(
'blendColors', au=True, n='BC_Follow_Ctrl_Spine_Mid')
Connect_Pelvis_BC_Follow_Spine = cmds.connectAttr(
'M_Pelvis_CTL.translate',
NodeBColors_Follow_Ctrl_Spine_Mid + '.color1')
Connect_Chest_BC_Follow_Spine = cmds.connectAttr(
'M_Chest_CTL.translate', NodeBColors_Follow_Ctrl_Spine_Mid + '.color2')
Connect_BC_Follow_Spine_Loc_Follow = cmds.connectAttr(
NodeBColors_Follow_Ctrl_Spine_Mid + '.output',
'Loc_Follow_Spine_Mid.translate')
Aim_Cons_Pelvis_Loc_Follow_Spine = cmds.aimConstraint(
'Loc_Follow_Spine_Chest',
'Loc_Follow_Spine_Pelvis',
w=1,
aim=(0, 1, 0),
u=(0, 1, 0),
wut="objectrotation",
wu=(1, 0, 0),
wuo=('Loc_Follow_Spine_Chest'),
mo=True)
Connect_Ctrl_Chest_Loc_Follow_Spine_Chest = cmds.connectAttr(
'M_Chest_CTL' + '.translate', 'Loc_Follow_Spine_Chest.translate')
Connect_Ctrl_Pelvis_Loc_Follow_Spine_Pelvis = cmds.connectAttr(
'M_Pelvis_CTL' + '.translate', 'Loc_Follow_Spine_Pelvis.translate')
Connect_Loc_Follow_Spine_Z_Ctrl_Spine_Ajuste_Rot = cmds.connectAttr(
'Loc_Follow_Spine_Pelvis' + '.rotate', 'Loc_Follow_Spine_Mid.rotate')
Connect_Loc_Follow_Spine_Z_Ctrl_Spine_Ajuste_Trans = cmds.connectAttr(
'Loc_Follow_Spine_Mid' + '.translate', 'Z_M_SpineAdj_CTL.translate')
Connect_Loc_Follow_Spine_Z_Ctrl_Spine_Ajuste_Rot = cmds.connectAttr(
'Loc_Follow_Spine_Mid' + '.rotate', 'Z_M_SpineAdj_CTL.rotate')
ParentCons_Ctrl_Spine_Fk_2_Ctrl_Spine_Ajuste = cmds.parentConstraint(
'M_SpineFK_01_CTL', 'P_M_SpineAdj_CTL', mo=True)
ParentCons_Ctrl_Spine_Mid_Ctrl_Spine_Ajuste = cmds.parentConstraint(
'M_SpineFK_00_CTL', 'P_M_SpineAdj_CTL', mo=True)
Herarchy_P_Loc_Follow_Spine_Mid_Ctrl_COG = cmds.parent(
ZGrp_Loc_Follow_Spine_Mid, 'M_Cog_CTL')
Herarchy_P_Loc_Follow_Spine_Pelvis_Ctrl_COG = cmds.parent(
ZGrp_Loc_Follow_Spine_Pelvis, 'M_Cog_CTL')
Herarchy_P_Loc_Follow_Spine_Chest_Ctrl_COG = cmds.parent(
ZGrp_Loc_Follow_Spine_Chest, 'M_Cog_CTL')
#Herarchy_COG_Pelvis_Spine#
Herarchy_Pelvis_COG = cmds.parent('Z_J_Pelvis', 'J_COG')
Herarchy_P_Ctrl_Pelvis_Ctrl_COG = cmds.parent('P_M_Pelvis_CTL',
'M_Cog_CTL')
Herarchy_P_Ctrl_Spine_Fk_1_Ctrl_COG = cmds.parent('P_M_SpineFK_00_CTL',
'M_Cog_CTL')
#TwistSpine#
Set_Enable_Twist_Control = cmds.setAttr(
"IkSpline_Spine.dTwistControlEnable", 1)
Set_WorldUpType = cmds.setAttr("IkSpline_Spine.dWorldUpType", 4)
Set_FowardAxis = cmds.setAttr("IkSpline_Spine.dForwardAxis", 2)
Set_WorldUpAxis = cmds.setAttr("IkSpline_Spine.dWorldUpAxis", 3)
Set_WorldUpVectorY_0 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorY", 0)
Set_WorldUpVectorEndY_0 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorEndY",
0)
Set_WorldUpVectorZ_1 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorZ", 1)
Set_WorldUpVectorEndZ_1 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorEndZ",
1)
Connect_World_Matrix_World_Up_Matrix = cmds.connectAttr(
'M_Pelvis_CTL.worldMatrix[0]', 'IkSpline_Spine.dWorldUpMatrix', f=True)
Connect_World_Matrix_World_Up_MatrixEnd = cmds.connectAttr(
'M_Chest_CTL.worldMatrix[0]',
'IkSpline_Spine.dWorldUpMatrixEnd',
f=True)
cmds.select(d=True)
#Neck#
rot_Guide_Neck = cmds.xform('Guide_Neck', ws=True, q=True, ro=True)
trans_Guide_Neck = cmds.xform('Guide_Neck', ws=True, q=True, t=True)
J_Neck = cmds.joint(p=trans_Guide_Neck, n=('J_Neck'), rad=.6 * Scale_Guide)
Grp_J_Neck = cmds.group(n='Z_J_Neck')
cmds.select(d=True)
#Head#
rot_Guide_Head = cmds.xform('Guide_Head', ws=True, q=True, ro=True)
trans_Guide_Head = cmds.xform('Guide_Head', ws=True, q=True, t=True)
J_Head = cmds.joint(p=trans_Guide_Head, n=('J_Head'), rad=.6 * Scale_Guide)
Grp_J_Head = cmds.group(n='Z_J_Head')
cmds.select(d=True)
#M_Head_CTL#
Position_Ctrl_Head = cmds.xform("P_M_Head_CTL",
ws=True,
t=trans_Guide_Head)
Rotate_Ctrl_Head = cmds.xform("P_M_Head_CTL", ws=True, ro=rot_Guide_Head)
Parent_Constraint_Chest = cmds.parentConstraint('M_Head_CTL',
'J_Head',
mo=True)
#M_Neck_CTL#
Position_Ctrl_Neck = cmds.xform("P_M_Neck_CTL",
ws=True,
t=trans_Guide_Neck)
Rotate_Ctrl_Neck = cmds.xform("P_M_Neck_CTL", ws=True, ro=rot_Guide_Neck)
Parent_Constraint_Chest = cmds.parentConstraint('M_Neck_CTL',
'J_Neck',
mo=True)
#Herarchy_Joints#
Grp_J_Head_J_Neck = cmds.parent(Grp_J_Head, J_Neck)
Grp_J_Neck_J_Chest = cmds.parent(Grp_J_Neck, Joint_Chest)
#Herarchy_Ctrls#
Grp_Ctrl_Head_Ctrl_Neck = cmds.parent('P_M_Head_CTL', 'M_Neck_CTL')
Grp_Ctrl_Neck_Ctrl_Chest = cmds.parent('P_M_Neck_CTL', 'M_Chest_CTL')
cmds.select(d=True)
cmds.rename('curveInfo1', 'Cv_Info_Spine')
def build(self):
'''
'''
super(Spine, self).build()
# store the joint list
jointList = eval(self.jointList)
# initialize the spline class
scaleFactor = self.getAttributeByName('scaleFactor').getValue()
self.spline = spline.SplineBase(jointList=jointList +
[self._chestBind],
splineName=self._splineName,
scaleFactor=scaleFactor)
# create the spline
self.spline.create()
# get the name of the curveInfo node. This is hard coded to be this way in the
# spline code. If that changes, this will not work. We can change the code below
# to use the API to get the length of the curve instead of this node, but for now, this
# is quicker because it's available already.
spineCurveInfo = self._splineName + "_curveInfo"
# get the attributes from the user
geometry = self.getAttributeByName("geometry").getValue()
bendyCurve = self.getAttributeByName("bendyCurve").getValue()
createBendySpline = self.getAttributeByName(
"createBendySpline").getValue()
hipSwivelPivotValue = self.getAttributeByName(
"hipSwivelPivot").getValue()
chestPivotValue = self.getAttributeByName("chestPivot").getValue()
# Hips
hipMatrix = mc.xform(self._hipsBind, q=True, ws=True, matrix=True)
hipsPivotNul, hipsPivotCtrl = control.create(
name="hipsPivot",
controlType="cube",
hideAttrs=["sx", "sy", "sz", "v"],
hierarchy=['nul'],
color=rigrepo.libs.common.RED)
# create the grp that we will use to move the pivot of the hips
movablePivotGrp = mc.createNode("transform",
name="{}_grp".format(hipsPivotCtrl))
mc.xform(hipsPivotNul, ws=True, matrix=hipMatrix)
mc.xform(movablePivotGrp, ws=True, matrix=hipMatrix)
mc.parent(movablePivotGrp, hipsPivotNul)
# connect the movable pivot control to the grp
mc.connectAttr("{}.t".format(hipsPivotCtrl),
"{}.rotatePivot".format(movablePivotGrp),
f=True)
mc.connectAttr("{}.r".format(hipsPivotCtrl),
"{}.r".format(movablePivotGrp),
f=True)
hipsCtrlHierarchy = control.create(name="hips",
controlType="cube",
hideAttrs=["sx", "sy", "sz", "v"],
hierarchy=['nul'])
hipsCtrl = hipsCtrlHierarchy[-1]
hipsNul = hipsCtrlHierarchy[0]
rigrepo.libs.attribute.lockAndHide(hipsCtrl, ["sx", "sy", "sz", "v"])
mc.xform(hipsNul, ws=True, matrix=hipMatrix)
hipsGimbalCtrlHierarchy = control.create(
name="hips_gimbal",
controlType="cube",
hierarchy=['nul'],
hideAttrs=["sx", "sy", "sz", "v"],
parent=hipsCtrl)
hipsGimbalCtrl = hipsGimbalCtrlHierarchy[-1]
hipsGimbalNul = hipsGimbalCtrlHierarchy[0]
rigrepo.libs.attribute.lockAndHide(hipsGimbalCtrl,
["sx", "sy", "sz", "v"])
mc.xform(hipsGimbalNul, ws=True, matrix=hipMatrix)
# hip swivel
ctrlHierarchy = control.create(name="hip_swivel",
controlType="cube",
color=common.GREEN,
hideAttrs=["sx", "sy", "sz", "v"],
hierarchy=['nul'])
hipSwivelCtrl = ctrlHierarchy[-1]
hipSwivelNul = ctrlHierarchy[0]
rigrepo.libs.attribute.lockAndHide(hipSwivelCtrl,
["sx", "sy", "sz", "v"])
mc.xform(hipSwivelNul, ws=True, matrix=hipMatrix)
averagePos = rigrepo.libs.transform.getAveragePosition([jointList[0]])
mc.xform(hipSwivelNul,
ws=True,
t=mc.xform(jointList[0], q=True, ws=True, t=True))
mc.parent(hipSwivelNul, hipsGimbalCtrl)
clusters = self.spline._clusters
# create a group that is driven by the ctrl
hipSwivelGrp = mc.createNode("transform", n="hips_swivel_grp")
# move the group into the same matrix as the control
mc.xform(hipSwivelGrp,
ws=True,
matrix=mc.xform(hipSwivelCtrl, q=True, ws=True, matrix=True))
# parent the group into the same space as the control
mc.parent(hipSwivelGrp, hipSwivelCtrl)
mc.parent(clusters[0:2], hipSwivelGrp)
mc.orientConstraint(hipSwivelGrp, self.spline._startTwistNul, mo=1)
# Parent the entire ik group to the hips
mc.parent(self.spline.getGroup(), hipsGimbalCtrl)
# torso
ctrlHierarchy = control.create(name="torso",
controlType="cube",
hideAttrs=["sx", "sy", "sz", "v"],
hierarchy=['nul'])
torsoCtrl = ctrlHierarchy[-1]
torsoNul = ctrlHierarchy[0]
rigrepo.libs.attribute.lockAndHide(torsoCtrl, ["sx", "sy", "sz", "v"])
rotation = mc.xform(hipsCtrl, q=True, ws=True, rotation=True)
averagePos = rigrepo.libs.transform.getAveragePosition(jointList[:2])
mc.xform(torsoNul, ws=True, rotation=rotation)
mc.xform(torsoNul, ws=True, t=averagePos)
mc.parent(torsoNul, hipsGimbalCtrl)
# chest
ctrlHierarchy = control.create(name="chest",
controlType="cube",
color=common.GREEN,
hideAttrs=["sx", "sy", "sz", "v"],
hierarchy=['nul'])
chestCtrl = ctrlHierarchy[-1]
chestNul = ctrlHierarchy[0]
rigrepo.libs.attribute.lockAndHide(chestCtrl, ["sx", "sy", "sz", "v"])
matrix = mc.xform(self._chestBind, q=True, ws=True, matrix=True)
mc.xform(chestNul, ws=True, matrix=matrix)
mc.parent(chestNul, torsoCtrl)
# chest IK
ctrlHierarchy = control.create(name="chest_ik",
controlType="cube",
color=common.GREEN,
hideAttrs=["sx", "sy", "sz", "v"],
hierarchy=['nul'])
chestIkCtrl = ctrlHierarchy[-1]
chestIkNul = ctrlHierarchy[0]
rigrepo.libs.attribute.lockAndHide(chestIkCtrl,
["sx", "sy", "sz", "v"])
mc.xform(chestIkNul, ws=True, matrix=matrix)
mc.parent(chestIkNul, chestCtrl)
# connect the rotate pivots so the pivots for these two controls are in the same location.
mc.connectAttr("{}.rp".format(chestCtrl),
"{}.rp".format(chestIkCtrl),
f=True)
# chest top
ctrlHierarchy = control.create(name="chest_top",
controlType="cube",
hideAttrs=["sx", "sy", "sz", "v"],
hierarchy=['nul'])
chestTopCtrl = ctrlHierarchy[-1]
chestTopNul = ctrlHierarchy[0]
rigrepo.libs.attribute.lockAndHide(chestTopCtrl,
["sx", "sy", "sz", "v"])
mc.xform(chestTopNul, ws=True, matrix=matrix)
mc.parent(chestTopNul, chestIkCtrl)
mc.parent(clusters[2:], chestIkCtrl)
chestTopGrp = mc.createNode("transform", name="chest_top_grp")
mc.xform(chestTopGrp, ws=True, matrix=matrix)
mc.parent(chestTopGrp, chestTopCtrl)
mc.orientConstraint(chestTopGrp, self.spline._endTwistNul, mo=1)
# ==========================================================================================
# chest pivot
# create pivot attributes to use for moving the pivot and tangent heights.
mc.addAttr(chestCtrl,
ln="pivotHeight",
at="double",
dv=0,
min=0,
max=10,
keyable=True)
mc.setAttr("{}.pivotHeight".format(chestCtrl), chestPivotValue)
# create the remap node to use to remap the pivot height to the lenght of the curve
chestRemapNode = mc.createNode("remapValue", n="chest_pivot_remap")
# map the 0-10 to the length of the curve on the spine
curveLength = mc.getAttr("{}.arcLength".format(spineCurveInfo))
# set the max output value for the remap to be the length of the curve
mc.setAttr("{}.outputMax".format(chestRemapNode), curveLength)
# set the input max
mc.setAttr("{}.inputMax".format(chestRemapNode), 10)
# connect the slider for pivot to the input max
mc.connectAttr("{}.pivotHeight".format(chestCtrl),
"{}.inputValue".format(chestRemapNode),
f=True)
# get the aim axis
chestPivotNulGrp = mc.createNode("transform",
name="chestPivot_aim_nul")
chestPivotAimGrp = mc.createNode("transform",
name="chestPivot_aim_grp")
chestPivotDriver = mc.createNode("transform",
name="chestPivot_aim_drv")
mc.parent(chestPivotAimGrp, chestPivotNulGrp)
mc.parent(chestPivotNulGrp, chestCtrl)
mc.parent(chestPivotDriver, chestPivotAimGrp)
mc.xform(chestPivotNulGrp, ws=True, matrix=matrix)
mc.xform(chestPivotDriver, ws=True, matrix=hipMatrix)
aimAxis, aimVector = self._getDistanceVector(
mc.getAttr('{}.t'.format(chestPivotDriver))[0])
mc.parent(chestPivotNulGrp, chestNul)
# move the transform back to the skull
mc.xform(chestPivotDriver, ws=True, matrix=matrix)
mc.xform(chestPivotNulGrp,
ws=True,
t=mc.xform(chestNul, q=True, ws=True, t=True))
mc.orientConstraint(chestNul, chestPivotNulGrp)
mc.parent(chestPivotDriver, chestNul)
mc.pointConstraint(chestPivotAimGrp, chestPivotDriver)
mc.orientConstraint(chestPivotAimGrp, chestPivotDriver)
if '-' in aimAxis:
chestCtrlPivotMdl = mc.createNode('multDoubleLinear',
n='chest_pivot_mdl')
mc.connectAttr('{}.outValue'.format(chestRemapNode),
'{}.input1'.format(chestCtrlPivotMdl),
f=True)
mc.setAttr('{}.input2'.format(chestCtrlPivotMdl), -1)
mc.connectAttr('{}.output'.format(chestCtrlPivotMdl),
'{}.t{}'.format(chestPivotAimGrp,
aimAxis.strip('-')),
f=True)
mc.connectAttr('{}.t'.format(chestPivotDriver),
'{}.rotatePivot'.format(chestCtrl),
f=True)
else:
mc.connectAttr('{}.outValue'.format(chestRemapNode),
'{}.t{}'.format(chestPivotAimGrp, aimAxis),
f=True)
mc.connectAttr('{}.t'.format(chestPivotDriver),
'{}.rotatePivot'.format(chestCtrl),
f=True)
# ==========================================================================================
# hip swivel pivot
# create pivot attributes to use for moving the pivot and tangent heights.
mc.addAttr(hipSwivelCtrl,
ln="pivotHeight",
at="double",
dv=0,
min=0,
max=10,
keyable=False)
mc.setAttr("{}.pivotHeight".format(hipSwivelCtrl), hipSwivelPivotValue)
# create the remap node to use to remap the pivot height to the lenght of the curve
hipSwivelRemapNode = mc.createNode("remapValue",
n="hipSwivel_pivot_remap")
# set the max output value for the remap to be the length of the curve
mc.setAttr("{}.outputMax".format(hipSwivelRemapNode), curveLength)
# set the input max
mc.setAttr("{}.inputMax".format(hipSwivelRemapNode), 10)
# connect the slider for pivot to the input max
mc.connectAttr("{}.pivotHeight".format(hipSwivelCtrl),
"{}.inputValue".format(hipSwivelRemapNode),
f=True)
# get the aim axis
tempNode = mc.createNode("transform", name="temp")
mc.parent(tempNode, hipSwivelGrp)
mc.xform(tempNode, ws=True, matrix=matrix)
aimAxis, aimVector = self._getDistanceVector(
mc.getAttr('{}.t'.format(tempNode))[0])
mc.delete(tempNode)
if '-' in aimAxis:
hipSwivelPivotMdl = mc.createNode('multDoubleLinear',
n='hipSwivel_pivot_pma')
mc.connectAttr("{}.outValue".format(hipSwivelRemapNode),
'{}.input1'.format(hipSwivelPivotMdl),
f=True)
mc.setAttr('{}.input2'.format(hipSwivelPivotMdl), -1)
mc.connectAttr('{}.output'.format(hipSwivelPivotMdl),
'{}.rotatePivot{}'.format(
hipSwivelCtrl,
aimAxis.strip('-').capitalize()),
f=True)
else:
mc.connectAttr("{}.outValue".format(hipSwivelRemapNode),
'{}.rotatePivot{}'.format(hipSwivelCtrl,
aimAxis.capitalize()),
f=True)
self._hipsCtrl = hipsCtrl
self._hipSwivelCtrl = hipSwivelCtrl
self._torsoCtrl = torsoCtrl
self._chestCtrl = chestCtrl
self._chestTopCtrl = chestTopCtrl
self._chestIkCtrl = chestIkCtrl
# Remove existing constraint on chestBind
orientConstraint = mc.orientConstraint(self._chestBind, q=1)
pointConstraint = mc.pointConstraint(self._chestBind, q=1)
if orientConstraint:
mc.delete(orientConstraint)
if pointConstraint:
mc.delete(pointConstraint)
mc.pointConstraint(chestTopGrp, self._chestBind, mo=1)
mc.orientConstraint(chestTopGrp, self._chestBind, mo=1)
#mc.connectAttr(chestTopCtrl+'.s', self._chestBind+'.s')
mc.parentConstraint(hipSwivelGrp, self._hipsBind, mo=1)
mc.connectAttr(hipSwivelGrp + '.s', self._hipsBind + '.s')
mc.parent(hipsPivotNul, self.name)
mc.parent(hipsNul, movablePivotGrp)
mc.hide(self.spline._group, clusters)
if createBendySpline and mc.objExists(bendyCurve):
bindmeshGeometry, follicleList, controlHieracrchyList, bendJointList = self.__buildCurveRig(
bendyCurve,
name='{}_bend'.format(self.getName()),
parent=self.name)
if mc.objExists(geometry):
#deform the lid bindmesh with the lid curve using a wire deformer.
wireDeformer = mc.wire(geometry,
gw=False,
en=1.00,
ce=0.00,
li=0.00,
w=bendyCurve,
name="{}_wire".format(bendyCurve))[0]
baseCurveJointList = list()
i = 0
for jnt, controlList in zip(bendJointList,
controlHieracrchyList):
# create the joint that we will use later to deform the base wire.
baseCurveJoint = mc.joint(
name=jnt.replace("_jnt", "_baseCurve_jnt"))
baseCurveJointList.append(baseCurveJoint)
# hide the base curve joint. Then parent it under the null node
mc.setAttr("{}.v".format(baseCurveJoint), 0)
mc.parent(baseCurveJoint, controlList[1])
mc.setAttr("{}.t".format(baseCurveJoint), 0, 0, 0)
baseCurve = "{}BaseWire".format(bendyCurve)
mc.parent([bendyCurve, baseCurve], self.name)
baseCurveSkin = mc.skinCluster(
*[baseCurveJointList] + mc.ls(baseCurve),
n="{}_skinCluster".format(baseCurve),
tsb=True)[0]
# set the default values for the wire deformer
mc.setAttr("{}.rotation".format(wireDeformer), 0)
mc.setAttr("{}.dropoffDistance[0]".format(wireDeformer), 100)
bindMeshSkin = mc.skinCluster(
*jointList + [self._hipsBind, self._chestBind] +
mc.ls(bindmeshGeometry),
n="{}_skinCluster".format(bindmeshGeometry),
tsb=True)[0]
mc.skinPercent(bindMeshSkin,
'{}.vtx[0:3]'.format(bindmeshGeometry),
transformValue=[(self._hipsBind, 1.0),
(jointList[0], 0.0)])
mc.skinPercent(bindMeshSkin,
'{}.vtx[4:7]'.format(bindmeshGeometry),
transformValue=[(jointList[0], 0.0),
(jointList[1], 1.0),
(jointList[2], 0.0)])
mc.skinPercent(bindMeshSkin,
'{}.vtx[8:11]'.format(bindmeshGeometry),
transformValue=[(jointList[3], 1.0),
(jointList[1], 0.0)])
mc.skinPercent(bindMeshSkin,
'{}.vtx[12:15]'.format(bindmeshGeometry),
transformValue=[(jointList[2], 0.0),
(jointList[4], 0.0),
(self._chestBind, 1.0)])
mc.skinPercent(bindMeshSkin,
'{}.vtx[16:19]'.format(bindmeshGeometry),
transformValue=[(self._chestBind, 1.0),
(jointList[1], 0.0),
(jointList[2], 0.0)])
# ------------------------------------------------------------------------------------
# Length Preservation
# ------------------------------------------------------------------------------------
spline.preserveLength(name='spineIk_length',
curve='spineIk_curve',
primary_control='chest',
rotate_controls=['torso', 'chest', 'chest_ik'],
no_rotate_cvs=[2, 3],
parent='spine',
position_output_child='chest_top_nul')
def R_ik_leg():
# create the Ik arm by duplicating
ik_leg = cmds.duplicate('R_Rig_femur_jnt', rc=True)
cmds.listRelatives(ik_leg, ad=True)
ik_femur = cmds.rename(ik_leg[0], 'R_Ik_femur_jnt')
ik_knee = cmds.rename(ik_leg[1], 'R_Ik_knee_jnt')
ik_ankle = cmds.rename(ik_leg[2], 'R_Ik_ankle_jnt')
ik_ball = cmds.rename(ik_leg[3], 'R_Ik_ball_jnt')
ik_toe = cmds.rename(ik_leg[4], 'R_Ik_toe_jnt')
# create Ik Rig
#create Rotate ikHandle between the femur and ankle
ik_hdl_femur = cmds.ikHandle(n='R_femurAnkle_Ikh',
sj=ik_femur,
ee=ik_ankle,
sol='ikRPsolver',
p=2,
w=1)
#create Single ikHandle between the ankle and ball
ik_hdl_ball = cmds.ikHandle(n='R_ankleBall_Ikh',
sj=ik_ankle,
ee=ik_ball,
sol='ikSCsolver',
p=2,
w=1)
#create Single ikHandle between the ball and toe
ik_hdl_toe = cmds.ikHandle(n='R_ballToe_Ikh',
sj=ik_ball,
ee=ik_toe,
sol='ikSCsolver',
p=2,
w=1)
# find the worldspace ws translate position of the ankle
pos_trans_ankle_ik = cmds.xform(ik_ankle, q=True, t=True, ws=True)
pos_trans_ball_ik = cmds.xform(ik_ball, q=True, t=True, ws=True)
pos_trans_toe_ik = cmds.xform(ik_toe, q=True, t=True, ws=True)
# find the worldspace ws orientation position of the ankle
pos_orient_ankle_ik = cmds.xform(ik_ankle, q=True, ro=True, ws=True)
pos_orient_ball_ik = cmds.xform(ik_ball, q=True, ro=True, ws=True)
pos_orient_toe_ik = cmds.xform(ik_toe, q=True, ro=True, ws=True)
# create the empty group
ik_grp = cmds.group(em=True, n='R_Ik_leg_Grp')
# create the control
ik_foot_ctl = cmds.circle(n='R_Ik_foot_Ctl',
nr=(0, 0, 1),
c=(0, 0, 0),
r=1.0)
cmds.xform(ik_foot_ctl, ro=(90, 0, 0), ws=True)
# create the offset control
ik_footOffset_ctl = cmds.circle(n='R_Ik_footOffset_Ctl',
nr=(0, 0, 1),
c=(0, 0, 0),
r=1.25)
cmds.xform(ik_footOffset_ctl, ro=(90, 0, 0), ws=True)
# orient the group to the ankle
cmds.xform(ik_grp, ro=(-90, -90, -90), ws=True)
# parent offset control to control
cmds.parent('R_Ik_footOffset_Ctl', 'R_Ik_foot_Ctl')
# parent the control to the group
cmds.parent('R_Ik_foot_Ctl', 'R_Ik_leg_Grp')
# freeze ik ctl
cmds.makeIdentity(ik_foot_ctl, r=True, a=True)
# remove history
cmds.delete(ik_foot_ctl, constructionHistory=True)
# move the group to the wrist
cmds.xform(ik_grp, t=pos_trans_ankle_ik, ws=True)
#create groups for the ikhandles
peel_heel_grp = cmds.group(em=True, n="R_peelheel_Grp")
toe_tap_grp = cmds.group(em=True, n="R_toeTap_Grp")
toe_tap_footRoll_grp = cmds.group(em=True, n="R_toeTap_footRoll_ball_Grp")
stand_tip_grp = cmds.group(em=True, n="R_standTip_Grp")
stand_tip_footRoll_grp = cmds.group(em=True,
n="R_standTip_footRoll_Toe_Grp")
heel_pivot_grp = cmds.group(em=True, n="R_heelPivot_Grp")
heel_pivot_footRoll_grp = cmds.group(em=True,
n="R_heel_pivot_footRoll_Grp")
peel_heel_footRoll_grp = cmds.group(em=True, n="R_peel_heel_footRoll_Grp")
twist_heel_grp = cmds.group(em=True, n="R_twistHeel_Grp")
twist_ball_grp = cmds.group(em=True, n="R_twistBall_Grp")
twist_toe_grp = cmds.group(em=True, n="R_twistToe_Grp")
left_bank_grp = cmds.group(em=True, n="R_leftBank_Grp")
right_bank_grp = cmds.group(em=True, n="R_rightBank_Grp")
foot_attr_grp = cmds.group(em=True, n="R_footAttr_Grp")
gimbal_grp = cmds.group(em=True, n="R_foot_gimbal_Grp")
#place the groups
cmds.xform(peel_heel_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(toe_tap_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(stand_tip_grp, t=pos_trans_toe_ik, ws=True)
cmds.xform(heel_pivot_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(heel_pivot_footRoll_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(toe_tap_footRoll_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(stand_tip_footRoll_grp, t=pos_trans_toe_ik, ws=True)
cmds.xform(heel_pivot_footRoll_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(twist_heel_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(twist_ball_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(twist_toe_grp, t=pos_trans_toe_ik, ws=True)
cmds.xform(left_bank_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(right_bank_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(foot_attr_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(gimbal_grp, t=pos_trans_ankle_ik, ws=True)
# parent the groups together to make the correct movement
cmds.parent("R_peelheel_Grp", "R_toeTap_footRoll_ball_Grp")
cmds.parent("R_toeTap_footRoll_ball_Grp", "R_peel_heel_footRoll_Grp")
cmds.parent("R_peel_heel_footRoll_Grp", "R_standTip_Grp")
cmds.parent("R_toeTap_Grp", "R_standTip_Grp")
cmds.parent("R_standTip_Grp", "R_standTip_footRoll_Toe_Grp")
cmds.parent("R_standTip_footRoll_Toe_Grp", "R_heelPivot_Grp")
cmds.parent("R_heelPivot_Grp", "R_heel_pivot_footRoll_Grp")
cmds.parent("R_heel_pivot_footRoll_Grp", "R_twistHeel_Grp")
cmds.parent("R_twistHeel_Grp", "R_twistBall_Grp")
cmds.parent("R_twistBall_Grp", "R_twistToe_Grp")
cmds.parent("R_twistToe_Grp", "R_leftBank_Grp")
cmds.parent("R_leftBank_Grp", "R_rightBank_Grp")
cmds.parent("R_rightBank_Grp", "R_footAttr_Grp")
cmds.parent("R_footAttr_Grp", "R_foot_gimbal_Grp")
# parent the ikhandles to the groups
cmds.parent('R_femurAnkle_Ikh', peel_heel_grp)
cmds.parent('R_ankleBall_Ikh', toe_tap_grp)
cmds.parent('R_ballToe_Ikh', toe_tap_grp)
# parent the Ikhandle GROUP to the controller
cmds.parent("R_foot_gimbal_Grp", 'R_Ik_footOffset_Ctl')
#create the attributes for the foot control
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="gimbalX", at="double")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="gimbalY", at="double")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="gimbalZ", at="double")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator1",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="PvControl",
min=0,
max=1,
en="off:on",
at="enum")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="legTwist", at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="offsetVis",
min=0,
max=1,
en="off:on",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator2",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="footFollow",
min=0,
max=3,
en="Fk ctl:hip:cog:world",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator3",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="footRoll", at="float")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="toeBreak", at="float")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="toeStraight", at="double")
cmds.setAttr('R_Ik_foot_Ctl.toeBreak', 20)
cmds.setAttr('R_Ik_foot_Ctl.toeStraight', 70)
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator4",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="heelUp",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="peelHeel", at="double")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="standTip",
min=0,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="toeTap",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="twistHeel",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="twistBall",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="twistToes",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="footBank",
min=-10,
max=10,
at="float")
#
# getting controller to control the orient of the wrist
cmds.orientConstraint('R_Ik_footOffset_Ctl', 'R_Ik_ankle_jnt', mo=True)
#Create Pole vec
# create a locator as a poleVector
pv_loc = cmds.spaceLocator(n='R_poleVec_Loc')
# create a group as the group for a poleVector
pv_grp = cmds.group(em=True, n='R_poleVec_Grp')
# parent locator to the group
cmds.parent('R_poleVec_Loc', 'R_poleVec_Grp')
# place the group between the shoulder and the wrist
cmds.pointConstraint(ik_femur, ik_ankle, pv_grp)
# aim the locator twoards the elbow
cmds.aimConstraint(ik_knee, pv_grp, aim=(1, 0, 0), u=(0, 1, 0))
# delete the constraints
cmds.delete('R_poleVec_Grp_pointConstraint1')
cmds.delete('R_poleVec_Grp_aimConstraint1')
# place the locater out from the elbow using the X axis trans
cmds.move(5, pv_loc, x=True, os=True, ws=False)
#create controller for the polevector
ik_knee_ctl = cmds.circle(n='R_Ik_knee_Ctl',
nr=(0, 0, 1),
c=(0, 0, 0),
r=0.5)
# rotate the controller
#cmds.rotate(0, '90deg', 0, ik_knee_ctl)
# move parent the controller to the locator locatieon
cmds.pointConstraint(pv_loc, ik_knee_ctl)
# delete pointConstraint from controller
cmds.delete('R_Ik_knee_Ctl_pointConstraint1')
# parent controller to grp
cmds.parent('R_Ik_knee_Ctl', 'R_poleVec_Grp')
# freeze orientation on controller
cmds.makeIdentity(ik_knee_ctl, a=True)
# delete history on ctl
cmds.delete(ik_knee_ctl, ch=True)
# parent poleVEc to controller
cmds.parent('R_poleVec_Loc', 'R_Ik_knee_Ctl')
# connect the polevector constraint to the ikhandle and the locator
cmds.poleVectorConstraint(pv_loc, 'R_femurAnkle_Ikh')
# hide locator
cmds.hide(pv_loc)
# hide scale from ik control
cmds.setAttr('R_Ik_foot_Ctl.scaleX', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_foot_Ctl.scaleY', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_foot_Ctl.scaleZ', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_foot_Ctl.v', keyable=False, ch=False, lock=True)
# hide scale from ik offset control
cmds.setAttr('R_Ik_footOffset_Ctl.scaleX',
keyable=False,
ch=False,
lock=True)
cmds.setAttr('R_Ik_footOffset_Ctl.scaleY',
keyable=False,
ch=False,
lock=True)
cmds.setAttr('R_Ik_footOffset_Ctl.scaleZ',
keyable=False,
ch=False,
lock=True)
cmds.setAttr('R_Ik_footOffset_Ctl.v', keyable=False, ch=False, lock=True)
#hide rotate and scale from knee ik control
cmds.setAttr('R_Ik_knee_Ctl.rotateX', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.rotateY', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.rotateZ', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.scaleX', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.scaleY', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.scaleZ', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.v', keyable=False, ch=False, lock=True)
#delete history on the ik control
cmds.delete('R_Ik_foot_Ctl', ch=True)
# place them in the group hierarchy if there is one
placeInGroup = cmds.ls('main_Grp')
# if it is there parent them respectly
if placeInGroup:
cmds.parent('R_Ik_leg_Grp', 'R_Ik_Grp')
cmds.parent('R_poleVec_Grp', 'R_Ik_Grp')
else:
return
def install(self):
# Create a master group
self.rig_info['mastergrp'] = cmds.group(n=self.module_info['rootname'][0].replace('s_', self.instance)+'_M_GRP', em=True)
cmds.xform(self.rig_info['mastergrp'], ws=True, t=self.rig_info['positions'][0])
# Create a world group
self.rig_info['worldgrp'] = cmds.group(n=self.module_info['rootname'][0].replace('s_', self.instance)+'_W_GRP', em=True)
cmds.xform(self.rig_info['worldgrp'], ws=True, t=self.rig_info['positions'][0])
# Create a local group
self.rig_info['localgrp'] = cmds.group(n=self.module_info['rootname'][0].replace('s_', self.instance)+'_L_GRP', em=True)
cmds.xform(self.rig_info['localgrp'], ws=True, t=self.rig_info['positions'][0])
cmds.parent(self.rig_info['worldgrp'], self.rig_info['mastergrp'])
cmds.parent(self.rig_info['localgrp'], self.rig_info['mastergrp'])
cmds.select(d=True)
#Try duplicate joint method
self.rig_info['ikjnts']=utils.duplicateJoints(self.rig_info['seljnts'], self.module_info['ikjnts'], self.instance)
cmds.parent(self.rig_info['ikjnts'][0], self.rig_info['localgrp'])
self.rig_info['fkjnts']=utils.duplicateJoints(self.rig_info['seljnts'], self.module_info['fkjnts'], self.instance)
cmds.parent(self.rig_info['fkjnts'][0], self.rig_info['localgrp'])
self.rig_info['rigjnts']=utils.duplicateJoints(self.rig_info['seljnts'], self.module_info['rigjnts'], self.instance)
cmds.parent(self.rig_info['rigjnts'][0], self.rig_info['localgrp'])
# Make a control for arm settings
lockattrs = (['.tx', '.ty', '.tz', '.rx', '.ry', '.rz', '.sx', '.sy', '.sz'])
setctrlname = self.module_info["settingscontrol"][0].replace('s_', self.instance)
self.rig_info['setcontrol']=utils.createControl([[self.rig_info['positions'][2], setctrlname, 'SettingsControl.ma', lockattrs]])[0]
cmds.addAttr(self.rig_info['setcontrol'][1], shortName='IK_FK', longName='Ik_Fk', defaultValue=1, min=0, max=1, k=True)
cmds.addAttr(self.rig_info['setcontrol'][1], shortName='stretch', longName='Stretchy', defaultValue=0, min=0, max=1, k=True)
cmds.addAttr(self.rig_info['setcontrol'][1], shortName='Root_Length', longName='Root_Length', defaultValue=0, min=-5, max=5, k=True)
cmds.addAttr(self.rig_info['setcontrol'][1], shortName='End_Length', longName='End_Length', defaultValue=0, min=-5, max=5, k=True)
cmds.parent(self.rig_info['setcontrol'][2], self.rig_info['localgrp'])
# Connect Ik and Fk to Rig joints
switchattr = self.rig_info['setcontrol'][1] + '.IK_FK'
self.rig_info['bcnodes'] = utils.connectThroughBC(self.rig_info['ikjnts'], self.rig_info['fkjnts'], self.rig_info['rigjnts'], self.instance, switchattr )
# Create Ik Rig
lockattrs = (['.sx', '.sy', '.sz'])
ikctrlname = self.module_info["ikcontrols"][0].replace('s_', self.instance)
self.rig_info['ikcontrol']=utils.createControl([[self.rig_info['positions'][2], ikctrlname, 'FootControl.ma', lockattrs]])[0]
cmds.parent(self.rig_info['ikcontrol'][0], self.rig_info['localgrp'])
lockattrs = (['.rx', '.ry', '.rz', '.sx', '.sy', '.sz'])
pvpos = utils.calculatePVPosition([self.rig_info['ikjnts'][0], self.rig_info['ikjnts'][1], self.rig_info['ikjnts'][2]])
pvctrlname = self.module_info["ikcontrols"][2].replace('s_', self.instance)
self.rig_info['pvcontrol']=utils.createControl([[[pvpos[0], pvpos[1], pvpos[2]], pvctrlname, 'PVControl.ma', lockattrs]])[0]
tmpcon = cmds.orientConstraint(self.rig_info['ikjnts'][1], self.rig_info['pvcontrol'][0], mo=False)
cmds.delete(tmpcon)
cmds.select(self.rig_info['pvcontrol'][0])
#cmds.move(-5, z=True, r=True)
cmds.parent(self.rig_info['pvcontrol'][2], self.rig_info['localgrp'])
# Generate a name for the ik handle using self.instance
ikhname = self.module_info["ikcontrols"][1].replace('s_', self.instance)
# Create Stretchy IK
pmas = 1
pvMA = self.instance + "PV"
self.rig_info['ikinfo']=utils.createStretchyIk(self.rig_info['ikjnts'], self.rig_info['rigjnts'], self.rig_info['ikcontrol'],
ikhname, pvctrlname, self.instance, False, pmas, pvMA, '.tx', self.rig_info['setcontrol'])
# Parent ikh to ctrl
cmds.parent(self.rig_info['ikinfo'][0], self.rig_info['ikcontrol'][1])
cmds.parent(self.rig_info['ikinfo'][1], self.rig_info['localgrp'])
for each in self.rig_info['ikinfo'][2]:
try:
cmds.parent(each, self.rig_info['worldgrp'])
except: pass
# orient constrain ik_wrist to ctrl
cmds.orientConstraint(self.rig_info['ikcontrol'][1], self.rig_info['ikjnts'][2], mo=True)
# Create FK rig
lockattrs = (['.sx', '.sy', '.sz'])
self.rig_info['fkcontrols'] = utils.createControl([
[self.rig_info['positions'][0], self.module_info["fkcontrols"][0].replace('s_', self.instance), 'RectangleControl.ma', lockattrs],
[self.rig_info['positions'][1], self.module_info["fkcontrols"][1].replace('s_', self.instance), 'RectangleControl.ma', lockattrs],
[self.rig_info['positions'][2], self.module_info["fkcontrols"][2].replace('s_', self.instance), 'RectangleControl.ma', lockattrs]])
# Orient the fk controls to the fk joints
for i in range(len(self.rig_info['fkcontrols'])):
tc = cmds.parentConstraint(self.rig_info['fkjnts'][i], self.rig_info['fkcontrols'][i][0], mo=False)
cmds.delete(tc)
# Parent fk controls
cmds.parent(self.rig_info['fkcontrols'][2][2], self.rig_info['fkcontrols'][1][1])
cmds.parent(self.rig_info['fkcontrols'][1][2], self.rig_info['fkcontrols'][0][1])
cmds.parent(self.rig_info['fkcontrols'][0][2], self.rig_info['localgrp'])
# Constrain fk joints to controls.
[cmds.parentConstraint(self.rig_info['fkcontrols'][i][1], self.rig_info['fkjnts'][i], mo=True) for i in range(len(self.rig_info['fkcontrols']))]
def build(bnd_jnts,
side='l',
prefix='leg',
rig_scale=1.0,
base_rig=None,
hip_ctrl=None):
"""
@param spine_jnts: list(str), list of 6 spine jnts
@param root_jnt: str, root_jnt
@param prefix: str, prefix to name new object
@param rig_scale: float, scale factor for size of controls
@param base_rig: instance of base.module.Base class
@return: dictionary with rig module objects
"""
#make rig module
rig_module = module.Module(prefix=side + '_' + prefix,
base_obj=base_rig,
create_dnt_grp=True,
drv_pos_obj='pelvis')
#create drv skels
ik_leg_jnts = joint.duplicate(bnd_jnts,
prefix='ik',
maintain_hierarchy=True)
fk_leg_jnts = joint.duplicate(bnd_jnts,
prefix='fk',
maintain_hierarchy=True)
cmds.parent(ik_leg_jnts[0], fk_leg_jnts[0], rig_module.drv_grp)
cmds.parentConstraint(hip_ctrl.ctrl, rig_module.drv_grp, mo=True)
#create IK controls
ik_anim_grp = side + '_' + prefix + '_ik_anim_grp'
cmds.group(n=ik_anim_grp, em=True, p=rig_module.ctrl_grp)
temp_pole_loc = limbs.create_pole_vector_locator(side + '_' + prefix,
bnd_jnts[1], [0, -30, 0])
ik_foot_ctrl = control.Control(shape=side + '_foot_ctrl_template',
prefix=side + '_foot_IK',
translate_to=bnd_jnts[2],
scale=rig_scale,
parent=ik_anim_grp,
lock_channels=['s', 'v'])
ik_knee_ctrl = control.Control(shape='sphere_ctrl_template',
prefix=side + '_knee_IK',
translate_to=temp_pole_loc,
scale=rig_scale,
parent=ik_anim_grp,
lock_channels=['v'])
cmds.delete(temp_pole_loc)
ik_ctrl_list = [ik_foot_ctrl, ik_knee_ctrl]
#create FK controls
fk_anim_grp = side + '_' + prefix + '_fk_anim_grp'
cmds.group(n=fk_anim_grp, em=True, p=rig_module.ctrl_grp)
# transform.snap('pelvis', fk_anim_grp)
transform.snap(hip_ctrl.ctrl, fk_anim_grp)
fk_thigh_ctrl = control.Control(shape='cube_ctrl_template',
prefix=side + '_thigh_FK',
translate_to=[bnd_jnts[0], bnd_jnts[1]],
rotate_to=bnd_jnts[0],
scale=rig_scale,
parent=fk_anim_grp,
lock_channels=['s', 'v'])
transform.snap_pivot(bnd_jnts[0], fk_thigh_ctrl.ctrl)
transform.snap_pivot(bnd_jnts[0], fk_thigh_ctrl.ofst)
fk_calf_ctrl = control.Control(shape='cube_ctrl_template',
prefix=side + '_calf_FK',
translate_to=[bnd_jnts[1], bnd_jnts[2]],
rotate_to=bnd_jnts[1],
scale=rig_scale * 0.7,
parent=fk_thigh_ctrl.ctrl,
lock_channels=['s', 'v'])
transform.snap_pivot(bnd_jnts[1], fk_calf_ctrl.ctrl)
transform.snap_pivot(bnd_jnts[1], fk_calf_ctrl.ofst)
fk_foot_ctrl = control.Control(shape='cube_ctrl_template',
prefix=side + '_foot_FK',
translate_to=[bnd_jnts[2], bnd_jnts[3]],
rotate_to=bnd_jnts[3],
scale=rig_scale * 0.6,
parent=fk_calf_ctrl.ctrl,
lock_channels=['s', 'v'])
transform.snap_pivot(bnd_jnts[2], fk_foot_ctrl.ctrl)
transform.snap_pivot(bnd_jnts[2], fk_foot_ctrl.ofst)
#hook up FK ctrls
fk_ctrl_list = [fk_thigh_ctrl, fk_calf_ctrl, fk_foot_ctrl]
for i in range(len(fk_ctrl_list)):
cmds.orientConstraint(fk_ctrl_list[i].ctrl, fk_leg_jnts[i], mo=False)
#set up ik
leg_ik_handle = cmds.ikHandle(n=side + '_leg_ikHandle',
sj=ik_leg_jnts[0],
ee=ik_leg_jnts[2],
sol='ikRPsolver')[0]
ball_ik_handle = cmds.ikHandle(n=side + 'ball_ikHandle',
sj=ik_leg_jnts[2],
ee=ik_leg_jnts[3],
sol='ikSCsolver')[0]
toe_ik_handle = cmds.ikHandle(n=side + 'toe_ikHandle_',
sj=ik_leg_jnts[3],
ee=ik_leg_jnts[4],
sol='ikSCsolver')[0]
ik_list = [leg_ik_handle, ball_ik_handle, toe_ik_handle]
cmds.hide(ik_list)
cmds.parent(ik_list, ik_foot_ctrl.ctrl)
cmds.poleVectorConstraint(ik_knee_ctrl.ctrl, leg_ik_handle)
#set up ik/fk switch
limbs.setup_ikfk_switch(base_rig.ikfk_ctrl, side, prefix, ik_leg_jnts[0:3],
fk_leg_jnts[0:3], bnd_jnts[0:3], ik_anim_grp,
fk_anim_grp)
#set up twist joints
limbs.create_twist_jnts(side + '_' + prefix, bnd_jnts)
#set up fk space switching
limbs.setup_fk_space_switching(side + '_' + prefix, fk_anim_grp,
fk_leg_jnts, base_rig.master_ctrl.ctrl,
fk_thigh_ctrl.ofst)
cmds.parentConstraint(hip_ctrl.ctrl, fk_anim_grp, mo=True)
#set up limb stretching
# limbs.setup_limb_stretch(prefix, rig_module, ik_leg_jnts, ik_ctrl_list)
limbs.add_ikpop_counter(side + '_' + prefix, ik_leg_jnts, bnd_jnts,
ik_foot_ctrl.ctrl)
#set up ribbon
ribbon.create_ep_curve('temp_' + prefix + '_ribbon_crv_01',
[bnd_jnts[0], bnd_jnts[1], bnd_jnts[2]],
degree=1)
ribbon_sfc = ribbon.loft_using_curve('temp_' + prefix + '_ribbon_crv_01',
10, 'z', side + '_' + prefix)
cmds.rebuildSurface(ribbon_sfc, su=0, sv=11, du=1, dv=3, ch=True)
limb_foll_list = ribbon.add_follicles(ribbon_sfc,
11,
on_edges=False,
create_joints=True)
limb_foll_jnts_list = limb_foll_list[1]
limb_foll_list = limb_foll_list[0]
for jnt in limb_foll_jnts_list:
cmds.xform(jnt, os=True, ro=[-90, 0, 90])
cmds.makeIdentity(jnt, t=0, r=1, s=0, apply=True)
limb_follicles_grp = '_'.join([side, prefix, 'follicles', 'grp'])
cmds.group(limb_foll_list, n=limb_follicles_grp)
#set up blendshapes
leg_drv_jnts = [
u'thigh_l', u'calf_l', u'ankle_l', u'calf_l_twist', u'thigh_l_twist'
]
cmds.select(leg_drv_jnts, ribbon_sfc)
limb_ribbon_clstr = cmds.skinCluster(tsb=True, dr=4.5)
shape = cmds.listRelatives(ribbon_sfc, shapes=True)[0]
#'body_geo' must have a skinCluster associated with it.
geo_skin_clstr = cmds.listConnections(shape, type='skinCluster')[0]
limbs.create_deformer_blend(side + '_' + prefix,
ribbon_sfc,
geo_skin_clstr,
ik_foot_ctrl.ctrl,
limb_foll_jnts_list,
num_jnts=3)
def build(spineJoints,
rootJnt,
spineCurve,
bodyLocator,
chestLocator,
pelvisLocator,
prefix='spine',
rigScale=1.0,
baseRig=None):
"""
@param spineJoints: list( str ), list of spine joints
@param rootJnt: str, root joint
@param spineCurve: str, name of spine cubic curve with CVs matching first 5 spine joints
@param bodyLocator: str, reference transform for position of body control
@param chestLocator: str, reference transform for position of chest control
@param pelvisLocator: str, reference transform for position of pelvis control
@param prefix: str, prefix to name new objects
@param rigScale: float, scale factor for size of controls
@param baseRig: instance of base.module.Base class
@return: dictionary with rig module objects
"""
# make rig module
rigmodule = module.Module(prefix=prefix, baseObj=baseRig)
# make spine curve clusters
spineCurveCVs = mc.ls(spineCurve + '.cv[*]', fl=1)
numSpineCVs = len(spineCurveCVs)
spineCurveClusters = []
for i in range(numSpineCVs):
cls = mc.cluster(spineCurveCVs[i], n=prefix + 'Cluster%d' % (i + 1))[1]
spineCurveClusters.append(cls)
mc.hide(spineCurveClusters)
# parent spine curve
mc.parent(spineCurve, rigmodule.partsNoTransGrp)
# make controls
bodyCtrl = control.Control(prefix=prefix + 'Body',
translateTo=bodyLocator,
scale=rigScale * 7,
parent=rigmodule.controlsGrp)
chestCtrl = control.Control(prefix=prefix + 'Chest',
translateTo=chestLocator,
scale=rigScale * 50,
parent=bodyCtrl.C,
shape='circleZ')
pelvisCtrl = control.Control(prefix=prefix + 'Pelvis',
translateTo=pelvisLocator,
scale=rigScale * 40,
parent=bodyCtrl.C,
shape='circleZ')
middleCtrl = control.Control(prefix=prefix + 'Middle',
translateTo=spineCurveClusters[-3],
scale=rigScale * 50,
parent=bodyCtrl.C,
shape='circleZ')
# attach controls
mc.parentConstraint(chestCtrl.C,
pelvisCtrl.C,
middleCtrl.Off,
sr=['x', 'y', 'z'],
mo=1)
# attach clusters
mc.parent(spineCurveClusters[3:], chestCtrl.C)
mc.parent(spineCurveClusters[2], middleCtrl.C)
mc.parent(spineCurveClusters[:2], pelvisCtrl.C)
# attach chest joint
mc.orientConstraint(chestCtrl.C, spineJoints[-1], mo=1)
# make IK handle
spineIk = mc.ikHandle(n=prefix + '_ikh',
sol='ikSplineSolver',
sj=spineJoints[0],
ee=spineJoints[-2],
c=spineCurve,
ccv=0,
parentCurve=0)[0]
mc.hide(spineIk)
mc.parent(spineIk, rigmodule.partsNoTransGrp)
# setup IK twist
mc.setAttr(spineIk + '.dTwistControlEnable', 1)
mc.setAttr(spineIk + '.dWorldUpType', 4)
mc.connectAttr(chestCtrl.C + '.worldMatrix[0]',
spineIk + '.dWorldUpMatrixEnd')
mc.connectAttr(pelvisCtrl.C + '.worldMatrix[0]',
spineIk + '.dWorldUpMatrix')
# attach root joint
mc.parentConstraint(pelvisCtrl.C, rootJnt, mo=1)
return {'module': rigmodule, 'bodyCtrl': bodyCtrl}
def Constraints(self, *args):
# creat a loc
# creat constrain from rootM to loc, all axes
# bake anim for loc
# rootm --> parent -w
# rootm delete keyfarme
# creat constrain from loc to root ,tx,tz, rz
# parent(rootm, root)
# creat constrain from loc to root ,all axes
# startNum = cmds.playbackOptions(q = True , ast = True)
# endNum = cmds.playbackOptions(q = True , aet = True)
# returnMess = cmds.confirmDialog( title='Confirm', message='烘焙时间轴为' + str(startNum) + '-' + str(endNum), button=['Yes','No'], defaultButton='Yes', cancelButton='No', dismissString='No' )
# if returnMess == "No":
# return
startNum = cmds.intFieldGrp("StartFrame", q = True, value1 = True)
endNum = cmds.intFieldGrp("EndFrame", q = True, value1 = True)
cmds.currentUnit( time='ntsc', linear='centimeter')
cmds.currentTime( startNum )
locPos = cmds.spaceLocator()
cmds.parentConstraint( 'Root_M', locPos, mo = True)
cmds.bakeResults( locPos, simulation=True, t = (startNum, endNum), hierarchy= "below", sb = 1, dic = True, pok = True, ral = False, rwl = False, cp = True)
cmds.parent( 'Root_M', world=True )
keyframelist = cmds.ls(type='animCurveTL')+cmds.ls(type='animCurveTA')+cmds.ls(type='animCurveTU')
for i in keyframelist:
if not ('Root_M' not in i):
cmds.delete(i)
ty = cmds.checkBoxGrp("translateAxes", q = True, value2 = True)
tx = cmds.checkBoxGrp("translateAxes", q = True, value1 = True)
trans = []
if not ty:
trans += "y"
if not tx:
trans += "x"
orientConA = None
ry = cmds.checkBoxGrp("rotateAxes", q = True, value2 = True)
rot = ["x","z"]
if ry:
orientConA = cmds.orientConstraint(locPos, 'Root', mo = True, skip=rot)
# parentConA = cmds.parentConstraint( locPos, 'Root', st=trans, sr=rot, mo = True)
pointConA = cmds.pointConstraint(locPos, 'Root', mo = True, skip=trans)
cmds.bakeResults( 'Root', simulation=True, t = (startNum, endNum), hierarchy= "below", sb = 1, dic = True, pok = True, ral = False, rwl = False, cp = True)
cmds.delete(pointConA)
cmds.delete(orientConA)
cmds.parent( 'Root_M', 'Root' )
parentConB = cmds.parentConstraint( locPos, 'Root_M', mo = True)
cmds.bakeResults( 'Root_M', simulation=True, t = (startNum, endNum), hierarchy= "below", sb = 1, dic = True, pok = True, ral = False, rwl = False, cp = True)
cmds.delete(parentConB)
cmds.delete(locPos)
keyframelist = cmds.ls(type='animCurveTL')+cmds.ls(type='animCurveTA')+cmds.ls(type='animCurveTU')
keyCurve = []
for i in keyframelist:
if 'Root_M' in i or 'Root' in i:
keyCurve.append(i)
cmds.filterCurve(keyCurve)
cmds.select(i)
Grupo = cmds.group(n=str(i) + '_mixamoConstraint')
cmds.parentConstraint(Mixamo[X], Grupo, mo=True)
X = X + 1
copyPart(RdMControllers_Arms, MixamoJoints_Arms)
#copyPart (RdMControllers_Legs, MixamoJoints_Legs)
copyPart(RdMControllers_Spine, MixamoJoints_Spine)
copyPart(RdMControllers_Head, MixamoJoints_Head)
#Legs
#LegNotWorking
cmds.orientConstraint('LeftUpLeg', 'L_Leg_FK_CC', mo=True)
cmds.orientConstraint('RightUpLeg', 'R_Leg_FK_CC', mo=True)
cmds.orientConstraint('LeftLeg', 'L_Knee_FK_CCGRP', mo=True)
cmds.orientConstraint('LeftFoot', 'L_Ankle_FK_CCGRP', mo=True)
cmds.orientConstraint('LeftToeBase', 'L_Ball_FK_CCGRP', mo=True)
cmds.orientConstraint('RightLeg', 'R_Knee_FK_CCGRP', mo=True)
cmds.orientConstraint('RightFoot', 'R_Ankle_FK_CCGRP', mo=True)
cmds.orientConstraint('RightToeBase', 'R_Ball_FK_CCGRP', mo=True)
