def convertSmoothSkin(
name,
path='C:/Users/Darrick/Documents/Maya/projects/_UE4-Chars/scenes'):
pm.newFile(force=True)
pm.importFile(path + '/Mesh/Ref/Mesh_' + name + '.ma')
pm.importFile(path + '/Rig/Ref/Skel_' + name + '.ma')
print('Smoothing meshes. Please wait...')
for mesh in pm.ls(type='mesh'):
pm.polySmooth(mesh, ch=False)
pm.select(None)
print('Averaging seam vertex normals...')
edge_dict = FIGURE_EDGES['g8f']
for name, edge in edge_dict.items():
mesh = pm.ls(name + ':Mesh')[0]
pm.polySelect(mesh, edgeBorder=edge, add=True)
pm.select(pm.polyListComponentConversion(pm.ls(sl=True), toVertex=True))
pm.polyAverageNormal()
pm.select(None)
print('Applying skins...')
applySkins()
print('Saving file to {}'.format('{0}/Rig/Ref/Skin_{1}.ma'.format(
path, name)))
print('Completed.')
def make_hair_joint_chain(obj, step=5):
"""Create joint chain for selected hair tube object."""
n = obj.name().split("_")
n.append("rig{:02d}")
pmc.select(cl=True)
edge_indices = pmc.polySelect(obj, edgeLoop=0, noSelection=True)[::-step]
jnts = []
for ni, i in enumerate(edge_indices):
ring = pmc.polySelect(obj, edgeRing=i, noSelection=True)
vi = 0
if len(ring) == 1:
# see if its index-1 vertex is either the first or last
# (pinch point breaks edge ring)
if obj.e[ring[0]].connectedVertices()[1] in (obj.vtx[0],
obj.vtx[-1]):
vi = 1
avg_pos = sum(obj.e[ri].getPoint(vi, space="world") for ri in ring) \
/ len(ring)
if ni:
# get eulers that transform from default to aim vector (local)
aim_mtx = pmc.dt.TransformationMatrix(j.wm.get())
aim_mtx[0] = avg_pos - j.getTranslation(ws=True)
local_aim_mtx = pmc.dt.TransformationMatrix(aim_mtx * j.pim.get())
j.jo.set(pmc.dt.degrees(local_aim_mtx.euler))
j = pmc.joint(p=avg_pos, n="_".join(n).format(ni + 1))
jnts.append(j)
jnts[-1].jo.set(0, 0, 0)
return jnts
def middle2(self, s):
middleL = []
#use input field data to determine flat uv set
flatUvSet = self.findFlatUvSet(s)
#get tips of geo and split to top and bottom pairs
pair1, pair2 = self.findTips(s, flatUvSet)
#select edges going the length on the cards and list as vertices
pm.polyUVSet(s, currentUVSet =1, uvSet=flatUvSet)
side1Edge = pm.polySelect(s, ass = 1, shortestEdgePathUV = (pair1[0].getUVIndices(str(flatUvSet))[0], pair1[1].getUVIndices(str(flatUvSet))[0]))
side1 = pm.ls(pm.polyListComponentConversion(side1Edge, fe =1, tv =1), fl = 1)
if len(side1) > 2:
side2Edge = pm.polySelect(s, ass = 1, shortestEdgePathUV = (pair2[0].getUVIndices(str(flatUvSet))[0], pair2[1].getUVIndices(str(flatUvSet))[0]))
side2 = pm.ls(pm.polyListComponentConversion(side2Edge, fe =1, tv =1), fl = 1)
#select bottom verts and walk(traverse) to the middle of the geo on both sides
mid1 = pm.ls(self.traverse(start = pair1[0], listToWalk = side1, multiplyBy = 0.5 ))
mid2 = pm.ls(self.traverse(start = pair2[0], listToWalk = side2, multiplyBy = 0.5 ))
#select shortest path between the 2 middle points and add to the middleL list
MidLine = pm.polySelect(s, ass = 1, shortestEdgePathUV = (mid1[0].getUVIndices(str(flatUvSet))[0], mid2[0].getUVIndices(str(flatUvSet))[0]))
middleL.append(MidLine)
pm.select(cl = 1)
if len(side1) % 2 == 0:
mid3 = pm.ls(self.traverse(start = pair1[-1], listToWalk = side1, multiplyBy = 0.5 ))
mid4 = pm.ls(self.traverse(start = pair2[-1], listToWalk = side2, multiplyBy = 0.5 ))
MidLine2 = pm.polySelect(s, ass = 1, shortestEdgePathUV = (mid3[0].getUVIndices(str(flatUvSet))[0], mid4[0].getUVIndices(str(flatUvSet))[0]))
middleL.append(MidLine2)
pm.select(cl = 1)
return pm.ls( middleL, fl = True)
def loc_edgeLoop():
sel = pm.ls(sl=True,fl=True)
index=1
for obj in sel:
transform = obj
if isinstance(obj,pm.MeshEdge):
transform = obj.node().getParent()
pm.polySelect(transform,elb=obj.indices()[0])
edgeLoop=pm.ls(sl=True)
pm.language.melGlobals.initVar( 'string', 'gMove' )
pm.setToolTo(pm.language.melGlobals['gMove'])
moveManip = pm.manipMoveContext('Move', q=True,p=True)
grpName = transform+'_ELP_LOC_GRP'
if pm.objExists(grpName):
elp_grp=pm.PyNode(grpName)
print 'addingIndex'
index+=1
else:
print 'removing index'
index=1
elp_grp = pm.group(em=True,n=grpName)
locName=transform+'_'+str(index)+'_LOC'
loc = pm.spaceLocator(n=locName)
loc.translate.set(moveManip)
loc.setParent(elp_grp)
pm.select(edgeLoop, r=True)
def makeLantern(): #clear workspace cmds.select(all=True) cmds.delete() #get values from sliders ridges = cmds.intSliderGrp(ridgesSlider, q=True, value=True) deform = cmds.intSliderGrp(deformSlider, q=True, value=True) bend = cmds.intSliderGrp(bendSlider, q=True, value=True) bendNum = bend/100.0+1.0 flatten = float(cmds.intSliderGrp(flattenSlider, q=True, value=True)) lantern = pm.polySphere(n='lantern', sx=10, r=1, sy=ridges) rings = pm.polySelect( lantern, er=1) pm.select(lantern, cl=True) toggle = True for i in rings: if toggle: pm.polySelect( lantern, el=i) pm.scale(pm.selected(), [bendNum,bendNum,bendNum], xz=True) toggle = not toggle pm.select(lantern) pm.displaySmoothness(divisionsU=3, divisionsV=3, pointsWire=16, pointsShaded=4, polygonObject=3) wave = pm.nonLinear(type='wave', amplitude=0.03) pm.setAttr(wave[0]+'.wavelength', deform/100+0.1) pm.rotate(wave, 0, 0, '45deg') pm.select(all=True) pm.scale(lantern, [1,1-(flatten/100),1], xyz=True) pm.delete(ch=True)
def insertEdgeLoop(weight=0.5, sma=3, splitType=1, div=1): """Mimics Insert Edge Loop in Maya, as it is used in the UI, and not how it works in MEL. """ edges = pm.filterExpand(expand=True, sm=32) for e in edges: e = pm.PyNode(e) pm.select(e, r=True) pm.polySelect(er=e.currentItemIndex()) pm.polySplitRing(weight=weight, fixQuads=1, splitType=splitType, sma=sma, div=div)
def insertEdgeLoop(weight=0.5, sma=3, splitType=1, div=1):
"""Mimics Insert Edge Loop in Maya, as it is
used in the UI, and not how it works in MEL.
"""
edges = pm.filterExpand(expand=True, sm=32)
for e in edges:
e = pm.PyNode(e)
pm.select(e, r=True)
pm.polySelect(er=e.currentItemIndex())
pm.polySplitRing(weight=weight,
fixQuads=1,
splitType=splitType,
sma=sma,
div=div)
def edgeLoopBetweenVertices(startPos, endPos):
""" Computes edge loop between two vertices.
Arguments:
startPos (vertex): Start of edge loop
endPos (vertex): End of edge loop
Returns:
Edge loop, if one exists. Otherwise None.
"""
oldSelection = pm.selected()
mesh = startPos.node()
edgeLoops = []
for startEdge in startPos.connectedEdges():
for endEdge in endPos.connectedEdges():
testEdgeLoop = pm.polySelect(
mesh, edgeLoopPath=[startEdge.index(),
endEdge.index()])
if testEdgeLoop:
edgeLoops.append(pm.selected())
pm.select(oldSelection, r=1)
if edgeLoops:
edgeLoops.sort(key=len)
return edgeLoops[0]
return None
def edgeFlow(self):
oldSel = pm.ls(sl = 1)
pm.select(pm.ls(o=1, sl=1))
selected = pm.ls(sl = 1)
pm.delete(selected, constructionHistory = 1)
pm.select(cl = 1)
for s in selected:
rootEdges = pm.ls( self.root(s) , fl = 1)
tipEdges = pm.ls( self.tip(s) , fl = 1)
############length edgeloops of the card
myEdges = pm.ls(pm.polySelect(s, ebp = [ rootEdges[0].index(), tipEdges[0].index() ],ass = True ), fl = 1)
side1Edges = [x for x in myEdges if x not in rootEdges and x not in tipEdges]
borderEdges = [x for x in pm.ls(s.e, fl = 1) if x.isOnBoundary()]
pm.select(tipEdges)
for x in range(len(side1Edges)*2):
if x != borderEdges and x!= rootEdges and x!= tipEdges:
pm.polyEditEdgeFlow(adjustEdgeFlow=1, constructionHistory=0)
pm.pickWalk(type = 'edgeloop', direction = 'left')
if self.lenCheckBox.getValue() == 1:
pm.select(side1Edges)
for x in range( len(rootEdges)*2 ):
pm.polyEditEdgeFlow(adjustEdgeFlow=1, constructionHistory=0)
pm.pickWalk(type = 'edgeloop', direction = 'left')
pm.select(oldSel)
def getLoopByLocators(mesh=None, loc1=None, loc2=None, loc3=None):
'''
Evaluates the mesh to find the edgeloop passing through the locators
:param mesh: polygon mesh
:param loc1: locator, start vertex
:param loc2: locator, end vertex
:param loc3: locator, edgeloop pass through this vertex
:return: list of edges
'''
foundSegment = None
pos1 = pm.xform(loc1, q=True, ws=True, t=True)
pos2 = pm.xform(loc2, q=True, ws=True, t=True)
pos3 = pm.xform(loc3, q=True, ws=True, t=True)
closest1 = getClosestVertex(mesh.name(), pos=pos1)
closest2 = getClosestVertex(mesh.name(), pos=pos2)
closest3 = getClosestVertex(mesh.name(), pos=pos3)
pm.select(closest1)
edges = closest1.connectedEdges()
foundLoop = None
for e in edges:
edgeloop = pm.polySelect(mesh,
edgeLoop=e.index(),
edgeBorder=e.index())
vertexLoop = pm.ls(pm.polyListComponentConversion(fe=True, tv=True),
fl=True)
if closest2 in vertexLoop and closest3 in vertexLoop:
foundLoop = vertexLoop
if foundLoop:
foundEdgeloop = []
for vtx in foundLoop:
edges = vtx.connectedEdges()
for e in edges:
conVtxs = e.connectedVertices()
if conVtxs[0] in foundLoop and conVtxs[1] in foundLoop:
foundEdgeloop.append(e)
sortedEdgeloop = edgeLoopSort(foundEdgeloop, closest1, closest2)
rev = False
foundSegment = None
for i in range(1, 3):
pm.select(sortedEdgeloop[i])
vertexLoop = pm.ls(pm.polyListComponentConversion(fe=True,
tv=True),
fl=True)
if closest3 in vertexLoop:
foundSegment = sortedEdgeloop[i]
pm.select(cl=True)
return foundSegment
def get_pos_center_from_edge(edge):
if type(edge) == pm.general.MeshEdge:
t_node = edge.node()
verts_set= set()
edge_loop_list = pm.ls(pm.polySelect(t_node, edgeLoop=edge.currentItemIndex(), ns=True, ass=True))
for ed in edge_loop_list:
unpack_edges = [t_node.e[edg] for edg in ed.indices()]
for true_edge in unpack_edges:
for vert in true_edge.connectedVertices():
verts_set.add(vert)
vert_pos = sum([v.getPosition('world') for v in list(verts_set)])/len(verts_set)
return vert_pos
def UVFix(self):
oldSel = pm.ls(sl = 1)
selected = pm.ls(sl = 1, o = 1)
pm.select(cl = 1)
for s in selected:
#############get info from other nodes
myCurrentUvSet = pm.polyUVSet(s, q = True , currentUVSet = True )[0]
pair1, pair2 = self.findTips(s, myCurrentUvSet)
###############select and store roots and tips
tipsUV = []
rootEdges = pm.ls( pm.polySelect( s, ass = 1 ,shortestEdgePath = (pair2[0].index(), pair2[1].index() ) ), fl = 1)
tipsUV.append( pm.ls( pm.polyListComponentConversion( rootEdges, fe =1, tuv =1), fl = True ) )
tipEdges = pm.ls( pm.polySelect( s, ass = 1 ,shortestEdgePath = (pair1[0].index(), pair1[1].index() ) ), fl = 1)
tipsUV.append( pm.ls( pm.polyListComponentConversion( tipEdges, fe =1, tuv =1), fl = True ) )
#########select and unfold the middle part of the mesh
pm.select( pm.ls(tipsUV, fl = 1), replace = True )
pm.runtime.InvertSelection()
if self.squareCheckBox.getValue() == 1:
pm.unfold(ps=0, us=False, i=4312, gmb=0.9457, pub=0, oa=1, ss=15.5797, gb=0.7597)
###########selecting length boarders
side1 = pm.ls(pm.polySelect(ebp = [ tipEdges[0].index(), rootEdges[0].index()], ass = True ), fl = 1)
side1 = [n for n in side1 if n not in rootEdges and n not in tipEdges]
side2 = pm.ls(pm.polySelect(ebp = [ tipEdges[-1].index(), rootEdges[-1].index()], ass = True ), fl = 1)
side2 = [n for n in side2 if n not in rootEdges and n not in tipEdges]
##########calculate all the averages
boarder1Avg = self.tupleAvg([pair1[0].getUV(uvSet = myCurrentUvSet), pair2[0].getUV(uvSet = myCurrentUvSet)])
boarder2Avg = self.tupleAvg([pair1[1].getUV(uvSet = myCurrentUvSet), pair2[1].getUV(uvSet = myCurrentUvSet)])
islandAvg = self.tupleAvg([boarder1Avg, boarder2Avg])
#########straighten length boarders
for x in side1:
pm.polyEditUV(x, u = boarder1Avg[0], r = False, uvSetName = myCurrentUvSet)
for x in side2:
pm.polyEditUV(x, u = boarder2Avg[0], r = False, uvSetName = myCurrentUvSet)
##########get the perimeter of the uv island
borderUVs = ['{}.map[{}]'.format(s,x.getUVIndices()[0]) for x in pm.ls(s.vtx, fl = 1) if x.isOnBoundary()]
pm.select(borderUVs)
pm.runtime.InvertSelection()
pm.Unfold3D(pm.selected(),rs=2, ite=0, bi=1, p=0, u=1, ms=1024, tf=1)
else: pm.Unfold3D(pm.selected(),rs=2, ite=0, bi=1, p=0, u=1, ms=1024, tf=1)
pm.select(oldSel)
def middle(self,s):
if self.midCtrlCheckBox.getValue() == 1:
number = self.randSliderT.getValue()/10
else: number = 0.5
#use input field data to determine flat uv set
flatUvSet = self.findFlatUvSet(s)
#get tips of geo and split to top and bottom pairs
pair1, pair2 = self.findTips(s, flatUvSet)
#select edges going the length on the cards and list as vertices
pm.polyUVSet(s, currentUVSet =1, uvSet=flatUvSet)###not sure that I need it
side1Edge = pm.polySelect(s, ass = 1, shortestEdgePathUV = (pair1[0].getUVIndices(str(flatUvSet))[0], pair2[0].getUVIndices(str(flatUvSet))[0]))
side1 = pm.ls(pm.polyListComponentConversion(side1Edge, fe =1, tv =1), fl = 1)
side2Edge = pm.polySelect(s, ass = 1, shortestEdgePathUV = (pair1[1].getUVIndices(str(flatUvSet))[0], pair2[1].getUVIndices(str(flatUvSet))[0]))
side2 = pm.ls(pm.polyListComponentConversion(side2Edge, fe =1, tv =1), fl = 1)
#select bottom verts and walk(traverse) to the middle of the geo on both sides
mid1 = pm.ls(self.traverse(start = pair1[0], listToWalk = side1, multiplyBy = number ))
mid2 = pm.ls(self.traverse(start = pair1[1], listToWalk = side2, multiplyBy = number ))
#select shortest path between the 2 middle points and add to the middleL list
MidLine = pm.polySelect(s, ass = 1, shortestEdgePathUV = (mid1[0].getUVIndices(str(flatUvSet))[0], mid2[0].getUVIndices(str(flatUvSet))[0]))
pm.select(cl = 1)
return MidLine
def root(self,s):
#######selects the root edges of the geo
flatUvSet = self.findFlatUvSet(s)
pair1, pair2 = self.findTips(s, flatUvSet)
root = []
if len(pair1) > 1:
for x in range(len(pair1)-1):
root.append( pm.polySelect(s, shortestEdgePathUV = (pair1[x].getUVIndices(str(flatUvSet))[0],
pair1[x+1].getUVIndices(str(flatUvSet))[0]), ass = 1) )
root = [val for sublist in root for val in sublist]
else:
root = pair1[0]
return root
def tip(self, s):
#######selects the tip edges of the geo
flatUvSet = self.findFlatUvSet(s)
pair1, pair2 = self.findTips(s, flatUvSet)
tip = []
if len(pair2) > 1:
for x in range(len(pair2)-1):
tip.append( pm.polySelect(s, shortestEdgePathUV = (pair2[x].getUVIndices(str(flatUvSet))[0],
pair2[x+1].getUVIndices(str(flatUvSet))[0]), ass = 1) )
tip = [val for sublist in tip for val in sublist]
else:
tip = pair2[0]
return tip
def getListOfComponentShells(*args):
if not args:
inputs = pymel.ls(selection=True)[0]
shellListOfLists = []
print 'inputs:',
print inputs
if pymel.nodeType(inputs) == 'transform':
mesh = inputs.getShape()
vtxDict = {}
vtxList = list(mesh.vtx)
vertIndices = range(len(mesh.vtx) / 50)
sortedVtxIndices = {}
for i, vtx in enumerate(vtxList):
if i not in sortedVtxIndices:
print 'i:',
print i
shellIndices = pymel.polySelect(vtx, extendToShell=True)
shellList = []
for shellIndex in shellIndices:
if shellIndex not in sortedVtxIndices:
print 'shellIndex:',
print shellIndex
sortedVtxIndices[shellIndex] = True
shellList.append(shellIndex)
shellListOfLists.append(shellList)
#while vertIndices:
#vtxNum = vertIndices[0]
#print 'len(vertIndices):',
#print len(vertIndices)
#shellIndices = pymel.polySelect(mesh.vtx[vtxNum], extendToShell=True)
##print 'shellIndices:',
##print shellIndices
#shellList = []
#for shellIndex in shellIndices:
##if shellIndex in vertIndices:
#shellList.append(shellIndex)
#vertIndices.remove(shellIndex)
#shellListOfLists.append(shellList)
for each in shellListOfLists:
print each
def getNextEdgeRing(edge, edgeRing=None):
if not edgeRing:
mesh = pm.PyNode(edge.name().split('.')[0])
edgeRing = [
pm.PyNode(x) for x in pm.polySelect(
mesh, edgeRing=edge.index(), ns=True, ass=True)
]
all = []
checked = [edge]
conn = edge.connectedEdges()
for e in conn:
temp = e.connectedEdges()
for x in temp:
all.append(x)
inRing = list(
set([x for x in all if x in edgeRing and x not in checked]))
return inRing
def selectLoopByLocators(mesh=None, loc1=None, loc2=None, loc3=None):
pos1 = pm.xform(loc1, q=True, ws=True, t=True)
pos2 = pm.xform(loc2, q=True, ws=True, t=True)
pos3 = pm.xform(loc3, q=True, ws=True, t=True)
closest1 = getClosestVertex(mesh.name(), pos=pos1)
closest2 = getClosestVertex(mesh.name(), pos=pos2)
closest3 = getClosestVertex(mesh.name(), pos=pos3)
pm.select(closest1)
edges = closest1.connectedEdges()
foundLoop = None
for e in edges:
edgeloop = pm.polySelect(mesh, edgeLoop=e.index())
vertexLoop = pm.ls(pm.polyListComponentConversion(fe=True, tv=True),
fl=True)
if closest2 in vertexLoop and closest3 in vertexLoop:
foundLoop = vertexLoop
foundEdgeloop = []
for vtx in foundLoop:
edges = vtx.connectedEdges()
for e in edges:
conVtxs = e.connectedVertices()
if conVtxs[0] in foundLoop and conVtxs[1] in foundLoop:
foundEdgeloop.append(e)
sortedEdgeloop = edgeLoopSort(foundEdgeloop, closest1, closest2)
rev = False
foundSegment = None
for i in range(1, 3):
pm.select(sortedEdgeloop[i])
vertexLoop = pm.ls(pm.polyListComponentConversion(fe=True, tv=True),
fl=True)
if closest3 in vertexLoop:
foundSegment = sortedEdgeloop[i]
return foundSegment
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)
def detect_topology(self):
curr = time.time()
sellist = [mesh for mesh in pm.ls(pm.pickWalk(d="down"), type="mesh")
] # pm.ls 返回场景中被选中的对象
# pickWalk命令允许您相对于当前选定的节点快速更改选择列表
if len(sellist) != 2:
pm.headsUpMessage(u"请选中两个对象")
return 0
self.lineEdit_pointNum.clear()
self.lineEdit_edgeNum.clear()
self.lineEdit_faceNum.clear()
self.textEdit_transInfor1.clear()
self.textEdit_transInfor2.clear()
W = True # 拓扑是否一致
numlist = [(sel.numVertices(), sel.numEdges(), sel.numFaces())
for sel in sellist] # num_list是2*3的列表
# 点、线、面数量不一至，拓扑肯定不一样
if numlist[0][0] != numlist[1][0]:
W = False
x = numlist[0][0] - numlist[1][0]
self.lineEdit_pointNum.setText(str(x))
if numlist[0][1] != numlist[1][1]:
W = False
x = numlist[0][0] - numlist[1][0]
self.lineEdit_edgeNum.setText(str(x))
if numlist[0][2] != numlist[1][2]:
W = False
x = numlist[0][0] - numlist[1][0]
self.lineEdit_faceNum.setText(str(x))
if numlist[0][1] > numlist[1][1]:
sellist.reverse()
edgenum = numlist[1][1]
else:
edgenum = numlist[0][1]
# 把数量小的换到前面
res_list = []
dif_list1 = []
dif_list2 = []
for i, sel in enumerate(sellist): # enumerate() 列出数据和数据下标 (0, mesh1)
edgeLoop_list = []
edge_list = set(range(edgenum))
while len(edge_list) > 1:
idx = next(iter(edge_list),
None) # iter() 函数用来生成迭代器 next()返回迭代器的下一个项目
if idx is None: break
edge_loop_1 = pm.polySelect(sel, edgeLoop=idx, ns=1) #
edgeLoop_list.append(edge_loop_1) # 遍历过的边的列表添加进循环边的表
edge_list -= set(edge_loop_1) # 遍历过的边删去
# NOTE 这里先判断一下同一个边序号获取的循环边数组是否一致
if i != 0: continue
edge_loop_2 = pm.polySelect(sellist[1].e[edge_loop_1[0]],
edgeLoop=idx,
ns=1)
# 第二个对象的第idx条循环边
if edge_loop_2 != edge_loop_1:
dif_list1.append(edge_loop_1)
dif_list2.append(edge_loop_2)
res_list.append(edgeLoop_list)
W = (res_list[0] == res_list[1])
if not W:
for edgeloops in dif_list1:
self.textEdit_transInfor1.append(str(edgeloops))
self.textEdit_transInfor1.append(u" ")
for edgeloops in dif_list2:
self.textEdit_transInfor2.append(str(edgeloops))
self.textEdit_transInfor2.append(u" ")
pm.select([
"%s.e[%s]" % (sellist[0], e) for sel in dif_list1 for e in sel
],
r=1)
pm.select([
"%s.e[%s]" % (sellist[1], e) for sel in dif_list2 for e in sel
],
add=1)
self.lineEdit_result.setText(u"拓扑不一致")
else:
self.lineEdit_result.setText(u"拓扑一致")
self.lineEdit_time.setText(str(time.time() - curr))
def curveFromCylinder(mesh = pm.selected()):
"""
Creates a curve from the middle point from every loops
@param mesh: List. By default is pm.selected()
"""
def createCurveFrom(selection = pm.selected(), curve_name = 'curve'):
"""
Creates a curve from the position values of the selection
"""
def createLocs(subject):
loc_align = pm.spaceLocator()
pm.matchTransform(loc_align,subject, rot=True, pos=True)
return loc_align
starting_locs = [createLocs(x) for x in selection]
pos = [pm.xform(x, ws=True, q=True, t=True) for x in starting_locs]
knot = []
for i in range(len(selection)):
knot.append(i)
_curve = pm.curve(p = pos, k =knot, d=1, n=curve_name)
pm.rebuildCurve(_curve, rt=0, ch=0, end=1, d=3, kr=0, s=len(selection), kcp=0, tol=0.1, kt=0, rpo=1, kep=1)
pm.delete(starting_locs)
return(_curve)
def centre_joint():
"""
Creates a joint in the centre of the selection. You can select objects, components...
"""
sel = pm.ls(sl=1, fl=1)
bb = [0, 0, 0, 0, 0, 0]
for obj in sel:
pos = pm.xform(obj, q=1, ws=1, bb=1)
for i in range(6):
bb[i] += pos[i]
for i in range(6):
bb[i] /= len(sel)
pm.select(cl=True)
return pm.joint(p=((bb[0] + bb[3]) / 2, (bb[1] + bb[4]) / 2, (bb[2] + bb[5]) / 2))
for mesh_name in mesh:
border_loop = pm.polySelect(mesh_name, eb = 1) or []
pm.polySelect(mesh_name, edgeRing = 1)
edgeLoop_num = len(pm.selected())
pm.polySelect(mesh_name, el = 1)
if border_loop:
[pm.pickWalk(type='edgeloop', d='left') for x in range(1)]
temp_all_jnts = []
for index in range(edgeLoop_num):
pm.polySelect(mesh_name,edgeLoopPattern=(1,1))
[pm.pickWalk(type='edgeloop', d='left') for x in range(index)]
joint = centre_joint()
temp_all_jnts.append(joint)
all_jnts = [x for x in temp_all_jnts[1:]]
pm.delete(temp_all_jnts[0])
else:
all_jnts = []
for index in range(edgeLoop_num):
pm.polySelect(mesh_name,edgeLoopPattern=(1,1))
[pm.pickWalk(type='edgeloop', d='left') for x in range(index)]
joint = centre_joint()
all_jnts.append(joint)
createCurveFrom(all_jnts)
pm.delete(all_jnts)
import pymel.core as pm
import maya.cmds as mc
mc.setToolTo('moveSuperContext')
edges = pm.ls(sl=True, fl=True)
#edges_sorted = sorted(edges, key=lambda e: e.index())
positions = []
for edge in edges:
pm.polySelect(edge, el=edge.index()) # ns=True if no selection...figure this out.
positions.append(mc.manipMoveContext('Move', q=True, p=True))
pm.curve(p=positions, degree=1)
def patternSelection():
with pm.UndoChunk():
#pm.scriptEditorInfo(suppressInfo=True)
selOrderTrackingEnabled = pm.selectPref(q=1, trackSelectionOrder=1)
if not selOrderTrackingEnabled:
#pm.confirmDialog( title='Warning', message='For pattern selection to work you need to enable selection order tracking [Windows > Settings/Preferences > Preferences > Selection > Track selection order]', button=['OK'])
pm.selectPref(trackSelectionOrder=1)
pm.mel.eval("selectPref -trackSelectionOrder true")
return
sel = pm.ls(orderedSelection=1,fl=1)
if len(sel) <= 1:
return
# get name of mesh object containing selected components
mesh = pm.ls(sel[0].name().split(".")[0])[0]
##########
# VERTEX #
##########
if sel[0].__class__.__name__ == "MeshVertex" and sel[1].__class__.__name__ == "MeshVertex":
print "vepe"
vertFirst = sel[-2].indices()[0]
vertLast = sel[-1].indices()[0]
# detect if two last selected vertices are next to each other
nextToEachother = False
pm.select( mesh+".vtx["+str(vertFirst)+"]",r=1)
pm.select( mesh+".vtx["+str(vertLast)+"]",add=1)
pm.mel.eval("ConvertSelectionToContainedEdges;")
if len(pm.ls(sl=1)) == 1:
nextToEachother = True
# restore selection order stack
pm.mel.eval("ConvertSelectionToVertices;") # avoid getting stuck in edge/multi-component mode
pm.select(sel,r=1)
pm.select(sel[-1],d=1)
pm.select(sel[-2],d=1)
pm.select(sel[-2],add=1)
pm.select(sel[-1],add=1)
if nextToEachother:
selectNextVertex("next")
return
# detect if two last selected vertices are on same edge loop
pm.select( mesh+".vtx["+str(vertFirst)+"]",r=1)
pm.select( mesh+".vtx["+str(vertLast)+"]",add=1)
# converting two verts on the same loop to and edge loop
# results in selecting all verts between them (why?)
pm.mel.eval("SelectEdgeLoopSp;")
path = pm.ls(sl=1,fl=1)
if ( path ): # on same loop
# get edge loop, needed for inversion later
pm.mel.eval("ConvertSelectionToContainedEdges;")
edgePath = pm.ls(sl=1,fl=1)
# SelectEdgeRingSp is sometimes unreliable with multiple consecutive
# edges selected so we use just one edge to find the current loop
pm.select(edgePath[0],r=1)
pm.mel.eval("SelectEdgeLoopSp;")
loop = pm.ls(sl=1)
# restore selection order stack
pm.select(sel,r=1)
pm.select(sel[-1],d=1)
pm.select(sel[-2],d=1)
pm.select(sel[-2],add=1)
pm.select(sel[-1],add=1)
if ( path ): # on same loop
selectNextVertex("pattern", mesh, len(edgePath)-1, loop)
########
# EDGE #
########
if sel[0].__class__.__name__ == "MeshEdge" and sel[1].__class__.__name__ == "MeshEdge":
edgeFirst = sel[-2].indices()[0]
edgeLast = sel[-1].indices()[0]
ring = pm.polySelect( mesh.name(), q=1, edgeRingPath=[edgeFirst,edgeLast] )
if ( ring ):
if ( len(ring) == 2 ):
selectNextEdge("ring")
if ( len(ring) > 2 ):
selectNextEdge("ringPattern", mesh, len(ring)-2)
loop = pm.polySelect( mesh.name(), q=1, edgeLoopPath=[edgeFirst,edgeLast] )
if ( loop ):
if (len(loop) == 2 ):
selectNextEdge("loop")
if ( len(loop) > 2 ):
selectNextEdge("loopPattern", mesh, len(loop)-2)
########
# FACE #
########
if sel[0].__class__.__name__ == "MeshFace" and sel[1].__class__.__name__ == "MeshFace":
faceFirst = sel[-2].indices()[0]
faceLast = sel[-1].indices()[0]
path = pm.polySelect( mesh.name(), q=1, shortestFacePath=[faceFirst,faceLast] )
if (path):
if len(path) == 2:
selectNextFace("next")
if len(path) > 2:
pm.select( mesh+".f["+str(faceFirst)+"]",r=1)
pm.select( mesh+".f["+str(faceLast)+"]",add=1)
pm.mel.eval("SelectEdgeLoopSp;")
facePath = pm.ls(sl=1,fl=1)
if (facePath):
# face path isnt sorted
pm.mel.eval("ConvertSelectionToContainedEdges;")
pm.select(pm.ls(sl=1,fl=1)[0],r=1)
pm.mel.eval("SelectEdgeRingSp;")
pm.mel.eval("ConvertSelectionToVertices;") # TODO REM buggy command was: pm.mel.eval("GrowPolygonSelectionRegion;")
pm.mel.eval("ConvertSelectionToContainedFaces;")
loop = pm.ls(sl=1)
print loop
print "-------------------"
# restore selection order stack
pm.select(sel,r=1)
pm.select(sel[-1],d=1)
pm.select(sel[-2],d=1)
pm.select(sel[-2],add=1)
pm.select(sel[-1],add=1)
#print len(facePath)
if (facePath):
selectNextFace("pattern", mesh, len(facePath)-2, loop)
