def setupIK(self):
#Create shoulder
self.m_shoulderCtrl = cmds.spaceLocator(
n=self.m_joints.m_shoulder.replace("_JNT", "_LOC")
)[0]
# Add to controls
rc.addToControlDict(self.m_allControls, "%s_IKShoulder" %(self.m_baseName), self.m_shoulderCtrl)
rc.addToLayer(self.m_sceneData, "hidden", self.m_shoulderCtrl)
rc.orientControl(self.m_shoulderCtrl, self.m_joints.m_shoulder)
rg.add3Groups(self.m_shoulderCtrl, ["_SDK", "_CONST", "_0"])
cmds.parent(self.m_shoulderCtrl+"_0", self.m_group, r=1)
cmds.pointConstraint(
self.m_shoulderCtrl,
self.m_joints.m_shoulder,
mo=1
)
desiredName = self.m_wristCtrl.replace("_CTRL", "_IK")
self.m_ikHandle = cmds.ikHandle(
n = desiredName,
sj = self.m_joints.m_shoulder,
ee = self.m_joints.m_wrist,
sol = "ikRPsolver",
see = True
)[0]
# deselect so we don't get errors
cmds.select(d=1)
rc.addToLayer(self.m_sceneData, "hidden", [self.m_ikHandle])
cmds.parent(self.m_ikHandle, self.m_wristCtrl)
self.setupPoleVec()
def rigWrist(self):
self.m_wristCtrl = rg.stripMiddle(self.m_joints.m_wrist, 0, 1)+"_CTRL"
self.m_wristCtrl = cmds.spaceLocator(n = self.m_wristCtrl)[0]
rc.orientControl(self.m_wristCtrl, self.m_joints.m_wrist)
rg.add3Groups(self.m_wristCtrl, ["_SDK", "_CONST", "_0"])
cmds.parent(self.m_wristCtrl+"_0", self.m_group, r=1)
# Add to controls
rc.addToControlDict(self.m_allControls, "%s_IKWrist" %(self.m_baseName), self.m_wristCtrl)
rc.addToLayer(self.m_sceneData, "mainCtrl", self.m_wristCtrl)
def rigElbow(self):
#Check that shoulder has been done
if not self.m_isShoulder:
self.rigShoulder()
#Rig for stretch
self.m_stretchCtrl = rc.changeExt(
self.m_joints.m_elbow1,
"_stretch_CTRL"
)
self.m_stretchCtrl = cmds.spaceLocator(
n = self.m_stretchCtrl
)[0]
rc.orientControl(self.m_stretchCtrl, self.m_joints.m_shoulder)
elbowDisplace = cmds.getAttr("%s.tx" %(self.m_joints.m_elbow1))
groups = rg.add3Groups(self.m_stretchCtrl, ["_SDK", "_CONST", "_0"])
cmds.parent(groups[2], self.m_shoulderGBLCtrl)
cmds.setAttr("%s.tx" %(groups[2]), elbowDisplace)
cmds.pointConstraint(self.m_stretchCtrl, self.m_joints.m_elbow1)
# --- Elbow --- #
self.m_elbowCtrl = rc.makeCTRL(
self.m_joints.m_elbow1,
False,
True,
["_SDK", "_CONST", "_0"]
)
cmds.parent(self.m_elbowCtrl+"_0", self.m_stretchCtrl)
#Connect up double rotations
try:
cmds.connectAttr(
self.m_joints.m_elbow1+".rotate",
self.m_joints.m_elbow2+".rotate",
f=1
)
except:
print "Warning, double joint rotations seem to already be connected"
#- lock and hide unused attributes -#
rc.lockAttrs(
self.m_stretchCtrl,
["ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz"]
)
rc.lockAttrs(
self.m_elbowCtrl,
["tx", "ty", "tz", "sx", "sy", "sz"]
)
rc.addToLayer(self.m_sceneData, "mainCtrl", [self.m_stretchCtrl, self.m_elbowCtrl])
#Add to controls
rc.addToControlDict(self.m_allControls, "%s_FKElbowStretch" %(self.m_baseName), self.m_stretchCtrl)
rc.addToControlDict(self.m_allControls, "%s_FKElbow" %(self.m_baseName), self.m_elbowCtrl)
self.m_isElbow = True
def aimWrist(self, _fkWrist, _blendControlAttrs):
error.assertType(_fkWrist, ["", u''])
error.assertList(_blendControlAttrs, ["", u''])
assert len(_blendControlAttrs) == 2, "_blendControls must contain two elements"
# Make sure wrist is aimed right
# create fix control that always aims as fk should.
# this is used to help blend between ik and fk
if (self.m_rigWrist):
group = cmds.group(n="%s_wrist_blendFix_GRP" %(self.m_name), em=True)
cmds.parent(group, self.m_group)
rc.orientControl(group, self.m_wristCtrl)
cmds.pointConstraint(self.m_joints.m_wrist, group, mo=1)
# Create up locator
wristAimFix = cmds.spaceLocator(n="%s_wristAimFix_LOC" %(self.m_name))[0]
rc.addToLayer(self.m_sceneData, "hidden", wristAimFix)
cmds.parent(wristAimFix, self.m_joints.m_elbow2, r=1)
aimOffset = 1
if self.m_isMirrored:
aimOffset *= -1
cmds.setAttr("%s.t%s" %(wristAimFix, self.m_twistAxis), aimOffset)
aim = cmds.aimConstraint(
self.m_joints.m_elbow2,
group,
worldUpType = "object",
worldUpObject = wristAimFix,
mo = True
)[0]
orient = cmds.orientConstraint(
_fkWrist,
"%s_SDK" %(self.m_wristCtrl),
mo= True
)[0]
orient = cmds.orientConstraint(
group,
"%s_SDK" %(self.m_wristCtrl),
mo= True
)[0]
cmds.setAttr("%s.interpType" %(orient), 2)
cmds.connectAttr(
_blendControlAttrs[0],
"%s.%sW0" %(orient, _fkWrist)
)
cmds.connectAttr(
_blendControlAttrs[1],
"%s.%sW1" %(orient, group)
)
def clusterPoint(self, _point, _control, _name, _constraint = cmds.parentConstraint, _aim = False):
#pos = cmds.xform(_control, t=1, q=1, ws=1)
#cmds.xform(_point, t=pos, ws=1)
clusterResult = cmds.cluster(_point, n=_name)
#cmds.setAttr(clusterResult[1]+".visibility", 0)
rc.addToLayer(self.m_sceneData, "hidden", [clusterResult[1]])
cmds.parent(clusterResult[1], self.m_group)
_constraint(_control, clusterResult[1], mo=1)
if _aim:
cmds.aimConstraint(
_aim,
clusterResult[1],
mo=True
)
return clusterResult[1]
def setupPoleVec(self):
middleName = rg.stripMiddle(self.m_joints.m_shoulder, 0, 3)
desiredName = self.m_name+"PoleVec_LOC"
self.m_poleVec = cmds.spaceLocator(n = desiredName)[0]
# Add to controls
rc.addToControlDict(self.m_allControls, "%s_IKPoleVec" %(self.m_baseName), self.m_poleVec)
rc.addToLayer(self.m_sceneData, "mainCtrl", self.m_poleVec)
cmds.addAttr(
self.m_poleVec,
ln=self.m_poleVecPinAttr,
min=0,
max=1,
k=True,
dv=0
)
cmds.addAttr(
self.m_poleVec,
ln=self.m_maxStretchAttr,
at = "float",
min=0,
dv=10,
k=1
)
self.m_maxStretch = "%s.%s" %(self.m_poleVec, self.m_maxStretchAttr)
rc.orientControl(self.m_poleVec, self.m_joints.m_elbow1)
groups = rg.add3Groups(self.m_poleVec, ["_SDK", "_CONST", "_0"])
cmds.poleVectorConstraint(self.m_poleVec, self.m_ikHandle)
cmds.parent(groups[-1], self.m_group, r=1)
# Lock unused attributes
rc.lockAttrs(
self.m_poleVec,
["scale", "rotate"],
True,
False
)
axis , offset = self.getPoleVecAxis(2)
if axis != "":
cmds.setAttr("%s.t%s" %(groups[1], axis), offset)
#Create line
midGroup = cmds.group(em=1, n=self.m_name+"PoleVec_GRP")
cmds.parent(midGroup, self.m_group)
cmds.pointConstraint(self.m_joints.m_elbow1, midGroup)
cmds.pointConstraint(self.m_joints.m_elbow2, midGroup)
lineNodes = rc.createLine([self.m_poleVec, midGroup], self.m_sceneData, "mainCtrl")
cmds.parent(lineNodes[0], self.m_group)
def rigShoulder(self):
try:
# --- Shoulder --- #
#Create shoulder controls
gimbalCtrls = rc.makeGimbalCTRL(
self.m_joints.m_shoulder,
False,
True
)
self.m_shoulderGBLCtrl = gimbalCtrls[0]
self.m_shoulderCtrl = gimbalCtrls[1]
# Add to controls
rc.addToControlDict(self.m_allControls, "%s_FKShoulder" %(self.m_baseName), self.m_shoulderCtrl)
rc.addToControlDict(
self.m_allControls,
"%s_FKShoulderGBL" %(self.m_baseName),
self.m_shoulderGBLCtrl
)
rc.addToLayer(self.m_sceneData, "mainCtrl", gimbalCtrls)
self.m_isShoulder = True
cmds.parent(self.m_shoulderCtrl+"_0", self.m_group, r=1)
cmds.pointConstraint(
self.m_shoulderGBLCtrl,
self.m_joints.m_shoulder
)
#Sort out scaling
cmds.scaleConstraint(
self.m_shoulderGBLCtrl,
self.m_joints.m_shoulder
)
#Lock unused attributes
rc.lockAttrs(
self.m_shoulderCtrl,
["translate", "scale"],
True,
False
)
rc.lockAttrs(
self.m_shoulderGBLCtrl,
["translate", "scale"],
True,
False
)
except:
print "WARNING: FK Shoulder setup was unsuccessful!"
self.m_isShoulder = False
def createToe(self):
if not self.m_ankleGenerated:
self.createAnkle()
self.m_toeCtrl = cmds.circle(
n="%s_toe_CTRL" %(self.m_name),
nr=(1, 0, 0)
)[0]
rc.addToControlDict(self.m_allControls, "%s_FKToe" %(self.m_baseName), self.m_toeCtrl)
rc.addToLayer(self.m_sceneData, "mainCtrl", self.m_toeCtrl)
rc.orientControl(self.m_toeCtrl, self.m_joints[1])
groups = rg.add3Groups(self.m_toeCtrl, ["_SDK", "_CONST", "_0"])
cmds.parentConstraint(self.m_toeCtrl, self.m_joints[1])
cmds.parent(groups[-1], self.m_ankleCtrl)
self.m_toeGenerated = True
#Lock unused attributes
rc.lockAttrs(self.m_toeCtrl, ["translate", "scale"], True, False)
def __init__(
self,
_sceneData,
_joints,
_name,
_baseName,
_twistAxis="y",
_rigWrist=True,
_blendControl=False
):
self.m_sceneData = _sceneData
self.m_startJoints = aj.ArmJoints(_joints)
# Make sure to strip blendParent2 attribute otherwise ik fk blending
# can break. This sometimes happens if joints are taken from a previous
# version of the rig and used to generate a new one.
for joint in self.m_startJoints.getJointList():
rc.stripAttr(joint, "blendParent2")
self.m_name = _name
self.m_baseName = _baseName
self.m_group = "%s_GRP" %(self.m_name)
if not cmds.objExists(self.m_group):
self.m_group = cmds.group(n=self.m_group, em=True)
self.m_twistAxis = _twistAxis
self.m_rigWrist = _rigWrist
self.m_blendControl = _blendControl
self.m_isMirrored = self.checkMirroring()
self.m_allControls = {}
if not self.m_blendControl:
self.m_blendControl = cmds.circle(n=self.m_name+"_IKFKBlend_CTRL")[0]
cmds.parent(self.m_blendControl, self.m_group)
rc.addToLayer(self.m_sceneData, "mainCtrl", self.m_blendControl)
rc.addToControlDict(self.m_allControls, "%s_IKFKBlend" %(self.m_baseName), self.m_blendControl)
self.m_isGenerated = False
# stretch chain parameters
self.m_numUpperControls = 2
self.m_numLowerControls = 2
self.m_numUpperJoints = 5
self.m_numLowerJoints = 5
self.m_upperStretchJoints = False
self.m_lowerStretchJoints = False
def setupElbowTwist(self):
# Create joints
cmds.select(d=1)
joint1 = cmds.joint(n="%s_midTwist_JNT" %(self.m_name))#, s=[0.1, 0.1, 0.1])
cmds.setAttr("%s.radius" %(joint1), 0.15)
rc.orientControl(joint1, self.m_joints.m_elbow1)
joint2 = cmds.joint(n="%s_midTwistEnd_JNT" %(self.m_name))#, s=[0.1, 0.1, 0.1])
cmds.setAttr("%s.radius" %(joint2), 0.15)
rc.orientControl(joint2, self.m_joints.m_elbow2)
cmds.parent(joint1, self.m_group)
self.m_elbowTwistJoints = [joint1, joint2]
rc.addToLayer(self.m_sceneData, "ref", self.m_elbowTwistJoints)
rc.addToSet(self.m_sceneData, "bind", self.m_elbowTwistJoints[0])
# sort out joint orientations
tmpLocator = cmds.spaceLocator()[0]
cmds.parent(tmpLocator, self.m_joints.m_elbow1, r=1)
cmds.setAttr("%s.t%s" %(tmpLocator, self.m_twistAxis), 1)
rc.reorientJoints(self.m_elbowTwistJoints, tmpLocator)
cmds.delete(tmpLocator)
# Create control
self.m_elbowTwist = cmds.spaceLocator(n="%s_midTwist_CTRL" %(self.m_name))[0]
rc.orientControl(self.m_elbowTwist, self.m_elbowTwistJoints[0])
cmds.parent(self.m_elbowTwist, self.m_group)
groups = rg.add3Groups(self.m_elbowTwist, ["_SDK", "_CONST", "_0"])
# Create aim locator
self.m_elbowTwistAimLoc = cmds.spaceLocator(n="%s_midTwistAim_LOC" %(self.m_name))[0]
cmds.parent(self.m_elbowTwistAimLoc, self.m_elbowTwist, r=1)
aimOffset = 1
if(self.m_isMirrored):
aimOffset *=1
cmds.setAttr("%s.tx" %(self.m_elbowTwistAimLoc), aimOffset)
rc.addToLayer(self.m_sceneData, "hidden", self.m_elbowTwistAimLoc)
# Connect up joint
cmds.pointConstraint(self.m_elbowTwist, self.m_elbowTwistJoints[0])
cmds.parentConstraint(self.m_joints.m_elbow1, groups[1])
self.m_twistAimConstraint = cmds.aimConstraint(
self.m_elbowTwistAimLoc,
self.m_elbowTwistJoints[0],
mo=1
)
def rigWrist(self):
gimbalCtrls = rc.makeGimbalCTRL(self.m_joints.m_wrist, False, False)
self.m_wristCtrl = gimbalCtrls[1]
self.m_wristGBLCtrl = gimbalCtrls[0]
rc.addToControlDict(self.m_allControls, "%s_bindWrist" %(self.m_baseName), self.m_wristCtrl)
rc.addToControlDict(self.m_allControls, "%s_bindWristGBL" %(self.m_baseName), self.m_wristGBLCtrl)
rc.addToLayer(self.m_sceneData, "mainCtrl", gimbalCtrls)
#Lock controls
for control in [self.m_wristCtrl, self.m_wristGBLCtrl]:
cmds.setAttr(control+".translate", l=1)
cmds.setAttr(control+".scale", l=1)
cmds.parent(self.m_wristCtrl+"_0", self.m_group)
cmds.pointConstraint(self.m_joints.m_wrist, self.m_wristCtrl+"_CONST")
cmds.orientConstraint(
self.m_wristGBLCtrl,
self.m_joints.m_wrist,
mo=True
)
def createJoints(self):
if not self.m_userJoints:
self.m_bindJoints = []
startPos = cmds.xform(self.m_parent1, q=1, t=1, ws=1)
endPos = cmds.xform(self.m_parent2, q=1, t=1, ws=1)
stepVec = vec.divide(
vec.subtract(endPos, startPos),
self.m_numJoints - 1
)
currentPos = startPos
for i in range(self.m_numJoints):
newJoint = self.m_name+"_"+str(i)+"_BIND_JNT"
newJoint = cmds.joint(n=newJoint, p=currentPos)
cmds.setAttr("%s.radius" %(newJoint), 0.1)
self.m_bindJoints.append(newJoint)
currentPos = vec.add(currentPos, stepVec)
#fix orientations
cmds.joint(
self.m_bindJoints[0],
e=1,
oj="xyz",
sao = "yup",
ch=1,
zso=1
)
else:
# Duplicate joints and rename
newJoints = cmds.duplicate(self.m_userJoints[0], rc=1)
for i in range(len(newJoints)):
newJoint = "%s_%d_BIND_JNT" %(self.m_name, i)
newJoints[i] = cmds.rename(newJoints[i], newJoint)
self.m_bindJoints = newJoints
#Put it in the right group
cmds.parent(self.m_bindJoints[0], self.m_group)
rc.addToLayer(self.m_sceneData, "ref", self.m_bindJoints[0])
#Strip sets
for joint in self.m_bindJoints:
rc.stripSets(joint)
#Add all except first and last to bind set
for joint in self.m_bindJoints[:-1]:
rc.addToSet(self.m_sceneData, "bind", joint)
def rigWrist(self):
#Check that shoulder has been done
if not self.m_isElbow:
self.rigElbow()
# --- Wrist --- #
self.m_wristCtrl = rc.makeCTRL(
self.m_joints.m_wrist,
False,
False,
["_SDK", "_CONST", "_0"]
)
# Sort orientation
rc.orientControl(self.m_wristCtrl+"_0", self.m_joints.m_elbow2)
rc.copyTranslation(self.m_wristCtrl+"_0", self.m_joints.m_wrist)
#Parent for neatness
cmds.parent(self.m_wristCtrl+"_0", self.m_elbowCtrl)
#Connect up to previous joint
cmds.parentConstraint(
self.m_joints.m_elbow2,
self.m_wristCtrl+"_CONST",
mo=1
)
cmds.pointConstraint(
self.m_wristCtrl,
self.m_joints.m_wrist,
skip=["y", "z"]
)
rc.lockAttrs(
self.m_wristCtrl,
["ty", "tz", "rotate", "scale"],
True,
False
)
# Add to controls
rc.addToControlDict(self.m_allControls, "%s_FKWrist" %(self.m_baseName), self.m_wristCtrl)
rc.addToLayer(self.m_sceneData, "mainCtrl", self.m_wristCtrl)
self.m_isWrist = True
def generate(self):
cmds.cycleCheck(e=False)
# -- Duplicate joints and rename for IK-FK switch --- #
self.m_bindJoints = self.duplicateJoints(self.m_startJoints, "BIND")
rc.addToLayer(self.m_sceneData, "ref", self.m_bindJoints[0])
self.m_ikJoints = self.duplicateJoints(self.m_startJoints, "IK")
rc.addToLayer(self.m_sceneData, "ref", self.m_ikJoints[0])
self.m_fkJoints = self.duplicateJoints(self.m_startJoints, "FK")
rc.addToLayer(self.m_sceneData, "ref", self.m_fkJoints[0])
# -- Create shoulder locator -- #
self.m_shoulderLocator = self.m_name+"_shoulder_CTRL"
self.m_shoulderLocator = cmds.spaceLocator(n=self.m_shoulderLocator)[0]
rc.addToLayer(self.m_sceneData, "detailCtrl", self.m_shoulderLocator)
rc.orientControl(self.m_shoulderLocator, self.m_startJoints.m_shoulder)
shoulderGRPs = rg.add3Groups(
self.m_shoulderLocator,
["_SDK", "_CONST", "_0"]
)
cmds.parent(shoulderGRPs[-1], self.m_group)
# -- Setup FK rig -- #
tmpList = self.m_fkJoints.getJointList()
self.m_fkRig = fk.FKArmRig(self.m_sceneData, tmpList, self.m_name+"_FK", self.m_baseName)
self.m_fkRig.generate()
cmds.parent(self.m_fkRig.m_group, self.m_group)
cmds.parentConstraint(
self.m_shoulderLocator,
self.m_fkRig.getMainTransform(),
mo=True
)
# -- Setup IK rig -- #
tmpList = self.m_ikJoints.getJointList()
self.m_ikRig = ik.IKArmRig(
self.m_sceneData,
tmpList,
self.m_name+"_IK",
self.m_baseName,
self.m_isMirrored,
self.m_twistAxis
)
self.m_ikRig.generate()
cmds.parent(self.m_ikRig.m_group, self.m_group)
cmds.pointConstraint(
self.m_shoulderLocator,
self.m_ikRig.getMainTransform(),
mo=True
)
# -- Setup BIND rig -- #
tmpList = self.m_bindJoints.getJointList()
self.m_bindRig = bind.BINDArmRig(
self.m_sceneData,
tmpList,
self.m_name+"_BIND",
self.m_baseName,
self.m_blendControl,
self.m_numUpperControls,
self.m_numLowerControls,
self.m_numUpperJoints,
self.m_numLowerJoints,
self.m_upperStretchJoints,
self.m_lowerStretchJoints,
self.m_isMirrored,
self.m_twistAxis,
self.m_rigWrist
)
self.m_bindRig.generate()
cmds.parent(self.m_bindRig.m_group, self.m_group)
cmds.pointConstraint(
self.m_shoulderLocator,
self.m_bindRig.getMainTransform(),
mo=True
)
# rig the blend control for aestethics
if self.m_rigWrist:
self.rigBlendControl(self.m_bindRig.getWristCtrl())
# -- Connect up rigs -- #
try:
tmp = self.m_blendControl
except:
self.m_blendControl = self.createBlendControl()
self.connectIKFK()
# -- Setup visibility -- #
self.setupVisibility()
cmds.cycleCheck(e=True)
# Add all controls
rc.addToControlDict(
self.m_allControls,
"%s_shoulderLocator" %(self.m_baseName),
self.m_shoulderLocator
)
rc.addDictToControlDict(self.m_allControls, self.m_fkRig.getAllControls())
rc.addDictToControlDict(self.m_allControls, self.m_ikRig.getAllControls())
rc.addDictToControlDict(self.m_allControls, self.m_bindRig.getAllControls())
self.m_isGenerated = True
def generate(self):
# Generate controls
self.m_heelRoll = cmds.spaceLocator(
n="%s_heelRoll_CTRL" %(self.m_name)
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_heelRoll" %(self.m_baseName),
self.m_heelRoll
)
self.m_insideRoll = cmds.spaceLocator(
n="%s_insideRoll_CTRL" %(self.m_name)
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_insideRoll" %(self.m_baseName),
self.m_insideRoll
)
self.m_outsideRoll = cmds.spaceLocator(
n="%s_outsideRoll_CTRL" %(self.m_name)
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_outsideRoll" %(self.m_baseName),
self.m_outsideRoll
)
self.m_toeRoll = cmds.spaceLocator(
n="%s_toeRoll_CTRL" %(self.m_name)
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_toeRoll" %(self.m_baseName),
self.m_toeRoll
)
self.m_ballRoll = cmds.spaceLocator(
n="%s_ballRoll_CTRL" %(self.m_name)
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_ballRoll" %(self.m_baseName),
self.m_ballRoll
)
self.m_toeFlap = cmds.spaceLocator(
n="%s_toeFlap_CTRL" %(self.m_name)
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_toeFlap" %(self.m_baseName),
self.m_toeFlap
)
rc.addToLayer(
self.m_sceneData,
"detailCtrl",
[
self.m_heelRoll,
self.m_insideRoll,
self.m_outsideRoll,
self.m_toeRoll,
self.m_ballRoll,
self.m_toeFlap
]
)
self.m_mainCtrl = cmds.circle(
n="%s_main_CTRL" %(self.m_name),
nr=(1, 0, 0)
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_mainCtrl" %(self.m_baseName),
self.m_mainCtrl
)
rc.addToLayer(self.m_sceneData, "mainCtrl", self.m_mainCtrl)
rc.orientControl(self.m_mainCtrl, self.m_footMainLoc)
cmds.parent(self.m_mainCtrl, self.m_group)
mainCtrlGroups = rg.add3Groups(
self.m_mainCtrl,
["_SDK", "_CONST", "_0"]
)
# Move everything into the right places
rc.orientControl(self.m_heelRoll, self.m_heelPivotLoc)
rc.orientControl(self.m_insideRoll, self.m_insidePivotLoc)
rc.orientControl(self.m_outsideRoll, self.m_outsidePivotLoc)
rc.orientControl(self.m_toeRoll, self.m_toePivotLoc)
rc.orientControl(self.m_ballRoll, self.m_joints[1])
rc.orientControl(self.m_toeFlap, self.m_joints[1])
# Parent everything
cmds.parent(self.m_heelRoll, self.m_mainCtrl)
cmds.parent(self.m_insideRoll, self.m_heelRoll)
cmds.parent(self.m_outsideRoll, self.m_insideRoll)
cmds.parent(self.m_toeRoll, self.m_outsideRoll)
cmds.parent(self.m_ballRoll, self.m_toeRoll)
cmds.parent(self.m_toeFlap, self.m_toeRoll)
# Create Groups above
defaultExt = ["_SDK", "_CONST", "_0"]
rg.add3Groups(self.m_heelRoll, defaultExt)
rg.add3Groups(self.m_insideRoll, defaultExt)
rg.add3Groups(self.m_outsideRoll, defaultExt)
rg.add3Groups(self.m_toeRoll, defaultExt)
rg.add3Groups(self.m_ballRoll, defaultExt)
rg.add3Groups(self.m_toeFlap, defaultExt)
# Create IKs
self.m_footIK = cmds.ikHandle(
sj=self.m_joints[0],
ee=self.m_joints[1],
sol="ikRPsolver"
)[0]
# deselect so we don't get warnings
cmds.select(d=1)
cmds.parent(self.m_footIK, self.m_ballRoll)
self.m_toeIK = cmds.ikHandle(
sj=self.m_joints[1],
ee=self.m_joints[2],
sol="ikRPsolver"
)[0]
# deselect so we don't get warnings
cmds.select(d=1)
cmds.parent(self.m_toeIK, self.m_toeFlap)
rc.addToLayer(self.m_sceneData, "hidden", [self.m_footIK, self.m_toeIK])
# Sort ankle
cmds.parentConstraint(self.m_ballRoll, self.m_ankleIK, mo=True)
cmds.parentConstraint(self.m_ankleIK, self.m_joints[0], mo=True)
def createControls(self):
#If no blend control is speified add one
if not self.m_blendControl:
self.m_blendControl = cmds.circle(n=self.m_name+"Blend_CTRL")[0]
cmds.parent(self.m_blendControl, self.m_group)
self.m_allControls.append(self.m_blendControl)
rc.addToControlDict(
self.m_allControls,
"%s_StretchChainCtrl" %(self.m_baseName),
self.m_blendControl
)
cmds.addAttr(
self.m_blendControl,
ln=self.m_attrHeading,
k=True,
at = "enum",
en = "---------:"
)
if self.m_isAutoBend:
cmds.addAttr(
self.m_blendControl,
ln=self.m_blendAttrName,
k=1, min=0, max=1, dv=0
)
blendNodeAttr = self.m_blendControl+"."+self.m_blendAttrName
oppBlendNodeAttr = rc.create1MinusNode(
blendNodeAttr,
self.m_name+"OppBlend_CTRL"
)
self.m_controls = []
self.m_parentCtrls = []
self.m_pointCtrls = []
startPos = cmds.xform(self.m_parent1, q=1, t=1, ws=1)
endPos = cmds.xform(self.m_parent2, q=1, t=1, ws=1)
stepVec = vec.divide(
vec.subtract(endPos, startPos),
self.m_numCtrls + 1
)
currentPos = vec.add(startPos, stepVec)
for i in range(self.m_numCtrls):
newCtrl = self.m_name+"_"+str(i)+"_CTRL"
parentCtrl = self.m_name+"_"+str(i)+"_parent_CTRL"
pointCtrl = self.m_name+"_"+str(i)+"_point_CTRL"
newCtrl = cmds.spaceLocator(n=newCtrl)[0]
self.m_controls.append(newCtrl)
cmds.parent(newCtrl, self.m_group)
cmds.xform(newCtrl, t=currentPos, ws=1)
newCtrlGroups = rg.add3Groups(newCtrl, ["_SDK", "_CONST", "_0"])
if self.m_isAutoBend:
parentCtrl = cmds.duplicate(newCtrl, n=parentCtrl)[0]
cmds.parent(parentCtrl, newCtrlGroups[2])
#cmds.setAttr(parentCtrl+".visibility", 0)
pointCtrl = cmds.duplicate(newCtrl, n=pointCtrl)[0]
cmds.parent(pointCtrl, newCtrlGroups[2])
#cmds.setAttr(pointCtrl+".visibility", 0)
rc.addToLayer(self.m_sceneData, "hidden", [parentCtrl, pointCtrl])
#Create blend between parent and point setups
blendConst = cmds.pointConstraint(parentCtrl, newCtrlGroups[1])
cmds.connectAttr(blendNodeAttr, blendConst[0]+"."+parentCtrl+"W0")
blendConst = cmds.pointConstraint(pointCtrl, newCtrlGroups[1])
cmds.connectAttr(oppBlendNodeAttr, blendConst[0]+"."+pointCtrl+"W1")
self.m_parentCtrls.append(parentCtrl)
self.m_pointCtrls.append(pointCtrl)
grandParent = cmds.listRelatives(self.m_parent1, p=1)
if grandParent == None or not self.m_isParentBend:
grandParent = self.m_parent1
parentConst = rc.applyWeightedConstraint(
grandParent,
parentCtrl,
self.m_parent2,
cmds.parentConstraint
)
pointConst = rc.applyWeightedConstraint(
self.m_parent1,
pointCtrl,
self.m_parent2,
cmds.pointConstraint
)
cmds.aimConstraint(
self.m_parent2,
newCtrlGroups[1]
)
currentPos = vec.add(currentPos, stepVec)
#lock attrs
cmds.setAttr(newCtrl+".rotate", l=1)
cmds.setAttr(newCtrl+".scale", l=1)
rc.addToLayer(self.m_sceneData, "detailCtrl", self.m_controls)
# Add controls
i=0
for control in self.m_controls:
rc.addToControlDict(self.m_allControls, "%s_%d_detail" %(self.m_baseName, i), control)
i+=1
def createIK(self):
numCVs = self.m_numCtrls - 1
if self.m_numCtrls == 1:
numCVs = 4
ikResult = cmds.ikHandle(
sol = "ikSplineSolver",
sj=self.m_bindJoints[0],
ee=self.m_bindJoints[-1],
ns=numCVs,
n = self.m_name + "_IK"
)
# deselect so we don't get warnings
cmds.select(d=1)
self.m_ikCurve = ikResult[2]
rc.addToLayer(self.m_sceneData, "hidden", self.m_ikCurve)
newCurveName = self.m_name+"_IK_CURVE"
self.m_ikCurve = cmds.rename(self.m_ikCurve, newCurveName)
self.m_ikHandle = ikResult[0]
cmds.parent(self.m_ikHandle, self.m_group)
#cmds.setAttr(self.m_ikHandle+".visibility", 0)
rc.addToLayer(self.m_sceneData, "hidden", [self.m_ikHandle])
#Make sure curve does not get double transformed
cmds.setAttr(self.m_ikCurve+".inheritsTransform", 0)
self.m_clusters = []
#Create clusters
if len(self.m_controls) == 1:
name = self.m_parent1[:self.m_parent1.rfind("_")]+"_stretch_CLUSTER"
self.m_clusters.append(self.clusterPoint(
[
self.m_ikCurve+".cv[0]",
self.m_ikCurve+".cv[1]"
],
self.m_parent1,
name,
cmds.pointConstraint,
self.m_parent2
))
name = self.m_controls[0][:self.m_controls[0].rfind("_")]+\
"_stretch_CLUSTER"
self.m_clusters.append(self.clusterPoint(
[
self.m_ikCurve+".cv["+str(2)+"]",
self.m_ikCurve+".cv["+str(3)+"]",
self.m_ikCurve+".cv["+str(4)+"]"
],
self.m_controls[0],
name
))
name = self.m_parent2[:self.m_parent2.rfind("_")]+"_stretch_CLUSTER"
self.m_clusters.append(self.clusterPoint(
[
self.m_ikCurve+".cv["+str(5)+"]",
self.m_ikCurve+".cv["+str(6)+"]"
],
self.m_parent2,
name,
cmds.pointConstraint,
self.m_parent1
))
else:
name = self.m_parent1[:self.m_parent1.rfind("_")]+"_stretch_CLUSTER"
self.m_clusters.append(self.clusterPoint(self.m_ikCurve+".cv[0]", self.m_parent1, name))
for i in range(0, len(self.m_controls)):
name = self.m_controls[i][:self.m_controls[i].rfind("_")]+\
"_stretch_CLUSTER"
self.m_clusters.append(self.clusterPoint(
self.m_ikCurve+".cv["+str(i+1)+"]",
self.m_controls[i],
name
))
name = self.m_parent2[:self.m_parent2.rfind("_")]+"_stretch_CLUSTER"
self.m_clusters.append(self.clusterPoint(
self.m_ikCurve+".cv["+str(self.m_numCtrls+2)+"]",
self.m_parent2,
name
))
#Do stretch
self.m_curveInfo = cmds.createNode(
"curveInfo",
n=self.m_name+"_CURVEINFO"
)
cmds.connectAttr(
self.m_ikCurve+".worldSpace",
self.m_curveInfo+".inputCurve"
)
scaleComp = cmds.createNode(
"multiplyDivide",
n=self.m_name+"_IK_scaleComp_MULT"
)
cmds.setAttr(scaleComp+".operation", 2)
cmds.connectAttr(
self.m_curveInfo+".arcLength",
scaleComp+".input1X"
)
cmds.connectAttr(self.m_scaleNull+".sx", scaleComp+".input2X")
normaliseNode = cmds.createNode(
"multiplyDivide",
n=self.m_name+"_normalise_MULT"
)
cmds.connectAttr(scaleComp+".outputX", normaliseNode+".input1X")
cmds.setAttr(normaliseNode+".input2X", self.m_numJoints-1)
cmds.setAttr(normaliseNode+".operation", 2)
# VOLUME RETENTION #
#Create overall stretch node
stretchAmount = cmds.createNode(
"multiplyDivide",
n=self.m_name+"_IK_sretchValue_MULT"
)
# #---set to division
cmds.setAttr(stretchAmount+".operation", 2)
cmds.connectAttr(
self.m_curveInfo+".arcLength",
stretchAmount+".input1X"
)
currentLen = cmds.getAttr(self.m_curveInfo+".arcLength")
cmds.setAttr(stretchAmount+".input2X", currentLen)
# Add squetch control
cmds.addAttr(
self.m_blendControl,
ln=self.m_squetchAttrName,
min=0,
dv=1,
k=1
)
cmds.addAttr(
self.m_blendControl,
ln=self.m_squetchBoolAttrName,
k=1,
dv=1,
at="bool"
)
stretchExp = self.makeStretchExpression(
self.m_blendControl+"."+self.m_squetchAttrName,
stretchAmount+".outputX",
self.m_blendControl+"."+self.m_squetchBoolAttrName
)
cmds.expression(n=self.m_name+"_IK_stretch_EXP", s=stretchExp)
def createTwist(self):
numJoints = len(self.m_bindJoints)
if numJoints == 0:
raise Exception, "No joints, cannot create twist setup"
#Create twist controls
# Twist 1
self.m_twistControl1 = cmds.spaceLocator(
n="%s_upperTwist_CTRL" %(self.m_name)
)[0]
#cmds.parent(self.m_twistControl1, self.m_parent1, r=1)
# Twist 2
self.m_twistControl2 = cmds.spaceLocator(
n="%s_lowerTwist_CTRL" %(self.m_name)
)[0]
#cmds.parent(self.m_twistControl2, self.m_parent2, r=1)
for control, parent in map(
None,
[self.m_twistControl1, self.m_twistControl2],
[self.m_parent1, self.m_parent2]
):
rc.orientControl(control, parent)
groups = rg.add3Groups(control, ["_SDK", "_CONST", "_0"])
if self.m_isMirrored:
cmds.setAttr(
"%s.t%s" %(groups[0], self.m_twistAxis),
1
)
else:
cmds.setAttr(
"%s.t%s" %(groups[0], self.m_twistAxis),
-1
)
if self.m_isParentTwist:
cmds.parentConstraint(parent, groups[1], mo=1)
cmds.parent(groups[2], self.m_group)
rc.lockAttrs(
control,
["rotate", "scale", "visibility"],
True,
False
)
cmds.setAttr("%s.dTwistControlEnable" %(self.m_ikHandle), 1)
cmds.setAttr("%s.dWorldUpType" %(self.m_ikHandle), 2)
cmds.setAttr("%s.dTwistValueType" %(self.m_ikHandle), 1)
if self.m_twistAxis == "y":
if self.m_isMirrored:
cmds.setAttr("%s.dWorldUpAxis" %(self.m_ikHandle), 0)
else:
cmds.setAttr("%s.dWorldUpAxis" %(self.m_ikHandle), 1)
else:
if self.m_isMirrored:
cmds.setAttr("%s.dWorldUpAxis" %(self.m_ikHandle), 3)
else:
cmds.setAttr("%s.dWorldUpAxis" %(self.m_ikHandle), 4)
cmds.connectAttr(
"%s.worldMatrix[0]" %(self.m_twistControl1),
"%s.dWorldUpMatrix" %(self.m_ikHandle),
f = True
)
cmds.connectAttr(
"%s.worldMatrix[0]" %(self.m_twistControl2),
"%s.dWorldUpMatrixEnd" %(self.m_ikHandle),
f = True
)
rc.addToLayer(self.m_sceneData, "detailCtrl", [self.m_twistControl1, self.m_twistControl2])
#Add to controls
rc.addToControlDict(self.m_allControls, "%s_topTwist" %(self.m_baseName), self.m_twistControl1)
rc.addToControlDict(self.m_allControls, "%s_lowTwist" %(self.m_baseName), self.m_twistControl2)
def setupStretch(self):
#Create the bendy bits
self.m_upperStretch = chain.StretchChain(
self.m_sceneData,
self.m_joints.m_shoulder,
self.m_elbowTwistJoints[0], #self.m_joints.m_elbow1,#
self.m_name+"_upperStretch",
"%s_upperStretch" %(self.m_baseName),
self.m_numLowerControls,
self.m_numUpperJoints
)
self.m_upperStretch.setMirroring(self.m_isMirrored)
self.m_upperStretch.setBendFromParent(False)
self.m_upperStretch.setBlendControl(self.m_controlObject)
self.m_upperStretch.setBlendAttrName("upperBend")
self.m_upperStretch.setSquetchAttrName("upperSquetchiness")
self.m_upperStretch.setSquetchBoolAttrName("upperSquetchOnOff")
self.m_upperStretch.setAttrHeading("UPPER")
self.m_upperStretch.setTwistAxis(self.m_twistAxis)
self.m_upperStretch.setBindJoints(self.m_upperStretchJoints)
self.m_upperStretch.setIsParentTwist(False)
self.m_upperArmGRP = self.m_upperStretch.generate()
cmds.parent(self.m_upperArmGRP, self.m_group)
self.m_lowerStretch = chain.StretchChain(
self.m_sceneData,
self.m_elbowTwistJoints[1], #self.m_joints.m_elbow1,#
self.m_joints.m_wrist,
self.m_name+"_lowerStretch",
"%s_lowerStretch" %(self.m_baseName),
self.m_numLowerControls,
self.m_numLowerJoints
)
self.m_lowerStretch.setMirroring(self.m_isMirrored)
self.m_lowerStretch.setBlendControl(self.m_controlObject)
self.m_lowerStretch.setBlendAttrName("lowerBend")
self.m_lowerStretch.setSquetchAttrName("lowerSquetchiness")
self.m_lowerStretch.setSquetchBoolAttrName("lowerSquetchOnOff")
self.m_lowerStretch.setAttrHeading("LOWER")
self.m_lowerStretch.setTwistAxis(self.m_twistAxis)
self.m_lowerStretch.setBindJoints(self.m_lowerStretchJoints)
self.m_lowerStretch.setIsParentTwist(False)
self.m_lowerArmGRP = self.m_lowerStretch.generate()
cmds.parent(self.m_lowerArmGRP, self.m_group)
# Sort out twist controls (parenting)
lowerTwistControls = self.m_lowerStretch.getTwistControls()
upperTwistControls = self.m_upperStretch.getTwistControls()
# --- connect up elbow twists
cmds.parentConstraint(upperTwistControls[1], "%s_CONST" %(lowerTwistControls[0]))
# --- parent elbow twist to bind joint
cmds.parentConstraint(self.m_joints.m_elbow1, "%s_CONST" %(upperTwistControls[1]), mo=1)
# --- parent wrist twist to bind joint
cmds.parentConstraint(self.m_joints.m_wrist, "%s_CONST" %(lowerTwistControls[1]), mo=1)
# fix elbow twist
cmds.aimConstraint(self.m_twistAimConstraint, e=1, wut="object", wuo=upperTwistControls[1])
rc.addDictToControlDict(self.m_allControls, self.m_upperStretch.getAllControls())
rc.addDictToControlDict(self.m_allControls, self.m_lowerStretch.getAllControls())
# Hide unused twist controls
rc.addToLayer(self.m_sceneData, "detailCtrl", [lowerTwistControls[1]] + upperTwistControls)
rc.addToLayer(self.m_sceneData, "hidden", lowerTwistControls[0])
def generate(self):
# Create IK
self.m_ikJoints = self.duplicateJoints(self.m_topJoint, "IK")
rc.addToLayer(self.m_sceneData, "ref", self.m_ikJoints[0])
self.m_ikFoot = IKFoot.IKFootRig(
self.m_sceneData,
"%s_IK" %(self.m_name),
self.m_baseName,
self.m_ikJoints,
self.m_footToePivot,
self.m_footHeelPivot,
self.m_footInsidePivot,
self.m_footOutsidePivot,
self.m_footMain,
self.m_ankleIK
)
self.m_ikFoot.generate()
cmds.parent(self.m_ikFoot.getGroup(), self.m_group)
# Create FK
self.m_fkJoints = self.duplicateJoints(self.m_topJoint, "FK")
rc.addToLayer(self.m_sceneData, "ref", self.m_fkJoints[0])
self.m_fkFoot = FKFoot.FKFootRig(
self.m_sceneData,
"%s_FK" %(self.m_name),
self.m_baseName,
self.m_fkJoints,
self.m_footMain,
self.m_parentFK
)
self.m_fkFoot.generate()
cmds.parent(self.m_fkFoot.getGroup(), self.m_group)
# Create BIND
self.m_bindJoints = self.duplicateJoints(
self.m_topJoint,
"BIND"
)
rc.addToLayer(self.m_sceneData, "ref", self.m_bindJoints[0])
bindGroups = rg.add3Groups(
self.m_bindJoints[0],
["_SDK", "_CONST", "_0"]
)
cmds.parent(bindGroups[-1], self.m_group)
self.connectBind()
# connect to parent
cmds.parentConstraint(self.m_parentBIND, bindGroups[-1], mo=1)
# connect to parent twist
# Strip constraint
targetList = cmds.parentConstraint(self.m_parentTwist, q=1, tl=1)
try:
cmds.parentConstraint(targetList, self.m_parentTwist, e=True, rm=True)
except:
print "Warning couldn't remove constraint when creating foot attachment"
# Add new constraint
cmds.parentConstraint(self.m_bindJoints[0], self.m_parentTwist, mo=1)
# Add to sets
rc.addToSet(self.m_sceneData, "bind", self.m_bindJoints)
# Add to controls
rc.addDictToControlDict(self.m_allControls, self.m_ikFoot.getAllControls())
rc.addDictToControlDict(self.m_allControls, self.m_fkFoot.getAllControls())
def setupStretch(self):
# Create nodes to get locator positions
topDecomp = cmds.createNode(
"decomposeMatrix",
n=self.m_name+"_posMatTop_NODE"
)
bottomDecomp = cmds.createNode(
"decomposeMatrix",
n=self.m_name+"_posMatBottom_NODE"
)
middleDecomp = cmds.createNode(
"decomposeMatrix",
n="%s_posMatMid_NODE" %(self.m_name)
)
cmds.connectAttr(
self.m_shoulderCtrl+".worldMatrix",
topDecomp+".inputMatrix"
)
cmds.connectAttr(
self.m_wristCtrl+".worldMatrix",
bottomDecomp+".inputMatrix"
)
cmds.connectAttr(
self.m_poleVec+".worldMatrix",
middleDecomp+".inputMatrix"
)
#Create distance nodes
distTotal = cmds.createNode(
"distanceDimShape",
n=self.m_name+"_StretchMain_DIST"
)
distTop = cmds.createNode(
"distanceDimShape",
n=self.m_name+"_StretchTop_DIST"
)
distBottom = cmds.createNode(
"distanceDimShape",
n=self.m_name+"_StretchBottom_DIST"
)
# Connect distance nodes to locator positions
# main
cmds.connectAttr(topDecomp+".outputTranslate", distTotal+".startPoint")
cmds.connectAttr(bottomDecomp+".outputTranslate", distTotal+".endPoint")
# top
cmds.connectAttr(
"%s.outputTranslate" %(topDecomp),
"%s.startPoint" %(distTop)
)
cmds.connectAttr(
"%s.outputTranslate" %(middleDecomp),
"%s.endPoint" %(distTop)
)
# bottom
cmds.connectAttr(
"%s.outputTranslate" %(middleDecomp),
"%s.startPoint" %(distBottom)
)
cmds.connectAttr(
"%s.outputTranslate" %(bottomDecomp),
"%s.endPoint" %(distBottom)
)
#Neaten up dist nodes
distNodes = [distTotal, distTop, distBottom]
for node in distNodes:
distParent = cmds.listRelatives(node, p=1)
distParent = distParent[0]
cmds.parent(distParent, self.m_group)
rc.addToLayer(self.m_sceneData, "hidden", distNodes)
#Create angle nodes
angleAttr = self.createAngleNode(
cmds.listRelatives(self.m_shoulderCtrl, s=1)[0],
cmds.listRelatives(self.m_poleVec, s=1)[0],
cmds.listRelatives(self.m_wristCtrl, s=1)[0]
)
exp = self.createStretchExp(distTotal, distTop, distBottom, angleAttr)
cmds.expression(n="%s_stretch_EXP" %(self.m_name), s=exp)
