def RMCircularControl(self, Obj, radius=1, axis="X", name=""):
Obj = RMRigTools.validate_pymel_nodes(Obj)
if name == '':
defaultName = "circularControl"
else:
defaultName = name
if axis in "yY":
Ctrl, Shape = pm.circle(normal=[0, 1, 0],
radius=radius,
name=defaultName)
elif axis in "zZ":
Ctrl, Shape = pm.circle(normal=[0, 0, 1],
radius=radius,
name=defaultName)
elif axis in "xX":
Ctrl, Shape = pm.circle(normal=[1, 0, 0],
radius=radius,
name=defaultName)
if name == 'circularControl':
if self.NameConv.is_name_in_format(Obj):
self.NameConv.rename_based_on_base_name(Obj, Ctrl)
else:
self.NameConv.rename_name_in_format(Ctrl,
name=name,
objectType='control')
else:
self.NameConv.rename_name_in_format(Ctrl,
name=name,
objectType='control')
RMRigTools.RMAlign(Obj, Ctrl, 3)
ResetGroup = self.rigTools.RMCreateGroupOnObj(Ctrl)
return ResetGroup, Ctrl
def RMCircularControl(Obj, radius=1, NameConv=None, axis="X", name=""):
Obj = RMRigTools.validate_pymel_nodes(Obj)
if not NameConv:
NameConv = nameConvention.NameConvention()
if name == '':
defaultName = "circularControl"
else:
defaultName = name
if axis in "yY":
Ctrl, Shape = pm.circle(normal=[0, 1, 0],
radius=radius,
name=defaultName)
elif axis in "zZ":
Ctrl, Shape = pm.circle(normal=[0, 0, 1],
radius=radius,
name=defaultName)
elif axis in "xX":
Ctrl, Shape = pm.circle(normal=[1, 0, 0],
radius=radius,
name=defaultName)
if name == '' and NameConv.is_name_in_format(Obj):
NameConv.rename_based_on_base_name(Obj, Ctrl)
else:
NameConv.rename_based_on_base_name(Obj, Ctrl, name=Ctrl)
NameConv.rename_set_from_name(Ctrl, "control", "objectType")
RMRigTools.RMAlign(Obj, Ctrl, 3)
ResetGroup = RMRigTools.RMCreateGroupOnObj(Ctrl)
return ResetGroup, Ctrl
def SpiralOfPoints(initRadius, endRadius, turns, numberOfPoints):
loc1 = cmds.spaceLocator()
loc2 = cmds.spaceLocator()
cmds.parent(loc2[0], loc1[0])
cmds.setAttr(loc2[0] + ".translateX", float(initRadius))
groupPoints = cmds.group(empty=True)
degreeTurns = float(turns * 360)
degreeStep = float(degreeTurns) / (numberOfPoints - 1)
posStep = (float(initRadius) - float(endRadius)) / (numberOfPoints - 1)
spcLocArray = []
startRot = 0.0
startPos = float(initRadius)
for point in range(0, numberOfPoints):
NewLoc = cmds.spaceLocator()
spcLocArray.append(NewLoc[0])
RMRigTools.RMAlign(loc2[0], spcLocArray[point], 3)
startPos += (-posStep)
cmds.setAttr(loc2[0] + ".translateX", startPos)
startRot += degreeStep
cmds.setAttr(loc1[0] + ".rotateZ", startRot)
cmds.parent(NewLoc, groupPoints)
jointArray = mel.eval('''source "RMRigTools.mel";\nsource "RMRigShapeControls.mel";\n
RMCreateBonesAtPoints( ''' + melstringArray(spcLocArray) + ''');''')
control = mel.eval('''RMCreaControl("''' + spcLocArray[0] + '''",''' + str(float(endRadius)) + ''');''')
cmds.addAttr(control, longName="unfold", keyable=True, hasMinValue=True, hasMaxValue=True, maxValue=10, minValue=0)
unfoldStep = 10.0 / numberOfPoints
currentStep = 0.0
for joints in jointArray:
currentrot = cmds.joint(joints, q=True, orientation=True)
RMRigTools.connectWithLimits(control + ".unfold", joints + ".rotateZ",
[[currentStep, 0], [currentStep + unfoldStep, abs(currentrot[2])]])
currentStep = currentStep + unfoldStep
def clavicleSpaceSwitch():
kinematics = cmds.ls("kinematics")[0]
Mover01 = cmds.ls("*_MD_mover00_ctr_Rig")[0]
rightClavicleControl = cmds.ls("*RH_clavicle00_ctr_Rig")[0]
leftClavicleControl = cmds.ls("*LF_clavicle00_ctr_Rig")[0]
resetLeftClavicleControl = cmds.ls("*LF_clavicle01_grp_Rig")[0]
resetRightClavicleControl = cmds.ls("*RH_clavicle01_grp_Rig")[0]
LimbArmRightikControl= cmds.ls("*_RH_wristIK00_ctr_Rig")[0]
LimbArmLeftikControl= cmds.ls("*_LF_wristIK00_ctr_Rig")[0]
NameConv = nameConvention.NameConvention()
moverWorld = cmds.group( empty = True, name ="moverWorld")
cmds.parent(moverWorld, kinematics)
cmds.parentConstraint( Mover01 , moverWorld )
SPSW = RMSpaceSwitch.RMSpaceSwitch()
LFShoulderFK = cmds.ls("*_LF_shoulder00_grp_Limbfk")[0]
LFFKShoulder = cmds.ls("*_LF_clavicle01_jnt_Rig")[0]
LFControlShoulder = cmds.ls("*_LF_shoulderFK00_ctr_Rig")[0]
RHShoulderFK = cmds.ls("*_RH_shoulder00_grp_Limbfk")[0]
RHFKShoulder = cmds.ls("*_RH_clavicle01_jnt_Rig")[0]
RHControlShoulder = cmds.ls("*_RH_shoulderFK00_ctr_Rig")[0]
LFWorldFKArm = cmds.group(empty = True, name = "ArmWorld" )
LFWorldFKArm = NameConv.rename_based_on_base_name (LFShoulderFK, LFWorldFKArm, {'name': "world", 'system': "LFKArmSpaceSwitch"})
RMRigTools.RMAlign(LFShoulderFK, LFWorldFKArm ,3)
cmds.parent( LFWorldFKArm, moverWorld)
LSpaceSwitchGroup = RMRigTools.RMCreateGroupOnObj(LFShoulderFK)
SPSW.CreateSpaceSwitchReverse(LFShoulderFK,[LSpaceSwitchGroup, LFWorldFKArm],LFControlShoulder,sswtype = "float", Name="", mo = False, constraintType = "orient")
RHWorldFKArm = cmds.group(empty = True, name = "ArmWorld" )
RHWorldFKArm = NameConv.rename_based_on_base_name (RHShoulderFK, RHWorldFKArm, {'name': "world", 'system': "RFKArmSpaceSwitch"})
RMRigTools.RMAlign(RHShoulderFK, RHWorldFKArm ,3)
cmds.parent( RHWorldFKArm, moverWorld)
RSpaceSwitchGroup = RMRigTools.RMCreateGroupOnObj(RHShoulderFK)
SPSW.CreateSpaceSwitchReverse(RHShoulderFK,[RSpaceSwitchGroup, RHWorldFKArm],RHControlShoulder,sswtype = "float", Name="", mo = False , constraintType = "orient")
SPSW.AddSpaceObject(LimbArmRightikControl,moverWorld)
SPSW.AddSpaceObject(LimbArmLeftikControl,moverWorld)
def FetTipRotationCorrect(side="RH"):
# "Character_LF_TipGrp00_UDF_Rig"
# "Character01_LF_ankleIK00_ctr_Rig"
# "Character_LF_TipGrp00_grp_Rig"
ArrayOfChildren = RMRigTools.RMRemoveChildren("Character_%s_TipGrp00_UDF_Rig" % side)
childGroup = RMRigTools.RMCreateGroupOnObj("Character_%s_TipGrp00_UDF_Rig" % side, Type="world")
ParentConst = cmds.listConnections("Character_%s_TipGrp00_grp_Rig" % side, type="parentConstraint")
cmds.delete(ParentConst[0])
cmds.makeIdentity("Character_%s_TipGrp00_grp_Rig" % side)
loc = cmds.spaceLocator(name="ReferencePoint")[0]
RMRigTools.RMAlign("Character_%s_TipGrp00_grp_Rig" % side, loc, 2)
cmds.setAttr("%s.rotateX" % loc, 0)
# cmds.setAttr( "%s.rotateX"%loc, -90)f
cmds.setAttr("%s.rotateZ" % loc, 0)
RMRigTools.RMAlign(loc, "Character_%s_TipGrp00_grp_Rig" % side, 2)
cmds.parentConstraint("Character01_%s_ankleIK00_ctr_Rig" % side, "Character_%s_TipGrp00_grp_Rig" % side, mo=True,
name=ParentConst[0])
cmds.parent(childGroup, "Character_%s_TipGrp00_UDF_Rig" % side)
RMRigTools.RMParentArray(childGroup, ArrayOfChildren)
cmds.delete(loc)
def RMCreateBoxCtrl(Obj,
NameConv=None,
Xratio=1,
Yratio=1,
Zratio=1,
ParentBaseSize=False,
customSize=0,
name="",
centered=False):
if not NameConv:
NameConv = nameConvention.NameConvention()
if name == "":
defaultName = "BoxControl"
else:
defaultName = name
Parents = pm.listRelatives(Obj, parent=True)
if Parents and len(Parents) != 0 and ParentBaseSize == True:
JntLength = RMRigTools.RMLenghtOfBone(Parents[0])
Ctrl = RMCreateCubeLine(JntLength * Xratio,
JntLength * Yratio,
JntLength * Zratio,
name=defaultName,
centered=centered)
else:
if customSize != 0:
JntLength = customSize
elif pm.objectType(Obj) == "joint":
JntLength = RMRigTools.RMLenghtOfBone(Obj)
else:
JntLength = 1
Ctrl = RMCreateCubeLine(JntLength * Xratio,
JntLength * Yratio,
JntLength * Zratio,
name=defaultName,
centered=centered)
if name == '' and NameConv.is_name_in_format(Obj):
NameConv.rename_based_on_base_name(Obj, Ctrl)
else:
NameConv.rename_based_on_base_name(Obj, Ctrl, name=Ctrl)
NameConv.rename_set_from_name(Ctrl, "control", "objectType")
RMRigTools.RMAlign(Obj, Ctrl, 3)
ResetGroup = RMRigTools.RMCreateGroupOnObj(Ctrl)
return ResetGroup, Ctrl
def RMCreateSpineJointStructure(self, SpineRef):
rootSpine, joints = RMRigTools.RMCreateBonesAtPoints(
SpineRef, ZAxisOrientation="z")
SpineLength = RMRigTools.RMPointDistance(joints[0],
joints[len(joints) - 1])
chestJoint = pm.joint(name="chest")
self.NameConv.rename_name_in_format(chestJoint, name=chestJoint)
RMRigTools.RMAlign(joints[len(joints) - 1], chestJoint, 3)
#pm.parent(chestJoint, joints[len(joints)-1])
pm.makeIdentity(chestJoint, apply=True, r=False, t=True, s=True, n=0)
pm.xform(chestJoint, t=[SpineLength / 4, 0, 0], os=True, relative=True)
return rootSpine, joints, chestJoint
def fetAnkleRotationCorrect(side="RH"):
# IKCorrection
control = "Character01_%s_ankleIK00_ctr_Rig" % side
Ball = "Character01_%s_BallIk00_jnt_Rig" % side
# ArrayOfChildren = RMRigTools.RMRemoveChildren (control)
ParentConst = cmds.listConnections(control, type="parentConstraint")
IKGroup = cmds.listConnections("%s.constraintRotateX" % ParentConst[0])[0]
cmds.delete(ParentConst)
controlParent = cmds.listRelatives(control, parent=True)
loc = cmds.spaceLocator(name="ReferencePoint")[0]
loc2 = cmds.spaceLocator(name="ReferencePoint")[0]
Balltranslation = cmds.xform(Ball, q=True, ws=True, translation=True)
controlTranslation = cmds.xform(control, q=True, ws=True, translation=True)
cmds.xform(loc, translation=(Balltranslation[0], controlTranslation[1], Balltranslation[2]))
RMRigTools.RMAlign(control, loc2, 3)
cmds.aimConstraint(loc, loc2, aimVector=[0, 1, 0], upVector=[-1, 0, 0], worldUpType='scene')
RMRigTools.RMAlign(loc2, controlParent, 3)
cmds.parentConstraint(control, IKGroup, mo=True)
# FK Correction
FKcontrol = "Character01_%s_ankleFK00_ctr_Rig" % side
ParentConst = cmds.listConnections(FKcontrol, type="parentConstraint")
resultingSet = set(ParentConst)
FKparentConstrained = []
for eachConstraint in resultingSet:
FKparentConstrained.append(cmds.listConnections("%s.constraintRotateX" % eachConstraint)[0])
cmds.delete(eachConstraint)
FKcontrolParent = cmds.listRelatives(FKcontrol, parent=True)
RMRigTools.RMAlign(control, FKcontrolParent[0], 3)
for eachobject in FKparentConstrained:
cmds.parentConstraint(FKcontrol, eachobject, mo=True)
cmds.delete(loc)
cmds.delete(loc2)
def skeletonHands():
NameConv = nameConvention.NameConvention()
palmGroups = [
"R_middle00_Rig_grp", "R_ring00_Rig_grp", "R_pinky00_Rig_grp",
"R_index00_Rig_grp", "L_middle00_Rig_grp", "L_ring00_Rig_grp",
"L_pinky00_Rig_grp", "L_index00_Rig_grp"
]
for eachGroup in palmGroups:
Group = cmds.ls(eachGroup)[0]
NewJoint = cmds.joint(name=NameConv.get_a_short_name(Group) + "Carpos")
NewJoint = NameConv.rename_based_on_base_name(Group, NewJoint,
{'name': str(NewJoint)})
NewJoint = NameConv.rename_set_from_name(NewJoint, "skinjoint",
"objectType")
RMRigTools.RMAlign(Group, NewJoint, 3)
cmds.parent(NewJoint, Group)
def CreateHandJointStructure(self, Palm):
referenceRoots = pm.listRelatives(Palm, children=True, type="transform")
palmJoint = pm.joint(name=self.NameConv.get_from_name(Palm, "name"))
RMRigTools.RMAlign(Palm, palmJoint, 3)
self.NameConv.rename_based_on_base_name(Palm, palmJoint, system="rig")
self.fingers = []
for eachPoint in referenceRoots:
fingerPoints = RMRigTools.RMCustomPickWalk(eachPoint, "transform", -1)
FingerRoot, fingerJoints = self.rig_tools.RMCreateBonesAtPoints(fingerPoints)
pm.parent(FingerRoot, palmJoint)
self.fingerRoots.append(FingerRoot)
self.fingers.append(fingerJoints)
self.palmJoint = palmJoint
if pm.listRelatives(self.palmJoint, parent=True):
pm.parent(self.palmJoint, world=True)
return palmJoint
def nurbPlaneBetweenObjects(self, Object01, Object02):
VP1 = om.MVector(pm.xform(Object01, a=True, ws=True, q=True, rp=True))
VP2 = om.MVector(pm.xform(Object02, a=True, ws=True, q=True, rp=True))
longitud = VP1 - VP2
plano = pm.nurbsPlane(ax=[0, 1, 0],
p=[(longitud.length()) / 2, 0, 0],
w=longitud.length(),
lr=.05,
d=3,
u=8,
v=1,
ch=0,
name="%sTo%sPlane" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.set_name_in_format(plano, useName=True)
RMRigTools.RMAlign(Object01, plano[0], 3)
return plano[0]
def RMCreateBonesBetweenPoints(self, InitialPoint, FinalPoint, NumberOfTB, AlignObject=None):
DirectionVector = FinalPoint-InitialPoint
TotalLength = DirectionVector.length()
Step = TotalLength / NumberOfTB
StepVector = DirectionVector.normal() * Step
locatorsList = []
for count in range(0, NumberOfTB + 1):
Locator = pm.spaceLocator()
if AlignObject:
if self.NameConv.is_name_in_format(AlignObject):
self.NameConv.rename_based_on_base_name(AlignObject, Locator,
name='TwistJoint%s' %
(self.NameConv.get_from_name(AlignObject,"name").capitalize()))#.capitalize()
locatorsList.append(Locator)
pm.xform(Locator, translation=list(InitialPoint+(StepVector*count)), worldSpace=True)
RMRigTools.RMAlign(AlignObject, Locator, 2)
self.TwistResetJoints, self.TwistJoints = RMRigTools.RMCreateBonesAtPoints(locatorsList)
self.deleteList(locatorsList)
return self.TwistResetJoints, self.TwistJoints
def CreatePalmRig(self, PalmControl=None):
if self.NameConv.get_from_name(self.GHS.palmJoint, "side") == "L":
sideVariation = -1
else:
sideVariation = 1
self.CreatePalmReferencePoints()
if PalmControl == None:
palmResetPoint, PalmControl = RMRigShapeControls.RMCircularControl(
self.GHS.palmJoint)
else:
palmResetPoint = pm.group(empty=True, name="palmControl")
self.NameConv.rename_based_on_base_name(self.GHS.palmJoint,
palmResetPoint,
name=palmResetPoint)
RMRigTools.RMAlign(self.GHS.palmJoint, palmResetPoint, 3)
self.PalmControl = PalmControl
self.PalmResetPoint = palmResetPoint
self.MainControl = palmResetPoint
# palmResetPoint = self.NameConv.RMRenameSetFromName(palmResetPoint,"palmControls","Name")
self.RMaddPalmControls(self.PalmControl)
RMRigTools.RMLockAndHideAttributes(self.PalmControl, "0000000000")
pinky = self.GHS.fingerJointsByName("pinky")
if pinky:
self.PalmFingerControlGrp[
"pinky"] = self.name_conv.RMCreateGroupOnObj(pinky[0])
RMRigTools.RMChangeRotateOrder(pinky, "yxz")
RMRigTools.RMConnectWithLimits(
"%s.Spread" % self.PalmControl,
'%s.rotateZ' % self.PalmFingerControlGrp["pinky"],
[[-10, sideVariation * 10], [0, 0], [10, sideVariation * -60]])
ring = self.GHS.fingerJointsByName("ring")
if ring:
self.PalmFingerControlGrp[
"ring"] = self.name_conv.RMCreateGroupOnObj(ring[0])
RMRigTools.RMChangeRotateOrder(ring, "yxz")
RMRigTools.RMConnectWithLimits(
"%s.Spread" % self.PalmControl,
'%s.rotateZ' % self.PalmFingerControlGrp["ring"],
[[-10, sideVariation * 5], [0, 0], [10, sideVariation * -30]])
middle = self.GHS.fingerJointsByName("middle")
if middle:
self.PalmFingerControlGrp[
"middle"] = self.name_conv.RMCreateGroupOnObj(middle[0])
RMRigTools.RMChangeRotateOrder(middle, "yxz")
RMRigTools.RMConnectWithLimits(
"%s.Spread" % self.PalmControl,
'%s.rotateZ' % self.PalmFingerControlGrp["middle"],
[[-10, 0], [0, 0], [10, sideVariation * -5]])
index = self.GHS.fingerJointsByName("index")
if index:
self.PalmFingerControlGrp[
"index"] = self.name_conv.RMCreateGroupOnObj(index[0])
RMRigTools.RMChangeRotateOrder(index, "yxz")
RMRigTools.RMConnectWithLimits(
"%s.Spread" % self.PalmControl,
'%s.rotateZ' % self.PalmFingerControlGrp["index"],
[[-10, sideVariation * -5], [0, 0], [10, sideVariation * 30]])
thumb = self.GHS.fingerJointsByName("thumb")
if thumb:
self.PalmFingerControlGrp[
"thumb"] = self.name_conv.RMCreateGroupOnObj(thumb[0])
RMRigTools.RMChangeRotateOrder(thumb, "yxz")
RMRigTools.RMConnectWithLimits(
"%s.Spread" % self.PalmControl,
'%s.rotateZ' % self.PalmFingerControlGrp["thumb"],
[[-10, sideVariation * -10], [0, 0], [10, sideVariation * 60]])
for eachFingerName in self.fingerRoot:
if eachFingerName != 'thumb':
RMRigTools.RMConnectWithLimits(
"%s.PalmBend" % self.PalmControl,
'%s.rotateY' % self.PalmFingerControlGrp[eachFingerName],
[[-10, 90], [0, 0], [10, -90]])
RMRigTools.RMConnectWithLimits(
"%s.Twist" % self.PalmControl,
'%s.rotateX' % self.PalmReferencePoints[eachFingerName],
[[-10, sideVariation * 45], [0, 0],
[10, sideVariation * -45]])
RMRigTools.RMConnectWithLimits(
"%s.PalmCup" % self.PalmControl,
'%s.rotateX' % self.PalmReferencePoints["pinky"],
[[0, 0], [10, sideVariation * 50]])
RMRigTools.RMConnectWithLimits(
"%s.PalmCup" % self.PalmControl,
'%s.rotateX' % self.PalmReferencePoints["ring"],
[[0, 0], [10, sideVariation * 25]])
RMRigTools.RMConnectWithLimits(
"%s.PalmCup" % self.PalmControl,
'%s.rotateX' % self.PalmReferencePoints["middle"],
[[0, 0], [10, sideVariation * 5]])
RMRigTools.RMConnectWithLimits(
"%s.PalmCup" % self.PalmControl,
'%s.rotateX' % self.PalmReferencePoints["index"],
[[0, 0], [10, sideVariation * -30]])
RMRigTools.RMConnectWithLimits(
"%s.PalmCup" % self.PalmControl,
'%s.rotateX' % self.PalmReferencePoints["thumb"],
[[0, 0], [10, sideVariation * -60]])
def EyeLidsSetUp(self, EyeNode):
Rigtools = RMRigTools.RMRigTools()
EyeNodeBB = RMRigTools.boundingBoxInfo(EyeNode)
eyeRadius = (EyeNodeBB.zmax - EyeNodeBB.zmin) / 2
# eyeScale = cmds.getAttr("%s.scale"%EyeNode) [0]
# cmds.setAttr ( EyeNode + ".scale", 1.0, 1.0, 1.0)
MainUpperLid = cmds.joint(name="EyeUpperLid", rad=eyeRadius / 5)
UpperLid = cmds.joint(name="EyeUpperLidTip", rad=eyeRadius / 5)
MainLowerLid = cmds.joint(name="EyeLowerLid", rad=eyeRadius / 5)
LowerLid = cmds.joint(name="EyeLowerLidTip", rad=eyeRadius / 5)
RMRigTools.RMAlign(EyeNode, MainUpperLid, 3)
EyeParent = Rigtools.RMCreateGroupOnObj(MainUpperLid, Type='parent')
EyeParent = self.NameConv.rename_set_from_name(EyeParent, "EyeLidSpin", Token='name')
MainEye = Rigtools.RMCreateGroupOnObj(EyeParent, Type='parent')
MainEye = self.NameConv.rename_set_from_name(MainEye, "Eye", Token='name')
upperLidParent = Rigtools.RMCreateGroupOnObj(MainUpperLid)
upperLidParent = self.NameConv.rename_set_from_name(upperLidParent, "EyeUpperLidReset", Token='name')
cmds.parent(MainLowerLid, EyeParent)
LowerLidParent = Rigtools.RMCreateGroupOnObj(MainLowerLid)
RMRigTools.RMAlign(EyeParent, LowerLid, 3)
MiddleMainUpperLid = cmds.joint(name="EyeMiddleMainUpperLid", rad=eyeRadius / 5)
MiddleUpperLid = cmds.joint(name="EyeMiddleUpperLidTip", rad=eyeRadius / 5)
MiddleMainLowerLid = cmds.joint(name="EyeMiddleLowerLid", rad=eyeRadius / 5)
MiddleLowerLid = cmds.joint(name="EyeMiddleLowerLidTip", rad=eyeRadius / 5)
RMRigTools.RMAlign(EyeParent, MiddleMainUpperLid, 3)
cmds.parent(MiddleMainUpperLid, upperLidParent)
cmds.parent(MiddleMainLowerLid, LowerLidParent)
cmds.setAttr("%s.translateX" % UpperLid, eyeRadius)
cmds.setAttr("%s.translateX" % LowerLid, eyeRadius)
cmds.setAttr("%s.translateX" % MiddleUpperLid, eyeRadius)
cmds.setAttr("%s.translateX" % MiddleLowerLid, eyeRadius)
mDUpper = cmds.shadingNode("multiplyDivide", asUtility=True, name="EyeUpperMultDiv")
cmds.connectAttr("%s.rotate" % MainUpperLid, "%s.input1" % mDUpper)
cmds.setAttr("%s.input2" % mDUpper, .5, .5, .5)
cmds.connectAttr("%s.output" % mDUpper, "%s.rotate" % MiddleMainUpperLid)
mDLower = cmds.shadingNode("multiplyDivide", asUtility=True, name="EyeLowerMultDiv")
cmds.connectAttr("%s.rotate" % MainLowerLid, "%s.input1" % mDLower)
cmds.setAttr("%s.input2" % mDLower, .5, .5, .5)
cmds.connectAttr("%s.output" % mDLower, "%s.rotate" % MiddleMainLowerLid)
# cmds.setAttr(EyeParent +".scale",eyeScale[0],eyeScale[1],eyeScale[2])
cmds.setAttr("%s.rotateY" % MainEye, -90)
cmds.select(EyeNode, replace=True)
# latticeAttr, lattice, latticeBase = cmds.lattice(name = "EyeLattice", oc= True, dv = [2, 2, 2], ol = 2, ofd = (eyeRadius/3) )
# latticeScale = cmds.getAttr(lattice+".scale")[0]
# cmds.setAttr ( lattice + ".scale", float(latticeScale[0]) + float(eyeScale[0]), float(latticeScale[1]) + float(eyeScale[1]), float(latticeScale[2]) + float(eyeScale[2]))
# renamingto NameConvention.
if self.NameConv.is_name_in_format(EyeNode):
side = self.NameConv.get_from_name(EyeNode, Token="Side")
else:
side = "MD"
# latticeAttr, lattice, latticeBase,
self.NameConv.rename_name_in_format(
[mDUpper, mDLower, UpperLid, LowerLid, MiddleMainUpperLid, MiddleMainLowerLid], {'side':side})
self.NameConv.rename_set_from_name([EyeParent, LowerLidParent, upperLidParent], side, Token="side")
MainEye = self.NameConv.rename_set_from_name(MainEye, side, Token="side")
self.NameConv.rename_name_in_format([MiddleUpperLid, MiddleLowerLid], {'objectType': "sknjnt", 'side': side})
MainLowerLid = self.NameConv.rename_name_in_format(MainLowerLid, {'objectType': "sknjnt", 'side': side})
MainUpperLid = self.NameConv.rename_name_in_format(MainUpperLid, {'objectType': "sknjnt", 'side': side})
if not cmds.objExists("Character_MD_EyesRig00_grp_rig"):
EyesRig = self.NameConv.set_name_in_format("EyesRig", Type="grp", System="rig")
cmds.group(empty=True, name=EyesRig)
RMRigTools.RMChangeRotateOrder(EyesRig, "xzy")
cmds.setAttr("%s.rotateY" % EyesRig, -90)
else:
EyesRig = "Character_MD_EyesRig00_grp_rig"
cmds.parent(MainEye, EyesRig)
cmds.makeIdentity(MainUpperLid, apply=True, r=1)
cmds.makeIdentity(MainLowerLid, apply=True, r=1)
return MainEye
def lastTwoJointsInChain(selection):
for eachObject in selection:
childJoints = RMRigTools.RMCustomPickWalk(eachObject, "joint", -1)
RMRigTools.RMAlign(childJoints[len(childJoints) - 2],
childJoints[len(childJoints) - 1], 2)
def CreateBipedRig(self):
try:
CharacterName = self.MetaNameConv.AssetType + "_" + self.MetaNameConv.AssetName + "_rig"
except:
CharacterName = "MainCharacter"
if pm.objExists(CharacterName):
MainGroup = CharacterName
else:
MainGroup = pm.group(empty=True, name=CharacterName)
if pm.objExists("mesh_grp"):
mesh = pm.ls("mesh_grp")[0]
else:
mesh = pm.group(empty=True, name="mesh_grp")
if pm.objExists("rig_grp"):
rig = pm.ls("rig_grp")[0]
else:
rig = pm.group(empty=True, name="rig_grp")
pm.setAttr("%s.visibility" % rig, False)
for eachgroup in self.geometryGroups:
if not pm.objExists(eachgroup):
pm.group(empty=True, name=eachgroup)
pm.parent(eachgroup, mesh)
deformation = pm.group(empty=True, name="deformation")
kinematics = pm.group(empty=True, name="kinematics")
joints = pm.group(empty=True, name="joints")
controls = pm.group(empty=True, name="controls_grp")
self.world = pm.group(empty=True, name="world" + CharacterName)
self.moverWorld = pm.group(empty=True,
name="moverWorld" + CharacterName)
self.Spine = RMSpine.RMSpine()
self.LimbArmLeft = RMLimbIKFK.RMLimbIKFK(worldNode=self.world,
NameConv=self.NameConv)
self.LimbLegRight = RMLimbIKFK.RMLimbIKFK(worldNode=self.world,
NameConv=self.NameConv)
self.LimbLegLeft = RMLimbIKFK.RMLimbIKFK(worldNode=self.world,
NameConv=self.NameConv)
self.LimbArmRight = RMLimbIKFK.RMLimbIKFK(worldNode=self.world,
NameConv=self.NameConv)
self.LFfeet = RMFeet.RMFeetRig()
self.RHfeet = RMFeet.RMFeetRig()
self.kinematics = kinematics
self.deformation = deformation
self.joints = joints
self.controls = controls
pm.parent(self.world, self.kinematics)
pm.parent(self.moverWorld, self.kinematics)
meshp = pm.listRelatives(mesh, parent=True)
if not meshp:
pm.parent(mesh, MainGroup)
rigp = pm.listRelatives(rig, parent=True)
if not rigp:
pm.parent(rig, MainGroup)
pm.parent(controls, MainGroup)
pm.parent(deformation, rig)
pm.parent(kinematics, rig)
pm.parent(joints, rig)
#Creacion del spine
spineJoints = [
"C_Spine01_rig_pnt", "C_Spine02_rig_pnt", "C_Spine03_rig_pnt",
"C_Spine04_rig_pnt", "C_Spine05_rig_pnt"
]
hip = ["C_Spine01_rig_pnt", "C_Hip01_rig_pnt"]
clavLF = ["L_clavicle01_rig_pnt", "L_shoulder01_rig_pnt"]
clavRH = ["R_clavicle01_rig_pnt", "R_shoulder01_rig_pnt"]
self.Spine.RMCreateSpineRig(spineJoints, hip, clavLF, clavRH)
spineKinematics = pm.group(empty=True, name="spineKinematics")
self.NameConv.rename_name_in_format(spineKinematics,
system="kinematics")
spineControls = pm.group(empty=True, name="spineControls")
self.NameConv.rename_name_in_format(spineControls, system="controls")
spineJoints = pm.group(empty=True, name="spineJoints")
self.NameConv.rename_name_in_format(spineJoints, system="joints")
pm.parent(spineKinematics, kinematics)
pm.parent(spineControls, controls)
pm.parent(spineJoints, deformation)
pm.parent(self.Spine.ResetCOG, spineControls)
pm.parent(self.Spine.kinematics, spineKinematics)
pm.parent(self.Spine.rootSpineJoints, spineJoints)
mover01Reset, self.Mover01 = RMRigShapeControls.RMCircularControl(
self.world,
axis="Y",
radius=self.Spine.SpineLength * 1.5,
name="mover02")
mover02Reset, self.Mover02 = RMRigShapeControls.RMCircularControl(
self.world,
axis="Y",
radius=self.Spine.SpineLength * 2,
name="mover01")
placerReset, self.placer = RMRigShapeControls.RMCircularControl(
self.world,
axis="Y",
radius=self.Spine.SpineLength * 2.5,
name="mainPlacer")
self.mainMover = self.Mover01
pm.parent(placerReset, controls)
pm.parent(mover02Reset, self.placer)
pm.parent(mover01Reset, self.Mover02)
pm.parent(spineControls, self.Mover01)
pm.parentConstraint(self.Mover01, self.moverWorld)
'''
WorldRClavicle = pm.group(empty = True, name = "clavicleWorld" )
WorldRClavicle = self.NameConv.RMRenameBasedOnBaseName (self.Spine.rightClavicleControl, WorldRClavicle, NewName = "world", System = "RClavicleSpaceSwitch")
RMRigTools.RMAlign(self.Spine.rightClavicleControl, WorldRClavicle ,3)
pm.parent( WorldRClavicle, self.moverWorld)
RSpaceSwitchGroup = RMRigTools.RMCreateGroupOnObj(self.Spine.rightClavicleControl)
self.SPSW.CreateSpaceSwitch(RSpaceSwitchGroup,[self.Spine.resetRightClavicleControl, WorldRClavicle],self.Spine.rightClavicleControl, constraintType = "orient")
WorldLClavicle = pm.group(empty = True, name = "clavicleWorld" )
WorldLClavicle = self.NameConv.RMRenameBasedOnBaseName (self.Spine.leftClavicleControl, WorldLClavicle, NewName = "world", System = "LClavicleSpaceSwitch")
RMRigTools.RMAlign(self.Spine.leftClavicleControl, WorldLClavicle ,3)
pm.parent( WorldLClavicle, self.moverWorld)
LSpaceSwitchGroup = RMRigTools.RMCreateGroupOnObj(self.Spine.leftClavicleControl)
self.SPSW.CreateSpaceSwitch(LSpaceSwitchGroup,[self.Spine.resetLeftClavicleControl, WorldLClavicle],self.Spine.leftClavicleControl, constraintType = "orient")
'''
#Creacion de la cabeza
neck = ["C_neck01_rig_pnt", "C_head01_rig_pnt"]
Head = ["C_head01_rig_pnt", "C_headTip01_rig_pnt"]
Jaw = ["C_jaw01_rig_pnt", "C_jawTip01_rig_pnt"]
self.NeckHead.RMCreateHeadAndNeckRig(Head, neck, Jaw)
pm.parent(self.NeckHead.RootNeckJoints, self.Spine.chestJoint)
pm.parent(self.NeckHead.resetNeckControl,
self.Spine.ChestRotationControl)
WorldHead = pm.group(empty=True, name="worldHead")
self.NameConv.rename_based_on_base_name(self.NeckHead.headControl,
WorldHead,
name="world",
system="HeadSpaceSwitch")
RMRigTools.RMAlign(self.NeckHead.resetHeadControl, WorldHead, 3)
pm.parent(WorldHead, self.world)
HeadResetPoint = pm.group(empty=True, name="NeckOrientConstraint")
self.NameConv.rename_based_on_base_name(self.NeckHead.headControl,
HeadResetPoint,
name="Neck",
system="HeadSpaceSwitch")
RMRigTools.RMAlign(self.NeckHead.resetHeadControl, HeadResetPoint, 3)
pm.parent(HeadResetPoint, self.NeckHead.NeckJoints[1])
self.SPSW.CreateSpaceSwitch(self.NeckHead.resetHeadControl,
[HeadResetPoint, WorldHead],
self.NeckHead.headControl,
constraintType="orient",
mo=True)
#Creacion de Brazos
#BrazoDerecho
self.LimbArmRight.RMLimbRig("R_shoulder01_rig_pnt", FKAxisFree='010')
RHArmDic = self.OrganizeLimb(self.LimbArmRight, "RH", "Arm",
self.Spine.RightClavicleJoints[1],
self.Spine.chestJoint)
RHWorldFKArm = pm.group(empty=True, name="ArmWorld")
self.NameConv.rename_based_on_base_name(
self.LimbArmRight.FKparentGroup,
RHWorldFKArm,
name="world",
system="RFKArmSpaceSwitch")
RMRigTools.RMAlign(self.LimbArmRight.FKparentGroup, RHWorldFKArm, 3)
pm.parent(RHWorldFKArm, self.moverWorld)
RSpaceSwitchGroup = self.rig_tools.RMCreateGroupOnObj(
self.LimbArmRight.FKparentGroup)
self.SPSW.CreateSpaceSwitchReverse(
self.LimbArmRight.FKparentGroup, [RSpaceSwitchGroup, RHWorldFKArm],
self.LimbArmRight.FKFirstLimbControl,
sswtype="float",
Name="",
mo=False,
constraintType="orient")
#BrazoIzquierdo
self.LimbArmLeft.RMLimbRig("L_shoulder01_rig_pnt", FKAxisFree='010')
RHArmDic = self.OrganizeLimb(self.LimbArmLeft, "LF", "Arm",
self.Spine.LeftClavicleJoints[1],
self.Spine.chestJoint)
LFWorldFKArm = pm.group(empty=True, name="ArmWorld")
self.NameConv.rename_based_on_base_name(self.LimbArmLeft.FKparentGroup,
LFWorldFKArm,
name="world",
system="LFKArmSpaceSwitch")
RMRigTools.RMAlign(self.LimbArmLeft.FKparentGroup, LFWorldFKArm, 3)
pm.parent(LFWorldFKArm, self.moverWorld)
LSpaceSwitchGroup = self.rig_tools.RMCreateGroupOnObj(
self.LimbArmLeft.FKparentGroup)
self.SPSW.CreateSpaceSwitchReverse(self.LimbArmLeft.FKparentGroup,
[LSpaceSwitchGroup, LFWorldFKArm],
self.LimbArmLeft.FKFirstLimbControl,
sswtype="float",
Name="",
mo=False,
constraintType="orient")
#ManoDerecha
self.GHRightRig = RMGenericHandRig.RMGenericHandRig()
self.GHRightRig.CreateHandRig("R_palm01_rig_pnt",
self.LimbArmRight.SpaceSwitchControl)
#pm.group(name = "R_palmMover_grp_rig")
RMRigTools.RMAlign("R_palm01_rig_pnt",
self.LimbArmRight.IKControlResetPoint, 3)
RMRigTools.RMAlign("R_palm01_rig_pnt",
self.LimbArmRight.ThirdLimbParent, 3)
self.LimbArmRight.SPSW.RMCreateListConstraintSwitch(
[self.GHRightRig.MainKinematics],
[self.LimbArmRight.IKjointStructure[2]],
self.LimbArmRight.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch")
self.LimbArmRight.SPSW.RMCreateListConstraintSwitch(
[self.GHRightRig.MainKinematics],
[self.LimbArmRight.FKTrirdLimbControl],
self.LimbArmRight.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch",
reverse=True)
self.LimbArmLeft.SPSW.CreateSpaceSwitch(
self.LimbArmRight.IKControlResetPoint, [
self.Spine.rightClavicleControl, self.world, self.Spine.COG,
self.Spine.hipJoints[0], self.NeckHead.HeadJoints[0],
self.moverWorld
], self.LimbArmRight.ikControl)
pm.parent(self.GHRightRig.MainKinematics, RHArmDic["kinematics"])
pm.parent(
self.GHRightRig.GHS.palmJoint,
self.LimbArmRight.TJElbow.TwistJoints[
len(self.LimbArmRight.TJElbow.TwistJoints) - 1])
pm.parent(self.GHRightRig.PalmResetPoint, RHArmDic["controls"])
#ManoIzquierda
self.GHLeftRig = RMGenericHandRig.RMGenericHandRig()
self.GHLeftRig.CreateHandRig(
"L_palm01_rig_pnt",
PalmControl=self.LimbArmLeft.SpaceSwitchControl)
RMRigTools.RMAlign("L_palm01_rig_pnt",
self.LimbArmLeft.IKControlResetPoint, 3)
RMRigTools.RMAlign("L_palm01_rig_pnt",
self.LimbArmLeft.ThirdLimbParent, 3)
self.LimbArmLeft.SPSW.RMCreateListConstraintSwitch(
[self.GHLeftRig.MainKinematics],
[self.LimbArmLeft.IKjointStructure[2]],
self.LimbArmLeft.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch")
self.LimbArmLeft.SPSW.RMCreateListConstraintSwitch(
[self.GHLeftRig.MainKinematics],
[self.LimbArmLeft.FKTrirdLimbControl],
self.LimbArmLeft.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch",
reverse=True)
self.LimbArmLeft.SPSW.CreateSpaceSwitch(
self.LimbArmLeft.IKControlResetPoint, [
self.Spine.leftClavicleControl, self.world, self.Spine.COG,
self.Spine.hipJoints[0], self.NeckHead.HeadJoints[0],
self.moverWorld
], self.LimbArmLeft.ikControl)
pm.parent(self.GHLeftRig.MainKinematics, RHArmDic["kinematics"])
pm.parent(
self.GHLeftRig.GHS.palmJoint, self.LimbArmLeft.TJElbow.TwistJoints[
len(self.LimbArmLeft.TJElbow.TwistJoints) - 1])
pm.parent(self.GHLeftRig.PalmResetPoint, RHArmDic["controls"])
#Creacion de pierna
self.LimbLegRight.RMLimbRig("R_leg01_rig_pnt", FKAxisFree='001')
RHLegDic = self.OrganizeLimb(self.LimbLegRight, "RH", "Leg",
self.Spine.hipJoints[1],
self.Spine.hipJoints[1])
self.LimbLegLeft.RMLimbRig("L_leg01_rig_pnt", FKAxisFree='001')
LFLegDic = self.OrganizeLimb(self.LimbLegLeft, "LF", "Leg",
self.Spine.hipJoints[1],
self.Spine.hipJoints[1])
Locator = pm.spaceLocator(name="referenceLocator")
RMRigTools.RMAlign("L_ball01_rig_pnt", Locator, 1)
pm.setAttr(Locator + ".rotateX", 90)
pm.setAttr(Locator + ".rotateZ", -90)
RMRigTools.RMAlign(Locator, self.LimbLegLeft.IKControlResetPoint, 2)
RMRigTools.RMAlign(Locator, self.LimbLegLeft.ThirdLimbParent, 2)
RMRigTools.RMAlign(Locator, self.LimbLegRight.IKControlResetPoint, 2)
RMRigTools.RMAlign(Locator, self.LimbLegRight.ThirdLimbParent, 2)
pm.delete(Locator)
StandarFeetLFPoints = {
"feet":
["L_ankleFeet01_rig_pnt", "L_ball01_rig_pnt", "L_toe01_rig_pnt"],
"limitBack":
"L_footLimitBack01_rig_pnt",
"limitOut":
"L_footLimitOuter01_rig_pnt",
"limitIn":
"L_footLimitInner01_rig_pnt"
}
self.LFfeet.RigFeetIKFK(StandarFeetLFPoints,
self.LimbLegLeft.ikControl,
self.LimbLegLeft.FKTrirdLimbControl)
self.LimbLegLeft.SPSW.RMCreateListConstraintSwitch(
self.LFfeet.StandardFeetJoints,
self.LFfeet.StandardFeetIKJoints,
self.LimbLegLeft.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch")
self.LimbLegLeft.SPSW.RMCreateListConstraintSwitch(
self.LFfeet.StandardFeetJoints,
self.LFfeet.StandardFeetFKJoints,
self.LimbLegLeft.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch",
reverse=True)
pm.parent(
self.LFfeet.rootJoints, self.LimbLegLeft.TJElbow.TwistJoints[
len(self.LimbLegLeft.TJElbow.TwistJoints) - 1])
feetJointsGroup = pm.group(empty=True, name="FeetJoints")
self.NameConv.rename_name_in_format(feetJointsGroup, side="LF")
pm.parent(self.LFfeet.MainFeetKinematics, feetJointsGroup)
pm.parent(self.LFfeet.rootFKJoints, feetJointsGroup)
pm.parent(feetJointsGroup, self.joints)
pm.pointConstraint(self.LimbLegLeft.ikControl,
self.LimbLegLeft.IkHandle,
remove=True)
pm.parent(self.LimbLegLeft.IkHandle, self.LFfeet.IKAttachPoint)
pm.parent(self.LFfeet.rootIKJoints,
self.LimbLegLeft.IKjointStructure[2])
StandarFeetRHPoints = {
"feet":
["R_ankleFeet01_rig_pnt", "R_ball01_rig_pnt", "R_toe01_rig_pnt"],
"limitBack":
"R_footLimitBack01_rig_pnt",
"limitOut":
"R_footLimitOuter01_rig_pnt",
"limitIn":
"R_footLimitInner01_rig_pnt"
}
self.RHfeet.RigFeetIKFK(StandarFeetRHPoints,
self.LimbLegRight.ikControl,
self.LimbLegRight.FKTrirdLimbControl)
self.LimbLegRight.SPSW.RMCreateListConstraintSwitch(
self.RHfeet.StandardFeetJoints,
self.RHfeet.StandardFeetIKJoints,
self.LimbLegRight.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch")
self.LimbLegRight.SPSW.RMCreateListConstraintSwitch(
self.RHfeet.StandardFeetJoints,
self.RHfeet.StandardFeetFKJoints,
self.LimbLegRight.SpaceSwitchControl,
SpaceSwitchName="IKFKSwitch",
reverse=True)
pm.parent(
self.RHfeet.rootJoints, self.LimbLegRight.TJElbow.TwistJoints[
len(self.LimbLegRight.TJElbow.TwistJoints) - 1])
feetJointsGroup = pm.group(empty=True, name="FeetJoints")
self.NameConv.rename_name_in_format(feetJointsGroup, side="right")
pm.parent(self.RHfeet.MainFeetKinematics, feetJointsGroup)
pm.parent(self.RHfeet.rootFKJoints, feetJointsGroup)
pm.parent(feetJointsGroup, self.joints)
pm.pointConstraint(self.LimbLegRight.ikControl,
self.LimbLegRight.IkHandle,
remove=True)
pm.parent(self.LimbLegRight.IkHandle, self.RHfeet.IKAttachPoint)
pm.parent(self.RHfeet.rootIKJoints,
self.LimbLegRight.IKjointStructure[2])
#pm.parentConstraint(placer,self.kinematics)
self.ColorCode()
self.Visibility()
def Visibility(self):
'''self.Spine = None
self.LimbArmLeft = None
self.LimbLegRight = None
self.LimbLegLeft = None
self.LimbArmRight = None
self.LFfeet = None
self.RHfeet = None
self.moverMain = None
self.Mover01 = None
self.Mover02 = None
self.placer = None
self.NeckHead
self.GHRightRig = None
self.GHLeftRig = None
'''
VisSwitch = RMVisibilitySwitch.RMVisibilitySwitch()
Vgroup, VControl = RMRigShapeControls.RMImportMoveControl(
self.NeckHead.HeadJoints[0],
scale=RMRigTools.RMLenghtOfBone(self.NeckHead.HeadJoints[0]),
Type="v")
pm.setAttr("%s.rotateX" % Vgroup, 0)
pm.setAttr("%s.rotateY" % Vgroup, 0)
pm.setAttr("%s.rotateZ" % Vgroup, 0)
RMRigTools.RMAlign(self.NeckHead.HeadJoints[1], Vgroup, 1)
pm.parentConstraint(self.Mover01, Vgroup, mo=True)
pm.parent(Vgroup, "controls_grp")
VisSwitch.ConstraintVisibility([
self.LimbArmLeft.PoleVectorControl, self.LimbArmLeft.ikControl,
self.LimbArmLeft.FKFirstLimbControl,
self.LimbArmLeft.FKSecondLimbControl,
self.LimbArmLeft.FKTrirdLimbControl,
self.LimbArmLeft.SpaceSwitchControl,
self.LimbArmRight.PoleVectorControl, self.LimbArmRight.ikControl,
self.LimbArmRight.FKFirstLimbControl,
self.LimbArmRight.FKSecondLimbControl,
self.LimbArmRight.FKTrirdLimbControl,
self.LimbArmRight.SpaceSwitchControl,
self.LimbLegLeft.PoleVectorControl, self.LimbLegLeft.ikControl,
self.LimbLegLeft.FKFirstLimbControl,
self.LimbLegLeft.FKSecondLimbControl,
self.LimbLegLeft.FKTrirdLimbControl,
self.LimbLegLeft.SpaceSwitchControl,
self.LimbLegRight.PoleVectorControl, self.LimbLegRight.ikControl,
self.LimbLegRight.FKFirstLimbControl,
self.LimbLegRight.FKSecondLimbControl,
self.LimbLegRight.FKTrirdLimbControl,
self.LimbLegRight.SpaceSwitchControl,
self.Spine.rightClavicleControl, self.Spine.leftClavicleControl,
self.Spine.waistControl, self.Spine.chestControl,
self.Spine.hipControl, self.Spine.COG,
self.LFfeet.SecondLimbFeetControl,
self.RHfeet.SecondLimbFeetControl, self.GHRightRig.MainControl,
self.GHLeftRig.MainControl
],
VControl,
VisibilitySwitch="Controls",
visibilityType="lodVisibility")
#print self.LFfeet.feetMainMoveIK
#print self.RHfeet.feetMainMoveIK
VisSwitch.ConstraintVisibility([
self.LimbArmLeft.TJArm.TwistControl,
self.LimbArmLeft.TJElbow.TwistControl,
self.LimbArmRight.TJArm.TwistControl,
self.LimbArmRight.TJElbow.TwistControl,
self.LimbLegLeft.TJArm.TwistControl,
self.LimbLegLeft.TJElbow.TwistControl,
self.LimbLegRight.TJArm.TwistControl,
self.LimbLegRight.TJElbow.TwistControl
],
VControl,
VisibilitySwitch="Secondary",
visibilityType="lodVisibility")
VisSwitch.ConstraintVisibility(["body_grp"],
VControl,
VisibilitySwitch="Geometry")
VisSwitch.AddAffectedObject(VControl,
self.Spine.secondaryControls,
VisibilitySwitch="Secondary",
visibilityType="lodVisibility")
VisSwitch.AddAffectedObject(VControl,
self.GHRightRig.fingerControlsReset,
VisibilitySwitch="Controls",
visibilityType="lodVisibility")
VisSwitch.AddAffectedObject(VControl,
self.GHLeftRig.fingerControlsReset,
VisibilitySwitch="Controls",
visibilityType="lodVisibility")
RMRigTools.RMLockAndHideAttributes(VControl, "0000000000")
#VisSwitch.AddEnumParameters( VControl, VisibilitySwitch = "Facial" )
pass
def RMImportMoveControl(Obj, scale=1, NameConv=None, name='', Type="move"):
Obj = RMRigTools.validate_pymel_nodes(Obj)
MoversTypeDic = {
"move": {
"filename": "ControlMover.mb",
"object": "MoverControl"
},
"v": {
"filename": "ControlV.mb",
"object": "VControl"
},
"head": {
"filename": "ControlHead.mb",
"object": "HeadControl"
},
"circleDeform": {
"filename": "ControlCircularDeform.mb",
"object": "CircularDeform"
}
}
if not NameConv:
NameConv = nameConvention.NameConvention()
path = os.path.dirname(RMRigTools.__file__)
RMPYPATH = os.path.split(path)
FinalPath = os.path.join(RMPYPATH[0], "RMPY\AutoRig\RigShapes",
MoversTypeDic[Type]["filename"])
if os.path.isfile(FinalPath):
print 'ready to import'
pm.importFile(FinalPath,
i=True,
type="mayaBinary",
ignoreVersion=True,
mergeNamespacesOnClash=False,
rpr="ControlMover",
pr=False)
print 'imported !!'
else:
print "archivo no encontrado %s , %s, %s " % (path, RMPYPATH,
FinalPath)
return None
Ctrl = pm.ls(MoversTypeDic[Type]["object"])[0]
if pm.objExists(Ctrl):
if name != '':
Ctrl = pm.rename(Ctrl, name)
pm.setAttr(Ctrl + ".scale", scale, scale, scale)
pm.makeIdentity(Ctrl, apply=True, t=1, r=1, s=1)
if name != '' and NameConv.is_name_in_format(Obj):
NameConv.rename_based_on_base_name(Obj, Ctrl)
else:
NameConv.rename_based_on_base_name(Obj, Ctrl, name=Ctrl)
NameConv.rename_set_from_name(Ctrl, "control", "objectType")
RMRigTools.RMAlign(Obj, Ctrl, 3)
ParentGroup = RMRigTools.RMCreateGroupOnObj(Ctrl)
return ParentGroup, Ctrl
else:
print "Error importing Shape File"
return None
def SinglePropRig(scene_object, referencePositionControl, centerPivot=False):
#if Object.__class__ == list :
#elif Object.__class__ in [str,unicode]:
GRS = RMGenericRigStructure.genericRigStructure()
NameConv = nameConvention.NameConvention()
bbMesh = RMRigTools.boundingBoxInfo(scene_object)
CtrlPosition = pm.xform(referencePositionControl,
q=True,
rp=True,
worldSpace=True)
NameList = scene_object.split(".")
cntrlToMeshX = bbMesh.position[0] - CtrlPosition[0]
cntrlToMeshY = bbMesh.position[1] - CtrlPosition[1]
cntrlToMeshZ = bbMesh.position[2] - CtrlPosition[2]
if len(NameList) > 1:
Ctrl = RMRigShapeControls.RMCreateCubeLine(
bbMesh.lenX,
bbMesh.lenY,
bbMesh.lenZ,
offsetX=-bbMesh.minDistanceToCenterX + cntrlToMeshX,
offsetY=-bbMesh.minDistanceToCenterY + bbMesh.lenY / 2 +
cntrlToMeshY,
offsetZ=-bbMesh.minDistanceToCenterZ + bbMesh.lenZ / 2 +
cntrlToMeshZ,
name=NameList[1])
if centerPivot == True:
pm.xform(Ctrl, cp=1)
joint = pm.joint(name=NameList[1] + "jnt")
else:
Ctrl = RMRigShapeControls.RMCreateCubeLine(
bbMesh.lenX,
bbMesh.lenY,
bbMesh.lenZ,
offsetX=-bbMesh.minDistanceToCenterX + cntrlToMeshX,
offsetY=-bbMesh.minDistanceToCenterY + bbMesh.lenY / 2 +
cntrlToMeshY,
offsetZ=-bbMesh.minDistanceToCenterZ + bbMesh.lenZ / 2 +
cntrlToMeshZ,
name=NameList[0] + "Ctrl")
if centerPivot == True:
pm.xform(Ctrl, cp=1)
joint = pm.joint(name=NameList[0] + "jnt")
Ctrl = NameConv.rename_name_in_format(Ctrl, {'objectType': "control"})
ResetGroup = RMRigTools.RMCreateGroupOnObj(Ctrl)
pm.parent(ResetGroup, GRS.groups["controls"]["group"])
rigJntGrp = pm.ls("*SimpleRigJoints*")
if len(rigJntGrp) == 0:
jointGroup = pm.group(empty=True, name="SimpleRigJoints")
jointGroup = NameConv.rename_name_in_format(jointGroup, {})
pm.parent(jointGroup, GRS.groups["rig"]['group'])
else:
jointGroup = rigJntGrp
if centerPivot != True:
RMRigTools.RMAlign(referencePositionControl, ResetGroup, 3)
joint = NameConv.rename_name_in_format(joint, {})
RMRigTools.RMAlign(referencePositionControl, joint, 3)
ResetJoint = RMRigTools.RMCreateGroupOnObj(joint)
pm.parent(ResetJoint, jointGroup)
#if pm.objExists
#for eachObject in Object:
pm.parentConstraint(Ctrl, joint)
pm.skinCluster(joint, scene_object)
def StandardFeetIKRig(self, StandarFeetPointsDic, FeetControl=None):
self.StandardFeetPointsDic = StandarFeetPointsDic
Side = self.NameConv.get_from_name(
self.StandardFeetPointsDic["feet"][0], "side")
self.rootIKJoints, StandardFeetIKJoints = self.StandardReverseFeetJointStructure(
StandarFeetPointsDic)
self.NameConv.rename_set_from_name(StandardFeetIKJoints,
"IK",
"name",
mode="add")
FootIn = self.StandardFeetPointsDic["limitIn"]
FootOut = self.StandardFeetPointsDic["limitOut"]
FootBK = self.StandardFeetPointsDic["limitBack"]
Length = RMRigTools.RMPointDistance(
self.StandardFeetPointsDic["feet"][2], FootBK)
Width = RMRigTools.RMPointDistance(FootIn, FootOut)
BallGrp = pm.group(empty=True,
name=self.NameConv.set_name_in_format(name="Ball",
side=Side))
BallLift = pm.group(empty=True,
name=self.NameConv.set_name_in_format(
name="BallLift", side=Side))
TapGrp = pm.group(empty=True,
name=self.NameConv.set_name_in_format(name="TapGrp",
side=Side))
TipGrp = pm.group(empty=True,
name=self.NameConv.set_name_in_format(name="TipGrp",
side=Side))
SideInGrp = pm.group(empty=True,
name=self.NameConv.set_name_in_format(
name="SideInGrp", side=Side))
SideOutGrp = pm.group(empty=True,
name=self.NameConv.set_name_in_format(
name="SideOutGrp", side=Side))
FeetOrient = pm.group(empty=True,
name=self.NameConv.set_name_in_format(
name="FeetOrient", side=Side))
FeetPalmOrient = pm.group(empty=True,
name=self.NameConv.set_name_in_format(
name="FeetPalmOrient", side=Side))
RMRigTools.RMAlign(StandardFeetIKJoints[1], BallGrp, 3)
RMRigTools.RMAlign(StandardFeetIKJoints[1], BallLift, 3)
RMRigTools.RMAlign(StandardFeetIKJoints[1], TipGrp, 3)
RMRigTools.RMAlign(StandardFeetIKJoints[2], TipGrp, 1)
RMRigTools.RMAlign(StandardFeetIKJoints[1], TapGrp, 3)
RMRigTools.RMAlign(FootIn, SideInGrp, 3)
RMRigTools.RMAlign(FootOut, SideOutGrp, 3)
RMRigTools.RMAlign(FootBK, TapGrp, 3)
RMRigTools.RMAlign(BallGrp, FeetPalmOrient, 3)
RMRigTools.RMAlign(StandardFeetIKJoints[0], FeetOrient, 3)
pm.xform(FeetOrient, objectSpace=True, relative=True, t=[0, 0, Width])
pm.xform(FeetPalmOrient,
objectSpace=True,
relative=True,
t=[0, 0, Width])
BallIK, BallIkEffector = pm.ikHandle(
sj=StandardFeetIKJoints[0],
ee=StandardFeetIKJoints[1],
name="BallIK") # solver="ikRPsolver",
TipIK, TipIkEffector = pm.ikHandle(
sj=StandardFeetIKJoints[1],
ee=StandardFeetIKJoints[2],
name="TipIK") # solver="ikRPsolver",
self.NameConv.rename_name_in_format(BallIK, side=Side)
self.NameConv.rename_name_in_format(TipIK, side=Side)
self.NameConv.rename_name_in_format(BallIkEffector, side=Side)
self.NameConv.rename_name_in_format(TipIkEffector, side=Side)
# pm.poleVectorConstraint (FeetOrient, BallIK)
# pm.poleVectorConstraint (FeetPalmOrient, TipIK)
pm.parent(BallIK, BallLift)
pm.parent(TipIK, BallLift)
pm.parent(BallLift, SideInGrp)
pm.parent(BallGrp, SideInGrp)
pm.parent(SideInGrp, SideOutGrp)
pm.parent(SideOutGrp, TapGrp)
pm.parent(TapGrp, TipGrp)
pm.parent(FeetOrient, BallGrp)
pm.parent(FeetPalmOrient, BallLift)
TipData = self.rig_tools.RMCreateGroupOnObj(TipGrp)
MainFeet = self.rig_tools.RMCreateGroupOnObj(TipData)
self.NameConv.rename_set_from_name(MainFeet, "MainFeet", "name")
if not FeetControl:
fetControlReset, FeetControl = RMRigShapeControls.RMCreateBoxCtrl(
StandarFeetPointsDic["feet"][0],
customSize=Length,
Yratio=.6,
Zratio=.3,
name="FeetControl")
self.fetControlReset = fetControlReset
# self.feetMainMoveIK = TipData
pm.parentConstraint(FeetControl, TipData, mo=True)
self.RMStandardRigAttributes(FeetControl)
pm.makeIdentity(BallGrp, apply=True, t=1, r=1, s=1, n=0)
pm.makeIdentity(BallLift, apply=True, t=1, r=1, s=1, n=0)
pm.makeIdentity(TapGrp, apply=True, t=1, r=1, s=1, n=0)
pm.makeIdentity(TipGrp, apply=True, t=1, r=1, s=1, n=0)
pm.makeIdentity(SideInGrp, apply=True, t=1, r=1, s=1, n=0)
pm.makeIdentity(SideOutGrp, apply=True, t=1, r=1, s=1, n=0)
pm.makeIdentity(FeetOrient, apply=True, t=1, r=1, s=1, n=0)
pm.makeIdentity(FeetPalmOrient, apply=True, t=1, r=1, s=1, n=0)
# pm.parent (self.rootIKJoints, BallGrp)
RMRigTools.RMConnectWithLimits("%s.ToeLift" % FeetControl,
"%s.rotateZ" % BallLift,
[[-10, -70], [0, 0], [10, 70]])
RMRigTools.RMConnectWithLimits("%s.BallPivot" % FeetControl,
"%s.rotateZ" % BallGrp,
[[-10, 70], [0, 0], [10, -70]])
RMRigTools.RMConnectWithLimits("%s.HeelPivot" % FeetControl,
"%s.rotateZ" % TapGrp,
[[-10, -70], [0, 0], [10, 70]])
RMRigTools.RMConnectWithLimits("%s.ToePivot" % FeetControl,
"%s.rotateZ" % TipGrp,
[[-10, 70], [0, 0], [10, -70]])
if (Side == "L"):
RMRigTools.RMConnectWithLimits("%s.Tilt" % FeetControl,
"%s.rotateX" % SideInGrp,
[[-10, 70], [0, 0]])
RMRigTools.RMConnectWithLimits("%s.Tilt" % FeetControl,
"%s.rotateX" % SideOutGrp,
[[0, 0], [10, -70]])
RMRigTools.RMConnectWithLimits("%s.ToePivotSide" % FeetControl,
"%s.rotateY" % TipGrp,
[[-10, 70], [0, 0], [10, -70]])
# RMRigTools.RMConnectWithLimits( "%s.ToePivot" , TipGrp + ".rotateZ", [[-10,-70],[0,0],[10,70]])
else:
RMRigTools.RMConnectWithLimits("%s.Tilt" % FeetControl,
"%s.rotateX" % SideInGrp,
[[-10, -70], [0, 0]])
RMRigTools.RMConnectWithLimits("%s.Tilt" % FeetControl,
"%s.rotateX" % SideOutGrp,
[[0, 0], [10, 70]])
RMRigTools.RMConnectWithLimits("%s.ToePivotSide" % FeetControl,
"%s.rotateY" % TipGrp,
[[-10, -70], [0, 0], [10, 70]])
# RMRigTools.RMCreateGroupOnObj( FeetControl)
pm.scaleConstraint(FeetControl, MainFeet)
self.MainFeetKinematics = MainFeet
self.IKAttachPoint = BallGrp
self.StandardFeetIKJoints = StandardFeetIKJoints
def RibbonCreation(self, Object01, Object02, foliculeNumber=5):
print 'creating riboon in %s and %s' % (Object01, Object02)
self.baseObjects.append(Object01)
self.baseObjects.append(Object02)
VP1 = om.MVector(pm.xform(Object01, a=True, ws=True, q=True, rp=True))
VP2 = om.MVector(pm.xform(Object02, a=True, ws=True, q=True, rp=True))
plano = self.nurbPlaneBetweenObjects(Object01, Object02)
planoShape = pm.listRelatives(plano, shapes=True)[0]
pm.select(cl=True)
RibbonSize = VP1 - VP2
print "plano = %s" % plano
print "len = %s" % RibbonSize.length()
MainSkeleton = pm.group(em=True,
name="%sTo%sRibbon" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(MainSkeleton, {}, useName=True)
HairGroup = pm.group(em=True,
name="%sTo%sHairSystem" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.set_name_in_format(HairGroup, useName=True)
nstep = 1.0 / (foliculeNumber - 1.0)
Hys = pm.language.Mel.eval('createNode hairSystem')
Hys = "hairSystem1"
ArrayJoints = []
HairSystemIndex = [0]
folicules = []
for n in range(foliculeNumber):
pm.language.Mel.eval(
'createHairCurveNode("%s", "%s" ,%s ,.5 , 1 ,0 ,0 ,0 ,0 ,"" ,1.0 ,{%s} ,"" ,"" ,2 );'
% (Hys, planoShape, nstep * n, n))
NewFolicule = self.name_conv.rename_name_in_format("follicle1", {})
folicules.append(NewFolicule)
pm.parent(NewFolicule, HairGroup)
self.folicules = folicules
pm.delete(pm.listRelatives(Hys, p=True))
index = 0
skinedJoints = pm.group(em=True,
name="%sTo%sskinedJoints" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(skinedJoints, useName=True)
for eachFolicule in folicules:
ArrayJoints.append(
pm.joint(name="%sTo%sRibbonJoints" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02))))
self.name_conv.set_name_in_format(ArrayJoints[index], useName=True)
RMRigTools.RMAlign(eachFolicule, ArrayJoints[index], 3)
pm.parentConstraint(eachFolicule, ArrayJoints[index])
index += 1
self.jointStructure = ArrayJoints
controles = []
resetControles = []
locatorControlesList = []
locatorLookAtList = []
jointsLookAtList = []
groupLookAtList = []
GroupControls = pm.group(empty=True,
name="%sTo%sControls" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(GroupControls, {}, useName=True)
GroupJoints = pm.group(empty=True,
name="%sTo%sGroupJointsLookAt" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(GroupJoints, {}, useName=True)
self.allControls.append(GroupControls)
self.joints.append(GroupJoints)
for iloop in range(3):
resetControlGroup, control = self.rig_controls.RMCircularControl(
Object01,
radius=RibbonSize.length() / 3,
name="%sTo%sCtrl" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
controles.append(control)
resetControles.append(resetControlGroup)
locatorControl = pm.spaceLocator(
name="%sTo%sLocatorCntrl" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(locatorControl, {},
useName=True)
locatorControlesList.append(locatorControl[0])
RMRigTools.RMAlign(Object01, locatorControl[0], 3)
locatorLookAt = pm.spaceLocator(
name="%sTo%sLocatorLookAt" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(locatorLookAt, {},
useName=True)
locatorLookAtList.append(locatorLookAt[0])
RMRigTools.RMAlign(Object01, locatorLookAt[0], 3)
pm.select(clear=True)
jointsLookAt = pm.joint(
name="%sTo%sJointsLookAt" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(jointsLookAt, {},
useName=True)
jointsLookAtList.append(jointsLookAt)
RMRigTools.RMAlign(Object01, jointsLookAt, 3)
groupLookAt = pm.group(empty=True,
name="%sTo%sGroupLookAt" %
(self.name_conv.get_a_short_name(Object01),
self.name_conv.get_a_short_name(Object02)))
self.name_conv.rename_name_in_format(groupLookAt, {}, useName=True)
self.kinematics.append(groupLookAt)
groupLookAtList.append(groupLookAt)
RMRigTools.RMAlign(Object01, groupLookAt, 3)
pm.parent(groupLookAtList, MainSkeleton)
pm.move(RibbonSize.length() / 2 * iloop,
0,
0,
resetControlGroup,
r=True,
os=True,
moveX=True)
pm.move(RibbonSize.length() / 2 * iloop,
0,
0,
locatorControl,
r=True,
os=True,
moveX=True)
pm.move(RibbonSize.length() / 2 * iloop,
0,
1,
locatorLookAt,
r=True,
os=True,
moveXYZ=True)
pm.move(RibbonSize.length() / 2 * iloop,
0,
0,
jointsLookAt,
r=True,
os=True,
moveX=True)
pm.move(RibbonSize.length() / 2 * iloop,
0,
0,
groupLookAt,
r=True,
os=True,
moveX=True)
pm.parent(resetControlGroup, GroupControls)
pm.parent(locatorControl, groupLookAt)
pm.parent(locatorLookAt, groupLookAt)
pm.parent(jointsLookAt, GroupJoints)
pm.makeIdentity(control, apply=True, t=1, r=0, s=1, n=0)
pm.makeIdentity(jointsLookAt, apply=True, t=1, r=0, s=1, n=0)
pm.parentConstraint(locatorControl, jointsLookAt)
pm.parentConstraint(control, groupLookAt)
self.controls = controles
self.resetControls = resetControles
self.resetControls = resetControles
pm.aimConstraint(controles[1],
locatorControlesList[0],
aim=[1, 0, 0],
upVector=[0, 0, 1],
wut='object',
worldUpObject=locatorLookAtList[0])
pm.aimConstraint(controles[1],
locatorControlesList[2],
aim=[1, 0, 0],
upVector=[0, 0, 1],
wut='object',
worldUpObject=locatorLookAtList[2])
pm.parent(GroupJoints, MainSkeleton)
pm.select(plano, replace=True)
print jointsLookAtList
for eachJoint in jointsLookAtList:
pm.select(eachJoint, add=True)
pm.SmoothBindSkin()
pm.parent(plano, HairGroup)
def SetupEyes(self):
if cmds.objExists("LEye") and cmds.objExists("REye"):
cmds.group(em=True, name="ReyeOrientacion")
cmds.joint(name="REyeJoint")
cmds.group(em=True, name="ReyeBase")
cmds.group(em=True, name="ReyeLookAt")
cmds.group(em=True, name="ReyePointLookAt")
cmds.group(em=True, name="LeyeOrientacion")
cmds.joint(name="LEyeJoint")
cmds.group(em=True, name="LeyeBase")
cmds.group(em=True, name="LeyeLookAt")
cmds.group(em=True, name="LeyePointLookAt")
cmds.group(em=True, name="eyeOrientation")
RMRigTools.RMAlign("LEye", "LeyeBase", 3)
RMRigTools.RMAlign("LEye", "LeyeOrientacion", 3)
RMRigTools.RMAlign("LEye", "LeyeLookAt", 3)
RMRigTools.RMAlign("LEye", "LeyePointLookAt", 3)
cmds.move(10, "LeyePointLookAt", moveZ=True)
EyeParent = cmds.listRelatives("LEye", parent=True)
cmds.parent("LeyeBase", EyeParent)
cmds.parent("LeyeLookAt", "LeyeBase")
cmds.parent("LeyeOrientacion", "LeyeLookAt")
cmds.aimConstraint("LeyePointLookAt",
"LeyeLookAt",
aimVector=[0, 0, 1],
worldUpObject="eyeOrientation",
worldUpType="objectrotation")
cmds.expression(name="LEyeExpresionX", unitConversion="none")
script = "LeyeOrientacion.rotateY = (Character_LF_Ojo_Ctrl_fc.translateX * 4 + Character_MD_OjoRectangle_ctrl_fc.translateX * 4)/10"
cmds.expression("LEyeExpresionX",
edit=True,
string=script,
unitConversion="none")
cmds.expression(name="LEyeExpresionY", unitConversion="none")
script = "LeyeOrientacion.rotateX = -(Character_LF_Ojo_Ctrl_fc.translateY * 4 + Character_MD_OjoRectangle_ctrl_fc.translateY * 4)/10"
cmds.expression("LEyeExpresionY",
edit=True,
string=script,
unitConversion="none")
RMRigTools.RMAlign("REye", "ReyeBase", 3)
RMRigTools.RMAlign("REye", "ReyeOrientacion", 3)
RMRigTools.RMAlign("REye", "ReyeLookAt", 3)
RMRigTools.RMAlign("REye", "ReyePointLookAt", 3)
cmds.move(10, "ReyePointLookAt", moveZ=True)
EyeParent = cmds.listRelatives("REye", parent=True)
cmds.parent("ReyeBase", EyeParent)
cmds.parent("ReyeLookAt", "ReyeBase")
cmds.parent("ReyeOrientacion", "ReyeLookAt")
cmds.aimConstraint("ReyePointLookAt",
"ReyeLookAt",
aimVector=[0, 0, 1],
worldUpObject="eyeOrientation",
worldUpType="objectrotation")
cmds.expression(name="REyeExpresionX", unitConversion="none")
script = "ReyeOrientacion.rotateY = (Character_RH_Ojo_Ctrl_fc.translateX * 4 + Character_MD_OjoRectangle_ctrl_fc.translateX * 4)/10"
cmds.expression("REyeExpresionX",
edit=True,
string=script,
unitConversion="none")
cmds.expression(name="REyeExpresionY", unitConversion="none")
script = "ReyeOrientacion.rotateX = -(Character_RH_Ojo_Ctrl_fc.translateY * 4 + Character_MD_OjoRectangle_ctrl_fc.translateY * 4)/10"
cmds.expression("REyeExpresionY",
edit=True,
string=script,
unitConversion="none")
RMRigTools.RMAlign(EyeParent, "eyeOrientation", 1)
cmds.parent("eyeOrientation", EyeParent)
# $LeyeBase.parent=$LEye.parent;
# $ReyeBase.parent=$REye.parent;
cmds.parent("LEye", "LeyeOrientacion")
cmds.parent("REye", "ReyeOrientacion")
'''if cmds.objExists("*REyeGeo*"):
EyeGeo=cmds.ls("*REyeGeo*",type="transform")
for geo in EyeGeo:
cmds.bindSkin(geo,"REyeJoint")
if cmds.objExists("*LEyeGeo*"):
EyeGeo=cmds.ls("*LEyeGeo*",type="transform")
for geo in EyeGeo:
cmds.bindSkin(geo,"LEyeJoint")
'''
cmds.parent("OjosLookAt", EyeParent)
cmds.parent("LeyePointLookAt", "OjosLookAt_L")
cmds.parent("ReyePointLookAt", "OjosLookAt_R")
else:
print "No existen los objetos LEye y REye"
