Ejemplo n.º 1
0
    def oneToNumberSkin(self, widget=None):
        rootName = self.skilineEdit.text()
        suitedName = self.skilineEdit2.text()

        suitedListName = suitedName.split(',')
        suitedNode = [pm.PyNode(n) for n in suitedListName]

        rootSki = self.getSkinCluste(pm.PyNode(rootName))

        for node in suitedNode:
            if rootSki:
                jointlist = rootSki.getInfluence()
                if not self.getSkinCluste(node):
                    s = pm.skinCluster(jointlist, node, dr=4.5)
                    pm.copySkinWeights(ss=rootSki,
                                       ds=s,
                                       noMirror=True,
                                       sa='closestPoint',
                                       ia='closestJoint')
                else:
                    s = self.getSkinCluste(node)
                    pm.copySkinWeights(ss=rootSki,
                                       ds=s,
                                       noMirror=True,
                                       sa='closestPoint',
                                       ia='closestJoint')

        widget.reject()
Ejemplo n.º 2
0
    def copy_weights(self, from_this, to_this):

        try:
            # skin = current_skin_host.inputs(type='skinCluster')[0]
            skin = pm.PyNode(pm.mel.findRelatedSkinCluster(from_this.name()))

        except:
            # -- If there is no skin cluster we skip this step (this is
            # -- useful whilst progressively building
            return

        # -- Get a list of the influence objects being used
        # -- by the skin currently
        influences = skin.influenceObjects()

        # -- Apply a new skin cluster
        new_skin = pm.skinCluster(
            influences,
            to_this,
            toSelectedBones=True,
            maximumInfluences=skin.getMaximumInfluences())

        # -- Copy the skin weights between them
        pm.copySkinWeights(
            sourceSkin=skin,
            destinationSkin=new_skin,
            noMirror=True,
            surfaceAssociation='closestPoint',
            influenceAssociation=['name', 'closestJoint', 'label'],
        )
Ejemplo n.º 3
0
    def run(self, current_skin_host=None, target=None):

        # -- Get our mesh candidates
        current_skin_host = pm.selected()[0]
        target = pm.selected()[1]

        # -- Look for the mesh
        log.debug(current_skin_host.inputs())

        # skin = current_skin_host.inputs(type='skinCluster')[0]
        skin = pm.PyNode(pm.mel.findRelatedSkinCluster(current_skin_host))

        # -- Get a list of the influence objects being used
        # -- by the skin currently
        influences = skin.influenceObjects()

        # -- Apply a new skin cluster
        new_skin = pm.skinCluster(
            influences,
            target,
            toSelectedBones=True,
            maximumInfluences=skin.getMaximumInfluences())

        # -- Copy the skin weights between them
        pm.copySkinWeights(
            sourceSkin=skin,
            destinationSkin=new_skin,
            noMirror=True,
            surfaceAssociation='closestPoint',
            influenceAssociation=['name', 'closestJoint', 'label'],
        )
Ejemplo n.º 4
0
def batchCovert():
	sels = pm.selected()
	if sels:
		for sel in sels:
			if sel.getShape().type() == 'mesh':
				originNode = sel
				originShapeNodes = originNode.getShapes()
				pm.select(cl=True)
				if originShapeNodes:
					originShapeNode = originShapeNodes[0]
					historyNodes = originShapeNode.listHistory()
					if historyNodes:
						influenceJoints = []
						for node in historyNodes:
							if node.type() == 'joint':
								influenceJoints.append(node)
						tempNode = pm.duplicate(originNode,name=originNode+'_temp')[0]
						pm.setAttr(tempNode+'.visibility',0)
						pm.select(influenceJoints,r=True)
						pm.select(tempNode,add=True)
						pm.skinCluster(name=tempNode.name()+'_skinCluster',toSelectedBones=True,maximumInfluences=5,dropoffRate=4)
						pm.copySkinWeights(originNode,tempNode,noMirror=True,surfaceAssociation='closestPoint',influenceAssociation='closestJoint',normalize=True)
						pm.deltaMushToSkinCluster(source=originShapeNode.name(),target=tempNode.getShape().name())
						pm.copySkinWeights(tempNode,originNode,noMirror=True,surfaceAssociation='closestPoint',influenceAssociation='closestJoint')
						pm.delete(tempNode)
	else:
		pm.displayWarning('Please select polygon object!')
Ejemplo n.º 5
0
def retargetSkin(meshes=None):
    """
    Creates new meshes retargeted to the root skeleton.
    
    Args:
        meshes(list): A list of meshes, defaults to the current selection. 
    """
    meshes = meshes or pmc.selected()
    meshes = getMeshes(meshes)

    newMeshes = []
    for srcMesh in meshes:
        # Create a duplicate mesh
        dstParent = pmc.duplicate(srcMesh.getParent())
        pmc.parent(dstParent, world=True)

        # Copy the skinning
        srcCluster = pmc.ls(srcMesh.listHistory(), type='skinCluster')[0]
        dstCluster = pmc.skinCluster(dstParent, getBindSkeleton(), mi=4, tsb=True)
        pmc.copySkinWeights(ss=srcCluster, ds=dstCluster, noMirror=True)
        newMeshes.append(dstParent)

    # If more than one mesh selected, combine meshes
    if len(newMeshes) > 1:
        newMesh, newCluster = pmc.polyUniteSkinned(newMeshes, ch=False)
        pmc.delete(newMeshes)
        pmc.rename(newMesh, 'body')

    bindRootSkeleton()
Ejemplo n.º 6
0
 def copy_skin(self, *args):
     """
     Copy's the skinning between different meshes
     only by providing the meshes.\n
     :args[0] the source mehs, this geo \n
     :args[1:] the destination  mehs where the skin will be copied\n
     :return a list with all the skin clusters that where created during execution
     """
     source = args[0]
     destination = args[1:]
     skin_cluster_node = self.get_skin_cluster(source)
     skin_cluster_list = []
     if skin_cluster_node:
         list_joints = skin_cluster_node.influenceObjects()
         if destination:
             for each_node in destination:
                 new_skin_cluster = pm.skinCluster(list_joints, each_node)
                 skin_cluster_list.append(new_skin_cluster)
                 self.name_convention.rename_name_in_format(
                     new_skin_cluster,
                     name=self.name_convention.get_a_short_name(each_node))
                 pm.copySkinWeights(source,
                                    destination,
                                    influenceAssociation=[
                                        'label', 'name', 'closestJoint',
                                        'oneToOne'
                                    ])
     return new_skin_cluster
