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 __init__(self, NameConv=None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.ControlObject = None
self.AfectedObjectList = []
def color_code_controls(controls, force=None):
name_convention = nameConvention.NameConvention()
for each in controls:
if not force:
if name_convention.is_name_in_format(each):
if name_convention.get_from_name(each, 'side') == 'L':
each.overrideEnabled.set(True)
each.overrideColor.set(17)
elif name_convention.get_from_name(each, 'side') == 'R':
each.overrideEnabled.set(True)
each.overrideColor.set(13)
else:
each.overrideEnabled.set(True)
each.overrideColor.set(18)
shape = pm.ls(each.getShape())
else:
print('{} name_not in format'.format(each))
if 'L_' in str(each):
each.overrideEnabled.set(True)
each.overrideColor.set(17)
elif 'R_' in str(each):
each.overrideEnabled.set(True)
each.overrideColor.set(13)
else:
each.overrideEnabled.set(True)
each.overrideColor.set(18)
shape = pm.ls(each.getShape())
if shape:
shape[0].overrideEnabled.set(False)
else:
each.overrideEnabled.set(True)
each.overrideColor.set(14)
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 RMCreateGroupOnObj(Obj, Type="inserted", NameConv = None):
Obj = validate_pymel_nodes(Obj)
'''
"world","child","parent","inserted"
'''
if not NameConv:
NameConv = nameConvention.NameConvention()
Group = pm.group(empty=True)
if NameConv.is_name_in_format(Obj):
Group = NameConv.rename_based_on_base_name(Obj, Group, objectType="transform")
else:
ValidNameList = Obj.split("_")
ValidName = ""
for eachToken in ValidNameList:
ValidName += eachToken
NewName = NameConv.set_name_in_format(name = NameConv.add_to_numbered_string(ValidName, "Group"), objectType= "transform")
Group = pm.rename(Group, NewName)
RMAlign(Obj, Group, 3)
Parent = pm.listRelatives(Obj, parent=True)
if not (Type == "world"):
if Type == "inserted":
if Parent:
RMInsertInHierarchy(Obj, Group)
else:
pm.parent(Obj, Group)
elif Type == "parent":
pm.parent(Obj, Group)
elif Type == "child":
pm.parent(Group, Obj)
return Group
def RMCreateLineBetwenPoints(Point1, Point2, NameConv=None):
if not NameConv:
NameConv = nameConvention.NameConvention()
Curve = pm.curve(degree=1, p=[[0, 0, 0], [1, 0, 0]], name="curveLineBetweenPnts")
Curve = NameConv.rename_based_on_base_name(Point1, Curve, name=Curve)
NumCVs = pm.getAttr(Curve + ".controlPoints", size=True)
Cluster1, Cluster1Handle = pm.cluster(Curve + ".cv[0]", relative=True, name="clusterLineBetweenPnts")
Cluster1 = NameConv.rename_based_on_base_name(Point1, Cluster1, name= Cluster1)
Cluster1Handle = NameConv.rename_based_on_base_name(Point1, Cluster1Handle, name= Cluster1Handle)
Cluster2, Cluster2Handle = pm.cluster(Curve + ".cv[1]", relative=True, name="clusterLineBetweenPnts")
Cluster2 = NameConv.rename_based_on_base_name(Point2, Cluster2, name= Cluster2)
Cluster2Handle = NameConv.rename_based_on_base_name(Point2, Cluster2Handle, name= Cluster2Handle)
pm.setAttr(Curve + ".overrideEnabled", 1)
pm.setAttr(Curve + ".overrideDisplayType", 1)
RMAlign(Point1, Cluster1Handle, 1)
RMAlign(Point2, Cluster1Handle, 1)
PointConstraint1 = pm.pointConstraint(Point1, Cluster1Handle, name="PointConstraintLineBetweenPnts")
PointConstraint1 = NameConv.rename_based_on_base_name(Point1, PointConstraint1, name= PointConstraint1)
PointConstraint2 = pm.pointConstraint(Point2, Cluster2Handle, name="PointConstraintLineBetweenPnts")
PointConstraint2 = NameConv.rename_based_on_base_name(Point2, PointConstraint2, name= PointConstraint2)
DataGroup = pm.group(em=True, name="DataLineBetweenPnts")
DataGroup = NameConv.rename_based_on_base_name(Point1, DataGroup, name= DataGroup)
pm.parent(Cluster1Handle, DataGroup)
pm.parent(Cluster2Handle, DataGroup)
pm.parent(Curve, DataGroup)
return DataGroup, Curve
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 NameConv:
self.NameConv = NameConv
else:
self.NameConv = nameConvention.NameConvention()
RigTools = RMRigTools.RMRigTools(self.NameConv)
self.FaceBlendShapeDic = {}
def __init__(self, *args):
self._model = RigStructureModel()
self.name_convention = nameConvention.NameConvention()
if args:
self.name_convention.default_names[
'system'] = self.name_convention.get_a_short_name(args[0])
self.name_convention.default_names[
'side'] = self.name_convention.get_from_name(args[0], 'side')
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 getMeshObjects(Objects):
MeshObjects = []
OtherObjects = []
NameConv = nameConvention.NameConvention()
for eachObject in Objects:
if NameConv.guess_object_type(eachObject) == "msh":
MeshObjects.append(eachObject)
else:
OtherObjects.append(eachObject)
return {"meshObjects": MeshObjects, "other": OtherObjects}
def __init__(self, NameConv = None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.kinematics = []
self.TwistJoints = None
self.TwistResetJoints = None
self.TwistControlResetPoint = None
self.TwistControl = None
self.TwistOrigin = None
self.TwistEnd = None
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 lockKneeOnSpecific(Constraint, IKJointLimb, SkinJointLimb,
PoleVectorControl, TwistJointsControl):
NameConv = nameConvention.NameConvention()
ShortName = NameConv.get_a_short_name(IKJointLimb)
Side = NameConv.get_from_name(IKJointLimb, 'Side')
group = cmds.group(empty=True,
name="Character01_%s_%sLockDriver00_grp_Rig" %
(Side, ShortName))
RigTools = RMRigTools.RMRigTools()
ChildPoleVector = RigTools.RMCreateGroupOnObj(PoleVectorControl, "child")
cmds.orientConstraint(IKJointLimb, ChildPoleVector, mo=False)
# RMRigTools.RMAlign( IKJointLimb, IKJointLimb, 1)
cmds.parentConstraint(SkinJointLimb, TwistJointsControl, mo=True)
LegSknJoint = cmds.listRelatives(SkinJointLimb, parent=True)
cmds.parent(group, LegSknJoint)
# RMRigTools.RMAlign( PoleVectorControl, IKJointLimb, 1)
SpcSw = RMSpaceSwitch.RMSpaceSwitch()
SpcSw.CreateSpaceSwitchReverse(group, [IKJointLimb, ChildPoleVector],
PoleVectorControl,
Name="KneeLock",
mo=False,
sswtype="float")
SpaceSwitchDic = (SpcSw.getParentConstraintDic(Constraint))
Plug = [
keys for keys in SpaceSwitchDic['alias']
if SpaceSwitchDic['alias'][keys] == IKJointLimb
]
Connection = cmds.listConnections("%s.%s" % (Constraint, Plug[0]),
plugs=True,
destination=False)
print "Plug:%s" % Plug
print "Connection:%s" % Connection
cmds.parentConstraint(IKJointLimb, SkinJointLimb, e=True, remove=True)
cmds.parentConstraint(group, SkinJointLimb, mo=False)
SpaceSwitchDic = (SpcSw.getParentConstraintDic(Constraint))
NewPlug = [
keys for keys in SpaceSwitchDic['alias']
if SpaceSwitchDic['alias'][keys] == group
]
print "NewPlug:%s" % NewPlug
cmds.connectAttr(Connection[0], "%s.%s" % (Constraint, NewPlug[0]))
def setInName(selection):
NameConv = nameConvention.NameConvention()
for eachObject in selection:
childJoints = RMRigTools.RMCustomPickWalk(eachObject, "joint", -1)
for eachJoint in childJoints:
Name = eachJoint.split("_")
Value = re.split(r"([0-9]+$)", Name[len(Name) - 1])
NewName = Value[0]
cmds.rename(
eachJoint,
NameConv.set_name_in_format(
Name=NewName,
side="R",
Type=NameConv.guess_object_type(eachJoint)))
def pathFollow(curve, control, objectArray, NameConv=None):
if not NameConv:
NameConv = nameConvention.NameConvention()
controlAttr = cmds.listAttr(control)
if "Percent" not in controlAttr:
cmds.addAttr(control, at="float", ln="Percent", h=0, k=1)
if "Stretch" not in controlAttr:
cmds.addAttr(control,
at="float",
ln="Stretch",
hnv=1,
hxv=0,
h=0,
k=1,
smn=0)
numberOfElements = len(objectArray)
sumPath = []
multiplyDivide = []
index = 0
for eachObject in objectArray:
motionPath = cmds.pathAnimation(eachObject,
c=curve,
follow=True,
worldUpType="scene",
name="motionpath%s" % index)
motionPath = NameConv.rename_name_in_format(motionPath,
{'name': motionPath})
multDivFactor = cmds.shadingNode('multiplyDivide',
asUtility=True,
name="factor%s" % index)
multDivFactor = NameConv.rename_name_in_format(multDivFactor,
{'name': multDivFactor})
cmds.connectAttr("%s.Stretch" % control, "%s.input1X" % multDivFactor)
cmds.setAttr("%s.input2X" % multDivFactor,
float(index) / float(len(objectArray)))
cmds.setAttr("%s.operation" % multDivFactor, 1)
multiplyDivide.append(multDivFactor)
addition = cmds.shadingNode('plusMinusAverage',
asUtility=True,
name="Addition%s" % index)
addition = NameConv.rename_name_in_format(addition, {'name': addition})
cmds.connectAttr("%s.outputX" % multDivFactor,
"%s.input1D[0]" % addition)
cmds.connectAttr("%s.Percent" % control, "%s.input1D[1]" % addition)
cmds.connectAttr("%s.output1D" % addition,
"%s.uValue" % motionPath,
force=True)
index += 1
def __init__(self, name_conv=None):
if not name_conv:
self.name_conv = nameConvention.NameConvention()
else:
self.name_conv = name_conv
self.rig_controls = RMRigShapeControls.RMRigShapeControls(
NameConv=name_conv)
self.kinematics = []
self.joints = []
self.controls = []
self.baseObjects = []
self.jointStructure = []
self.folicules = []
self.resetControls = []
self.allControls = []
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 __init__(self, NameConv=None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.rig_tools = RMRigTools.RMRigTools()
self.rootHeadJoints = None
self.HeadJoints = None
self.RootNeckJoints = None
self.NeckJoints = None
self.resetHeadControl = None
self.headControl = None
self.RootJaw = None
self.JawJoints = None
self.NeckControl = None
self.resetNeckControl = None
def space_locator_on_average_vertex_selection(vertex_list):
name_convention = nameConvention.NameConvention()
position_list = []
for each in vertex_list:
for each_index in range(each.count()):
each.setIndex(each_index)
position_list.append(each.getPosition(space='world'))
position = mid_point(*position_list)
new_space_locator = pm.spaceLocator()
new_space_locator.translate.set(position)
name_convention.rename_name_in_format(str(new_space_locator), {
'side': 'C',
'name': 'locator',
'system': 'reference'
})
return new_space_locator
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 RMCreateClustersOnCurve(curve, NameConv=None):
if not NameConv:
NameConv = nameConvention.NameConvention()
degree = pm.getAttr(curve + ".degree")
spans = pm.getAttr(curve + ".spans")
form = pm.getAttr(curve + ".form")
print ("degree:%s", degree)
print ("spans:%s", spans)
print ("form:%s", form)
# Form (open = 0, closed = 1, periodic = 2)
clusterList = []
print form
if form == 0 or form == 1:
print "Open Line"
for i in range(0, (degree + spans)):
Cluster2Handle, cluster = pm.cluster(curve + ".cv[" + str(i) + "]", name="ClusterOnCurve")
if NameConv.is_name_in_format(curve):
cluster = NameConv.rename_based_on_base_name(curve, cluster, name=cluster)
# Cluster2Handle = NameConv.RMRenameBasedOnBaseName(curve, Cluster2Handle, NewName = Cluster2Handle)
else:
cluster = NameConv.rename_name_in_format(cluster)
# Cluster2Handle = NameConv.RMRenameNameInFormat(Cluster2Handle)
clusterList.append(cluster)
pm.setAttr(cluster + ".visibility", 0)
##pm.cluster(cluster,edit=True,geometry = curve + ".["+str(i)+"]")
if form == 2:
print "periodic Line"
for i in range(0, spans):
Cluster2Handle, cluster = pm.cluster(curve + ".cv[" + str(i) + "]", name="ClusterOnCurve")
print cluster
if NameConv.is_name_in_format(curve):
cluster = NameConv.rename_based_on_base_name(curve, cluster, name= cluster)
# Cluster2Handle = NameConv.RMRenameBasedOnBaseName(curve, Cluster2Handle, NewName = Cluster2Handle)
else:
cluster = NameConv.rename_name_in_format(cluster)
# Cluster2Handle = NameConv.RMRenameNameInFormat(Cluster2Handle)
clusterList.append(cluster)
pm.setAttr(cluster + ".visibility", 0)
# pm.cluster(cluster,edit=True,geometry = curve + ".["+str(i)+"]")
return clusterList
def __init__(self, NameConv=None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.kinematics = []
self.spineIK = None
self.spineJoints = None
self.rootSpineJoints = None
self.spineCurve = None
self.chestJoint = None
self.COG = None
self.ResetCOG = None
self.rootHip = None
self.hipJoints = None
self.SpineLength = None
self.secondaryControls = []
self.hipControl = None
self.resetHipControl = None
self.chestControl = None
self.resetChestControl = None
self.waistControl = None
self.resetWaistControl = None
self.rootLeftClavicleJoints = None
self.LeftClavicleJoints = None
self.rootRightClavicleJoints = None
self.RightClavicleJoints = None
self.ResetChestRotationControl = None
self.ChestRotationControl = None
self.resetRightClavicleControl = None
self.rightClavicleControl = None
self.resetLeftClavicleControl = None
self.leftClavicleControl = None
def __init__(self, NameConv=None, parent=None):
super(main, self).__init__(parent=getMayaWindow())
self.ui = FormBipedRig.Ui_Form()
self.ui.setupUi(self)
self.setWindowTitle('AutoRig')
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.ui.CreateRigBtn.clicked.connect(self.CreateRigBtnPressed)
self.ui.CreateReferencePointsBtn.clicked.connect(
self.CreateReferencePointsBtnPressed)
self.ui.MirrorSelectionBtn.clicked.connect(
self.MirrorSelectionBtnPressed)
self.ui.ClavicleSpaceSwitchBtn.clicked.connect(
self.ClavicleSpaceSwitchBtnPressed)
self.ui.PoleVectorBtn.clicked.connect(self.PoleVectorBtnPressed)
self.ui.SkeletonHandsBtn.clicked.connect(self.SkeletonHandsBtnPressed)
self.ui.supportScaleRigBtn.clicked.connect(
self.supportScaleRigBtnPressed)
self.ui.feetOrientationBtn.clicked.connect(
self.feetOrientationBtnPressed)
def __init__(self, *args, **kwargs):
"""
initializes all the variables on the rig
by default looks for inherited properties, like name_conventionention, or system structure, that can be
passed as kwargs.
:name_convention:
:rig_system:
"""
super(RigBase, self).__init__()
self.name_convention = kwargs.pop('name_convention',
nameConvention.NameConvention())
if 'rig_system' in kwargs.keys():
self.rig_system = kwargs.pop('rig_system',
SystemStructure.SystemStructure())
self.name_convention = self.rig_system.name_convention
else:
self.rig_system = SystemStructure.SystemStructure()
self.rm = rm
self._joint_creation_kwargs = {}
self._control_creation_kwargs = {}
self.create = creators
self.transform = transform
self._model = kwargs.pop('model', BaseModel())
def __init__(self, NameConv=None):
if not NameConv:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
self.NameConv.default_names["LastName"] = "Character01"
self.SPSW = RMSpaceSwitch.RMSpaceSwitch()
self.rig_tools = RMRigTools.RMRigTools()
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.GHRightRig = None
self.GHLeftRig = None
self.Mover01 = None
self.Mover02 = None
self.placer = None
self.NeckHead = RMNeckHead.RMNeckHead()
try:
self.MetaNameConv = MetacubeFileNameConvention.MetacubeFileNameConvention(
)
except:
pass
self.GHRightRig = None
self.GHLeftRig = None
self.geometryGroups = [
"body_grp", "cloth_grp", "accesories_grp", "hair_grp",
"trackers_grp", "collision_grp", "pxycloth_grp", "pxyhair_grp",
"dynspline_grp"
]
from RMPY import nameConvention
import pymel.core as pm
name_conv = nameConvention.NameConvention()
name_conv.default_names['system'] = 'reference'
selection = pm.ls(selection=True)
def rename_selection():
selection = pm.ls(selection=True)
fix_shapes(*selection)
for index, each in enumerate(selection):
side = 'C'
system_name = 'body'
# name_conv.rename_name_in_format(each, side=side, system=system_name, name='shoe{}'.format(chr(65+index)))
# name_conv.rename_name_in_format(each, side=side, system=system_name, name='finger{}'.format(chr(65 + index)))
name_conv.rename_name_in_format(each,
side=side,
system=system_name,
name='main')
# name_conv.rename_name_in_format(each, side=side, system=system_name, name='muscle')
def set_in_name():
selection = pm.ls(selection=True)
for each in selection:
name_conv.rename_set_from_name(each, 'chest', 'system')
def fix_shapes(*scene_object_list):
for index, each_object in enumerate(scene_object_list):
each_object.rename('geometry{}'.format(65 + index))
def __init__(self, *args, **kwargs):
self.name_convention = kwargs.pop('name_convention',
nameConvention.NameConvention())
def RMCreateBonesAtPoints(PointArray, NameConv=None, ZAxisOrientation="Y"):
if not NameConv:
NameConv = nameConvention.NameConvention()
jointArray = []
Obj1Position = pm.xform(PointArray[0], q=True, rp=True, ws=True)
Obj2Position = pm.xform(PointArray[1], q=True, rp=True, ws=True)
V1, V2 = om.MVector(Obj1Position), om.MVector(Obj2Position)
initVector = V1 - V2
firstJntAngle = V1.angle(om.MVector([0, 1, 0]))
Angle = firstJntAngle
ParentJoint = RMCreateGroupOnObj(PointArray[0], Type="world")
for index in range(0, len(PointArray)):
pm.select(cl=True)
newJoint = pm.joint(p=[0, 0, 0], name="joint")
NameConv.rename_based_on_base_name(PointArray[index], newJoint)
jointArray.append(newJoint)
if index == 0:
pm.parent(jointArray[0], ParentJoint)
RMAlign(PointArray[index], jointArray[index], 3)
pm.makeIdentity(jointArray[index], apply=True, t=1, r=1, s=0)
if (index > 0):
if index == 1:
AxisOrientJoint = pm.joint()
pm.parent(AxisOrientJoint, ParentJoint)
RMAlign(PointArray[0], AxisOrientJoint, 3)
pm.makeIdentity(AxisOrientJoint, apply=True, t=1, r=1, s=0)
if ZAxisOrientation in "Yy":
pm.xform(AxisOrientJoint, translation=[0, -1, 0], objectSpace=True)
elif ZAxisOrientation in "Zz":
pm.xform(AxisOrientJoint, translation=[0, 0, -1], objectSpace=True)
pm.parent(jointArray[0], AxisOrientJoint)
pm.parent(jointArray[index], jointArray[index - 1])
pm.joint(jointArray[index - 1], edit=True, orientJoint="xzy")
pm.parent(jointArray[index - 1], world=True)
pm.delete(AxisOrientJoint)
RMAlign(jointArray[index - 1], ParentJoint, 3)
pm.parent(jointArray[index - 1], ParentJoint)
else:
pm.parent(jointArray[index], jointArray[index - 1])
pm.joint(jointArray[index - 1], edit=True, orientJoint="xzy")
# , sao="yup" )
if index >= 2:
parentOrient = pm.joint(jointArray[index - 1], q=True, orientation=True)
pm.joint(jointArray[index - 1], e=True, orientation=[0, parentOrient[1], parentOrient[2]])
# if parentOrient[0] > 90 :
# pm.joint (jointArray[index-1], e = True, orientation = [parentOrient[0]-180, parentOrient[1], parentOrient[2]])
# else:
# if parentOrient[0] < -90:
# pm.joint (jointArray[index-1], e = True, orientation = [parentOrient[0]+180, parentOrient[1], parentOrient[2]])
if index == len(PointArray) - 1:
RMAlign(jointArray[index - 1], jointArray[index], 2)
pm.makeIdentity(jointArray[index], apply=True, t=0, r=1, s=0)
return ParentJoint, jointArray
def __init__(self, NameConv=None):
if NameConv == None:
self.NameConv = nameConvention.NameConvention()
else:
self.NameConv = NameConv
