def resetBindPose(jnts, selected_only=False):
"""
Resets the bind pose as if the skin was bound to the skeleton as it exists now it world space.
:param jnts: `List` of joints to be reset. Use in conjunction with selected flag to get hierarchy.
:param selected_only: By default will include all children of given jnts unless this is set to True.
:return: None
"""
jnts = makePyNodeList(jnts)
jnts_to_reset = set()
if selected_only:
jnts_to_reset |= set(jnts)
else:
for jnt in jnts:
children = jnt.getChildren(ad=True, type='joint')
jnts_to_reset |= set(children)
pm.dagPose(jnts_to_reset, bindPose=True, reset=True)
for jnt in jnts_to_reset:
inv_world_mtx = jnt.worldInverseMatrix[0].get()
skin_outputs = jnt.worldMatrix[0].outputs(p=True, type='skinCluster')
for skin in skin_outputs:
joint_index = skin.index()
pre_mtx_attr = skin.node().attr('bindPreMatrix')
jnt_pre_mtx = pre_mtx_attr.elementByLogicalIndex(joint_index)
jnt_pre_mtx.set(inv_world_mtx)
def bindPose(model):
nameSpace = getNamespace(model.name())
if nameSpace:
dagPoseName = nameSpace + ':dagPose1'
else:
dagPoseName = 'dagPose1'
pm.dagPose(dagPoseName, restore=True)
def updateBindPose():
"""
Updates bind pose to the selected joint hierarchies current state
"""
dag = pmc.dagPose(q=True, bindPose=True)
objects = pmc.dagPose(dag, q=True, members=True)
for obj in objects:
pmc.dagPose(obj, reset=True, name=dag[0])
def test_multiple_bind_poses_on_skel(self):
test_cube, test_joints, test_skincluster = self.create_skinned_cube()
expected = pm.ls(type='dagPose')[0]
dummy_cube = self.create_cube()
test_joints[2].rotateX.set(30)
skinutils.bind_mesh_to_joints(dummy_cube, test_joints)
pm.dagPose(test_joints[0], bindPose=True, save=True)
bind_poses = pm.ls(type='dagPose')
self.assertEqual(3, len(bind_poses))
result = skinutils.get_bind_pose_from_skincluster(test_skincluster)
self.assertEqual(expected, result)
def export_skinned_mesh(skinned_mesh, output_path, go_to_bind_pose=True):
with pm.UndoChunk():
if go_to_bind_pose:
bind_pose = skinutils.get_bind_pose_from_skinned_mesh(skinned_mesh)
pm.dagPose(bind_pose, restore=True, g=True)
with selutils.preserve_selection():
dup_mesh, dup_root, dup_cluster = skinutils.duplicate_skinned_mesh_and_skeleton(
skinned_mesh, dup_namespace=NAMESPACE_SKINCOPY_EXPORT, dup_parent=nsutils.PARENT_WORLD)
pm.select((dup_mesh, dup_root), replace=True)
pm.exportSelected(output_path, constraints=False, expressions=False, shader=False, preserveReferences=False,
type='mayaAscii', constructionHistory=True, force=True)
pm.undo()
def _callback(self, doDisconnect):
"""
Handles actual rig connection.
"""
rootControl = pmc.ls(selection=True)
joints = [
i for i in rootControl[0].getChildren(ad=True, type='joint')
if i.startswith(self._rigPrefix)
]
for jnt in joints:
if doDisconnect:
skinJoint = jnt.replace(self._rigPrefix, self._bindPrefix, 1)
if not pmc.objExists(skinJoint):
continue
constraintNodes = set(
pmc.listConnections(skinJoint,
type='constraint',
d=False,
s=True))
pmc.delete(list(constraintNodes))
else:
# Find matching jnt in skeleton, if available
skinJoint = jnt.replace(self._rigPrefix, self._bindPrefix, 1)
if skinJoint is jnt or not pmc.objExists(skinJoint):
continue
pmc.pointConstraint(jnt, skinJoint, maintainOffset=False)
orient = pmc.orientConstraint(jnt,
skinJoint,
maintainOffset=False)
orient.interpType.set(
2) # Interplotion 2 = shortest (to avoid flipping)
# After disconnect, revert skeleton to bind pose
if doDisconnect:
skinRoot = joints[0]
dagPoses = pmc.listConnections(skinRoot,
type='dagPose',
d=True,
s=False)
if len(dagPoses):
pmc.dagPose(skinRoot,
restore=True,
g=True,
bindPose=True,
name=dagPoses[0])
print 'COGSWELL COUPLER :: Rig Disconnected'
else:
print 'COGSWELL COUPLER :: Rig Connected'
def bindPose(model):
"""Restore the reset position of the rig
Args:
model (TYPE): Description
"""
nameSpace = getNamespace(model.name())
if nameSpace:
dagPoseName = nameSpace + ':dagPose1'
else:
dagPoseName = 'dagPose1'
pm.dagPose(dagPoseName, restore=True)
def import_skinning(skinned_mesh, skinweights_path, copy_weights_method=None, go_to_bindpose=True):
with selutils.preserve_selection():
copy_weights_method = copy_weights_method or skinutils.copy_weights
new_nodes = pm.importFile(skinweights_path, loadReferenceDepth='none',
namespace=NAMESPACE_SKINCOPY_IMPORT, returnNewNodes=True)
source_skinmesh = _get_skinned_mesh_from_import(new_nodes, skinweights_path, skinned_mesh.nodeName())
if go_to_bindpose:
bind_pose = skinutils.get_bind_pose_from_skinned_mesh(skinned_mesh)
pm.dagPose(bind_pose, restore=True, g=True)
copy_weights_method(source_skinmesh, skinned_mesh)
import_namespace = nsutils.get_namespace_as_pynode(NAMESPACE_SKINCOPY_IMPORT)
import_namespace.remove()
# evaluate all nodes
pm.mel.eval('doEnableNodeItems true all;')
def setSceneToBindPose():
"""
Sets the scene to bind pose.
:return: None
"""
bind_jnts = getBindJoints()
input_nodes = set()
for jnt in bind_jnts:
input_nodes |= set(jnt.inputs())
# set nodes to blocking
for node in input_nodes:
node.nodeState.set(2)
pm.dagPose(bind_jnts, bindPose=True, restore=True)
def rebuildDagPose():
"""
Walks through bind pose data in selected skeleton and consolidates it down to one new bindPose node
Directly inspired by Nathan Horne's NT_rebuildDagPose.mel script
"""
dagPoses = set()
connectedSkinClusters = set()
selection = pmc.selected()
joints = pmc.listRelatives(selection[0], path=True, allDescendents=True, type="joint")
joints.insert(0, selection[0])
for jnt in joints:
dagPoses.update(jnt.listConnections(type="dagPose"))
for dag in dagPoses:
connectedSkinClusters.update(dag.listConnections(type="skinCluster"))
pmc.delete(dagPoses)
pmc.select(joints, replace=True)
newDagPose = pmc.dagPose(save=True, selection=True, bindPose=True)
print "New dagPose, {0}, created".format(newDagPose.shortName())
for sc in connectedSkinClusters:
print "Connecting {0}.message to {1}.bindPose".format(newDagPose.shortName(), sc.shortName())
newDagPose.message.connect(sc.bindPose)
def returnToBindPose(joints=None):
"""
Returns the associated bindPoses of the given joints to the pose when they were originally bound.
Args:
joints (list): Joints to find bind poses of.
Note, these are NOT necessarily all the joints that will be restored since joints can share bindPose nodes.
Returns:
(set): Bind poses restored.
"""
# Get joints, find all the bind poses all the joints are using, restore the bind poses for each pose found.
joints = myu.validateSelect(joints, find='joint')
poses = {
pose
for joint in joints for pose in pm.dagPose(joint, bp=True, q=True)
}
[pm.dagPose(pose, g=True, restore=True) for pose in poses]
return poses
def setBindPose(meshXform):
"""Set the current skeleton pose as the bind pose for a transform.
All relevant sub-shapes will be fixed. Move joints BEFORE using this
(so skin is deformed) and skin will reset. Args:
- meshXForm: TRANSFORM node of the skincluster affectes mesh."""
for shape in meshXform.getShapes():
try:
skinClus = shape.inputs(type="skinCluster")[0]
except IndexError:
# perhaps an "Orig" shape, or just generally bad argument
# ignore it.
continue
jnts = skinClus.matrix.inputs()
for i, j in enumerate(jnts):
# skinCluster stores each joint's worldInverseMatrix
# at its bind pose
skinClus.bindPreMatrix[i].set(j.worldInverseMatrix.get())
pmc.dagPose(jnts, n=skinClus.bindPose.get(), reset=True)
print("Successfully reset bind pose on {0}".format(shape.name()))
def finalize(self):
"""
Finalize the rig.
"""
groupIdx = 0
# Properties --------------------------------------
mgear.log("Finalize")
# Groups ------------------------------------------
mgear.log("Creating groups")
# Retrieve group content from components
for name in self.componentsIndex:
component = self.components[name]
for name, objects in component.groups.items():
self.addToGroup(objects, name)
#Create master set to group all the groups
masterSet = pm.sets(n=self.model.name()+"_sets_grp", em=True)
pm.connectAttr(masterSet.message, self.model.rigGroups[groupIdx])
groupIdx += 1
# Creating all groups
pm.select(cl=True)
for name, objects in self.groups.items():
s = pm.sets(n=self.model.name()+"_"+name+"_grp")
s.union( objects)
pm.connectAttr(s.message, self.model.rigGroups[groupIdx])
groupIdx += 1
masterSet.add(s)
# Bind pose ---------------------------------------
print self.groups["controllers"]
pm.select(self.groups["controllers"])
node = pm.dagPose(save=True, selection=True)
pm.connectAttr(node.message, self.model.rigPoses[0])
print node
# Bind skin re-apply
if self.options["importSkin"]:
try:
pm.displayInfo("Importing Skin")
skin.importSkin(self.options["skin"])
except:
pm.displayWarning("Skin doesn't exist or is not correct. "+self.options["skin"]+" Skipped!")
def bdSetBindPose():
selection = pm.ls(sl=True, type='joint')
bindPose = ''
skRoot = None
if selection and len(selection) == 1:
bindPose = pm.dagPose(save=True, bp=1)
skRoot = selection[0]
else:
findRoot = pm.ls('Skeleton_Root', type='joint')
if findRoot and len(findRoot) == 1:
skRoot = findRoot[0]
bndPoses = pm.listConnections('%s.bindPose' % skRoot.name())
if bndPoses:
strPoses = ''
for p in bndPoses:
strPoses += (p.name() + ' ')
return '%s has already the following bind pose(s): %s' % (
skRoot.name(), strPoses)
else:
bindPose = pm.dagPose(skRoot, save=True, bp=1)
else:
return 'No selection and no Skeleton_Root found !!!'
return 'Created %s for %s' % (bindPose, skRoot.name())
def _callback(self, doDisconnect):
"""
Handles actual rig connection.
"""
rootControl = pmc.ls(selection=True)
joints = [i for i in rootControl[0].getChildren(ad=True, type='joint') if i.startswith(self._rigPrefix)]
for jnt in joints:
if doDisconnect:
skinJoint = jnt.replace(self._rigPrefix, self._bindPrefix, 1)
if not pmc.objExists(skinJoint):
continue
constraintNodes = set(pmc.listConnections(skinJoint, type='constraint', d=False, s=True))
pmc.delete(list(constraintNodes))
else:
# Find matching jnt in skeleton, if available
skinJoint = jnt.replace(self._rigPrefix, self._bindPrefix, 1)
if skinJoint is jnt or not pmc.objExists(skinJoint):
continue
pmc.pointConstraint(jnt, skinJoint, maintainOffset=False)
orient = pmc.orientConstraint(jnt, skinJoint, maintainOffset=False)
orient.interpType.set(2) # Interplotion 2 = shortest (to avoid flipping)
# After disconnect, revert skeleton to bind pose
if doDisconnect:
skinRoot = joints[0]
dagPoses = pmc.listConnections(skinRoot, type='dagPose', d=True, s=False)
if len(dagPoses):
pmc.dagPose(skinRoot, restore=True, g=True, bindPose=True, name=dagPoses[0])
print 'COGSWELL COUPLER :: Rig Disconnected'
else:
print 'COGSWELL COUPLER :: Rig Connected'
def bdAssumeBindPose():
selection = pm.ls(sl=True, type='joint')
bindPose = ''
skRoot = None
if selection and len(selection) == 1:
skRoot = selection[0]
poses = pm.listConnections('%s.bindPose' % skRoot.name())
if len(poses) > 1:
return 'Multiple poses found for selection, you have to create only one !!!'
else:
pm.dagPose(poses[0], restore=True)
return 'Bind pose \' %s \' restored ' % poses[0].name()
else:
findRoot = pm.ls('Skeleton_Root', type='joint')
if findRoot and len(findRoot) == 1:
skRoot = findRoot[0]
poses = pm.listConnections('%s.bindPose' % skRoot.name())
if len(poses) > 1:
return 'Multiple poses found for selection, you have to create only one !!!'
else:
pm.dagPose(poses[0], restore=True)
return 'Bind pose \' %s \' restored ' % poses[0].name()
else:
return 'Did\'t find a Skeleton_Root'
def combineBindPoses(self):
# find all skinCluster in the scene
skinCluster = pm.ls(type="skinCluster")
# find all connected bindPoses
influences = set()
for sc in skinCluster:
for i in pm.skinCluster(sc, q=1, influence=1):
if pm.nodeType(i) == "joint": influences.add(i)
# delete all dagPoses, create a new one and link to skin clusters
dagPoses = pm.ls(type="dagPose")
if dagPoses:
print("Converted:")
print(dagPoses)
pm.delete(dagPoses)
pose = pm.dagPose(list(influences), s=1, sl=1, bp=1)
for sc in skinCluster:
pm.connectAttr('%s.message' % pose, '%s.bindPose' % sc)
print("to: %s\n" % pose)
def combineBindPoses(self):
#find all skinCluster in the scene
skinCluster = pm.ls(type="skinCluster")
#find all connected bindPoses
influences = set()
for sc in skinCluster:
for i in pm.skinCluster( sc, q=1, influence=1):
if pm.nodeType(i)=="joint": influences.add(i)
#delete all dagPoses, create a new one and link to skin clusters
dagPoses = pm.ls(type="dagPose")
if dagPoses:
print( "Converted:")
print (dagPoses)
pm.delete( dagPoses)
pose = pm.dagPose( list(influences), s=1, sl=1, bp=1)
for sc in skinCluster:
pm.connectAttr( '%s.message'%pose, '%s.bindPose'%sc)
print("to: %s\n" % pose)
def test_get_bind_poses(self):
test_joints = [self.create_joint(position=(i, i, i)) for i in range(5)]
expected = [pm.dagPose(test_joints[0], bindPose=True, save=True)]
result = skeletonutils.get_bind_poses(test_joints[0])
self.assertEqual(expected, result)
def genereateRig(self, select=True):
# export_path,_ = self.getFilename()
# if not os.path.exists(export_path):
# return
Scene = self.preExport()
export_path = os.path.join(Scene.dirname(), "%s.FBX" % Scene.namebase)
export_path = export_path.replace('\\', '/')
mel.eval('FBXExportSkins -v true')
# NOTE 导入所有的 reference
[ref.importContents(True) for ref in pm.listReferences()]
# NOTE 获取场景中所有可见的模型
mesh_list = pm.ls("MODEL", ni=1, dag=1, type="mesh")
# # NOTE 删除非变形器历史
# pm.bakePartialHistory( mesh_list,prePostDeformers=True )
jnt_list = self.getJntList(mesh_list)
pm.select(cl=1)
root = pm.joint(n="root")
jnt_parent = self.getRelParent(jnt_list, root)
mel.eval('moveJointsMode 1;')
# # NOTE 删除所有 Blendshape
# pm.delete(pm.ls(type="ikEffector"))
pm.delete(pm.ls(type="blendShape"))
jnt_transform = {}
for jnt, pos in {
jnt: pm.xform(jnt, q=1, ws=1, t=1)
for jnt in jnt_list
}.iteritems():
jnt.tx.setLocked(0)
jnt.ty.setLocked(0)
jnt.tz.setLocked(0)
jnt.rx.setLocked(0)
jnt.ry.setLocked(0)
jnt.rz.setLocked(0)
jnt.sx.setLocked(0)
jnt.sy.setLocked(0)
jnt.sz.setLocked(0)
jnt.tx.showInChannelBox(1)
jnt.ty.showInChannelBox(1)
jnt.tz.showInChannelBox(1)
jnt.rx.showInChannelBox(1)
jnt.ry.showInChannelBox(1)
jnt.rz.showInChannelBox(1)
jnt.sx.showInChannelBox(1)
jnt.sy.showInChannelBox(1)
jnt.sz.showInChannelBox(1)
mel.eval('CBdeleteConnection %s' % jnt.tx)
mel.eval('CBdeleteConnection %s' % jnt.ty)
mel.eval('CBdeleteConnection %s' % jnt.tz)
mel.eval('CBdeleteConnection %s' % jnt.rx)
mel.eval('CBdeleteConnection %s' % jnt.ry)
mel.eval('CBdeleteConnection %s' % jnt.rz)
mel.eval('CBdeleteConnection %s' % jnt.sx)
mel.eval('CBdeleteConnection %s' % jnt.sy)
mel.eval('CBdeleteConnection %s' % jnt.sz)
jnt.setParent(root)
jnt.rename("%s_bind" % jnt)
parent = jnt.getParent()
if parent.name() == root:
jnt.t.set(pos)
else:
jnt_transform[jnt] = parent
# NOTE clear jnt transform node
for jnt, parent in jnt_transform.items():
pm.xform(parent, piv=pm.xform(jnt, q=1, ws=1, t=1), ws=1)
# jnt.s.set(parent.s.get())
# parent.s.set(1,1,1)
pm.ungroup(parent)
# NOTE delete unrelated node
[pm.delete(node) for jnt in jnt_list for node in jnt.getChildren()]
# NOTE reparent hierarchy
jnt_transform = {}
for jnt, parent in jnt_parent.items():
jnt.setParent(parent)
transform = jnt.getParent()
if transform != parent:
jnt_transform[jnt] = transform
for jnt, parent in jnt_transform.items():
pm.xform(parent, piv=pm.xform(jnt, q=1, ws=1, t=1), ws=1)
# NOTE 避免意外扭动
jnt.s.set(1, 1, 1)
parent.s.set(1, 1, 1)
pm.ungroup(parent)
[mesh.getParent().setParent(w=1) for mesh in mesh_list]
pm.select(root, mesh_list)
pm.delete(pm.ls(type="dagPose"))
pm.dagPose(bp=1, s=1)
# mel.eval('moveJointsMode 0;')
# NOTE 导出文件
mel.eval('FBXExport -f "' + export_path + '" -s')
os.startfile(os.path.dirname(export_path))
# NOTE 重新打开当前文件
pm.openFile(pm.sceneName(), f=1)
def simpleRig(rigName="rig", wCntCtl=False, *args):
"""Create a simple 1Click rig.
Args:
rigName (str, optional): Name of the rig.
wCntCtl (bool, optional): Place the Golbal control in the wolrd
center or use the general BBox of the selection.
*args: Description
Returns:
dagNode: Rig top node
"""
meshList = []
ctlList = []
lvlList = []
absBB = []
absRadio = 0.5
listSelection = [oSel for oSel in pm.selected()]
# Create base structure
rig = pm.createNode('transform', n=rigName)
geo = pm.createNode('transform', n="geo", p=rig)
geo.attr("overrideEnabled").set(1)
geo.attr("overrideDisplayType").set(2)
attribute.addAttribute(rig, "is_rig", "bool", True)
attribute.addAttribute(rig, "rig_name", "string", "rig")
attribute.addAttribute(rig, "user", "string", getpass.getuser())
attribute.addAttribute(rig, "date", "string", str(datetime.datetime.now()))
attribute.addAttribute(rig, "maya_version", "string",
str(pm.mel.eval("getApplicationVersionAsFloat")))
attribute.addAttribute(rig, "gear_version", "string", mgear.getVersion())
attribute.addAttribute(rig, "ctl_vis", "bool", True)
attribute.addAttribute(rig, "jnt_vis", "bool", False)
attribute.addAttribute(rig, "quickselA", "string", "")
attribute.addAttribute(rig, "quickselB", "string", "")
attribute.addAttribute(rig, "quickselC", "string", "")
attribute.addAttribute(rig, "quickselD", "string", "")
attribute.addAttribute(rig, "quickselE", "string", "")
attribute.addAttribute(rig, "quickselF", "string", "")
rig.addAttr("rigGroups", at='message', m=1)
rig.addAttr("rigPoses", at='message', m=1)
for oSel in listSelection:
bbCenter, bbRadio, bb = bBoxData(oSel)
lvl = pm.createNode('transform', n=oSel.name().split("_")[0] + "_npo")
lvlList.append(lvl)
t = transform.getTransformFromPos(bbCenter)
lvl.setTransformation(t)
ctl = ico.create(lvl,
oSel.name().split("_")[0] + "_ctl",
t,
14,
icon="circle",
w=bbRadio * 2)
cnsPart(ctl, oSel)
ctlList.append(ctl)
for oShape in oSel.listRelatives(ad=True, s=True, type='mesh'):
pm.connectAttr(ctl + ".visibility", oShape + ".visibility", f=True)
meshList.append(oShape)
# Reparenting
pm.parent(oSel, geo)
# calculate the global control BB
if not wCntCtl:
if not absBB:
absBB = bb
else:
absBB = [
[min(bb[0][0], absBB[0][0]),
max(bb[0][1], absBB[0][1])],
[min(bb[1][0], absBB[1][0]),
max(bb[1][1], absBB[1][1])],
[min(bb[2][0], absBB[2][0]),
max(bb[2][1], absBB[2][1])]
]
userPivots = dag.findChildrenPartial(oSel, PIVOT_EXTENSION)
# Loop selection
uPivotCtl = []
if userPivots:
for uPivot in userPivots:
try:
pstr = uPivot.name().split('_')[0] + "_" + PGROUP_EXTENSION
pgrp = pm.PyNode(pstr)
except TypeError:
pm.displayError("The selected pivot dont have the group"
" contrapart. Review your rig structure")
return False
objList = pgrp.listRelatives(ad=True)
if objList:
bbCenter, bbRadio, bb = bBoxData(objList)
t = uPivot.getMatrix(worldSpace=True)
lvlParent = pm.listRelatives(
uPivot, p=True)[0].name().split("_")[0] + "_ctl"
lvl = pm.createNode('transform',
n=uPivot.split("_")[0] + "_npo")
lvl.setTransformation(t)
icon = iconList[uPivot.attr("ctlIcon").get()]
ctlKeyable = []
if uPivot.attr("animTranslation").get():
ctlKeyable = ctlKeyable + ["tx", "ty", "tz"]
if uPivot.attr("animRotation").get():
ctlKeyable = ctlKeyable + ["ro", "rx", "ry", "rz"]
if uPivot.attr("animScale").get():
ctlKeyable = ctlKeyable + ["sx", "sy", "sz"]
ctl = ico.create(lvl,
uPivot.split("_")[0] + "_ctl",
t,
15,
icon=icon,
w=bbRadio * 2,
h=bbRadio * 2,
d=bbRadio * 2)
attribute.setKeyableAttributes(ctl, ctlKeyable)
pm.parent(lvl, lvlParent)
attribute.setKeyableAttributes(lvl, [])
uPivotCtl.append(ctl)
# Constraint
cnsPart(ctl, pgrp)
for oShape in uPivot.listRelatives(ad=True,
s=True,
type='mesh'):
pm.connectAttr(ctl + ".visibility",
oShape + ".visibility",
f=True)
meshList.append(oShape)
# hidde user pivot
uPivot.attr("visibility").set(False)
# setting the global control
if wCntCtl:
absCenter = [0, 0, 0]
else:
absCenter = [(axis[0] + axis[1]) / 2 for axis in absBB]
# set the cencter in the floor
absCenter[1] = absBB[1][0]
absRadio = max([absBB[0][1] - absBB[0][0], absBB[2][1] - absBB[2][0]
]) / 1.7
t = transform.getTransformFromPos(absCenter)
lvl = pm.createNode('transform', n="global_npo")
lvl.setTransformation(t)
pm.parent(lvl, rig)
ctlGlobal = ico.create(lvl,
"global_ctl",
t,
17,
icon="square",
w=absRadio * 2,
d=absRadio * 2)
pm.parent(lvlList, ctlGlobal)
ctlList.append(ctlGlobal)
attribute.setKeyableAttributes(lvl, [])
for lvl in lvlList:
attribute.setKeyableAttributes(lvl, [])
# Create sets
meshSet = pm.sets(meshList, n="CACHE_grp")
ctlSet = pm.sets([ctlList, uPivotCtl], n="rig_controllers_grp")
deformersSet = pm.sets(meshList, n="rig_deformers_grp")
compGroup = pm.sets(meshList, n="rig_componentsRoots_grp")
rigSets = pm.sets([meshSet, ctlSet, deformersSet, compGroup],
n="rig_Sets_grp")
pm.connectAttr(rigSets.attr("message"), "rig.rigGroups[0]")
pm.connectAttr(meshSet.attr("message"), "rig.rigGroups[1]")
pm.connectAttr(ctlSet.attr("message"), "rig.rigGroups[2]")
pm.connectAttr(deformersSet.attr("message"), "rig.rigGroups[3]")
pm.connectAttr(compGroup.attr("message"), "rig.rigGroups[4]")
if oSel.hasAttr("animSets") and oSel.attr("animSets").get():
# create anim Sets
pm.sets(n="animNodes", em=True)
animNodes_set = pm.PyNode("animNodes")
pm.sets(n="animSets", em=True)
animSets_set = pm.PyNode("animSets")
# adding set
pm.sets(animSets_set, add=animNodes_set)
pm.sets(animNodes_set, add=ctlSet.members())
pm.connectAttr(animSets_set.attr("message"), "rig.rigGroups[5]")
pm.connectAttr(animNodes_set.attr("message"), "rig.rigGroups[6]")
# create dagPose
pm.select(ctlSet)
o_node = pm.dagPose(save=True, selection=True)
pm.connectAttr(o_node.message, rig.rigPoses[0])
return rig
def finalize(self):
"""Finalize the rig."""
groupIdx = 0
# Properties --------------------------------------
mgear.log("Finalize")
# clean jnt_org --------------------------------------
if self.options["joint_rig"]:
mgear.log("Cleaning jnt org")
for jOrg in dag.findChildrenPartial(self.jnt_org, "org"):
if not jOrg.listRelatives(c=True):
pm.delete(jOrg)
# Groups ------------------------------------------
mgear.log("Creating groups")
# Retrieve group content from components
for name in self.componentsIndex:
component_ = self.components[name]
for name, objects in component_.groups.items():
self.addToGroup(objects, name)
for name, objects in component_.subGroups.items():
self.addToSubGroup(objects, name)
# Create master set to group all the groups
masterSet = pm.sets(n=self.model.name() + "_sets_grp", em=True)
pm.connectAttr(masterSet.message, self.model.rigGroups[groupIdx])
groupIdx += 1
# Creating all groups
pm.select(cl=True)
for name, objects in self.groups.items():
s = pm.sets(n=self.model.name() + "_" + name + "_grp")
s.union(objects)
pm.connectAttr(s.message, self.model.rigGroups[groupIdx])
groupIdx += 1
masterSet.add(s)
for parentGroup, subgroups in self.subGroups.items():
pg = pm.PyNode(self.model.name() + "_" + parentGroup + "_grp")
for sg in subgroups:
sub = pm.PyNode(self.model.name() + "_" + sg + "_grp")
if sub in masterSet.members():
masterSet.remove(sub)
pg.add(sub)
# Bind pose ---------------------------------------
# controls_grp = self.groups["controllers"]
# pprint(controls_grp, stream=None, indent=1, width=100)
ctl_master_grp = pm.PyNode(self.model.name() + "_controllers_grp")
pm.select(ctl_master_grp, replace=True)
dag_node = pm.dagPose(save=True, selection=True)
pm.connectAttr(dag_node.message, self.model.rigPoses[0])
print dag_node
# Bind skin re-apply
if self.options["importSkin"]:
try:
pm.displayInfo("Importing Skin")
skin.importSkin(self.options["skin"])
except RuntimeError:
pm.displayWarning("Skin doesn't exist or is not correct. " +
self.options["skin"] + " Skipped!")
def bindPose(model):
if len(model.name().split(":")) == 2:
dagPoseName = model.name().split(":")[0]+':dagPose1'
else:
dagPoseName = 'dagPose1'
pm.dagPose( dagPoseName, restore=True )
