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 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 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,
_joints,
_toePivot,
_heelPivot,
_insidePivot,
_outsidePivot,
_footMain,
_ankleIK
):
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_joints = _joints
jointGroup = rg.addGroup(self.m_joints[0], "%s_0" %(self.m_joints[0]))
cmds.parent(jointGroup, self.m_group)
self.m_toePivotLoc = _toePivot
self.m_heelPivotLoc = _heelPivot
self.m_insidePivotLoc = _insidePivot
self.m_outsidePivotLoc = _outsidePivot
self.m_footMainLoc = _footMain
self.m_ankleIK = _ankleIK
self.m_allControls = {}
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 __init__(
self,
_sceneData,
_joints,
_name,
_baseName,
_controlObject,
_numUpperControls,
_numLowerControls,
_numUpperJoints,
_numLowerJoints,
_upperStretchJoint,
_lowerStretchJoint,
_isMirrored=False,
_twistAxis = "y",
_rigWrist = True,
):
self.m_sceneData = _sceneData
self.m_isMirrored = _isMirrored
self.m_joints = aj.ArmJoints(_joints)
self.m_name = _name
self.m_baseName = _baseName
self.m_controlObject = _controlObject
self.m_twistAxis = _twistAxis
self.m_rigWrist = _rigWrist
tmp = rg.stripMiddle(self.m_joints.m_shoulder, 0, 3)
self.m_group = self.m_name+"_GRP"
self.m_group = cmds.group(n=self.m_group, em=1)
cmds.parent(self.m_joints.m_shoulder, self.m_group, r=1)
#Add transform group
self.m_mainTransform = rg.addGroup(
self.m_joints.m_shoulder,
"%s_0" %(self.m_joints.m_shoulder)
)
self.m_allControls = {}
self.m_isGenerated = False
self.m_elbowTwistJoints = []
# stretch chain parameters
self.m_numUpperControls = _numUpperControls
self.m_numLowerControls = _numLowerControls
self.m_numUpperJoints = _numUpperJoints
self.m_numLowerJoints = _numLowerJoints
self.m_upperStretchJoints = _upperStretchJoint
self.m_lowerStretchJoints = _lowerStretchJoint
def makeCTRL(_jointName, _isDigitCtrl, _attachFK, _ext = False,_jntExt = "_CTRL"):
_controlName = changeExt (_jointName, _jntExt)
#create a circle with the desired name and orient
#it to the joint
cmds.circle(name = _controlName, nr=(1, 0, 0), c=(0, 0, 0) )
orientControl (_controlName, _jointName)
#if it is a control meant for a finger or toe or claw or any other
#kind of digit imaginable, modify the shape accordingly
if (_isDigitCtrl == True):
cmds.select(_controlName+".cv[0:7]")
cmds.move(0,0,-2, os = True, r = True)
cmds.select(clear = True)
cmds.select(_controlName+".cv[4]", _controlName+".cv[6]")
cmds.scale(1,0.1,1)
cmds.move(0,0,-0.6, os = True, r = True)
cmds.select(clear = True)
cmds.select(_controlName+".cv[3]", _controlName+".cv[7]")
cmds.scale(1,0.7,1)
cmds.select(clear = True)
cmds.select(_controlName+".cv[0:7]")
cmds.scale(1,0.8,1)
cmds.scale(0.5,0.5,0.5, os = True)
cmds.select(clear = True)
#add the default 3 groups
rg.add3Groups(_controlName, _ext)
#if attachFK is true, set up the orient constraint
if (_attachFK == True):
"""
cmds.parentConstraint(
_controlName,
_jointName,
st = ["x", "y", "z"]
)
"""
cmds.orientConstraint(_controlName, _jointName)
return _controlName
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 __init__(self, _sceneData, _joints, _name, _baseName, _isMirrored=False, _twistAxis="y"):
self.m_sceneData = _sceneData
self.m_joints = aj.ArmJoints(_joints)
self.m_name = _name
self.m_baseName = _baseName
tmp = rg.stripMiddle(self.m_joints.m_shoulder, 0, 3)
self.m_group = _name+"_GRP"
self.m_group = cmds.group(n=self.m_group, em=1)
cmds.parent(self.m_joints.m_shoulder, self.m_group, r=1)
self.m_poleVecPinAttr = "polePin"
self.m_maxStretchAttr = "maxStretchOffset"
self.m_isMirrored = False
self.m_twistAxis = _twistAxis
self.m_allControls = {}
self.m_isGenerated = 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 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 __init__(
self,
_sceneData,
_name,
_baseName,
_joints,
_footMain,
_parent
):
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_joints = _joints
self.m_footMain = _footMain
self.m_parent = _parent
self.m_allControls = {}
jointGroup = rg.addGroup(self.m_joints[0], "%s_0" %(self.m_joints[0]))
cmds.parent(jointGroup, self.m_group)
self.m_ankleGenerated = False
self.m_toeGenerated = False
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 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 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 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 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 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