Ejemplo n.º 7
0
def mirror_eyeCurve_weights():
    '''
    mirror LT_eye_aimAt_crv_0 to RT_eye_aimAt_crv_0
    '''
    lf_crv = nt.Transform(u'LT_eye_aimAt_crv_0')
    rt_crv = nt.Transform(u'RT_eye_aimAt_crv_0')
    lf_skn = pm.PyNode(mel.findRelatedSkinCluster(lf_crv))
    rt_skn = pm.PyNode(mel.findRelatedSkinCluster(rt_crv))

    def setEyeJointsLabels(joints):
        for jnt in joints:
            ### change the label

            label = '_'.join(jnt.name().split('_')[1:3])
            #label = '_'.join(jnt.name().split('_')[1:4])
            jnt.attr('type').set('Other')
            jnt.otherType.set(label)

    lf_infs = pm.skinCluster(lf_crv, q=True, inf=True)
    setEyeJointsLabels(lf_infs)

    rt_infs = pm.skinCluster(rt_crv, q=True, inf=True)
    setEyeJointsLabels(rt_infs)

    lf_crv.sx.setLocked(False)
    lf_crv.sx.set(-1)

    pm.copySkinWeights(ss=lf_skn,
                       ds=rt_skn,
                       sa='closestPoint',
                       ia='label',
                       nm=True)

    lf_crv.sx.set(1)
Ejemplo n.º 8
0
def mirror_eyeCurve_weights():
    """
    mirror LT_eye_aimAt_crv_0 to RT_eye_aimAt_crv_0
    """
    lf_crv = nt.Transform(u"LT_eye_aimAt_crv_0")
    rt_crv = nt.Transform(u"RT_eye_aimAt_crv_0")
    lf_skn = pm.PyNode(mel.findRelatedSkinCluster(lf_crv))
    rt_skn = pm.PyNode(mel.findRelatedSkinCluster(rt_crv))

    def setEyeJointsLabels(joints):
        for jnt in joints:
            ### change the label

            label = "_".join(jnt.name().split("_")[1:3])
            # label = '_'.join(jnt.name().split('_')[1:4])
            jnt.attr("type").set("Other")
            jnt.otherType.set(label)

    lf_infs = pm.skinCluster(lf_crv, q=True, inf=True)
    setEyeJointsLabels(lf_infs)

    rt_infs = pm.skinCluster(rt_crv, q=True, inf=True)
    setEyeJointsLabels(rt_infs)

    lf_crv.sx.setLocked(False)
    lf_crv.sx.set(-1)

    pm.copySkinWeights(ss=lf_skn, ds=rt_skn, sa="closestPoint", ia="label", nm=True)

    lf_crv.sx.set(1)
Ejemplo n.º 9
0
    def copySkin(skinedMesh, mesh):
        """
        Copy skin cluster from a skined mesh
        """
        # Checks nodetypes
        if not isinstance(skinedMesh, pm.nodetypes.Transform):
            skinedMesh = pm.PyNode(skinedMesh)
        if not isinstance(mesh, pm.nodetypes.Transform):
            mesh = pm.PyNode(mesh)

        # get shape
        skinedMeshShape = skinedMesh.getShape()

        # loop since a skin cluster are found
        skinCluster = pm.listHistory(skinedMeshShape, type='skinCluster')[0]
        # skinCluster = pm.PyNode(skinCluster)
        skinInf = skinCluster.maxInfluences.get()

        # joint list
        jointList = skinCluster.influenceObjects()

        # create skinCluster
        copySkinCluster = pm.skinCluster(mesh, jointList, mi=skinInf)
        print copySkinCluster
        # copy skin weigths
        pm.copySkinWeights(ss=skinCluster,
                           ds=copySkinCluster,
                           noMirror=True,
                           surfaceAssociation='closestPoint',
                           influenceAssociation=('closestJoint',
                                                 'closestJoint'))
Ejemplo n.º 10
0
def copyBind(source, destination, sa='closestPoint', ia='closestJoint'):
    """
    Bind and Copy skincluster to destination GEO
    :param source: mesh str
    :param destination: mesh str
    :return: 
    """
    # Get Shape and skin from Object
    skinCluster = findRelatedSkinCluster(source)
    if skinCluster:
        skin = skinCluster
    else:
        print 'Missing source SkinCluster'

    # Get joint influence of the skin
    influnces = skin.getInfluence(q=True)  # influences is joint

    # Bind destination Mesh
    # pm.select(influnces[0])
    # pm.select(destination, add=True)
    # mel.eval('SmoothBindSkin;')
    pm.skinCluster(influnces[0], destination, dr=4.0)

    # copy skin wheights form source
    pm.select(source)
    pm.select(destination, add=True)
    pm.copySkinWeights(noMirror=True, surfaceAssociation=sa, influenceAssociation=ia)
    pm.select(cl=True)
Ejemplo n.º 11
0
def skinCopy(sourceMesh=None, targetMesh=None, *args):
    if not sourceMesh or not targetMesh:
        if len(pm.selected()) >=2:
            sourceMesh = pm.selected()[-1]
            targetMeshes = pm.selected()[:-1]
        else:
            pm.displayWarning("Please select target mesh/meshes and source mesh with skinCluster.")
            return
    else:
        targetMeshes = [targetMesh]

        #we check this here, because if not need to check when we work base on selection.
        if isinstance(sourceMesh, basestring):
            sourceMesh = pm.PyNode(sourceMesh)

    for targetMesh in targetMeshes:
        if  isinstance(targetMesh, basestring):
            sourceMesh = pm.PyNode(targetMesh)

        ss = getSkinCluster(sourceMesh)

        if ss:
            oDef = pm.skinCluster(sourceMesh, query=True, influence=True)
            skinCluster = pm.skinCluster(oDef, targetMesh, tsb=True, nw=2, n=targetMesh.name() + "_SkinCluster")
            pm.copySkinWeights( ss=ss.stripNamespace(), ds=skinCluster.name(), noMirror=True, ia="oneToOne", sm=True, nr=True)
        else:
            pm.displayError("Source Mesh :" + sourceMesh.name() + " Don't have skinCluster")
