def copy():
skin_cluster = None
mesh_name = None
selection = cmds.ls(sl=True)
if selection:
mesh_name = selection[0]
shape = cmds.listRelatives(selection[0])
skin_clusters = cmds.listConnections(shape[0], type='skinCluster')
if skin_clusters:
skin_cluster = skin_clusters[0]
else:
cmds.error('No skin cluster present')
else:
cmds.error('No valid selection')
bones = cmds.skinCluster(skin_cluster, q=True, inf=True)
num_verts = cmds.polyEvaluate(mesh_name, v=True)
data = dict()
for bone in bones:
data[bone] = []
for id in range(num_verts):
data[bone].append(cmds.skinPercent(skin_cluster, '{0}.vtx[{1}]'.format(mesh_name, id), q=True, t=bone))
pickled_list = pickle.dumps(data)
cmds.scrollField('jt_copy_skin_values_field', e=True, tx=pickled_list)
cmds.skinCluster(mesh_name, e=True, ub=True)
def add_skinCluster_weights (vertexIDs, src_mesh, dst_mesh, mask_joint=None):
src_skin = get_skinCluster(src_mesh)
dst_skin = get_skinCluster(dst_mesh)
src_skinCls_matrix_dict = loads_skinCluster_matrix(src_mesh)
dst_skinCls_matrix_dict = loads_skinCluster_matrix(dst_mesh)
cmds.skinCluster(dst_skin, e=True, normalizeWeights=False)
for vertexID in vertexIDs:
if not mask_joint: #if no mask joint defined, overwrite weight onto dst mesh
cmds.skinPercent( dst_skin, "%s.vtx[%s]"%(dst_mesh, vertexID), pruneWeights=100)
maskValue = 1
else:
mask_jointIndex = dst_skinCls_matrix_dict[mask_joint]
maskValue = cmds.getAttr("%s.wl[%s].w[%s]" %(dst_skin, vertexID, mask_jointIndex))
cmds.setAttr("%s.wl[%s].w[%s]" %(dst_skin, vertexID, mask_jointIndex), 0)
for src_joint, src_jointIndex in src_skinCls_matrix_dict.iteritems():
weight = cmds.getAttr("%s.wl[%s].w[%s]" %(src_skin, vertexID, src_jointIndex)) * maskValue
if weight != 0.0:
dst_jointIndex = dst_skinCls_matrix_dict[src_joint]
cmds.setAttr("%s.wl[%s].w[%s]" %(dst_skin, vertexID, dst_jointIndex), weight)
cmds.skinCluster(dst_skin, e=True, normalizeWeights=True)
def build(numBindJoints=6, numSpans=None, name='', numSkinJoints=3, width=None):
'''
builds a nurbs ribbon
If width is not specified, width will be set to numBindJoints
If numSpans is not specified, it will be set to numBindJoints
'''
if not width:
width = numBindJoints
if not numSpans:
numSpans = numBindJoints
main_grp = cmds.group(empty=1, name=(name + '_grp'))
plane = cmds.nurbsPlane(axis=(0, 1, 0), ch=0, lengthRatio=(1.0 / width), w=width, u=numSpans, name=(name + '_nurbsPlane'))[0]
cmds.parent(plane, main_grp)
# Creat Skin joints
skinJoints = []
skinJointPositions = common.pointsAlongVector( start=[width*.5, 0, 0], end=[width*-.5, 0, 0], divisions=(numSkinJoints-1) )
for index in range(len(skinJointPositions)):
cmds.select(main_grp)
j = cmds.joint(position = skinJointPositions[index], name=(name + '_' + str(index) + '_jnt'))
skinJoints.append(j)
# Add skinning to ribbon
cmds.skinCluster(skinJoints, plane, tsb=1, name=(plane + '_skinCluster'))
cmds.setAttr(plane+'.inheritsTransform', 0)
# Add follicles
for index in range(numBindJoints):
f = rivet.build( mesh=plane, paramU=(1.0 / (numBindJoints-1) * index), paramV=0.5, name=(name + '_' + str(index)))
cmds.parent(f, main_grp)
j = cmds.joint(name=(name + '_' + str(index) + '_bnd'))
def rigFace() :
jntGrp = 'facialJnt_grp'
if not mc.objExists(jntGrp) :
mc.group(em = True, n = jntGrp)
facePolyMap = {'L_brow_ply': 'L_brow_ctrl',
'L_baseEye_ply': 'L_baseEye_ctrl',
'L_eye_ply': 'L_eye_ctrl',
'R_brow_ply': 'R_brow_ctrl',
'R_baseEye_ply': 'R_baseEye_ctrl',
'R_eye_ply': 'R_eye_ctrl',
'nose_ply': 'noseface_ctrl',
'mouth_ply': 'mount_ctrl'
}
for each in facePolyMap :
poly = each
ctrl = facePolyMap[poly]
if mc.objExists(poly) :
movePivot(ctrl, poly)
joint = mc.createNode('joint', n = poly.replace('_ply', '_jnt'))
mc.delete(mc.pointConstraint(poly, joint))
mc.skinCluster(poly, joint, tsb = True)
mc.parentConstraint(ctrl, joint)
mc.scaleConstraint(ctrl, joint)
mc.parent(joint, jntGrp)
def bind_mesh():
# メッセージ
cmds.inViewMessage(
amg="ウエイト調整後、<hl>「アニメーションをインポート」</hl>を押し、animデータを選択して下さい。", pos="midCenter", fade=True, fit=1, fst=4000, fts=20
)
cmds.select("Root_M", add=True, hi=True)
# 正規表現、_controllerのジョイントを省く
deselectObj = cmds.ls(sl=True)
count = 0
matchTxtEnd = re.compile("(_)(.*?)(controller)(.*)")
for n in deselectObj:
matchTrueEnd = matchTxtEnd.search(deselectObj[count])
if matchTrueEnd != None:
cmds.select(deselectObj[count], deselect=True)
count += 1
cmds.select("Mesh", add=True, hi=True)
cmds.select("Mesh", deselect=True)
cmds.skinCluster(maximumInfluences=3, dropoffRate=4, tsb=True)
def joint(self):
"""
Getting vertax info and saves weights into txt file
"""
# Getting selected name of mesh and vertex
#self.name_mesh = cmds.ls(sl=True)
#self.name_vertex = cmds.ls(sl=True)
#self.name_vertex = cmds.ls(self.name_mesh + '.vtx[*]')
# Getting number and name of vertex
try :
splited_vertex = string.split(self.name_vertex[0], ':')
self.number_of_vertex = int(splited_vertex[-1][0:-1]) + 1
self.name_splited_vertex = string.split(self.name_vertex[0], '[')
# Check if vertex is selected
except :
print "please select vertex"
# Getting joint from skinned mesh
try :
self.name_skincluster = cmds.skinCluster(self.name_mesh, q=True, dt=True)
self.name_skincluster = self.name_skincluster[-1][0:-7]
self.name_joint = cmds.skinCluster(self.name_mesh, q=True, inf=True)
return self.name_joint
# Check if proper mesh is selected
except :
print "please select skinned mesh"
def copy_bind_from_ng_file(file):
""" Copies skinCluster from ngSkinTools JSON file to make the same skinCluster before importing weights.
Args:
file (str): file...
Returns [str]: list of joints that we used
Usage:
a=copy_bind_from_ng_file('/mpc/mayors1/scanaEnergyBears_5600278/build/char_linda_blackbear/maya/scenes/rig/andres-w/build/scripts/char_harry_blackbear_body_lodA_weights.json')
"""
influences = []
missing_influences = []
with open(file) as f:
data = f.read()
json_data = json.loads(data)
f.close()
for value in json_data['influences']:
influence = json_data['influences'][value]['path'].split('|')[-1]
if mc.objExists(influence):
influences.append(influence)
else:
missing_influences.append(influence)
print 'Missing Influences from your file:'
print missing_influences
result = cmds.confirmDialog(b=['OK','CANCEL'], m='You have %d missing influences...continue adding skin cluster from file?' % (len(missing_influences)))
if result == 'OK':
mc.skinCluster(influences, mc.ls(sl=True)[0], tsb=True)
return influences
def reset(geometry): ''' Reset the skin cluster attached to the specified object @param geometry: Object whose attached skinCluster will be reset @type geometry: str ''' # Delete bind pose nodes deleteBindPose() # Determine skinCluster skinCluster = findRelatedSkinCluster(geometry) # Detach skinCluster mc.skinCluster(geometry,e=True,ubk=True) # Get influence list influenceList = mc.skinCluster(skinCluster,q=True,inf=True) # Get MaxInfluence settings maxInfluences = mc.getAttr(skinCluster+'.maxInfluences') useMaxInfluences = mc.getAttr(skinCluster+'.maintainMaxInfluences') # Rebuild skinCluster skinCluster = mc.skinCluster(geometry,influenceList,dr=4,mi=maxInfluences,omi=useMaxInfluences,tsb=True) # Delete bind pose nodes deleteBindPose() # Return skinCluster return skinCluster
def bindCurve(crv=None):
'''
Creates a joint for each cv in the supplied or selected curve
performs a smooth bind on the curve to the joints
returns a list of the newly created joints
'''
# Validation of args
if not crv:
if len(cmds.ls(sl=1)) == 1:
crv = cmds.ls(sl=1)[0]
else:
return common.showDialog( 'Argument Error', 'Please supply or select a nurbs curve' )
jointList = []
cvs = cmds.getAttr("%s.cv[*]" % crv)
for cv in range(len(cvs)):
cmds.select(clear=1)
j = cmds.joint(p=cvs[cv], name='%s_%s_jnt' %(crv, cv+1))
jointList.append(j)
cmds.skinCluster(jointList, crv, tsb=1, name='%s_skinCluster' % crv)
return jointList
def create_ik_setup(self):
"""Creates the IK setup."""
ik = cmds.ikHandle(sj=self.result_jnts[0], ee=self.result_jnts[-1], sol='ikSplineSolver', ns=1)
cmds.rename(ik[1], '%s_%s_%s' % (self.side, 'neck', self.nc.effector))
curve = cmds.rename(ik[2], '%s_%s_%s' % (self.side, 'neck', self.nc.curve))
cmds.setAttr('%s.inheritsTransform' % curve, 0)
ik = cmds.rename(ik[0], '%s_%s_%s' % (self.side, 'neck', self.nc.ikhandle))
cmds.select(self.additional_jnts, curve)
cmds.skinCluster(tsb=True)
cmds.parent(ik, self.top_grp)
cmds.setAttr('%s.dTwistControlEnable' % ik, 1)
cmds.setAttr('%s.dWorldUpType' % ik, 4)
cmds.setAttr('%s.dWorldUpAxis' % ik, 4)
cmds.setAttr('%s.dWorldUpVectorY' % ik, -1)
cmds.setAttr('%s.dWorldUpVectorEndY' % ik, 1)
cmds.setAttr('%s.dWorldUpVectorEndZ' % ik, -1)
cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[0], '%s.dWorldUpMatrix' % ik, f=True)
cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[1], '%s.dWorldUpMatrixEnd' % ik, f=True)
self.head_grp = cmds.group(self.controls['head'])
self.head_grp = cmds.rename(self.head_grp, '%s_head_CTL_%s' % (self.side, self.nc.group))
cmds.parent(self.head_grp, self.top_grp)
self.c.move_pivot_to(self.guides['neckEnd'][0], self.guides['neckEnd'][1], self.guides['neckEnd'][2], self.head_grp)
cmds.parentConstraint(self.controls['head'], self.additional_jnts[-1], mo=True, weight=1)
cmds.orientConstraint(self.controls['head_rot'], self.result_jnts[-1], mo=True, weight=1)
def weightZero(skinClusterName, deformerName):
scNormalWeights = skinClusterName + '.normalizeWeights'
cmds.setAttr(scNormalWeights, 1)
cmds.skinPercent(skinClusterName, transformValue=[ (deformerName, 1.0)])
cmds.setAttr(scNormalWeights, 0)
cmds.skinCluster(skinClusterName, edit = True, fnw = True)
cmds.skinPercent(skinClusterName, transformValue=[ (deformerName, 0.0)])
def copyWeight( first, second ):
hists = cmds.listHistory( first, pdo=1 )
skinNode = None
for hist in hists:
if cmds.nodeType( hist ) == 'skinCluster':
skinNode = hist
if not skinNode: return None
targetSkinNode = None
targetHists = cmds.listHistory( second, pdo=1 )
if targetHists:
for hist in targetHists:
if cmds.nodeType( hist ) == 'skinCluster':
targetSkinNode = hist
if not targetSkinNode:
bindObjs = cmds.listConnections( skinNode+'.matrix', s=1, d=0, type='joint' )
bindObjs.append( second )
print bindObjs
cmds.skinCluster( bindObjs, tsb=1 )
cmds.copySkinWeights( first, second, noMirror=True, surfaceAssociation='closestPoint', influenceAssociation ='oneToOne' )
def skin_dragon(self):
"""@todo: insert doc for skin_dragon"""
cmds.setAttr('L_foot_CTL.tx', 3.061)
cmds.setAttr('R_foot_CTL.tx', -3.061)
data = 'C:/PROJECTS/GOT_Dragon/data/'
done = list()
for weight in os.listdir(data):
cmds.select(clear=True)
if weight in done:
continue
name = weight.split('_weights')[0]
if not cmds.objExists('Drache:%s' % name):
continue
weight = self.get_latest_version(weight, data)
self.select_result_jnts(name)
cmds.select('Drache:%s' % name, add=True)
skin = cmds.skinCluster(tsb=True, sm=True)[0]
cmds.deformerWeights(weight, im=True, method='index', deformer=skin, path=data)
cmds.skinCluster(skin, e=True, forceNormalizeWeights=True)
cmds.select('Drache:%s' % name)
done.append(weight)
#mel.eval('removeUnusedInfluences;')
# end for weight in os.listdir(data)
cmds.setAttr('L_foot_CTL.tx', 0)
cmds.setAttr('R_foot_CTL.tx', 0)
def mirrorSkin(skinCluster,search='L_',replace='R_'):
'''
Create a mirrored skinCluster based on the influence list and weights of another specified skinCluster
@param skinCluster: The existing skinCluster to mirror
@type skinCluster: str
@param search: Name prefix of the source skinCluster
@type search: str
@param replace: Name prefix of the destination skinCluster geometry/influences
@type replace: str
'''
# Check skinCluster
if not isSkinCluster(skinCluster):
raise Exception('Object "'+skinCluster+'" is not a valid skinCluster!')
# Get affected object
sourceGeo = glTools.utils.deformer.getAffectedGeometry(skinCluster).keys()[0]
if not sourceGeo.startswith(search):
raise Exception('Search string "'+search+'" not found in source geometry name!')
destGeo = sourceGeo.replace(search,replace)
if not mc.objExists(destGeo):
raise Exception('Destination geometry "'+destGeo+'" does not exist!')
# Get influence list
influenceList = mc.skinCluster(skinCluster,q=True,inf=True)
# Check destination skinCluster
mSkinCluster = skinCluster.replace(search,replace)
destSkinCluster = findRelatedSkinCluster(destGeo)
if destSkinCluster and destSkinCluster != mSkinCluster:
mc.rename(destSkinCluster,mSkinCluster)
# Check influenceList
mInfluenceList = [inf.replace(search,replace) for inf in influenceList]
for mInf in mInfluenceList:
if not mc.objExists(mInf):
raise Exception('Mirror influence "'+mInf+'" does not exist!!')
# Check mirror skinCluster
if not mc.objExists(mSkinCluster):
# Create skinCluster
mSkinCluster = mc.skinCluster(mInfluenceList,destGeo,tsb=True,n=mSkinCluster)[0]
else:
# Add influence
destInfluenceList = mc.skinCluster(mSkinCluster,q=True,inf=True)
for mInf in mInfluenceList:
if not destInfluenceList.count(mInf):
mc.skinCluster(mSkinCluster,e=True,ai=mInf)
# Get Mirror Weights
mirroWeightList = {}
for inf in influenceList:
mirroWeightList[inf] = getInfluenceWeights(skinCluster,inf)
# Clear mirrorSkin weights
clearWeights(destGeo)
# Apply mirror weights
for i in range(len(influenceList)):
setInfluenceWeights(mSkinCluster,mInfluenceList[i],mirroWeightList[influenceList[i]])
def applyRigidSkin():
""""""
sel = cmds.ls(sl=1, ap=1)
if len(sel) < 2:
om.MGlobal.displayError("Please select joints first, then mesh.")
return
mesh = sel.pop()
cmds.skinCluster(sel, mesh, tsb=1, mi=0, nw=1, bm=1)
def rigFace2() :
jntGrp = 'facialJnt_grp'
if not mc.objExists(jntGrp) :
mc.group(em = True, n = jntGrp)
facePolyMap = {'L_brow_ply': 'L_brow_ctrl',
'L_baseEye_ply': 'L_baseEye_ctrl',
'L_eye_ply': 'L_eye_ctrl',
'R_brow_ply': 'R_brow_ctrl',
'R_baseEye_ply': 'R_baseEye_ctrl',
'R_eye_ply': 'R_eye_ctrl',
'nose_ply': 'noseface_ctrl',
'mouth_ply': 'mouth_ctrl',
'L_eyeLine_ply': 'L_eyeLine_ctrl',
'R_eyeLine_ply': 'R_eyeLine_ctrl',
'L_wrinkle_ply': 'L_wrinkle_ctrl',
'R_wrinkle_ply': 'R_wrinkle_ctrl'
}
# facePolyMap = {'L_brow_ply': 'L_brow_ctrl',
# 'L_Eye_line_ply': 'L_baseEye_ctrl',
# 'L_eye_ply': 'L_eye_ctrl',
# 'R_brow_ply': 'R_brow_ctrl',
# 'R_Eye_line_ply': 'R_baseEye_ctrl',
# 'R_eye_ply': 'R_eye_ctrl',
# 'nose_ply': 'noseface_ctrl',
# 'mouth_ply': 'mount_ctrl',
# 'L_wrinkle_ply': 'L_wrinkle_ctrl',
# 'R_wrinkle_ply': 'R_wrinkle_ctrl'
# }
for each in facePolyMap :
poly = each
ctrl = facePolyMap[poly]
if mc.objExists(poly) :
joint = mc.createNode('joint', n = ctrl.replace('_ctrl', '_jnt'))
jntZgrp = mc.group(joint, n = '%sJnt_zGrp' % ctrl.replace('_ctrl', '_jnt'))
mc.delete(mc.pointConstraint(poly, jntZgrp))
mc.skinCluster(poly, joint, tsb = True)
mc.pointConstraint(ctrl, joint, mo = True)
# mc.connectAttr('%s.translateX' % ctrl, '%s.translateX' % joint, f = True)
# mc.connectAttr('%s.translateY' % ctrl, '%s.translateY' % joint, f = True)
# mc.connectAttr('%s.translateZ' % ctrl, '%s.translateZ' % joint, f = True)
mc.connectAttr('%s.rotateX' % ctrl, '%s.rotateX' % joint, f = True)
mc.connectAttr('%s.rotateY' % ctrl, '%s.rotateY' % joint, f = True)
mc.connectAttr('%s.rotateZ' % ctrl, '%s.rotateZ' % joint, f = True)
mc.connectAttr('%s.scaleX' % ctrl, '%s.scaleX' % joint, f = True)
mc.connectAttr('%s.scaleY' % ctrl, '%s.scaleY' % joint, f = True)
mc.connectAttr('%s.scaleZ' % ctrl, '%s.scaleZ' % joint, f = True)
mc.parent(jntZgrp, jntGrp)
else :
print '%s not exists' % poly
def buildPointWeights( points,
influenceList,
skinCluster,
maxInfluences = 3 ):
'''
Build and execute skinPercent commands to apply distance based weights given a list of deformed components and a list of influences.
Weights are calculated using an inverse distance function using a set number of influences per point.
@param points: List of deformed points to calculate skin weights for
@type points: list
@param influenceList: List of skinCluster influences to calculate weights from
@type influenceList: list
@param skinCluster: SkinCluster to apply weights to
@type skinCluster: str
@param maxInfluences: Number of influences per component
@type maxInfluences: int
'''
# ==========
# - Checks -
# ==========
# Build Influence Points
influencePts = [glTools.utils.base.getPosition(i) for i in influenceList]
# Add Missing Influences
skinInfList = mc.skinCluster(skinCluster,q=True,inf=True)
missingInfList = list(set(influenceList)-set(skinInfList)) or []
for inf in missingInfList:
mc.skinCluster(skinCluster,e=True,addInfluence=inf,lockWeights=True)
for inf in missingInfList:
mc.setAttr(inf+'.liw',0)
# =======================
# - Build Point Weights -
# =======================
#glTools.utils.progressBar.init('Beginning Weights', len(points)/10)
cmd = ''
ptWts = {}
for i, pt in enumerate(points):
ptPos = glTools.utils.base.getPosition(pt)
wt, influenceID = calcPointWeights(ptPos,influencePts,maxInfluences)
ptWts[pt] = [influenceID, wt]
cmd += buildSkinPercentCmd(pt, influenceList, wt, skinCluster, ptWts)
#if not i%10: glTools.utils.progressBar.update(1,'Generating Weights')
# =================
# - Return Result -
# =================
#glTools.utils.progressBar.end()
# Run Cmd
mm.eval(cmd)
def transferSingleFunction(self, getChildrenController, getChildrenTarget, skinPath):
print "here is "+getChildrenController[0], getChildrenTarget[0]
queryJoint=cmds.optionMenu(jointSelect, q=1, v=1)
queryJoint=queryJoint+":"
try:
newname, skinID=getClass.getSkinWeightsforXML(getChildrenController[0])
cmds.deformerWeights (newname+".xml", p=skinPath, ex=True, deformer=skinID)
print "deformer weights have been exported from "+getChildrenController[0]
except:
print "shape missing"
pass
try:
GetPath=skinPath+newname+".xml"
except:
print getChildrenController[0]+" does not have a skinCluster to reference from"
getCtrlgetChildrenTargetName=getChildrenController[0].split(":")
getTgtgetChildrenTargetName=getChildrenTarget[0].split(":")
getOldMeshNameSpace=':'.join(getCtrlgetChildrenTargetName[:-1])+":"
try:
getSkinCluster=cmds.skinCluster(getChildrenController[0], q=1, dt=1)
skinID, getInf=getClass.skinClust(getSkinCluster, getChildrenController[0])
getJointNameSpace=getInf[0].split(":")
getOldJointNameSpace=':'.join(getJointNameSpace[:-1])+":"
dataFromTextFile=open(GetPath).read()
dataFromTextFile=dataFromTextFile.replace(getOldJointNameSpace, queryJoint)
if "face" in getOldJointNameSpace:
dataFromTextFile=dataFromTextFile.replace(getOldJointNameSpace, "")
replacedDataTextFile=open(GetPath, 'w')
replacedDataTextFile.write(dataFromTextFile)
replacedDataTextFile.close()
print "xml has been updated with new joint names"
pass
except:
print "shape is missing - passed"
pass
getJointBucket=[]
for jointItem in getInf:
getJointName=jointItem.split(":")
getJoint=getJointName[-1:][0]
getNewJoint=queryJoint+getJoint
getJointBucket.append(getNewJoint)
cmds.select(getChildrenTarget[0])
try:
cmds.skinCluster(getChildrenTarget[0],getJointBucket[0], tsb=1, nw=1)
print getChildrenTarget[0]+" has been successfully bound to "+getJointBucket[0]
if len(getJointBucket)>1:
for eachjoint in getJointBucket[1:]:
try:
cmds.skinCluster(getChildrenTarget[0], e=1, ai=eachjoint, tsb=1, nw=1)
print eachjoint+" has been successfully added to "+getChildrenTarget[0]
except:
pass
except:
print getChildrenTarget[0]+" is already bound"
newgetChildrenTargetName, newskinID=getClass.getSkinWeightsforXML(getChildrenTarget[0])
cmds.deformerWeights (newname+".xml", p=skinPath, im=True, deformer=newskinID)
print "deformer weights have been applied to "+newgetChildrenTargetName
def checkLockedInfluences(self, skinCluster):
'''
Check if provided skinCluster has locked influences
'''
influenceObjects = cmds.skinCluster(skinCluster,q=True, inf=True )
for currentJoint in influenceObjects:
if (cmds.skinCluster(skinCluster,q=True,lw=True, inf=currentJoint )):
return True
return False
def copyWeight(self, arg = None) :
joints = mc.skinCluster(self.editObj, q = True, inf = True)
mc.skinCluster(joints, self.newObj, tsb = True)
mc.select(self.editObj, self.newObj)
mm.eval('CopySkinWeights;')
mc.select(self.newObj)
mc.button('%s_editBT' % self.win, e = True, en = True)
mc.button('%s_doneBT' % self.win, e = True, en = False)
def ReSeat(joints):
""" Allow movement of Joints. """
skins = set(cmds.listConnections(joints, type="skinCluster", s=True) or [])
for sk in skins:
cmds.skinCluster(sk, e=True, mjm=True) # Turn off skin
try:
yield
finally:
for sk in skins:
cmds.skinCluster(sk, e=True, mjm=False) # Turn on skin
def create_system(self):
"""
Creates the system necessary for simple sync integration into rig.
"""
mc.select(clear=True)
bindjoints = []
#Queries GUI text fields for their current values.
rt_eye = py.textField('rt_eye_text', q=True, tx=True)
lf_eye = py.textField('lfeye_text', q=True, tx=True)
up_jaw = py.textField('up_jaw_text', q=True, tx=True)
low_jaw = py.textField('low_jaw_text', q=True, tx=True)
head = py.textField('head_text', q=True, tx=True)
mesh = py.textField('mesh_text', q=True, tx=True)
#Centers the pivot of the right and left eye
py.xform(rt_eye, cp=True)
py.xform(lf_eye, cp=True)
#Queries the position of the left and right eye
rt_eye_pivot = py.xform(rt_eye, q=True, rp=True, ws=True, a=True)
lf_eye_pivot = py.xform(lf_eye, q=True, rp=True, ws=True, a=True)
#creates right eye joint and appends it to the bindjoints list
mc.joint(n='Right_eye_jnt', p=rt_eye_pivot)
bindjoints.append(mc.joint(n='Right_U_eyelid_jnt', p=rt_eye_pivot))
mc.parent(rt_eye, 'Right_eye_jnt')
mc.select(clear=True)
#creates left eye joint and appends it to the bindjoints list
mc.joint(n='Left_eye_jnt', p=lf_eye_pivot)
bindjoints.append(mc.joint(n='Left_U_eyelid_jnt', p=lf_eye_pivot))
mc.parent(lf_eye, 'Left_eye_jnt')
mc.parent('Left_eye_jnt', head)
mc.select(clear=True)
#makes cn_headroot_joint at the position of the locator/appends it to the bindjoints list.
#Does the same for cn_low_jaw joint and low_jaw_tip joint.
mc.joint(n='cn_headroot_jnt', p=(py.xform('cn_headroot_jnt_L', q=True, ws=True, a=True, t=True)))
bindjoints.append(mc.joint(n='cn_low_jaw_jnt', p=(py.xform('cn_low_jaw_jnt_L', q=True, ws=True, a=True, t=True))))
mc.joint(n='cn_low_jaw_tip_jnt', p=(py.xform('cn_low_jaw_tip_jnt_L', q=True, ws=True, a=True, t=True)))
mc.select(clear=True)
#parents the joints
mc.parent('Right_eye_jnt', 'cn_headroot_jnt')
mc.parent('Left_eye_jnt', 'cn_headroot_jnt')
mc.parent(up_jaw, 'cn_headroot_jnt')
mc.parent(low_jaw, 'cn_low_jaw_jnt')
mc.parent('cn_headroot_jnt', head)
#deletes locators and adds to influence
mc.delete('cn_headroot_jnt_L', 'cn_low_jaw_jnt_L', 'cn_low_jaw_tip_jnt_L')
mc.select(mesh)
mc.skinCluster(mesh, edit=True, ai=bindjoints, wt=0)
mc.select(clear=True)
def _connect_fk_system(self):
"""
Skin FK joints to dynamic curve.
"""
fk_joints = self.fk_joints
curve = self.curve
skin_cluster_name = self._get_unique_name("dynamicCluster", "DyCtr")
# select them in correct order and bind
cmds.select(fk_joints, curve, r=True)
cmds.skinCluster(n=skin_cluster_name, tsb=1, bm=0, sm=0, nw=1, wd=0,
mi=5, omi=1, dr=4, rui=1)
def addJntFn(self):
sel = cmds.ls(sl=1)
if len(sel) == 2:
mesh, jnt = None, None
for node in sel:
if cmds.nodeType(node) == 'joint': jnt = node
if cmds.listRelatives(node, allDescendents=True, noIntermediate=True, fullPath=True, type="mesh"):
mesh = node
if jnt and mesh:
cmds.skinCluster(self.findRelatedSkinCluster(mesh), e=1, lw=1, wt=0, ai=jnt)
cmds.setAttr(jnt + '.liw', 0)
else:
cmds.warning('skinWrangler: Cannot find joint and mesh in selection: ' + str(sel))
def duplicateFirst(doShaders=False):
#1. make an array of all selected objects
target = mc.ls(sl=1)
#2. if only one selection, just make a new duplicate at the same coordinates...
if(len(target)==1):
#call through mel because python has no rc option!
mel.eval("duplicate -un -ic -rc")
else:
try:
#3. check if the first selection is skinned.
mc.select(target[0])
mc.skinCluster(q=True)
print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
print "Select the root joint for this to work properly."
print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
except:
#4. ...otherwise, for each selected object...
for i in range(1,len(target)):
#5. ...get current selection's position and copy keyframes and shader
mc.select(target[i])
pos = mc.xform(target[i], q=True, t=True, ws=True)
try:
shader = getShader()
except:
print "Couldn't get shader."
try:
mc.copyKey()
except:
print "Couldn't copy keys."
#6. duplicate the first selection
mc.select(target[0])
#call through mel because python has no rc option!
mel.eval("duplicate -un -ic -rc")
#7. move first selection to position and paste keyframes and shader
mc.move(pos[0],pos[1],pos[2])
if(doShaders==True):
setShader(shader)
try:
mc.pasteKey()
except:
print "Couldn't paste keys."
#8. delete selection
mc.delete(target[i])
def attachGeoToBlueprint_skinning(self,blueprintJoints,geometry): blueprintModules = set([]) for joint in blueprintJoints: blueprintNamespace = utils.stripLeadingNamespace(joint)[0] blueprintModules.add(blueprintNamespace) for module in blueprintModules: cmds.lockNode(module+':module_container',lock=False, lockUnpublished=False) for geo in geometry: cmds.skinCluster(blueprintJoints, geo, tsb=True, n=geo+'_skinCluster') for module in blueprintModules: cmds.lockNode(module+':module_container',lock=True, lockUnpublished=True)
def create_ik_setup(self):
"""Creates the IK setup:
1. A spline IK
2. Skin the spline IK to the bind joints
3. Setup the twisting of the spline IK
4. Connect the hip and shoulder FK controls and bring them into the
right hierarchy
"""
ik = cmds.ikHandle(sj=self.result_jnts[0], ee=self.result_jnts[-1],
sol='ikSplineSolver', ns=1, scv=False)
cmds.rename(ik[1], '%s_%s_%s' % (self.side, 'spine', self.nc.effector))
curve = cmds.rename(ik[2], '%s_%s_%s' % (self.side, 'spine', self.nc.curve))
cmds.setAttr('%s.inheritsTransform' % curve, 0)
ik = cmds.rename(ik[0], '%s_%s_%s' % (self.side, 'spine', self.nc.ikhandle))
cmds.select(self.additional_jnts, curve)
cmds.skinCluster(tsb=True)
cmds.parent(ik, self.top_grp)
cmds.setAttr('%s.dTwistControlEnable' % ik, 1)
cmds.setAttr('%s.dWorldUpType' % ik, 4)
cmds.setAttr('%s.dWorldUpAxis' % ik, 1)
cmds.setAttr('%s.dWorldUpVectorY' % ik, -1)
cmds.setAttr('%s.dWorldUpVectorEndY' % ik, -1)
cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[0],
'%s.dWorldUpMatrix' % ik, f=True)
cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[1],
'%s.dWorldUpMatrixEnd' % ik, f=True)
hip_const = cmds.group(n='%s_hip_FK_const_%s' % (self.side, self.nc.group),
empty=True)
cmds.parent(hip_const, self.top_grp)
self.c.move_pivot_to(self.guides['spineBase'][0], self.guides['spineBase'][1],
self.guides['spineBase'][2], hip_const)
c = cmds.parentConstraint(self.fk_jnts[0], hip_const, mo=False, weight=1)[0]
cmds.parent(self.controls['hip'], hip_const)
cmds.makeIdentity(self.controls['hip'], apply=True, t=1, r=1, s=1, n=0, pn=1)
cmds.parentConstraint(self.controls['hip'], self.additional_jnts[0], mo=True, weight=1)
shoulder_const = cmds.group(n='%s_shoulder_FK_const_%s' % (self.side, self.nc.group),
em=True)
cmds.parent(shoulder_const, self.top_grp)
self.c.move_pivot_to(self.guides['spineEnd'][0], self.guides['spineEnd'][1],
self.guides['spineEnd'][2], shoulder_const)
c = cmds.parentConstraint(self.fk_jnts[-1], shoulder_const, mo=False, weight=1)[0]
cmds.parent(self.controls['shoulder'], shoulder_const)
cmds.makeIdentity(self.controls['shoulder'], apply=True, t=1, r=1, s=1, n=0, pn=1)
cmds.parentConstraint(self.controls['shoulder'], self.additional_jnts[-1],
mo=True, weight=1)
def make_loc_ctrl(self, arg=None):
try:
selObj=cmds.ls(sl=1, fl=1)
except:
print "must select a vert"
for each in selObj:
try:
getObjName=each.split(":")[1]
except:
getObjName=each
try:
getName=getObjName.split(".")
secondName=getName[1].replace("[", "_")
secondName=secondName.replace("]", "")
getName=getName[0]+secondName
except:
print "must select a vert"
position, rotation=getBaseClass.locationXForm(each)
try:
getSkinCluster=cmds.skinCluster(each, q=1, dt=1)
if getSkinCluster:
for item in getSkinCluster:
if "GroupId" in item:
skinID=[eachDefObj for eachDefObj in cmds.listConnections(item, s=1) if cmds.nodeType(eachDefObj)=="skinCluster"][0]
getBaseClass.buildJoint(getName, position, rotation)
# cmds.skinCluster(skinID, e=1, ai=getName+"_jnt", lw=1, wt=0)
name=getName+"_Ctrl"
grpname=getName+"_grp"
self.circle_shape(each, name, grpname, position, rotation)
cmds.parentConstraint(name, getName+"_jnt", mo=1 )
else:
pass
except:
thisIsAVariableName=getName[0]+'0001'
getBaseClass.buildJoint(thisIsAVariableName, position, rotation)
try:
cmds.skinCluster(each, thisIsAVariableName+"_jnt", tsb=1)
# cmds.skinCluster(skinID, e=1, ai=thisIsAVariableName+"_jnt", lw=1, wt=0)
except:
# cmds.skinCluster(each, thisIsAVariableName+"_jnt", tsb=1)
print "object already belongs to a skin cluster. add to skin cluster"
pass
name=getName[0]+"_Ctrl"
grpname=getName[0]+"_grp"
colour=13
getBaseClass.buildLoc(name, grpname, position, rotation, colour)
# self.circle_shape(each, name, grpname, position, rotation)
cmds.parentConstraint(name, thisIsAVariableName+"_jnt", mo=1 )
def _bind_joint_setup(self):
"""Skinweight the nurbs curve which affects the nurbs surface."""
skn = cmds.skinCluster(self.nrbcurve, self.joints,
tsb=True, nw=1, sm=0, bm=0, mi=1, dr=10)[0]
bindpose = cmds.listConnections('%s.bindPose' % skn)[0]
cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % skn)
cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % bindpose)
def getDeformers(geometry, deformerType):
if not mc.objExists(geometry):
return []
deformers = mayaTool.findDeformer(geometry)
deformers = [dfm for dfm in deformers if mc.nodeType(dfm) == deformerType]
if len(deformers) == 0:
return []
if deformerType == 'cluster':
return deformers
elif deformerType == 'blendShape':
attributes = []
for bsp in deformers:
attributes.append('%s.envelope'%bsp)
for attr in mayaTool.getBlendShapeAttributes(bsp):
attributes.append('%s.%s'%(bsp, attr))
return attributes
elif deformerType == 'skinCluster':
return mc.skinCluster(deformers[0], q=True, inf=True)
else:
return []
def _infFstList(self):
tmpd = {}
for i in range(len(self.tgt_lst)):
self.val = []
src = self.src_lst[0]
src_obj = src.split('.')
temp = mc.connectionInfo('{}.inMesh'.format(src_obj[0]), sfd=True)
self.src_skn = temp.split('.')
self.src_jnt = mc.skinCluster(self.src_lst[0], q=True, inf=True)
self.src_wgt = mc.skinPercent(self.src_skn[0], self.src_lst[0], q=True, v=True)
if self.mode is True:
for j in range(len(self.src_jnt)):
temp = ('{}'.format(self.src_jnt[j]), self.src_wgt[j])
self.val.append(temp)
else :
self.div_jnt = []
self.div_wgt = []
tgt = self.tgt_lst[i]
tgt_obj = tgt.split('.')
temp = mc.connectionInfo('{}.inMesh'.format(tgt_obj[0]), sfd=True)
self.tgt_skn = temp.split('.')
self.tgt_jnt = mc.skinCluster(self.tgt_lst[i], q=True, inf=True)
self.tgt_wgt = mc.skinPercent(self.tgt_skn[0], self.tgt_lst[i], q=True, v=True)
self.div_jnt.append(self.src_jnt[0])
if self.src_jnt[0] in self.tgt_jnt:
idx = self.tgt_jnt.index(self.src_jnt[0])
self.div_wgt.append(self.src_wgt[0] * self.div + self.tgt_wgt[idx] * (1.00 - self.div))
else:
self.div_wgt.append(self.src_wgt[0] * self.div)
for f in range(len(self.tgt_jnt)):
if self.tgt_jnt[f] not in self.div_jnt:
self.div_jnt.append(self.tgt_jnt[f])
self.div_wgt.append(self.tgt_wgt[f] * (1.00 - self.div))
for f in range(len(self.div_jnt)):
temp = ('{}'.format(self.div_jnt[f]), self.div_wgt[f])
self.val.append(temp)
tmpd[self.tgt_lst[i]] = self.val
self.inf.append(tmpd)
def doSkinWeightExport(one, path):
#find geo by looking at skinclusters
skinClusters = cmds.ls(type='skinCluster')
print "saved skin weights for " + one + " to " + path
for skin in skinClusters:
#go through each found skin cluster, and if we find a skin cluster whose geometry matches our selection, get influences
bigList = []
for cluster in skinClusters:
geometry = cmds.skinCluster(cluster, q=True, g=True)[0]
geoTransform = cmds.listRelatives(geometry, parent=True)[0]
if geoTransform == one:
f = open(path, 'w')
skinCluster = cluster
#find all vertices in the current geometry
verts = cmds.polyEvaluate(one, vertex=True)
for i in range(int(verts)):
#get weighted transforms
transforms = cmds.skinPercent(skinCluster,
one + ".vtx[" + str(i) + "]",
ib=.001,
query=True,
t=None)
#get skinPercent value per transform
values = cmds.skinPercent(skinCluster,
one + ".vtx[" + str(i) + "]",
ib=.001,
query=True,
value=True)
list = []
list.append(i)
for x in range(int(len(values))):
list.append([transforms[x], values[x]])
#add each vert info's transforms, and values to the overall huge list
bigList.append(list)
#write that overall list to file
cPickle.dump(bigList, f)
#close the file
f.close()
#operation complete
cmds.headsUpMessage("Skin Weights Exported!", time=3.0)
return
def setInfluenceWeightsAll(skinCluster,
weightList,
normalize=True,
componentList=[]):
'''
'''
# Verify skinCluster
if not isSkinCluster(skinCluster):
raise Exception('Invalid skinCluster "' + skinCluster + '" specified!')
# Get SkinCluster Influence List
influenceList = mc.skinCluster(skinCluster, q=True, inf=True)
infIndexArray = OpenMaya.MIntArray()
[
infIndexArray.append(getInfluencePhysicalIndex(skinCluster, inf))
for inf in influenceList
]
infDict = {}
for inf in influenceList:
infDict[inf] = getInfluencePhysicalIndex(skinCluster, inf)
# Get SkinCluster Geometry
skinGeo = glTools.utils.deformer.getAffectedGeometry(skinCluster).keys()[0]
if not mc.objExists(skinGeo):
raise Exception('SkinCluster geometry "' + skinGeo +
'" does not exist!')
# Check Component List
if not componentList:
componentList = glTools.utils.component.getComponentStrList(skinGeo)
componentSel = glTools.utils.selection.getSelectionElement(
componentList, 0)
# Get Component Index List
indexList = OpenMaya.MIntArray()
componentFn = OpenMaya.MFnSingleIndexedComponent(componentSel[1])
componentFn.getElements(indexList)
componentIndexList = list(indexList)
# Check SkinCluster Weights List
if len(weightList) != len(influenceList):
raise Exception('Influence and weight list miss-match!')
# Build Master Weight Array
wtArray = OpenMaya.MDoubleArray()
oldWtArray = OpenMaya.MDoubleArray()
for c in componentIndexList:
for inf in influenceList:
wtArray.append(weightList[infDict[inf]][c])
# Get skinCluster function set
skinFn = glTools.utils.skinCluster.getSkinClusterFn(skinCluster)
# Set skinCluster weights
skinFn.setWeights(componentSel[0], componentSel[1], infIndexArray, wtArray,
False, oldWtArray)
def weightCopy(self):
saveData = {}
# 保存ディレクトリが無かったら作成
if not os.path.exists(self.filePath):
os.makedirs(os.path.dirname(self.filePath + '\\')) # 末尾\\が必要なので注意
else: # ある場合は中身を削除
files = os.listdir(self.filePath)
if files is not None:
for file in files:
os.remove(self.filePath + '\\' + file)
skinFlag = False
for skinMesh in self.skinMeshes:
try:
cmds.bakePartialHistory(skinMesh, ppt=True)
except:
pass
# ノードの中からスキンクラスタを取得してくる#inMesh直上がSkinClusterとは限らないので修正
srcSkinCluster = cmds.ls(cmds.listHistory(skinMesh),
type='skinCluster')
if not srcSkinCluster:
continue # スキンクラスタがなかったら次に移行
tempSkinNode = skinMesh #親を取得するためスキンクラスタのあるノードを保存しておく
# スキンクラスタのパラメータ色々を取得しておく
srcSkinCluster = srcSkinCluster[0]
skinningMethod = cmds.getAttr(srcSkinCluster + ' .skm')
dropoffRate = cmds.getAttr(srcSkinCluster + ' .dr')
maintainMaxInfluences = cmds.getAttr(srcSkinCluster + ' .mmi')
maxInfluences = cmds.getAttr(srcSkinCluster + ' .mi')
bindMethod = cmds.getAttr(srcSkinCluster + ' .bm')
normalizeWeights = cmds.getAttr(srcSkinCluster + ' .nw')
influences = cmds.skinCluster(srcSkinCluster, q=True, inf=True)
saveData[skinMesh + ';skinningMethod'] = skinningMethod
saveData[skinMesh + ';dropoffRate'] = dropoffRate
saveData[skinMesh +
';maintainMaxInfluences'] = maintainMaxInfluences
saveData[skinMesh + ';maxInfluences'] = maxInfluences
saveData[skinMesh + ';bindMethod'] = bindMethod
saveData[skinMesh + ';normalizeWeights'] = normalizeWeights
saveData[skinMesh + ';influences'] = influences
skinFlag = True
if self.engine == 'maya':
# 読みに行くセーブファイル名を指定、autoならメッシュ名
if self.weightFile == 'auto':
weightFile = skinMesh
else:
weightFile = self.weightFile
# Pipeはファイル名に出来ないので変換しておく
meshName = str(weightFile).replace('|', '__pipe__')
# コロンはファイル名に出来ないので変換しておく
meshName = str(meshName).replace(':', '__colon__')
cmds.deformerWeights(meshName + '.xml',
export=True,
deformer=srcSkinCluster,
path=self.filePath + '\\')
with open(self.fileName, 'w') as f: # ファイル開く'r'読み込みモード'w'書き込みモード
json.dump(saveData, f)
def transform_f(self):
if not mc.objExists(self.main_joint + '_trf'):
joint_trf = mc.duplicate(self.main_joint,
n='{}'.format(self.main_joint) + '_trf')
seachAndReplaceNamse(joint_trf[0])
for jnt in self.joint:
if mc.nodeType(jnt) == 'joint':
mc.parentConstraint(jnt, '{}'.format(jnt) + '_trf', mo=1)
for obj in self.model:
if not obj:
return
if not (mc.objExists(obj) or mc.objExists(obj + '_dup')):
print('Missing mesh or mush!')
return
if not mc.objExists(obj + '_trf'):
obj_trf = mc.duplicate(obj, n=obj + '_trf')[0]
obj_dup = obj + '_dup'
new_joint = self.main_joint + '_trf'
#try:
mc.bakeDeformer(ss=self.new_joint,
sm=obj_dup,
ds=new_joint,
dm=obj_trf,
mi=3)
#except:
#print 'error {}'.format(obj_trf)
#pass
numV = mc.polyEvaluate(obj_trf, v=True)
skinClusterStr = 'findRelatedSkinCluster("' + obj_trf + '")'
skinCluster = mel.eval(skinClusterStr)
jointInf = mc.skinCluster(obj_trf, q=True, inf=True)
#dataWeight = {}
for n in range(numV):
data = []
weightInf = mc.skinPercent(skinCluster,
'{}.vtx[{}]'.format(obj_trf, n),
q=True,
v=True)
for i in range(len(weightInf)):
if weightInf[i] != 0:
data.append([jointInf[i], weightInf[i]])
print '{}.vtx[{}],{} = {}'.format(
obj_trf, n, jointInf[i], weightInf[i])
self.dataWeight['{}.vtx[{}]'.format(obj_trf, n)] = data
print self.dataWeight
'''
skinClusterStr = 'findRelatedSkinCluster("' + obj + '")'
skinCluster = mel.eval(skinClusterStr)
mc.skinPercent(skinCluster,prw=0.01)'''
print '!!! COMPLETED !!!'
def slInfluence(self):
skinMesh = rig.textScrollList(self.slSkinTV, q=True, si=True)
index = rig.textScrollList(self.slSkinTV, q=True, sii=True)
skin = SK_getSkinCluster(skinMesh)
rig.treeView(self.slJointTV, e=True, ra=True)
infs = rig.skinCluster(skin, q=True, inf=True)
rig.treeView(self.slJointTV,
e=True,
addItem=[(inf, '') for inf in infs])
def autoGenerateRagdollForEachJoint( joints, threshold=0.65 ): convexifiedMeshes = [] for j in joints: meshes = extractMeshForEachJoint( [ j ], threshold ) if len( meshes ) > 1: mesh = cmd.polyUnite( meshes, ch=False )[ 0 ] cmd.delete( meshes ) meshes = [ mesh ] else: mesh = meshes[ 0 ] convexifiedMesh = convexifyObjects( mesh )[ 0 ] convexifiedMesh = cmd.rename( convexifiedMesh, j +'_ragdoll' ) cmd.skinCluster( [ j ], convexifiedMesh ) cmd.delete( meshes ) convexifiedMeshes.append( convexifiedMesh ) return convexifiedMeshes
def bind_curves(self):
'''
This needs to be a post build function, else the curves get stuffed when re-parenting because they are locked
'''
cmds.skinCluster(self.upper_ctrl_jnts,
self.upper_crv,
tsb=True,
bm=True)
cmds.skinCluster(self.lower_ctrl_jnts,
self.lower_crv,
tsb=True,
bm=True)
# lock and hide these just in case
utils.lock_hide(self.input_upper)
utils.lock_hide(self.input_lower)
utils.visibility(self.upper_crv)
utils.visibility(self.lower_crv)
def edo_imPolyWeights():
cmds.undoInfo(state=0)
sels=cmds.ls(sl=1)
path=''
paths=cmds.fileDialog(dm='*.skw',m=0,t='import')
if paths:
path=paths
if path=='':
cmds.undoInfo(state=1)
return False
fobj=open(path,'r')
tx=[]
for line in fobj.readlines():
tx.append(line)
fobj.close()
lc=len(tx)
n=0
for t in tx:
#t=tx[0]
if n%1000==0:
print str(n)+'/'+str(lc)
n=n+1
t=t.replace('\n','')
sp=t.split(':')
c=sp[0]
obj=c.split('.')[0]
if (not obj in sels) and (not sels==[]):
continue
iw=sp[1]
iws=iw.split(' ')
sk=edo_findNodeFromHis(c,'skinCluster')
edo_setVertexWeightZero(sk,c)
tvs=edo_combineTheWeightData(iws)
tvsl=[]
lst=tvs.keys()
for l in lst:
#l=lst[0]
tvsl.append((l,tvs[l]))
#print tvsl
#edo_lockAllInfluence(sk)
cmds.skinPercent(sk,c,tv=tvsl)
cmds.skinCluster(sk,e=1,nw=1)
cmds.undoInfo(state=1)
def rebindWithIncrMesh(skinnedMeshBaseName):
skinnedMesh = mc.ls(skinnedMeshBaseName + "*", type="transform")[-1]
shape = mc.listRelatives(skinnedMesh, c=True, s=True)[0]
skinClusterNode = mc.listConnections(shape + '.inMesh', s=True, d=False)[0]
joints = mc.listConnections(skinClusterNode + '.matrix',
s=True,
d=False,
type='joint')
mc.setAttr(skinClusterNode + '.envelope', 0)
newMesh = mc.duplicate(skinnedMesh)[0]
mc.select(joints)
mc.skinCluster(joints, newMesh, toSelectedBones=True)
mc.copySkinWeights(skinnedMesh,
newMesh,
noMirror=True,
surfaceAssociation='closestPoint',
influenceAssociation='closestJoint')
mc.setAttr(skinnedMesh + '.visibility', 0)
def ParentAllGeometryToWorld():
print 'Parenting geometry to world'
skinList = cmds.ls(type='skinCluster')
meshes = set(sum([cmds.skinCluster(c, q=1, g=1) for c in skinList], []))
for mesh in meshes:
transformList = cmds.listRelatives(mesh, parent=True)
for tf in transformList:
if cmds.listRelatives(tf, parent=True):
cmds.parent(tf, world=True)
def add_to_system():
# on selectionne des mesh et un joint.
depart = mc.ls(sl=True)
bone = []
ajout = []
for i in depart:
if mc.objectType(i, i='joint') == 1:
bone.append(i)
else:
ajout.append(i)
if len(bone) >= 1:
bone = bone[0]
for ind, plane in enumerate(ajout):
mc.skinCluster(plane, bone, tsb=True, rui=True)
swName = mc.listHistory(plane)[2]
deform = mc.deformer(swName, e=True, g=plane)
mc.polyMoveFacet(plane, ltz=float(ind + 2) / 1000)
def softSelectionSkinWeights(*args):
model = mc.ls(sl=True, o=True)
joints = mc.ls(model, type='joint')
mc.select(joints, deselect=True)
weights = getSoftSelectionWeights()
if not model or not joints or not weights:
raise RuntimeError('Select vertices followed by a joint')
if len(joints) > 1:
raise RuntimeError('Only one joint can be selected at a time')
joint = joints[0]
skin = utl.getSkinCluster(model[0])
if not skin:
raise RuntimeError('Mesh must have an existing skinCluster')
influences = mc.skinCluster(skin, query=True, influence=True)
if joint not in influences:
mc.skinCluster(skin,
edit=True,
addInfluence=joint,
lockWeights=False,
weight=0)
for influence in influences:
mc.skinCluster(skin, edit=True, influence=influence, lockWeights=False)
for vertex, weight in weights.items():
mc.skinPercent(skin, vertex, transformValue=(joint, weight))
mc.select(joint)
# ______________________
# - -/__ Revision History __/- - - - - - - - - - - - - - - - - - - - - - - -
#
# Revision 1: 2016-12-31 : Initial publish
#
# Revision 2: 2018-02-17 : Updating license to MIT.
def createIkSpineSystem(self):
self.clearSelection()
cmds.select(self.joints[0], self.joints[-1], add=True)
self.ikSystemObjs = cmds.ikHandle(solver="ikSplineSolver",
simplifyCurve=False)
newObjs = []
for x in range(len(self.ikSystemObjs)):
if x == 0:
newObjs.append(
cmds.rename(
self.ikSystemObjs[x],
NamingAgreementHandler(
base=NAMING["spineJointName"],
suffix=NAMING["ikHandleSuffix"]).nodeName))
elif x == 2:
newObjs.append(
cmds.rename(
self.ikSystemObjs[x],
NamingAgreementHandler(
base=NAMING["spineJointName"],
suffix=NAMING["curveSuffix"]).nodeName))
self.clearSelection()
cmds.skinCluster(self.bindJoints,
newObjs[-1],
bindMethod=0,
normalizeWeights=1,
weightDistribution=0,
maximumInfluences=2,
obeyMaxInfluences=True,
dropoffRate=4,
removeUnusedInfluence=True)
if x == 1:
newObjs.append(
cmds.rename(
self.ikSystemObjs[x],
NamingAgreementHandler(
base=NAMING["spineJointName"],
suffix=NAMING["effectorSuffix"]).nodeName))
self.ikSystemObjs = newObjs
def bindSkin(prefix):
#### Binds skin to mesh, if mesh not selected than message appears ####
sel = cmds.ls(sl=True)
if (len(sel) == 0):
cmds.confirmDialog(
title="Empty Selection",
message=
"You have to select a mesh, cause I can't do everything for you.",
button=['Ok'])
else:
for i in range(0, len(sel)):
cmds.skinCluster(sel[i],
prefix + "_Root_Jnt",
bm=3,
sm=0,
name="Mesh" + str(i))
cmds.geomBind('Mesh' + str(i), bm=3, mi=4, gvp=[1024, 1])
def get_skin(cls, mesh_shape):
mesh_shape = cls.get_shape(mesh_shape)
skins = cmds.ls(type="skinCluster")
for skin in skins:
try:
if mesh_shape in cmds.skinCluster(skin, q=True, g=True):
return skin
except:
return None
return None
def add_influences(skin_name="", influences=[]):
"""
adding influences to the designated skin cluster.
:param skin_name: <str> the skin cluster to add influences to.
:param influences: <list> the influence objects to add to the skin cluster.
:return: <bool> True for success.
"""
current_influences = get_existing_influences(skin_name)
new_influences = tuple(set(current_influences) - set(influences))
# add the objects not part of the current influences to the skin cluster provided.
for influence in new_influences:
cmds.skinCluster(
skin_name,
edit=True,
addInfluence=influence,
weight=0.0
)
return True
def applyWeightInfo(self):
for shape in self.shapes:
#make a skincluster using the joints
if cmds.objExists(shape):
ss = self.shapes[shape]
skinList = ss.joints
skinList.append(shape)
cmds.select(skinList, r=True)
cluster = cmds.skinCluster(name=ss.skin, tsb=1)
cmds.deformerWeights(fname , path = fpath, deformer=ss.skin, im=1)
def store_all_influence(self):
skin_cluster = cmds.ls(cmds.listHistory(self.marged_mesh),
type='skinCluster')
if not skin_cluster:
return
skin_cluster = skin_cluster[0]
self.all_influences = cmds.ls(cmds.skinCluster(skin_cluster,
q=True,
inf=True),
l=True)
def attachToMesh(self, mesh):
self._mesh = mesh
self._skinCluster = mel.findRelatedSkinCluster(mesh)
joints = cmd.skinCluster(self._skinCluster, q=True, inf=True)
self._prefix = getCommonPrefix(joints)
self.UI_tsl.setItems(joints)
self.on_updateState()
def duplicates(self):
self.main_joint = find_parentUp(self.joint[0])
#if not mc.objExists(allJoint[0] + '_dup'):
self.joint_dup = mc.duplicate(self.main_joint,
n='{}'.format(self.main_joint) + '_dup')
seachAndReplaceNamse(self.joint_dup[0])
for model in self.model:
obj = model
if not obj:
return
if mc.objExists(obj + '_dup'):
print(obj + '_dup already exists!')
return
self.obj_dup = mc.duplicate(obj, n=obj + '_dup')
self.model_dup.append(self.obj_dup)
skinClusterStr = 'findRelatedSkinCluster("' + obj + '")'
skinCluster = mel.eval(skinClusterStr)
joint = mc.skinCluster(skinCluster, q=True, inf=True)
obj_dup = obj + '_dup'
self.new_joint = self.main_joint + '_dup'
try:
mc.bakeDeformer(ss=self.main_joint,
sm=obj,
ds=self.new_joint,
dm=obj_dup,
mi=3)
mc.deltaMush(obj_dup,
smoothingIterations=25,
smoothingStep=0.35,
pinBorderVertices=True,
inwardConstraint=1,
outwardConstraint=0,
envelope=1)
except:
print obj
pass
skinClusterStr2 = 'findRelatedSkinCluster("' + obj_dup + '")'
skinCluster2 = mel.eval(skinClusterStr2)
mc.select(obj_dup)
mc.skinPercent(skinCluster2, prw=0.01)
#self.joint_dup = mc.skinCluster(skinCluster2 ,q=True ,inf=True)
for jnt in self.joint:
if mc.nodeType(jnt) == 'joint':
mc.parentConstraint(jnt, '{}'.format(jnt) + '_dup', mo=1)
print '!!! COMPLETED !!!'
def setInfluenceWeightsSlow(skinCluster,
influence,
weightList,
normalize=True,
componentList=[]):
'''
Set the weights of an influence for a specified skinCluster using an input weight list. Uses slower skinPercent cmd.
@param skinCluster: SkinCluster to set influence weights for
@type skinCluster: str
@param influence: Influence to set weights for
@type influence: str
@param weightList: Influence weight list to apply.
@type weightList: list
@param normalize: Normalize weights as they are applied
@type normalize: bool
@param componentList: List of components to set weights for
@type componentList: list
'''
# Verify skinCluster
if not isSkinCluster(skinCluster):
raise Exception('Invalid skinCluster "' + skinCluster + '" specified!')
# Check influence
if not mc.objExists(influence):
raise Exception('Influence object "' + influence +
'" does not exists!')
if not mc.skinCluster(skinCluster, q=True, inf=True).count(influence):
raise Exception('Influence "' + influence +
'" not connected to skinCluster "' + skinCluster +
'"!')
# Get geometry
affectedGeo = glTools.utils.deformer.getAffectedGeometry(
skinCluster).keys()[0]
# Check component list
if not componentList:
componentList = glTools.utils.component.getComponentStrList(
affectedGeo)
componentIndexList = glTools.utils.component.getComponentIndexList(
componentList)
componentIndexList = componentIndexList[componentIndexList.keys()[0]]
# Check component and weight list lengths
if len(componentIndexList) != len(weightList):
raise Exception('List length mis-match!')
# Set weight values
for i in range(len(componentIndexList)):
comp = glTools.utils.component.getComponentStrList(
affectedGeo, [componentIndexList[i]])[0]
mc.skinPercent(skinCluster,
comp,
tv=(influence, weightList[i]),
normalize=normalize)
def loadInf(cls, *args):
'''
Main method.
Populate influence and weight value text scroll list.
'''
# Get options
hideZroInfOpt = cmds.menuItem(cls.uiWidgets['hideZroInfMenuItem'],
q=True,
checkBox=True)
hierSortOpt = cmds.menuItem(cls.uiWidgets['sortHierMenuItem'],
q=True,
checkBox=True)
# Make a list
cls.vtxList = cmds.ls(sl=True)
logger.debug('Selected Vertex: %s' % cls.vtxList)
# User feedback when did not select a vertex
if not '.' in str(cls.vtxList):
cls.userFeedback()
return
# Check selected geometry number and if select more than two geometry exit program
geoChkResult = cls.checkGeoNum()
if not geoChkResult:
return
# Get skin cluster from selected vertex
cls.getSkinClst(cls.vtxList[0])
if not cls.skinClst:
cls.userFeedback()
return
# Get influences
infs = cmds.skinCluster(cls.skinClst, q=True, inf=True)
logger.debug('Influences: %s' % infs)
# Make influences weight value table
cls.skinWeightTable(cls.skinClst, cls.vtxList, infs)
# Hide zero weighted influences depend on option state
if hideZroInfOpt:
rmvedZroWghtTable = cls.hideZeroWghtInfs()
infs = rmvedZroWghtTable.keys()
# Sorting
if hierSortOpt:
infs = cls.sortByHierarchy(infs)
else:
infs = cls.sortByAlphabetically(infs)
# Populate text scroll list
cls.populateInfList(infs)
cls.populateWghtList(infs)
def averageWeights(tol=0.000001):
"""
Average weights of selected vertices
@param tol: Minimum influence weight tolerance
@type tol: float
"""
# Get Component Selection
sel = cmds.filterExpand(ex=True, sm=[28, 31, 46])
if not sel: return
# Get Component Selection by Object
sel = glTools.utils.selection.componentListByObject(sel)
if not sel: return
sel = sel[0]
# Get Object from Components
geo = cmds.ls(sel[0], o=True)[0]
# Get SkinCluster
skin = glTools.utils.skinCluster.findRelatedSkinCluster(geo)
if not skin:
raise Exception('Geometry "' + geo +
'" is not attached to a valid skinCluster!')
# Get Influence List
joints = cmds.skinCluster(skin, q=True, inf=True)
# Initialize skinPercent Command
cmd = 'skinPercent'
# For Each SkinCluster Influence
for jnt in joints:
# Initialize Average Influence Weight
wt = 0.0
# For each CV
for cv in sel:
wt += cmds.skinPercent(skin, cv, q=True, transform=jnt)
# Average Weight
wt /= len(joints)
# Check Weight Tolerance
if wt < tol: continue
# Append to skinPercent Command
cmd += (' -tv ' + jnt + ' ' + str(round(wt, 5)))
# Finalize skinPercent Command
cmd += (' -zri true ### ')
# Return Result
gl_globals.glCopyPasteWeightCmd = cmd
print gl_globals.glCopyPasteWeightCmd
def create_joint(cvs, wts):
tform = cvs[0].partition(".")[0]
curve = cmds.listRelatives(tform, f=True, s=True)[0]
ps = []
center = []
for cv in cvs:
ps.append(cmds.pointPosition(cv))
center = [sum(y)/len(y) for y in zip(*ps)]
#create joint at location
# ----------- should get closest point on surface
cmds.select(cl=True)
jnt = cmds.joint()
cmds.xform(jnt, ws=True, t=center)
#---------------- orient the joint along the curve?
#---------------- here create the ctrl set up for the joint
ctrl = rig.createControl(name="{0}Ctrl".format(jnt), type="sphere", color="red")
grp = cmds.group(name="{0}Grp".format(ctrl), em=True)
cmds.parent(ctrl, grp)
cmds.xform(grp, ws=True, t=center)
cmds.parent(jnt, ctrl)
# scale the control
comps = cmds.ls("{0}.cv[*]".format(ctrl))
cmds.select(comps, r=True)
cmds.scale(.2,.2,.2)
#add influence to skin Cluster
cmds.select(tform, r=True)
cmds.skinCluster(e=True, ai=jnt, wt=0)
cmds.setAttr("{0}.v".format(jnt), 0)
#apply weights to that joint
cls = mel.eval("findRelatedSkinCluster " + tform)
for v in range(len(cvs)):
cmds.skinPercent(cls, cvs[v], transformValue=[jnt, wts[v]])
return(jnt, ctrl, grp)
def addCompCtrl(self):
self.selVetices=mc.ls(sl=1,fl=1)
self.objShape=mc.ls(sl=1,o=1)
self.obj=mc.listRelatives(self.objShape,p=1)[0]
self.allVetices=mc.polyEvaluate(self.obj,v=1)
self.souceAllPos=[]
for i in range(0,self.allVetices):
soucePos=mc.xform(self.obj+'.vtx['+str(i)+']',q=1,ws=1,t=1)
self.souceAllPos.append(soucePos)
mc.move(0,100,0,r=1,ws=1,wd=1)
self.allPos=[]
for i in range(0,self.allVetices):
pos=mc.xform(self.obj+'.vtx['+str(i)+']',q=1,ws=1,t=1)
self.allPos.append(pos)
mc.move(0,-100,0,r=1,ws=1,wd=1)
self.weights=[]
for i in range(0,self.allVetices):
self.weights.append((self.allPos[i][1]-self.souceAllPos[i][1])*0.01)
self.jointPos=self.centerPos(self.selVetices)
self.strCtrl = mm.eval("curve -d 1 -p -8.19564e-008 0 0.5 -p 0.0975451 0 0.490393 -p 0.191342 0 0.46194 -p 0.277785 0 0.415735 -p 0.353553 0 0.353553 -p 0.415735 0 0.277785 -p 0.46194 0 0.191342 -p 0.490393 0 0.0975452 -p 0.5 0 0 -p 0.490392 0 -0.0975448 -p 0.461939 0 -0.191341 -p 0.415734 0 -0.277785 -p 0.353553 0 -0.353553 -p 0.277785 0 -0.415734 -p 0.191342 0 -0.461939 -p 0.0975453 0 -0.490392 -p 2.23517e-007 0 -0.5 -p -0.0975448 0 -0.490392 -p -0.191341 0 -0.461939 -p -0.277785 0 -0.415735 -p -0.353553 0 -0.353553 -p -0.415734 0 -0.277785 -p -0.461939 0 -0.191342 -p -0.490392 0 -0.0975453 -p -0.5 0 -1.63913e-007 -p -0.490392 0 0.097545 -p -0.46194 0 0.191341 -p -0.415735 0 0.277785 -p -0.353553 0 0.353553 -p -0.277785 0 0.415735 -p -0.191342 0 0.46194 -p -0.0975452 0 0.490392 -p -8.19564e-008 0 0.5 -p -8.03816e-008 0.0975452 0.490392 -p -7.57178e-008 0.191342 0.46194 -p -6.81442e-008 0.277785 0.415735 -p -5.79519e-008 0.353553 0.353553 -p -4.55325e-008 0.415735 0.277785 -p -3.13634e-008 0.46194 0.191342 -p -1.59889e-008 0.490393 0.0975451 -p 0 0.5 0 -p 4.36061e-008 0.490393 -0.0975451 -p 8.55364e-008 0.46194 -0.191342 -p 1.2418e-007 0.415735 -0.277785 -p 1.58051e-007 0.353553 -0.353553 -p 1.85848e-007 0.277785 -0.415734 -p 2.06503e-007 0.191342 -0.461939 -p 2.19223e-007 0.0975452 -0.490392 -p 2.23517e-007 0 -0.5 -p 2.19223e-007 -0.0975452 -0.490392 -p 2.06503e-007 -0.191342 -0.461939 -p 1.85848e-007 -0.277785 -0.415734 -p 1.58051e-007 -0.353553 -0.353553 -p 1.2418e-007 -0.415735 -0.277785 -p 8.55364e-008 -0.46194 -0.191342 -p 4.36061e-008 -0.490393 -0.0975451 -p 0 -0.5 0 -p -1.59889e-008 -0.490393 0.0975451 -p -3.13634e-008 -0.46194 0.191342 -p -4.55325e-008 -0.415735 0.277785 -p -5.79519e-008 -0.353553 0.353553 -p -6.81442e-008 -0.277785 0.415735 -p -7.57178e-008 -0.191342 0.46194 -p -8.03816e-008 -0.0975452 0.490392 -p -8.19564e-008 0 0.5 -p -0.0975452 0 0.490392 -p -0.191342 0 0.46194 -p -0.277785 0 0.415735 -p -0.353553 0 0.353553 -p -0.415735 0 0.277785 -p -0.46194 0 0.191341 -p -0.490392 0 0.097545 -p -0.5 0 -1.63913e-007 -p -0.490392 -0.0975452 -1.60763e-007 -p -0.461939 -0.191342 -1.51436e-007 -p -0.415735 -0.277785 -1.36288e-007 -p -0.353553 -0.353553 -1.15904e-007 -p -0.277785 -0.415735 -9.10651e-008 -p -0.191342 -0.46194 -6.27267e-008 -p -0.0975451 -0.490393 -3.19778e-008 -p 0 -0.5 0 -p 0.0975452 -0.490393 0 -p 0.191342 -0.46194 0 -p 0.277785 -0.415735 0 -p 0.353553 -0.353553 0 -p 0.415735 -0.277785 0 -p 0.46194 -0.191342 0 -p 0.490393 -0.0975452 0 -p 0.5 0 0 -p 0.490393 0.0975452 0 -p 0.46194 0.191342 0 -p 0.415735 0.277785 0 -p 0.353553 0.353553 0 -p 0.277785 0.415735 0 -p 0.191342 0.46194 0 -p 0.0975452 0.490393 0 -p 0 0.5 0 -p -0.0975451 0.490393 -3.19778e-008 -p -0.191342 0.46194 -6.27267e-008 -p -0.277785 0.415735 -9.10651e-008 -p -0.353553 0.353553 -1.15904e-007 -p -0.415735 0.277785 -1.36288e-007 -p -0.461939 0.191342 -1.51436e-007 -p -0.490392 0.0975452 -1.60763e-007 -p -0.5 0 -1.63913e-007 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 -k 15 -k 16 -k 17 -k 18 -k 19 -k 20 -k 21 -k 22 -k 23 -k 24 -k 25 -k 26 -k 27 -k 28 -k 29 -k 30 -k 31 -k 32 -k 33 -k 34 -k 35 -k 36 -k 37 -k 38 -k 39 -k 40 -k 41 -k 42 -k 43 -k 44 -k 45 -k 46 -k 47 -k 48 -k 49 -k 50 -k 51 -k 52 -k 53 -k 54 -k 55 -k 56 -k 57 -k 58 -k 59 -k 60 -k 61 -k 62 -k 63 -k 64 -k 65 -k 66 -k 67 -k 68 -k 69 -k 70 -k 71 -k 72 -k 73 -k 74 -k 75 -k 76 -k 77 -k 78 -k 79 -k 80 -k 81 -k 82 -k 83 -k 84 -k 85 -k 86 -k 87 -k 88 -k 89 -k 90 -k 91 -k 92 -k 93 -k 94 -k 95 -k 96 -k 97 -k 98 -k 99 -k 100 -k 101 -k 102 -k 103 -k 104");mc.DeleteHistory()
self.findNestCompCtrl()
self.strCtrl =mc.rename(self.strCtrl,self.compName)
self.strCtrlDrv = mc.group(self.strCtrl,n=self.strCtrl +'_C')
self.strCtrlGrp = mc.group(self.strCtrlDrv,n=self.strCtrl +'_G')
mc.xform(self.strCtrlGrp,a=True,ws=True,t=self.jointPos)
mc.makeIdentity(self.strCtrlGrp,apply=1,t=0,r=0,s=1,n=0)
self.softSelJoint=mc.joint(self.strCtrl,p=self.jointPos,n=self.strCtrl+'_joint');mc.hide(self.softSelJoint)
self.softSelJointGrp = mc.group(self.softSelJoint,n=self.strCtrl+'_joint_G')
mc.setAttr(self.strCtrl+'.overrideEnabled',1)
mc.setAttr(self.strCtrl+'.overrideColor',13)
mc.skinCluster(self.obj,e=1,wt=0,ai=self.softSelJoint)
self.ObjSkinClusterNode=mm.eval('findRelatedSkinCluster(%s)'%('\"'+self.obj+'\"'))
for i in range(0,self.allVetices):
mc.skinPercent(self.ObjSkinClusterNode,self.obj+'.vtx['+str(i)+']',tv=[self.softSelJoint,self.weights[i]])
mc.skinCluster(self.obj,e=1,lw=1,inf=self.softSelJoint)
try:
mc.select('Master',r=1)
except:
pass
else:
mc.parent(self.strCtrlGrp,'Master')
mc.select(self.strCtrl,r=1)
def skinAs(src, dst, smooth=False):
'''
Bind a destination mesh based on the influence list and weights of the skinCluster of a source mesh.
@param src: Source mesh that will be used to determine influence list and weights of destination mesh.
@type src: str
@param dst: Destination mesh to bind based on source mesh skinCluster.
@type dst: str
@param smooth: Smooth incoming skinCluster weights for destination mesh.
@type smooth: bool
'''
# Check inputs
if not mc.objExists(src):
raise Exception('Source object "' + src + '" does not exist!')
if not mc.objExists(dst):
raise Exception('Destination object "' + dst + '" does not exist!')
# Get source skinCluster
srcSkin = findRelatedSkinCluster(src)
# Check destination skinCluster
dstSkin = findRelatedSkinCluster(dst)
# Build destination skinCluster
if not dstSkin:
dstPrefix = dst.split(':')[-1]
srcInfList = mc.skinCluster(srcSkin, q=True, inf=True)
dstSkin = mc.skinCluster(srcInfList,
dst,
toSelectedBones=True,
rui=False,
n=dstPrefix + '_skinCluster')[0]
# Copy skin weights
mc.copySkinWeights(sourceSkin=str(srcSkin),
destinationSkin=str(dstSkin),
surfaceAssociation='closestPoint',
influenceAssociation='name',
noMirror=True,
smooth=smooth)
# Return result
return dstSkin
def mirrorSkinWIP(srcGeo,
dstGeo,
axis='x',
infMethod='closest',
search='lf_',
replace='rt_',
jointList=None):
'''
'''
# ==========
# - Checks -
# ==========
# Check Source Geometry and SkinCluster
if not mc.objExists(srcGeo):
raise Exception('Source geometry "' + srcGeo + '" does not exist!')
srcSkin = findRelatedSkinCluster(srcGeo)
if not srcSkin:
raise Exception('No skinCluster found for source geometry "' + srcGeo +
'"!')
# Check Destination Geometry and SkinCluster
if not mc.objExists(dstGeo):
raise Exception('Destination geometry "' + dstGeo +
'" does not exist!')
dstSkin = findRelatedSkinCluster(dstGeo)
if not dstSkin: dstSkin = dstGeo.split(':')[-1] + '_skinCluster'
# Get Source Influence List
srcInfluenceList = mc.skinCluster(srcSkin, q=True, inf=True)
# Check Joint List
if not jointList: jointList = mc.ls(type='joint')
# ====================================
# - Build Destination Influence List -
# ====================================
# Get Destination Influence List
dstInfluenceList = []
if mc.objExists(dstSkin):
dstInfluenceList = mc.skinCluster(dstSkin, q=True, inf=True)
def xfer(srcGeom, dstGeom, smooth=False, uv=False, rui=False):
srcSkin = mel.eval('findRelatedSkinCluster("' + srcGeom + '")')
if cmds.objExists(srcSkin):
srcInfs = cmds.skinCluster(srcSkin, q=True, inf=True)
dstSkin = mel.eval('findRelatedSkinCluster("' + dstGeom + '")')
if dstSkin:
cmds.delete(dstSkin)
dstSkin = cmds.skinCluster(srcInfs,
dstGeom,
n=dstGeom + '_skinCluster',
tsb=True)[0]
if uv:
if isinstance(uv, basestring):
uvMap = uv
else:
uvMap = 'utility'
cmds.copySkinWeights(ss=srcSkin,
ds=dstSkin,
sa='closestPoint',
ia='oneToOne',
nm=True,
sm=smooth,
uvSpace=[uvMap, uvMap])
else:
cmds.copySkinWeights(ss=srcSkin,
ds=dstSkin,
sa='closestPoint',
ia='oneToOne',
nm=True,
sm=smooth)
cmds.connectAttr(srcSkin + '.skinningMethod',
dstSkin + '.skinningMethod',
f=True)
cmds.disconnectAttr(srcSkin + '.skinningMethod',
dstSkin + '.skinningMethod')
if rui:
clean(dstGeom)
return (dstSkin)
else:
return (None)
def bindGeo(cls, *args):
'''
Bind geometry with bind joints.
'''
selLs = cmds.ls(sl=True)
ctrl = selLs[0]
geoLs = selLs[1:]
crv = re.match(r'(.+)_.+_ctrl', ctrl).group(1)
bndJntRoot = crv + '_0_bnd_jnt'
bndJnts = cmds.listRelatives(bndJntRoot, ad=True, type='joint')
for geo in geoLs:
cmds.select(bndJntRoot, r=True)
cmds.select(bndJnts, add=True)
cmds.select(geo, add=True)
cmds.skinCluster(dr=4, toSelectedBones=True, bindMethod=0)
