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 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 connectFromDefinition(self,
BSDefinition,
currentBlendShape,
blendShapeNode,
prefix,
extremeValue,
objectPrefix=''):
if prefix != "":
Side = self.getSideFromPrefix(prefix)
#print "Connecting:%s.%s To %s.%s"% (self.NameConv.RMSetFromName(BSDefinition["control"],Side,Token = "Side" ), BSDefinition['blendShapes'][currentBlendShape]["connection"], blendShapeNode, prefix +currentBlendShape)
control = self.NameConv.set_from_name(BSDefinition["control"],
Side,
Token="Side")
else:
control = BSDefinition["control"]
if extremeValue > 0:
RMRigTools.RMConnectWithLimits(
"%s.%s" %
(control,
BSDefinition['blendShapes'][currentBlendShape]["connection"]),
"%s.%s" %
(blendShapeNode, prefix + objectPrefix + currentBlendShape),
[[0, 0], [extremeValue, 1]])
else:
RMRigTools.RMConnectWithLimits(
"%s.%s" %
(control,
BSDefinition['blendShapes'][currentBlendShape]["connection"]),
"%s.%s" %
(blendShapeNode, prefix + objectPrefix + currentBlendShape),
[[extremeValue, 1], [0, 0]])
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 LockAndHide(selection):
if selection:
if (cmds.getAttr("%s.visibility"%selection[0])):
for eachObject in selection :
RMRigTools.RMLockAndHideAttributes( eachObject, "xxxxxxxxx1" )
cmds.setAttr("%s.visibility"%eachObject,False)
RMRigTools.RMLockAndHideAttributes( eachObject, "xxxxxxxxxl" )
else:
for eachObject in selection :
RMRigTools.RMLockAndHideAttributes( eachObject, "xxxxxxxxx1" )
cmds.setAttr("%s.visibility"%eachObject,True)
def getAngle(radius, joint1, joint2):
segmentLen01 = RMRigTools.RMLenghtOfBone(joint1)
if joint2:
segmentLen02 = RMRigTools.RMLenghtOfBone(joint2)
else:
segmentLen02 = segmentLen01
alpha = SegmentAngleInCircle(radius, segmentLen01)
beta = SegmentAngleInCircle(radius, segmentLen02)
return 180 - DeltaBetweenAngles(alpha, beta)
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 CreateJointChainSquareRig(self, JointChain, UDaxis="Y"):
if self.NameConv.is_name_in_format(JointChain[0]):
if self.NameConv.get_from_name(JointChain[0], "side") == "LF":
sideVariation = 1
else:
sideVariation = -1
else:
sideVariation = 1
if UDaxis in ["Y", "Z"]:
BoxResetPoint, BoxControl = RMRigShapeControls.RMCreateBoxCtrl(
JointChain[len(JointChain) - 1],
ParentBaseSize=True,
Xratio=.5,
Yratio=.5,
Zratio=.5)
self.addChainParameters(BoxControl, len(JointChain) - 1)
cmds.makeIdentity(BoxControl,
apply=True,
r=False,
t=True,
s=True,
n=0)
cmds.parentConstraint(JointChain[len(JointChain) - 1],
BoxResetPoint)
RMRigTools.RMLockAndHideAttributes(BoxControl, "0000000000")
if UDaxis == "Y":
LRaxis = "Z"
elif UDaxis == "Z":
LRaxis = "Y"
for eachjoint in range(len(JointChain) - 1):
RMRigTools.RMConnectWithLimits(
BoxControl + ".UD" + str(eachjoint + 1),
JointChain[eachjoint] + (".rotate%s" % UDaxis),
[[-10, 100], [0, 0], [10, -100]])
RMRigTools.RMConnectWithLimits(
BoxControl + ".LR" + str(eachjoint + 1),
JointChain[eachjoint] + (".rotate%s" % LRaxis),
[[-10, sideVariation * 100], [0, 0],
[10, sideVariation * -100]])
RMRigTools.RMConnectWithLimits(
BoxControl + ".Twist" + str(eachjoint + 1),
JointChain[eachjoint] + ".rotateX",
[[-10, sideVariation * 100], [0, 0],
[10, sideVariation * -100]])
else:
print "Not Valid UD Axis Provided"
def RemoveAffectedObject(self,
ControlObject,
removeObjectList,
VisibilitySwitch='visibility',
visibilityType="visibility"):
ControlObject = RMRigTools.validate_pymel_nodes(ControlObject)
removeObjectList = RMRigTools.validate_pymel_nodes(removeObjectList)
'''visibilityType valid values are overrideVisibility, lodVisibility or visibility'''
AffectedObjectList = self.GetAfectedObjectsList(
ControlObject, VisibilitySwitch=VisibilitySwitch)
for eachObject in removeObjectList:
if eachObject in AffectedObjectList:
pm.disconnectAttr(
("%s.%s" % (ControlObject, VisibilitySwitch)),
("%s.%s" % (eachObject, visibilityType)))
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 RMCreateHeadRig(self):
headSize = RMRigTools.RMLenghtOfBone(self.HeadJoints[0])
print '%s %s' % (self.rootHeadJoints, self.rootHeadJoints.__class__)
resetHeadControl, headControl = RMRigShapeControls.RMImportMoveControl(
self.rootHeadJoints, scale=headSize, name="head", Type="head")
pm.parentConstraint(headControl, self.HeadJoints[0])
return resetHeadControl, headControl
def addNoiseOnControl(Object, Control):
if Object.__class__ == list:
pass
elif Object.__class__ in [str, unicode]:
Object = [Object]
else:
"Not Valid Arguments on Add Noise"
return None
Expresion = '''//{0}
{0}.rotateX=`noise((time+{2})*{1}.frequency)`*{1}.amplitud;
{0}.rotateY=`noise((time+{2}+30)*{1}.frequency)`*{1}.amplitud;
{0}.rotateZ=`noise((time+{2}+60)*{1}.frequency)`*{1}.amplitud;
{0}.ty=`noise((time+{2}+90)*{1}.frequency)`*{1}.movY + {1}.movY;
'''
if not isNoiseControl(Control):
addAttributes(Control)
for eachObject in Object:
constraints = constraintComponents(gessFrom=eachObject)
ResetGroup = RMRigTools.RMCreateGroupOnObj(eachObject, Type="child")
for eachkey in constraints.constraintDic:
pm.delete(eachkey)
pm.parentConstraint(ResetGroup,
constraints.constraintDic[eachkey]["affected"],
mo=True)
ExpressionNode = pm.expression(name="NoiseMainExpresion",
string=Expresion.format(
ResetGroup, Control,
random.uniform(0, 100)))
def __init__(self, NameConv=None):
if NameConv:
self.NameConv = NameConv
else:
self.NameConv = nameConvention.NameConvention()
RigTools = RMRigTools.RMRigTools(self.NameConv)
self.FaceBlendShapeDic = {}
def __init__(self, NameConv=None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.GHS = RMGenericHandStructure.GenericHandJointStructure(
NameConv=NameConv)
self.name_conv = RMRigTools.RMRigTools(NameConv=NameConv)
self.fingerRoot = {
"middle": None,
"ring": None,
"pinky": None,
"index": None,
"thumb": None
}
self.PalmReferencePoints = {
"middle": None,
"ring": None,
"pinky": None,
"index": None,
"thumb": None
}
self.PalmFingerControlGrp = {
"middle": None,
"ring": None,
"pinky": None,
"index": None,
"thumb": None
}
self.PalmResetPoint = None
self.PalmControl = None
self.fingerControlsReset = []
self.fingerContols = []
self.MainKinematics = None
self.MainControl = None
def __init__(self, NameConv=None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.rig_tools = RMRigTools.RMRigTools()
self.StandardFeetPointsDic = None
self.rootFKJoints = None
self.rootIKJoints = None
self.StandardFeetIKJoints = None
self.StandardFeetFKJoints = None
self.MainFeetKinematics = None
self.FeetControl = None
self.FirstLimbFeetResetControl = None
self.SecondLimbFeetControl = None
self.SecondLimbControlResetPoint = None
# self.StandardFeetDefJoints = None
# self.rootStandardFeetDefJoints = None
self.IKAttachPoint = None
self.rootJoints = None
self.StandardFeetJoints = None
self.feetMainMoveIK = None
self.rootFKJoints
def get_oposite(scene_object):
if scene_object.__class__ is list:
return_list = True
else:
return_list = False
scene_object = [scene_object]
result_list = []
for each_object in scene_object:
each_object = RMRigTools.validate_pymel_nodes(each_object)
namespace_tokens = each_object.split(':')
if len(namespace_tokens) > 1:
namespace = '%s:' % namespace_tokens[0]
splitName = namespace_tokens[1]
else:
namespace = ''
splitName = str(each_object)
token_list = splitName.split('_')
if token_list[1] in ['FR', 'MR', 'BR', 'FL','ML', 'BL', 'C', 'R','L']:
if 'L' in token_list[1]:
token_list[1] = token_list[1].replace('L', 'R')
else:
if 'R' in token_list[1]:
token_list[1] = token_list[1].replace('R', 'L')
if pm.objExists('%s%s' % (namespace, '_'.join(token_list))):
result_list.append(RMRigTools.validate_pymel_nodes('%s%s' % (namespace, '_'.join(token_list))))
else:
print 'no oposite found for object %s' % each_object
else:
if token_list[0] in ['FR', 'MR', 'BR', 'FL', 'ML', 'BL', 'C', 'R', 'L']:
if 'L' in token_list[0]:
token_list[0] = token_list[0].replace('L', 'R')
else:
if 'R' in token_list[0]:
token_list[0] = token_list[0].replace('R', 'L')
if pm.objExists('%s%s' % (namespace, '_'.join(token_list))):
result_list.append(RMRigTools.validate_pymel_nodes('%s%s' % (namespace, '_'.join(token_list))))
else:
print 'no oposite found for object %s' % each_object
if return_list:
return result_list
else:
if len(result_list) == 1:
return result_list[0]
else:
return None
def CreateHandRig(self, PalmReferencePoint, PalmControl=None):
self.CreateHandStructure(PalmReferencePoint)
for fingers in self.GHS.fingers:
self.CreateFingerSquareRig(fingers)
self.CreatePalmRig(PalmControl=PalmControl)
RMRigTools.RMParentArray(self.PalmControl, self.fingerControlsReset)
palmLen = RMRigTools.RMPointDistance(self.PalmControl,
self.GHS.fingerRoots[0])
pm.parentConstraint(self.MainKinematics, self.GHS.palmJoint)
pm.parentConstraint(self.MainKinematics, self.MainControl)
self.NameConv.rename_set_from_name(self.GHS.palmJoint, "sknjnt",
"objectType")
for eachFinger in self.GHS.fingers:
self.NameConv.rename_set_from_name(eachFinger, "sknjnt",
"objectType")
def RMCreateClavicleJointStructure(self, ClavRefPnts):
rootClavicle, ClavicleJoints = RMRigTools.RMCreateBonesAtPoints(
ClavRefPnts, ZAxisOrientation="z")
self.NameConv.rename_set_from_name(ClavicleJoints[1], "clavicle",
"name")
pm.parent(rootClavicle, self.chestJoint)
return rootClavicle, ClavicleJoints
def ConstraintVisibility(self,
Objects,
ControlObject,
VisibilitySwitch='visibility',
visibilityType="visibility"):
Objects = RMRigTools.validate_pymel_nodes(Objects)
ControlObject = RMRigTools.validate_pymel_nodes(ControlObject)
'''visibilityType valid values are overrideVisibility, lodVisibility or visibility'''
if (self.AddEnumParameters(ControlObject,
VisibilitySwitch=VisibilitySwitch)):
for eachObject in Objects:
RMRigTools.RMLockAndHideAttributes(eachObject, "xxxxxxxxxL")
RMRigTools.RMLockAndHideAttributes(eachObject, "xxxxxxxxxh")
# print ("connecting Visibility %s.%s to %s.%s"%(ControlObject,VisibilitySwitch,eachObject,visibilityType) )
pm.connectAttr("%s.%s" % (ControlObject, VisibilitySwitch),
"%s.%s" % (eachObject, visibilityType))
else:
print "Not Valid Object"
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 orderPointsByDistance(straigtPnts, MaxDistanceDic):
shortArray = straigtPnts
shortArray.remove(MaxDistanceDic['points'][0])
shortArray.remove(MaxDistanceDic['points'][1])
distanceArray = {}
for eachElement in shortArray:
distanceArray[eachElement] = RMRigTools.RMPointDistance(
MaxDistanceDic['points'][0], eachElement)
return sorted(distanceArray, key=distanceArray.__getitem__)
def average_vertex_position(vertex_list):
position_list = []
for each in vertex_list:
if each.__class__ == pm.general.MeshVertex:
for each_vertex in each:
position = each_vertex.getPosition(space='world')
if len(position) == 3:
position_list.append([position[0], position[1], position[2]])
return RMRigTools.average(*position_list)
def __init__(self, NameConv=None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.rig_tools = RMRigTools.RMRigTools(NameConv=self.NameConv)
self.palmJoint = ""
self.fingerRoots = []
self.fingers = []
def getExtremePoints(listOfPnts):
MaxDistanceDic = {'points': [], 'distance': 0}
for eachPoint in listOfPnts:
for eachOtherPoint in listOfPnts:
distanceValue = RMRigTools.RMPointDistance(eachPoint,
eachOtherPoint)
if distanceValue > MaxDistanceDic['distance']:
MaxDistanceDic['points'] = [eachPoint, eachOtherPoint]
MaxDistanceDic['distance'] = distanceValue
return MaxDistanceDic
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 linkJointDefinition(self, Side, jointLinkDefinition):
control = jointLinkDefinition['control']
if Side in ["LF", "RH"]:
control = self.NameConv.set_from_name(
jointLinkDefinition['control'], Side, Token='Side')
if cmds.objExists(control):
for eachAttribute in jointLinkDefinition['order']:
jointsList = self.returnJointsByControl(
eachAttribute, jointLinkDefinition['joints'])
for eachJoint in jointsList:
JointName = eachJoint
if Side in ["LF", "RH"]:
JointName = self.NameConv.set_from_name(eachJoint,
Side,
Token='Side')
if cmds.objExists(JointName):
if jointLinkDefinition['joints'][eachJoint][
'value'] == None:
cmds.connectAttr(
'%s.%s' %
(control, jointLinkDefinition['joints']
[eachJoint]['connection']),
'%s.%s' %
(JointName, jointLinkDefinition['joints']
[eachJoint]['inputPlug']),
force=True)
else:
self.AddAttributes(
control, eachAttribute,
jointLinkDefinition['attributes']
[eachAttribute]['min'],
jointLinkDefinition['attributes']
[eachAttribute]['max'])
RMRigTools.RMConnectWithLimits(
'%s.%s' %
(control, jointLinkDefinition['joints']
[eachJoint]['connection']), '%s.%s' %
(JointName, jointLinkDefinition['joints']
[eachJoint]['inputPlug']),
jointLinkDefinition['joints'][eachJoint]
['value'])
else:
print "Joint object doesnt exists:%s" % JointName
else:
print "Control object doesnt exists:%s" % control
control = self.NameConv.set_from_name(
jointLinkDefinition['control'], Side, Token='Side')
#if __name__=="__main__":
# Manager = BSManager()
# Manager.AppyBlendShapeDefinition( SkinedJoints)
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 AddAffectedObject(self,
ControlObject,
addObjectList,
VisibilitySwitch='visibility',
visibilityType="visibility"):
ControlObject = RMRigTools.validate_pymel_nodes(ControlObject)
addObjectList = RMRigTools.validate_pymel_nodes(addObjectList)
'''visibilityType valid values are overrideVisibility, lodVisibility or visibility'''
for eachObject in addObjectList:
inputConnections = pm.listConnections("%s.%s" %
(eachObject, visibilityType),
plugs=True,
destination=True)
if inputConnections:
if len(inputConnections) > 0:
pm.disconnectAttr(inputConnections[0],
"%s.%s" % (eachObject, visibilityType))
pm.connectAttr("%s.%s" % (ControlObject, VisibilitySwitch),
"%s.%s" % (eachObject, visibilityType),
force=True)
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 StardardFeetFK(self, StandarFeetPointsDic, FeetControl=None):
Side = self.NameConv.get_from_name(
self.StandardFeetPointsDic["feet"][0], "side")
self.rootFKJoints, StandardFeetFKJoints = self.StandardReverseFeetJointStructure(
StandarFeetPointsDic)
self.NameConv.rename_set_from_name(StandardFeetFKJoints,
"FK",
"name",
mode="add")
FootIn = self.StandardFeetPointsDic["limitIn"]
FootOut = self.StandardFeetPointsDic["limitOut"]
FootBK = self.StandardFeetPointsDic["limitBack"]
Length = RMRigTools.RMPointDistance(
self.StandardFeetPointsDic["feet"][2], FootBK)
if not FeetControl:
self.FirstLimbFeetResetControl, FeetControl = RMRigShapeControls.RMCircularControl(
StandardFeetFKJoints[0], radius=Length, name="FKFeetControl")
self.FeetControl = FeetControl
SecondLimbfeetResetControl, SecondLimbFeetControl = RMRigShapeControls.RMCircularControl(
StandardFeetFKJoints[1], radius=Length, name="FKTipFeetControl")
pm.parentConstraint(FeetControl, StandardFeetFKJoints[0], mo=True)
pm.parentConstraint(SecondLimbFeetControl,
StandardFeetFKJoints[1],
mo=True)
pm.parentConstraint(StandardFeetFKJoints[0],
SecondLimbfeetResetControl,
mo=True)
pm.parent(SecondLimbfeetResetControl, FeetControl)
RMRigTools.RMLockAndHideAttributes(FeetControl, "000111000h")
RMRigTools.RMLockAndHideAttributes(SecondLimbFeetControl, "000111000h")
self.StandardFeetFKJoints = StandardFeetFKJoints
self.SecondLimbFeetControl = SecondLimbFeetControl
self.SecondLimbControlResetPoint = SecondLimbfeetResetControl