Ejemplo n.º 12
0
def shadowMesh(triCount=10000):
    meshArg = pm.ls(sl=True)
    meshList = pm.duplicate(meshArg, rr=True)
    shadowGeo = pm.polyUnite(meshList, ch=False, name='ShadowGeo')[0]
    pm.delete(meshList)  #deleting leftover garbage transform nodes
    pm.parent(shadowGeo, 'CharaA')

    newSkinClust = pm.skinCluster(
        shadowGeo, pm.listRelatives('CharaA', ad=True,
                                    type='joint'))  #skinning begins

    pm.select(meshArg)
    pm.select(shadowGeo, add=True)
    pm.copySkinWeights(
        noMirror=True,
        surfaceAssociation='closestPoint',
        influenceAssociation='closestJoint')  #copying skin weights
    pm.selectMode(o=True)
    #shadowmesh starts here
    pm.select(shadowGeo)
    mel.eval(
        'polyCleanupArgList 3 { "0","1","1","0","0","0","0","0","0","1e-005","0","1e-005","0","1e-005","0","1","0" };'
    )  #clean up before reduction
    pm.selectMode(o=True)
    #reduce polycount to fall under budget
    pm.polyReduce(shadowGeo,
                  ver=1,
                  trm=2,
                  triangleCount=triCount,
                  sharpness=0,
                  keepBorder=1,
                  keepColorBorder=1,
                  keepFaceGroupBorder=1,
                  keepHardEdge=1,
                  keepCreaseEdge=1,
                  keepBorderWeight=0.5,
                  keepMapBorderWeight=0,
                  keepColorBorderWeight=0,
                  keepFaceGroupBorderWeight=0,
                  keepHardEdgeWeight=0.25,
                  keepCreaseEdgeWeight=0,
                  useVirtualSymmetry=0,
                  symmetryTolerance=0.01,
                  sx=0,
                  sy=1,
                  sz=0,
                  sw=0,
                  preserveTopology=1,
                  keepQuadsWeight=1,
                  vertexMapName="",
                  replaceOriginal=1,
                  cachingReduce=1,
                  constructionHistory=1)
    pm.select(deselect=True)
    pm.bakePartialHistory(shadowGeo, prePostDeformers=True, preDeformers=True)
    pm.select(shadowGeo)
    print('EKKO shadowMesh successful!\nShadow Mesh specs:')
    print(pm.polyEvaluate(shadowGeo, fmt=True))
Ejemplo n.º 13
0
    def transfer_deformer_weights(self, geo_source, geo_target=None, deformer_source=None, deformer_target=None,
                                  surface_association="closestPoint"):
        """
        Copies the weight map of a deformer of an object to the deformer of another object.
        :param geo_source: Source Shape
        :param geo_target: Target Shape
        :param deformer_source: Source Deformer
        :param deformer_target: Target Deformer
        :param surface_association: Surface Association. Valid values: closestPoint, rayCast, or closestComponent.
        """
        assert geo_source and deformer_source and deformer_target, \
            "select a source and target geometry and then the source and target deformers"

        previous_selection = pm.selected()

        if not geo_target:
            geo_target = geo_source

        self.progress_bar_init()
        self.progress_bar_next()

        deformer_source_weights = deformer_source.weightList[0].weights.get()

        self.progress_bar_next()
        tmp_source = pm.duplicate(geo_source)[0]
        tmp_target = pm.duplicate(geo_target)[0]
        tmp_source.v.set(True)
        tmp_target.v.set(True)

        self.progress_bar_next()
        pm.select(clear=True)
        l_jnt = list()
        l_jnt.append(pm.joint(n="jnt_tmpA_01", p=[0, 0, 0]))
        l_jnt.append(pm.joint(n="jnt_tmpA_02", p=[0, 1, 0]))
        skin_source = pm.skinCluster(l_jnt, tmp_source, nw=1)
        skin_target = pm.skinCluster(l_jnt, tmp_target, nw=1)

        self.progress_bar_next()
        skin_source.setNormalizeWeights(0)
        pm.skinPercent(skin_source, tmp_source, nrm=False, prw=100)
        skin_source.setNormalizeWeights(True)
        [pm.setAttr('{}.wl[{}].w[{}]'.format(skin_source, i, 0), value) for i, value in enumerate(deformer_source_weights)]
        [pm.setAttr('{}.wl[{}].w[{}]'.format(skin_source, i, 1), 1.0 - value) for i, value in enumerate(deformer_source_weights)]

        self.progress_bar_next()
        pm.copySkinWeights(ss=skin_source, ds=skin_target, nm=True, sa=surface_association)

        self.progress_bar_next()
        deformer_target_weights = [v for v in skin_target.getWeights(tmp_target, 0)]
        [deformer_target.weightList[0].weights[i].set(val) for i, val in enumerate(deformer_target_weights)]

        self.progress_bar_next()
        pm.delete([tmp_source, tmp_target, l_jnt])
        pm.select(previous_selection)

        self.progress_bar_next()
        self.progress_bar_ends(message="Finished successfully!")
Ejemplo n.º 14
0
def copy_weights(source_mesh, target_nodes, **copySkinWeights_kwargs):
    """Copies weights using pm.copySkinWeights with the most commonly used default kwargs.
    target_nodes can be a single skinned mesh or vertex or it can be a list of vertices.
    """
    default_copySkinWeightsKwargs = {'noMirror': True,
                                     'surfaceAssociation': 'closestPoint',
                                     'influenceAssociation': ('label', 'name', 'closestJoint'),
                                     'normalize': True}
    default_copySkinWeightsKwargs.update(copySkinWeights_kwargs)
    pm.copySkinWeights(source_mesh, target_nodes, **default_copySkinWeightsKwargs)
Ejemplo n.º 15
0
def copy_skin_binding(source_object, destination_object):
    skin_cluster = get_skinCluster(source_object)
    if skin_cluster:
        skin_joints = skin_cluster.influenceObjects()
        dest_skin = get_skinCluster(destination_object)
        if dest_skin:
            pm.delete(dest_skin)
        new_skin = pm.skinCluster(skin_joints, destination_object, bindMethod=0, toSelectedBones=True)
        pm.copySkinWeights(sourceSkin=skin_cluster, destinationSkin=new_skin, surfaceAssociation='closestPoint',
                           influenceAssociation=['label', 'name', 'oneToOne'],
                           noMirror=True)
    print '%s -> %s\n' % (source_object, destination_object)
