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)