def rigBlendControl(self, _parent):
# Move and parent blend control
rc.orientControl(self.m_blendControl, _parent)
group = rg.addGroup(self.m_blendControl, "%s_0" %(self.m_blendControl))
moveValue = -2
if self.m_isMirrored:
moveValue *= -1
cmds.setAttr("%s.t%s" %(self.m_blendControl, self.m_twistAxis), moveValue)
cmds.parentConstraint(_parent, group, mo=1)
rc.lockAttrs(
self.m_blendControl,
[
"tx",
"ty",
"tz",
"rx",
"ry",
"rz",
"sx",
"sy",
"sz",
"visibility"
],
True,
True
)
def generate(self):
self.m_fingers = []
names = ["indexFing", "middleFing", "ringFing", "pinkyFing", "thumb"]
for i in range(len(names)):
thumb = False
if i == (len(names) - 1):
thumb = True
newFinger = fing.FingerRig(
"%s_%s" %(self.m_name, names[i]),
self.m_handJoints.getFinger(i),
thumb
)
newFinger.generate()
cmds.parent(newFinger.getGroup(), self.m_group)
self.m_fingers.append(newFinger)
#create control
self.m_control = cmds.spaceLocator(n="%s_CTRL" %(self.m_name))[0]
rc.orientControl(self.m_control, self.m_fingers[3].getKnuckle())
group = rg.addGroup(self.m_control, "%s_0" %(self.m_control))
rc.lockAttrs(self.m_control, ["tx", "rotate", "scale"], True, False)
cmds.parent(group, self.m_group)
cmds.expression(n="%s_EXP" %(self.m_name), s=self.createExp())
def __init__(
self,
_sceneData,
_name,
_baseName,
_topJoint,
_toePivot,
_heelPivot,
_insidePivot,
_outsidePivot,
_footMain,
_ankleIK,
_parentFK,
_parentBIND,
_parentTwist,
_blendControl = False,
_blendAttr = "IK_FK_Blend"
):
self.m_sceneData = _sceneData
self.m_name = _name
self.m_baseName = _baseName
self.m_group = cmds.group(n="%s_GRP" %(self.m_name), em=True)
self.m_topJoint = _topJoint
self.m_footToePivot = _toePivot
self.m_footHeelPivot = _heelPivot
self.m_footInsidePivot = _insidePivot
self.m_footOutsidePivot = _outsidePivot
self.m_footMain = _footMain
self.m_ankleIK = _ankleIK
self.m_parentFK = _parentFK
self.m_parentBIND = _parentBIND
self.m_parentTwist = _parentTwist
self.m_blendAttr = _blendAttr
self.m_allControls = {}
if _blendControl:
self.m_blendControl = _blendControl
else:
self.m_blendControl = cmds.circle(
n="%s_blend_CTRL" %(self.m_name),
)[0]
rc.addToControlDict(
self.m_allControls,
"%s_IKFKBlend" %(self.m_blendControl),
self.m_blendControl
)
cmds.parent(self.m_blendControl, self.m_group)
if not cmds.objExists(
"%s.%s" %(self.m_blendControl, self.m_blendAttr
)):
cmds.addAttr(
self.m_blendControl,
ln=self.m_blendAttr,
at="float",
min = 0,
max = 1,
dv = 0,
k=1
)
def generate(self):
# Generate Leg
self.m_legRig = arm.ArmRig(
self.m_sceneData,
self.m_legJoints,
self.m_name,
self.m_baseName,
self.m_twistAxis,
False
)
self.m_legRig.setUpperStretchChain(
self.m_numUpperControls,
self.m_upperStretchJoints,
self.m_numUpperJoints
)
self.m_legRig.setLowerStretchChain(
self.m_numLowerControls,
self.m_lowerStretchJoints,
self.m_numLowerJoints
)
self.m_legRig.generate()
rc.addDictToControlDict(self.m_allControls, self.m_legRig.getAllControls())
# Generate Foot
self.m_footRig = fr.FootRig(
self.m_sceneData,
"%s_foot" %(self.m_name),
self.m_baseName,
self.m_footJoints[0],
self.m_toePivot,
self.m_heelPivot,
self.m_insidePivot,
self.m_outsidePivot,
self.m_footMain,
self.m_legRig.getIKControl(),
self.m_legRig.getFKParent(),
self.m_legRig.getBINDParent(),
self.m_legRig.getAnkleTwist(),
self.m_legRig.getBlendControl()
)
self.m_footRig.generate()
rc.addDictToControlDict(self.m_allControls, self.m_footRig.getAllControls())
cmds.parent(self.m_footRig.getGroup(), self.m_group)
#Rig blend control
self.m_legRig.rigBlendControl(self.m_footRig.getAnkleJoint())
# Connect up visibility
ikVis, fkVis = self.m_legRig.getVisibilityAttrs()
cmds.connectAttr(
ikVis,
"%s.visibility" %(self.m_footRig.m_ikFoot.getGroup())
)
cmds.connectAttr(
fkVis,
"%s.visibility" %(self.m_footRig.m_fkFoot.getGroup())
)
def duplicateJoints(self, _joints, _postFix):
newJoints = cmds.duplicate(_joints.m_shoulder, rc=1)
if cmds.listRelatives(newJoints[0], p=True):
cmds.parent(newJoints[0], w=True)
for i in range(0, len(_joints)):
jointNameEnd = _joints[i].find("_")
newName = self.m_name+"_"+_postFix+"_"+\
_joints[i][:jointNameEnd] + "_JNT"
newJoints[i] = cmds.rename(newJoints[i], newName)
rc.stripSets(newJoints[i])
return aj.ArmJoints(newJoints)
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 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 duplicateJoints(self, _topJoint, _tagName):
dupJoints = cmds.duplicate(_topJoint, rc=True)
if cmds.listRelatives(dupJoints[0], p=True):
cmds.parent(dupJoints[0], w=True)
i = 0
for name in [
"%s_%s_ankle_JNT" %(self.m_name, _tagName),
"%s_%s_ball_JNT" %(self.m_name, _tagName),
"%s_%s_toeEND_JNT"%(self.m_name, _tagName)
]:
cmds.rename(dupJoints[i], name)
dupJoints[i] = name
rc.stripSets(dupJoints[i])
i+=1
return dupJoints
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 connectBind(self):
#Create opposite node to blend
blendOpposite = rc.create1MinusNode(
"%s.%s" %(self.m_blendControl, self.m_blendAttr),
"%s_IKFKBlendOpp_CTRL" %(self.m_name)
)
for i in range(len(self.m_bindJoints)):
const1 = cmds.parentConstraint(
self.m_ikJoints[i],
self.m_bindJoints[i],
st = ["x", "y", "z"]
)[0]
const2 = cmds.parentConstraint(
self.m_fkJoints[i],
self.m_bindJoints[i],
st = ["x", "y", "z"]
)[0]
cmds.connectAttr(
blendOpposite,
"%s.blendParent2" %(self.m_bindJoints[i])
)
# Change to quarternion
pairBlend = cmds.listConnections(
"%s.constraintRotateX" %(const1),
d=1
)[0]
cmds.setAttr("%s.rotInterpolation" %(pairBlend), 1)
def 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 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 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 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 __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 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 generateAutoClav(_name, _shoulderSDK, _wristIK):
print "doing something"
error.assertString(_name)
error.assertMayaObject(_shoulderSDK)
error.assertMayaObject(_wristIK)
cmds.select(clear=True)
# Create joints
joint1 = cmds.joint(n="%s_IK_JNT" %(_name))
rc.copyTranslation(joint1, _shoulderSDK)
joint2 = cmds.joint(n="%s_IKEND_JNT" %(_name))
rc.copyTranslation(joint2, _wristIK)
#cmds.parent(joint2, joint1)
# Create IK
ikControl = cmds.ikHandle(
n="%s_IK" %(_name),
sol="ikRPsolver",
sj= joint1,
ee=joint2
)[0]
# deselect so we don't get warnings
cmds.select(d=1)
# Create pole vec
locator = cmds.spaceLocator(n="%s_up_LOC" %(_name))[0]
rc.orientControl(locator, _wristIK)
locGroup = rg.addGroup(locator, "%s_0" %(locator))
cmds.setAttr("%s.ty" %(locator), 2)
cmds.poleVectorConstraint(locator, ikControl)
# Connect up to rig
cmds.pointConstraint(_wristIK, locGroup, mo=1)
cmds.pointConstraint(_wristIK, ikControl, mo=1)
cmds.orientConstraint(joint1, _shoulderSDK, mo=1)
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 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 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 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 connectIKFK(self):
blendAttrName = "IK_FK_Blend"
self.m_blendAttr = self.m_blendControl + "." + blendAttrName
try:
cmds.setAttr(self.m_blendAttr, 0)
print "WARNING, IK_FK_Blend attribute already exsits"
except:
cmds.addAttr(
self.m_blendControl,
ln=blendAttrName,
min = 0,
max = 1,
k = 1
)
self.m_blendAttr = self.m_blendControl + "." + blendAttrName
self.m_blendOppAttr = rc.create1MinusNode(
self.m_blendAttr,
self.m_name+"_IKFKBlendOpp_CTRL"
)
# Attach each joint to BIND
bindJoints = self.m_bindRig.m_joints
ikJoints = self.m_ikRig.m_joints
fkJoints = self.m_fkRig.m_joints
for i in range(0, len(bindJoints) - 1):
#Orientation
const1 = cmds.parentConstraint(
ikJoints[i],
bindJoints[i],
st = ["x", "y", "z"]
)
const1 = const1[0]
const2 = cmds.parentConstraint(
fkJoints[i],
bindJoints[i],
st = ["x", "y", "z"]
)
const2 = const2[0]
cmds.connectAttr(
self.m_blendOppAttr,
"%s.blendParent2" %(bindJoints[i])
)
# Set rotation method to quarternion
# get pair blend node
pairBlend = cmds.listConnections(
"%s.constraintRotateX" %(const1),
d=True
)
pairBlend = pairBlend[0]
cmds.setAttr("%s.rotInterpolation" %(pairBlend), 1)
for i in range(1, len(bindJoints)):
# Connect up blended lengths
blendedAttr = self.createBlendAttr(
rg.stripMiddle(ikJoints[i], 0, 1),
ikJoints[i] + ".translateX",
fkJoints[i] + ".translateX",
self.m_blendAttr, self.m_blendOppAttr
)
cmds.connectAttr(blendedAttr, bindJoints[i] + ".translateX")
# Fix wrist rotations
self.m_bindRig.aimWrist(self.m_ikRig.getIKControl(), [self.m_blendAttr, self.m_blendOppAttr])
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 generate(self):
if self.m_isThumb:
names = ["metacarpal", "knuckle", "tip", "tipEND"]
else:
names = ["metacarpal", "knuckle", "mid", "tip", "tipEND"]
i = 0
parentControl = False
self.m_controls = []
self.m_stretchControls = []
for joint in self.m_joints:
# Create control
newStretch = False
if joint != self.m_joints[0]:
#Create stretch control
stretchName = "%s_%s_stretch_CTRL" %(self.m_name, names[i])
newStretch = cmds.spaceLocator(n=stretchName)[0]
rc.setMultiAttrs(
newStretch,
["localScaleX", "localScaleY", "localScaleZ"],
0.15
)
rc.orientControl(newStretch, cmds.listRelatives(joint, p=1)[0])
rc.copyTranslation(newStretch, joint)
if parentControl:
cmds.parent(newStretch, parentControl)
else:
cmds.parent(newStretch, self.m_group)
rg.add3Groups(
newStretch,
["_SDK", "_CONST", "_0"]
)
# lock unused attrs
rc.lockAttrs(
newStretch,
["ty", "tz", "rotate", "scale"],
True,
False
)
parentControl = newStretch
if joint != self.m_joints[-1]:
controlName = "%s_%s_CTRL" %(self.m_name, names[i])
newControl = cmds.circle(
n=controlName,
nr=(1, 0, 0),
r=0.1
)[0]
rc.orientControl(newControl, joint)
if parentControl:
cmds.parent(newControl, parentControl)
else:
cmds.parent(newControl, self.m_group)
self.m_controls.append(newControl)
groups = rg.add3Groups(newControl, ["_SDK", "_CONST", "_0"])
if newStretch:
# Attach to stretch
cmds.parentConstraint(newStretch, groups[1], mo=1)
# Attach to joint
cmds.parentConstraint(newControl, joint, mo=1)
rc.lockAttrs(
newControl,
["translate", "scale"],
True,
False
)
parentControl = newControl
i += 1
else:
cmds.parentConstraint(newStretch, joint, mo=1)
# Rig metacarpals
if not self.m_isThumb:
pass
self.m_isGenerated = True
def getUpperLength(self):
assert self.m_isGenerated, "Rig not generated"
return rc.getDistBetween(self.m_controls[0], self.m_controls[1])
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)
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):
# 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 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