Ejemplo n.º 16
0
def copySkinWeightBetweenMesh(selection=pm.ls(sl=True)):
    """
    Copy skin weight to mirrored mesh
    """

    sourceMesh = selection[0]
    destinationMesh = selection[1]

    sourceSkinCluster = mel.eval('findRelatedSkinCluster ' + sourceMesh)
    destinationSkinCluster = mel.eval('findRelatedSkinCluster ' + destinationMesh)

    pm.copySkinWeights(ss=sourceSkinCluster, ds=destinationSkinCluster, mirrorMode='YZ',
                       surfaceAssociation='closestPoint', influenceAssociation='closestJoint')
Ejemplo n.º 17
0
def SkinCopy(SEL):
    for a in SEL[1:]:
        pm.select(a)
        pm.select(jntList, add=1)
        pm.skinCluster(toSelectedBones=1,
                       bindMethod=0,
                       normalizeWeights=1,
                       mi=10,
                       omi=1,
                       dr=10,
                       sm=SknMthd)
        pm.select(SEL[0])
        pm.select(a, add=1)
        pm.copySkinWeights(noMirror=1, surfaceAssociation='closestPoint')
Ejemplo n.º 18
0
 def copy_weights(self, newTarget):
     '''@brief Additional function to copy weights from the source geometry to a new one.@details This new geometry will be skinned with the same influence joints.
     @code
     test = libWeights.SkinWeights()
     #Set the target geometry
     test.target = "pCube1"
     #copy the weights to the new gometery
     test.copy_weights("pCube2")
     @endcode
     '''
     currentInfluences = pm.skinCluster(self.target_deformer, inf=True, q=True)
     res = libUtilities.skinGeo(newTarget, currentInfluences)
     # Transfer the weights
     pm.copySkinWeights(ss=self.target_deformer, ds=res, noMirror=True, surfaceAssociation="rayCast",
                        influenceAssociation="closestJoint")
Ejemplo n.º 19
0
def copySkinRUI():
    sel = pm.ls(sl=1)
    if sel:
        source = sel[0]
        dest = sel[1:]

        for d in dest:
            pm.copySkinWeights(source,
                               d,
                               noMirror=True,
                               surfaceAssociation='closestPoint',
                               influenceAssociation='oneToOne')

        pm.select(sel[1:])
        mel.eval('removeUnusedInfluences')
Ejemplo n.º 20
0
def copyWeights(sourceMesh, destMesh):
    '''
    Select skinned mesh then non-skinned mesh and run: copyWeights(pmc.selected()[0], pmc.selected()[1])
    '''

    sourceSkin = [
        x for x in pmc.listHistory(sourceMesh)
        if pmc.nodeType(x) == "skinCluster"
    ][0]
    influences = pmc.skinCluster(sourceMesh, q=1, influence=1)
    pmc.select(influences)

    destSkin = pmc.skinCluster(influences, destMesh)
    pmc.copySkinWeights(ss=sourceSkin.name(),
                        ds=destSkin.name(),
                        noMirror=True)
Ejemplo n.º 21
0
 def copy_weights(self, newTarget):
     '''@brief Additional function to copy weights from the source geometry to a new one.
     @details This new geometry will be skinned with the same influence joints.
     @code
     test = libWeights.SkinWeights()
     #Set the target geometry
     test.target = "pCube1"
     #copy the weights to the new gometery
     test.copy_weights("pCube2")
     @endcode
     '''
     currentInfluences = pm.skinCluster(self.target_deformer, inf=True, q=True)
     res = libUtilities.skinGeo(newTarget, currentInfluences)
     # Transfer the weights
     pm.copySkinWeights(ss=self.target_deformer, ds=res, noMirror=True, surfaceAssociation="rayCast",
                        influenceAssociation="closestJoint")
Ejemplo n.º 22
0
def copy_skin_binding_structure(source, destination):
    match_structure = []
    # analysis.Main(source, destination)
    from pprint import pprint as pp
    pp(match_structure)
    done = 'coping from to:\n'
    for each_object in match_structure.match_dictionary:
        skin_cluster = get_skinCluster(each_object)
        if skin_cluster:
            skin_joints = skin_cluster.influenceObjects()
            new_skin = pm.skinCluster(skin_joints, match_structure.match_dictionary[each_object],
                                      bindMethod=0, toSelectedBones=True)
            pm.copySkinWeights(sourceSkin=skin_cluster, destinationSkin=new_skin, surfaceAssociation='closestPoint',
                               noMirror=True)
            done += '%s -> %s\n' % (each_object, match_structure.match_dictionary[each_object])
    print done
Ejemplo n.º 23
0
def mirror_transfer_skin_weights():
    """
    Helper function to mirror weights from two pieces of geo that are separate.
    Selection order: This -> That
    """
    user_sel = pm.ls(sl=True)

    # TODO: More robust way of finding from and to objects.
    from_object = user_sel[0]
    to_object = pm.PyNode(from_object.replace('_L', '_R'))

    # If the to object has no skin cluster, add one best we can.
    bind_mirror_weights(from_object, to_object)

    # Duplicate and combine the pieces
    duplicate_pieces = pm.duplicate([from_object, to_object])
    combined_geo, _ = pm.polyUnite(*duplicate_pieces,
                                   ch=1,
                                   mergeUVSets=1,
                                   centerPivot=True,
                                   name='TEMP_combined_mirror_geo')

    # Delete history
    pm.delete(combined_geo, constructionHistory=True)

    skin_cluster = copy_skin_influence(from_object, combined_geo)

    # Mirroring the skin cluster
    pm.copySkinWeights(ss=skin_cluster,
                       ds=skin_cluster,
                       mirrorMode='YZ',
                       surfaceAssociation='closestPoint',
                       influenceAssociation='closestJoint')

    # Final copy skin weights to target geo
    pm.copySkinWeights(combined_geo,
                       to_object,
                       noMirror=True,
                       surfaceAssociation='closestPoint',
                       influenceAssociation='closestJoint')

    # Cleanup
    pm.delete(combined_geo)
    pm.delete(duplicate_pieces)
    pm.select(user_sel, r=True)
    print('Copying Complete!')
Ejemplo n.º 24
0
def SkinCopy(SEL):
    BaseMod = SEL[0]
    TargetMod = SEL[1]
    skinClst = BaseMod.listHistory(type='skinCluster')
    if skinClst:
        skinJnt = pm.skinCluster(skinClst[0], query=True, inf=True)
        skinMhod = pm.getAttr(skinClst[0] + ".skinningMethod")
        pm.select(TargetMod, skinJnt)
        pm.skinCluster(sm=skinMhod, tsb=True)
        pm.copySkinWeights(BaseMod,
                           TargetMod,
                           nm=True,
                           sa="closestPoint",
                           ia="oneToOne")
    else:
        pass
    pm.select(cl=True)
Ejemplo n.º 25
0
def transfertSkinCluster():
    oOldSelection = pm.selected()
    _oSource = [oOldSelection[0]]
    _oTarget = oOldSelection[1:]
    oJoints = []
    #Check if there a source mesh
    if len(_oSource) < 1:
        pm.displayWarning('You need to have a source mesh')
    elif len(_oTarget) < 1:
        pm.displayWarning('You need to have a target mesh')
    else:
        #Check if there a skinCluster on the mesh. And add joints of the skinCluster to the lists
        try:
            oJoints.extend(pm.skinCluster(_oSource, query=True,
                                          influence=True))
        except:
            print "Exception: it doesn't appear to have a skinCluster."
        #Warnings : check if in the lists oJoints there's objects that are not joints
        oJointSkin = []
        for o in oJoints:
            if pm.nodeType(o) == 'joint':
                oJointSkin.append(o)
            else:
                pm.warning(
                    "removed the influence of {0} beacuse it's not a joint type object"
                    .format(o))

        #Getting skinCluster from the source mesh
        oSkinClusterSource = GetSkinCluster(_oSource[0])

        #Skin the new mesh and copy weight from the source mesh
        for each in _oTarget:
            print each
            pm.select(clear=True)
            pm.select(oJointSkin)
            pm.select(each, add=True)
            oNewSkinCluster = pm.skinCluster(toSelectedBones=True)
            print 'Transfert DONE'
            pm.copySkinWeights(sourceSkin=oSkinClusterSource,
                               destinationSkin=oNewSkinCluster,
                               influenceAssociation='oneToOne',
                               noMirror=True)
            print 'copy weight DONE'

    pm.select(oOldSelection)
Ejemplo n.º 26
0
def copy_skin_influence(from_obj, to_obj):
    """
    Copy Joint influence and skin weights form one object ot another.

    :param PyNode from_obj: Object to copy weights from.
    :param PyNode to_obj: Object to copy weights to.
    :return: The created skin cluster
    :rtype: PyNode
    """
    skinned_joints = pm.skinCluster(from_obj, query=True, influence=True)
    result_skin = pm.skinCluster(skinned_joints, to_obj)
    pm.copySkinWeights(from_obj,
                       to_obj,
                       noMirror=True,
                       surfaceAssociation='closestPoint',
                       influenceAssociation='closestJoint')

    return result_skin
Ejemplo n.º 27
0
def skinCopy(sourceMesh=None, targetMesh=None, *args):
    if not sourceMesh or not targetMesh:
        if len(pm.selected()) >= 2:
            sourceMesh = pm.selected()[-1]
            targetMeshes = pm.selected()[:-1]
        else:
            pm.displayWarning("Please select target mesh/meshes and source "
                              "mesh with skinCluster.")
            return
    else:
        targetMeshes = [targetMesh]

        # we check this here, because if not need to check when we work
        # base on selection.
        if isinstance(sourceMesh, basestring):
            sourceMesh = pm.PyNode(sourceMesh)

    for targetMesh in targetMeshes:
        if isinstance(targetMesh, basestring):
            sourceMesh = pm.PyNode(targetMesh)

        ss = getSkinCluster(sourceMesh)

        if ss:
            skinMethod = ss.skinningMethod.get()
            oDef = pm.skinCluster(sourceMesh, query=True, influence=True)
            # strip | from longName, or skinCluster command may fail.
            skinName = targetMesh.name().replace('|','') + "_SkinCluster"
            skinCluster = pm.skinCluster(oDef,
                                         targetMesh,
                                         tsb=True,
                                         nw=1,
                                         n=targetMesh.name() + "_SkinCluster")
            pm.copySkinWeights(sourceSkin=ss.stripNamespace(),
                               destinationSkin=skinCluster.name(),
                               noMirror=True,
                               influenceAssociation="oneToOne",
                               smooth=True,
                               normalize=True)
            skinCluster.skinningMethod.set(skinMethod)
        else:
            errorMsg = "Source Mesh : {} doesn't have a skinCluster."
            pm.displayError(errorMsg.format(sourceMesh.name()))
Ejemplo n.º 28
0
def mirror_skinBinding(scene_objects):
    for each_object in scene_objects:
        current_tokens = each_object.split('_')
        if current_tokens[0] in ['FR', 'MR', 'BR', 'R']:
            mirror_inverse = True
        else:
            mirror_inverse = False

        skin_cluster = get_skinCluster(each_object)
        if skin_cluster:
            skin_joints = get_oposite(skin_cluster.influenceObjects())
            oposite_object = get_oposite(each_object)
            if not get_skinCluster(oposite_object):
                destination_skin_cluster = pm.skinCluster(skin_joints, oposite_object, bindMethod=0, toSelectedBones=True)
                pm.copySkinWeights(ss=skin_cluster, ds=destination_skin_cluster, mirrorMode='YZ',
                                   influenceAssociation='oneToOne', mirrorInverse=mirror_inverse)
                destination_skin_cluster.skinningMethod.set(skin_cluster.skinningMethod.get())
            else:
                print 'object %s not processed, already skin cluster attached' % oposite_object
Ejemplo n.º 29
0
def copySkinWeights_old( objs ):
    '''weightTransfer('skin_mesh', cmds.ls(sl=True) )'''
    skinDataObj = objs[0]
    targetObjs  = [pm.PyNode( obj ) for obj in objs[1:]]

    sourceSkin = pm.mel.findRelatedSkinCluster( skinDataObj )
    for i ,mesh in enumerate( targetObjs ):
        destinationSkin = pm.mel.findRelatedSkinCluster( mesh )
        try:
            pm.copySkinWeights(
                ss=sourceSkin,
                ds=destinationSkin,
                noMirror=True,
                surfaceAssociation='closestPoint',
                influenceAssociation=['closestJoint', 'closestBone', 'oneToOne']
                )
            print 'copySkinWeights (%d/%d): "%s" --> "%s"'%( i+1, len(targetObjs), skinDataObj, mesh )

        except :
            print 'copySkinWeights Fail (%d/%d): "%s" --> "%s"'%( i+1, len(targetObjs), skinDataObj, mesh )
Ejemplo n.º 30
0
def copy_mirror_skin_binding(source, destination):
    """
    :param source: the source object from where the skinning will be copied
    :param destination:
    :return:
    """
    mirror_inverse = True
    print 'copying from {} to {}'.format(source, destination)
    skin_cluster = get_skinCluster(source)
    if skin_cluster:
        skinJoints = get_oposite(skin_cluster.influenceObjects())
        oposite_object = destination
        if not get_skinCluster(oposite_object):
            destination_skinCluster = pm.skinCluster(skinJoints, oposite_object, bindMethod=0, toSelectedBones=True)
            pm.copySkinWeights(ss=skin_cluster, ds=destination_skinCluster, mirrorMode='YZ',
                               influenceAssociation='oneToOne', mirrorInverse=mirror_inverse)
            destination_skinCluster.skinningMethod.set(skin_cluster.skinningMethod.get())
        else:
            print 'object %s not processed, allready skin cluster attached' % oposite_object
    else:
        print'didnt find skinCluster in source object'
Ejemplo n.º 31
0
def transfer_skincluster(source_object, target_objects, prune_after=False):
    """Bind the target objects based on source object,
    then copied the skin data from source to target objects.
    If target object have skincluster,
    it will get replaced by new skincluster.

    :arg source_object: PyNode object transfer source.
    :type source_object: pm.PyNode
    :arg target_objects: PyNode objects transfer destination.
    :type target_objects: list of pm.PyNode
    :key prune_after: Do prune operation after transfer skincluster or not.
    :type prune_after: bool
    :rtype: None
    """
    source_skin_node = get_skincluster_node(source_object)
    assert source_skin_node, 'Skincluster not found in source object.'
    skin_info = get_skincluster_info(source_skin_node)
    joint_list = skin_info['joint_list']
    skin_method = skin_info['skin_method']
    for tgt_obj in target_objects:
        old_tgt_skin_node = get_skincluster_node(tgt_obj)
        if old_tgt_skin_node:
            old_tgt_skin_node.unbind()
        try:
            tgt_skin_node = pm.skinCluster(joint_list,
                                           tgt_obj,
                                           skinMethod=skin_method)
        except:
            tgt_skin_node = pm.skinCluster(joint_list, tgt_obj)
        pm.copySkinWeights(
            sourceSkin=source_skin_node,
            destinationSkin=tgt_skin_node,
            noMirror=True,
            surfaceAssociation='closestPoint',
            influenceAssociation=['name', 'oneToOne', 'closestJoint'],
        )
        remove_unused_influence(tgt_skin_node)

        if prune_after:
            prune_skincluster(tgt_skin_node)
Ejemplo n.º 32
0
    def copySkin(cls, skin_from, skin_to):

        """
        !@Brief Copy Skin with point of shape.
        CopySkin of maya doesn't really works with different shape.

        :type skin_from: pymel.core.nodetypes.Transform / shape / SkinCluster
        :param skin_from: Maya node reference for copy skin
        :type skin_to: pymel.core.nodetypes.Transform / shape / SkinCluster
        :param skin_to: Maya node to copy skin.

        :rtype: bool
        :return: True if copy skin is finish.
        """

        #   Get skin Cluster
        from_node = pmc.listHistory(skin_from, type="skinCluster")[0]
        to_node = pmc.listHistory(skin_to, type="skinCluster")

        #   If to node is None add Skin cluster from from_node
        if not to_node:
            to_node = cls.skinFromOther(from_node, skin_to)
        else:
            to_node = to_node[0]

        #   Check two skin in case
        cls.checkTwoSkin(from_node, to_node)

        #   CopySkin
        pmc.copySkinWeights(
            node_utils.getPointName(skin_from),
            node_utils.getPointName(skin_to),
            sourceSkin=from_node.name(),
            destinationSkin=to_node.name(),
            noMirror=True,
            surfaceAssociation="closestComponent",
            influenceAssociation="oneToOne"
        )
Ejemplo n.º 33
0
def matchSkinning():
    """Select a skin mesh, followed the mesh you wish to match skinning to."""

    source, target = pm.ls(sl=1,type='transform')

    src_cluster = source.listHistory(type='skinCluster')[0]
    influences = src_cluster.influenceObjects()

    pm.select(influences, r=1 )
    pm.select(target, add=1)

    pm.skinCluster(toSelectedBones=1,
                   obeyMaxInfluences=src_cluster.getObeyMaxInfluences(),
                   maximumInfluences=src_cluster.getMaximumInfluences(),
                   dropoffRate=2,
                   removeUnusedInfluence=False
                   )

    tgt_cluster = target.listHistory(type='skinCluster')[0]

    pm.copySkinWeights( ss=src_cluster, ds=tgt_cluster, noMirror=True )

    pm.select(target, replace=1)
def transfer_deformer_weights(geo_source,
                              geo_target=None,
                              deformer_source=None,
                              deformer_target=None,
                              surface_association="closestPoint",
                              interface=None):
    """
    Copies the weight map of a deformer of an object to the deformer of another object.
    :param geo_source: Source Shape
    :param geo_target: Target Shape
    :param deformer_source: Source Deformer
    :param deformer_target: Target Deformer
    :param surface_association: Surface Association. Valid values: closestPoint, rayCast, or closestComponent.
    :param interface: Copy of class CopyDeformerWeightsUI
    """
    assert geo_source and deformer_source and deformer_target, \
        "select a source and target geometry and then the source and target deformers"

    previous_selection = pm.selected()

    if not geo_target:
        geo_target = geo_source

    if interface:
        interface.progress_bar_init()
        interface.progress_bar_next()

    source_weight_list = get_weight_list(deformer_source, geo_source)
    if not source_weight_list:
        pm.warning(
            "The deformer {} does not have the weight list for {}".format(
                deformer_source, geo_source))
        if interface:
            interface.progress_bar_ends(message="Finished with errors!")
        return

    target_weight_list = get_weight_list(deformer_target, geo_target)
    if not target_weight_list:
        pm.warning(
            "The deformer {} does not have the weight list for {}".format(
                deformer_target, geo_target))
        if interface:
            interface.progress_bar_ends(message="Finished with errors!")
        return

    initialize_weight_list(target_weight_list, geo_target)

    if interface: interface.progress_bar_next()
    tmp_source = pm.duplicate(geo_source)[0]
    tmp_target = pm.duplicate(geo_target)[0]
    pm.rename(tmp_source, tmp_source.nodeName() + "_cdw_DUP")
    pm.rename(tmp_target, tmp_target.nodeName() + "_cdw_DUP")
    tmp_source.v.set(True)
    tmp_target.v.set(True)

    if interface: interface.progress_bar_next()
    pm.select(clear=True)
    l_jnt = list()
    l_jnt.append(pm.joint(n="jnt_tmpA_01", p=[0, 0, 0]))
    l_jnt.append(pm.joint(n="jnt_tmpA_02", p=[0, 1, 0]))
    skin_source = pm.skinCluster(l_jnt, tmp_source, nw=1)
    skin_target = pm.skinCluster(l_jnt, tmp_target, nw=1)

    if interface: interface.progress_bar_next()
    skin_source.setNormalizeWeights(0)
    pm.skinPercent(skin_source, tmp_source, nrm=False, prw=100)
    skin_source.setNormalizeWeights(True)
    n_points = len(geo_source.getShape().getPoints())
    if deformer_source.type() == "blendShape":
        [
            skin_source.wl[i].w[0].set(source_weight_list.baseWeights[i].get())
            for i in range(n_points)
        ]
        [
            skin_source.wl[i].w[1].set(1.0 -
                                       source_weight_list.baseWeights[i].get())
            for i in range(n_points)
        ]
    else:
        [
            skin_source.wl[i].w[0].set(source_weight_list.weights[i].get())
            for i in range(n_points)
        ]
        [
            skin_source.wl[i].w[1].set(1.0 -
                                       source_weight_list.weights[i].get())
            for i in range(n_points)
        ]

    if interface: interface.progress_bar_next()
    pm.copySkinWeights(ss=skin_source,
                       ds=skin_target,
                       nm=True,
                       sa=surface_association)

    if interface: interface.progress_bar_next()
    tmp_shape = skin_target.getGeometry()[0]
    deformer_target_weights = [v for v in skin_target.getWeights(tmp_shape, 0)]
    [
        target_weight_list.weights[i].set(val)
        for i, val in enumerate(deformer_target_weights)
    ]

    if interface: interface.progress_bar_next()
    pm.delete([tmp_source, tmp_target, l_jnt])
    pm.select(previous_selection)

    if interface:
        interface.progress_bar_next()
        interface.progress_bar_ends(message="Finished successfully!")
Ejemplo n.º 35
0
def run():
	# validate that we selected 1 skinned mesh and 1 non-skinned mesh
	sel = pm.ls(sl=True)
	if len(sel)!=2:
		raise Exception("copyWeightsToFurCards: select skin mesh, shift select fur cards. Aborted.")
	#
	src_mesh_trans = sel[0]
	src_mesh_shape = pm.listRelatives(src_mesh_trans, s=True)[0]
	if type(src_mesh_shape) != pm.nodetypes.Mesh:
		raise Exception("copyWeightsToFurCards: source object must be a skinned mesh.")
	#
	fur_trans = sel[1]
	fur_shape = pm.listRelatives(fur_trans, s=True)[0]
	if type(fur_shape) != pm.nodetypes.Mesh:
		raise Exception("copyWeightsToFurCards: target object must be a mesh.")
	#
	src_skincluster = getRelatedSkinCluster(src_mesh_trans)
	if type(src_skincluster) != pm.nodetypes.SkinCluster:
		raise Exception("copyWeightsToFurCards: source mesh must have a skinCluster deformer.")
	#
	fur_skincluster = getRelatedSkinCluster(fur_trans)
	if fur_skincluster != None:
		raise Exception("copyWeightsToFurCards: target mesh must not be skinned.")

	# bind the fur cards to the same influences as the source mesh
	src_influences = src_skincluster.getInfluence()
	
	pm.select(src_influences, r=True)
	pm.select(fur_trans, add=True)
	fur_skincluster = pm.skinCluster(tsb=True)

	# copy skin weights from source to fur cards
	pm.copySkinWeights( ss=str(src_skincluster), 
						ds=str(fur_skincluster), 
						noMirror=True,
						surfaceAssociation = "closestPoint",
						influenceAssociation = "oneToOne")

	# split mesh into list of vertex lists (1 per shell)
	vertex_shells = []
	num_faces = pm.polyEvaluate(fur_trans,f=True)
	faces_checked = set(range(num_faces))
	#
	gMainProgressBar = mel.eval('$tmp = $gMainProgressBar');
	pm.progressBar( gMainProgressBar,
                    edit=True,
                    beginProgress=True,
                    isInterruptable=True,
                    status='Gathering vertex shells...',
                    maxValue=num_faces )
	#
	while len(faces_checked)>0:
		#progress
		if pm.progressBar(gMainProgressBar, query=True, isCancelled=True ) :
			return
		pm.progressBar(gMainProgressBar, edit=True, step=num_faces-len(faces_checked))

		face = faces_checked.pop()
		shell_faces = pm.polySelect( fur_trans, extendToShell=face )
		faces_checked = faces_checked.difference(shell_faces)
		face_vert_info = pm.polyInfo(faceToVertex=True)
		verts_in_shell = []
		#pm.polyInfo returns horrible unicode format that must be parsed
		for face_verts_str in face_vert_info:
			verts_str = face_verts_str.split(":")[1]
			vert_strings = verts_str.split(" ")
			for v in vert_strings:
				try:
					v_id = int(v)
					verts_in_shell.append(v_id)
				except:
					pass
		vertex_shells.append(verts_in_shell)

	# now search for closest vertex in each shell...
	sel_list = OpenMaya.MSelectionList()
	sel_list.add(str(fur_shape))
	nodeDagPath = sel_list.getDagPath(0)
	mfnMesh = OpenMaya.MFnMesh(nodeDagPath)
	space = OpenMaya.MSpace.kWorld

	pm.progressBar(gMainProgressBar, edit=True, step=0, status="Getting vertex positions...")
	verts = OpenMaya.MPointArray()
	verts = mfnMesh.getPoints(OpenMaya.MSpace.kWorld)

	pm.progressBar(gMainProgressBar, edit=True, status="Finding closest vertex per card...")
	pm.progressBar(gMainProgressBar, edit=True, step=0, maxValue=len(vertex_shells))
	
	closest_vert_per_shell = []
	for i,shell in enumerate(vertex_shells):
		#progress
		if pm.progressBar(gMainProgressBar, query=True, isCancelled=True ) :
			return
		pm.progressBar(gMainProgressBar, edit=True, step=i)

		closest_dist = None
		closest_vert = None
		for vert_id in shell:
			point = verts[vert_id]
			closestPoint, faceIdx = mfnMesh.getClosestPoint(point, space)
			dist = closestPoint.distanceTo(point)
			if closest_dist==None:
				closest_dist = dist
				closest_vert = vert_id
			elif dist < closest_dist:
				closest_dist = dist
				closest_vert = vert_id

		closest_vert_per_shell.append(closest_vert)


	pm.progressBar(gMainProgressBar, edit=True, status="Apply weights for each card...")
	pm.progressBar(gMainProgressBar, edit=True, step=0, maxValue=len(vertex_shells))
	#
	vtx_base = str(fur_trans)+".vtx["
	for i,shell in enumerate(vertex_shells):
		#progress
		if pm.progressBar(gMainProgressBar, query=True, isCancelled=True ) :
			return
		pm.progressBar(gMainProgressBar, edit=True, step=i)

		#get weight value of closest vertex
		c = closest_vert_per_shell[i]
		vtx = vtx_base+str(c)+"]"
		values = pm.skinPercent(fur_skincluster,vtx,q=1,v=1,ib=0.0001)
		transforms = pm.skinPercent(fur_skincluster,vtx,q=1,t=None,ib=0.0001)
		influences = []
		for i in range(len(transforms)):
			influences.append((transforms[i],values[i]))
		#paste weight values on all other vertices in shell
		for v in shell:
			vtx = vtx_base+str(v)+"]"
			pm.skinPercent(fur_skincluster,vtx,tv=influences)

	pm.progressBar(gMainProgressBar, edit=True, endProgress=True)
Ejemplo n.º 36
0
    def option_box_apply(self):
        pm.setParent(self.option_box)

        input_deformer = self.input_deformer_list.get_selected_deformer()
        input_shape, _ = self.input_shape_list.get_selected_shape()

        output_deformer = self.output_deformer_list.get_selected_deformer()
        output_shape, _ = self.output_shape_list.get_selected_shape()

        # Find the selected surface association mode, and map it to a copySkinWeights argument.
        surface_association = self.get_selected_surface_association_idx()
        surface_association_modes = {
            1: 'closestPoint',
            2: 'rayCast',
            3: 'closestComponent',
            4: 'uvSpace',
        }
        surface_association = surface_association_modes[surface_association]

        # Duplicate the input and output shapes.
        input_shape_copy = pm.duplicate(input_shape)[0].getShape()
        output_shape_copy = pm.duplicate(output_shape)[0].getShape()

        # Create a temporary joint, and skin both shapes to it.  Disable weight normalization,
        # or weights will get forced to 1 since we only have one joint.
        temporary_joint = pm.createNode('joint')
        input_shape_skin = pm.skinCluster([input_shape_copy, temporary_joint], removeUnusedInfluence=False, normalizeWeights=False)
        output_shape_skin = pm.skinCluster([output_shape_copy, temporary_joint], removeUnusedInfluence=False, normalizeWeights=False)
       
        # Disable the skinClusters.  We're using them to transfer data, and we don't want them
        # to influence the temporary meshes.
        input_shape_skin.attr('envelope').set(0)
        output_shape_skin.attr('envelope').set(0)

        try:
            # Figure out which attributes to copy where.
            attrs_to_map = self.get_selected_attrs()

            # Do the copy.
            for src_attr, dst_attr in attrs_to_map:
                if not maya_helpers.copy_weights_to_skincluster(src_attr, input_shape_skin, input_shape_copy):
                    log.warning('Input has no deformer weights: %s', src_attr)
                    continue

                copy_options = {
                    'sourceSkin': input_shape_skin,
                    'destinationSkin': output_shape_skin,
                    'noMirror': True,

                    # Always use one-to-one joint association, since we're always copying the
                    # two temporary joints.
                    'influenceAssociation': 'oneToOne',
                }

                # If we're in UV space mode, find a UV set to copy.  Otherwise, set the association
                # mode.
                if surface_association == 'uvSpace':
                    # Use the current UV set for each mesh.
                    def get_current_uv_set(shape):
                        uv_sets = pm.polyUVSet(shape, q=True, currentUVSet=True)
                        if uv_sets:
                            return uv_sets[0]
                        else:
                            return 'map1'

                    input_shape_uv_set = get_current_uv_set(input_shape)
                    output_shape_uv_set = get_current_uv_set(output_shape)
                    copy_options['uvSpace'] = (input_shape_uv_set, output_shape_uv_set)
                else:
                    copy_options['surfaceAssociation'] = surface_association

                pm.copySkinWeights(**copy_options)
     
                # Read the copied weights out of the skinCluster and copy them to the output attribute.
                copied_weights = list(output_shape_skin.getWeights(output_shape_copy, 0))

                dst_weight_path = str(dst_attr)
                for index, value in enumerate(copied_weights):
                    cmds.setAttr('%s[%i]' % (dst_weight_path, index), value)
        finally:
            # Clean up our temporary nodes.
            pm.delete(input_shape_copy.getTransform())
            pm.delete(output_shape_copy.getTransform())
            pm.delete(temporary_joint)

        log.info( 'Copied %i %s' % (len(attrs_to_map), 'map' if len(attrs_to_map) == 1 else 'maps'))