def get_invalid(cls, instance):
invalid = []
for node in cmds.ls(instance, type='mesh'):
uv = cmds.polyEvaluate(node, uv=True)
if uv == 0:
invalid.append(node)
continue
vertex = cmds.polyEvaluate(node, vertex=True)
if uv < vertex:
# Workaround:
# Maya can have instanced UVs in a single mesh, for example
# imported from an Alembic. With instanced UVs the UV count from
# `maya.cmds.polyEvaluate(uv=True)` will only result in the unique
# UV count instead of for all vertices.
#
# Note: Maya can save instanced UVs to `mayaAscii` but cannot
# load this as instanced. So saving, opening and saving
# again will lose this information.
uv_to_vertex = cmds.polyListComponentConversion(node + ".map[*]",
toVertex=True)
uv_vertex_count = len_flattened(uv_to_vertex)
if uv_vertex_count < vertex:
invalid.append(node)
else:
cls.log.warning("Node has instanced UV points: {0}".format(node))
return invalid
def copyWeights(sourceMesh, targetMesh, sourceDeformer, targetDeformer):
"""
Copy deformer weights from one mesh to another.
Source and Target mesh objects must have matching point order!
@param sourceMesh: Mesh to copy weights from
@type sourceMesh: str
@param targetMesh: Mesh to copy weights to
@type targetMesh: str
@param sourceDeformer: Deformer to query weights from
@type sourceDeformer: str
@param targetDeformer: Deformer to apply weights to
@type targetDeformer: str
"""
# Check source and target mesh
if not mc.objExists(sourceMesh):
raise Exception('Source mesh "' + sourceMesh + '" does not exist!!')
if not mc.objExists(targetMesh):
raise Exception('Target mesh "' + targetMesh + '" does not exist!!')
# Check deformers
if not mc.objExists(sourceDeformer):
raise Exception('Source deformer "' + sourceDeformer + '" does not exist!!')
if targetDeformer and not mc.objExists(targetDeformer):
raise Exception('Target deformer "' + targetDeformer + '" does not exist!!')
if not targetDeformer:
targetDeformer = sourceDeformer
# Compare vertex count
if mc.polyEvaluate(sourceMesh, v=True) != mc.polyEvaluate(targetMesh, v=True):
raise Exception("Source and Target mesh vertex counts do not match!!")
# Copy weights
wtList = glTools.utils.deformer.getWeights(sourceDeformer, sourceMesh)
# Paste weights
glTools.utils.deformer.setWeights(targetDeformer, wtList, targetMesh)
def getFaces():
# count faces
faceCount = cmds.polyEvaluate(geometryName[0],f=True)
# make a list of face count
faceRange = list(range(1,faceCount))
# empty list for face
faceList = []
# for each face in faceRange, get the name of the face
for f in faceRange:
# get the name of each face on the model
face = (str(geometryName[0])+'.f['+str(f)+']')
# append each face to the faceList
faceList.append(face)
faceCount = cmds.polyEvaluate(geometryName[0],f=True)
# empty list for facebounds
fb = []
# if the faceList is equal to the number of faces found
if len(faceList) == faceCount-1:
# for each face name found in face list
for face in faceList:
# select each face
cmds.select(face)
# get the UV bounding box on each face
faceBounds = cmds.polyEvaluate(bc2=True)
# print the facebounds
fb.append(faceBounds)
if len(fb) == len(faceList):
return fb,faceList
def MeshDict(mesh = None, pointCounts = True, calledFrom = None):
"""
Validates a mesh and returns a dict of data.
If a shape is the calling object, it will be the shape returned, otherwise, the first shape in the chain will be
:param mesh: mesh to evaluate
:returns:
dict -- mesh,meshType,shapes,shape,pointCount,pointCountPerShape
"""
_str_funcName = 'MeshDict'
if calledFrom: _str_funcName = "{0} calling {1}".format(calledFrom,_str_funcName)
_mesh = None
if mesh is None:
_bfr = mc.ls(sl=True)
if not _bfr:raise ValueError,"No selection found and no source arg"
mesh = _bfr[0]
log.info("{0}>> No source specified, found: '{1}'".format(_str_funcName,mesh))
_type = search.returnObjectType(mesh)
_shape = None
_callObjType = None
if _type in ['mesh']:
_mesh = mesh
_callObjType = 'meshCall'
elif _type in ['shape']:
_shape = mesh
_callObjType = 'shapeCall'
_mesh = getTransform(mesh)
else:
raise ValueError,"{0} error. Not a usable mesh type : obj: '{1}' | type: {2}".format(_str_funcName, mesh, _type)
_shapes = mc.listRelatives(_mesh,shapes=True,fullPath=False)
if _shape is None:
_shape = _shapes[0]
_return = {'mesh':_mesh,
'meshType':_type,
'shapes':_shapes,
'shape':_shape,
'callType':_callObjType,
}
if pointCounts:
if _callObjType == 'shapeCall':
_return['pointCount'] = mc.polyEvaluate(_shape, vertex=True)
else:
_l_counts = []
for s in _return['shapes']:
_l_counts.append( mc.polyEvaluate(s, vertex=True))
_return['pointCountPerShape'] = _l_counts
_return['pointCount'] = sum(_l_counts)
return _return
def returnObjectSize(obj,debugReport = False):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Semi intelligent object sizer. Currently works for verts, edges,
faces, poly meshes, nurbs surfaces, nurbs curve
ARGUMENTS:
obj(string) - mesh or mesh group
RETURNS:
size(float)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
objType = search.returnObjectType(obj)
#>>> Poly
if objType == 'mesh':
size = mc.polyEvaluate(obj,worldArea = True)
if debugReport: print ('%s%f' %('mesh area is ',size))
return size
elif objType == 'polyVertex':
meshArea = mc.polyEvaluate(obj,worldArea = True)
splitBuffer = obj.split('.')
vertices = mc.ls ([splitBuffer[0]+'.vtx[*]'],flatten=True)
size = meshArea/len(vertices)
if debugReport: print ('%s%f' %('Average mesh area per vert is ',size))
return size
elif objType == 'polyEdge':
size = returnEdgeLength(obj)
if debugReport: print ('%s%f' %('The Edge length is ',size))
return size
elif objType == 'polyFace':
size = returnFaceArea(obj)
if debugReport: print ('%s%f' %('face area is ',size))
return size
#>>> Nurbs
elif objType == 'nurbsSurface':
boundingBoxSize = returnBoundingBoxSize(obj)
size = cgmMath.multiplyList(boundingBoxSize)
if debugReport: print ('%s%f' %('Bounding box volume is ',size))
return size
elif objType == 'nurbsCurve':
size = returnCurveLength(obj)
if debugReport: print ('%s%f' %('Curve length is ',size))
return size
else:
if debugReport: print ("Don't know how to handle that one")
return False
def triangulateMesh(isObj, simplify, smoothe):
if isObj and not cmds.objExists('triObj'):
cmds.select(baseObject)
cmds.duplicate(baseObject, name = "triObj")
cmds.select('triObj')
if smoothe:
cmds.polySmooth('triObj', c=smoothe)
cmds.polyReduce(ver = 1)
cmds.polyReduce(ver = 1)
if simplify > 0:
cmds.polyReduce(ver = 1, p = simplify)
num_faces = cmds.polyEvaluate('triObj', f=True)
print "Triangulating faces..."
#iterate over faces
face_i = 0
while face_i < num_faces:
if ((num_faces - face_i) % 5 == 0):
print "Triangulate check: Approximately " + str(num_faces - face_i) + " faces remaining...."
face = cmds.select('triObj.f['+ str(face_i)+']')
verts = getCorners(isObj,face_i)
if not isCoplanar(verts):
cmds.polyTriangulate('triObj.f['+ str(face_i)+']')
num_faces = cmds.polyEvaluate('triObj', f=True)
face_i +=1
def ftb_gen_shell_doIt(dist,distUV,div):
if (mc.window('shellUiWin',q=True,exists=True)):
mc.deleteUI('shellUiWin')
#mc.loadPlugin( 'c:/ftb_mayaplugins/ppl/2011 x64/shellNode.mll')
sel = mc.ls(sl=True)
if(len(sel)!= 0):
shape = mc.listRelatives(sel[0],noIntermediate = True,shapes=True)
His = mc.listHistory(shape[0])
shell = ''
for h in His:
if(mc.nodeType(h) == 'polyShell'):
shell = h
if(shell == ''):
if(mc.attributeQuery('shThickness',node=shape[0],ex=True)):
dist = mc.getAttr(shape[0]+'.shThickness')
else:
mc.addAttr(shape[0],ln="shThickness",at='double',dv=0)
mc.setAttr(shape[0]+'.shThickness',e=True,keyable=True)
if(mc.attributeQuery('shUvThickness',node=shape[0],ex=True)):
distUV = mc.getAttr(shape[0]+'.shUvThickness')
else:
mc.addAttr(shape[0],ln="shUvThickness",at='double',dv=0)
mc.setAttr(shape[0]+'.shUvThickness',e=True,keyable=True)
if(mc.attributeQuery('shDiv',node=shape[0],ex=True)):
div = mc.getAttr(shape[0]+'.shDiv')
else:
mc.addAttr(shape[0],ln="shDiv",at='long',dv=0,min=0)
mc.setAttr(shape[0]+'.shDiv',e=True,keyable=True)
faceInitalCount = mc.polyEvaluate(sel[0],f=True)
mc.polyShell(thickness = dist,uvOffset = distUV);
sel2 = mc.ls(sl=True)
faceFinalCount = mc.polyEvaluate(sel[0],f=True)
mc.addAttr(sel2[0],ln="div",at='long',min=0,dv=0)
mc.setAttr(sel2[0]+'.div',e=True,keyable=True)
mc.setAttr(sel2[0]+'.div',div)
mc.addAttr(sel2[0],ln="splits",dt="string")
mc.setAttr(sel2[0]+'.splits',e=True,keyable=True)
mc.select((sel[0]+'.f[%i' % (faceInitalCount*2)+':%i' % faceFinalCount+']'))
faceList = mc.ls(sl=True,fl=True)
facesRings = makeFaceRingGroups(faceList)
for faceRing in facesRings:
mc.select(facesRings[faceRing])
mc.ConvertSelectionToContainedEdges()
mc.setAttr(sel2[0]+'.thickness',0.2)
split = mc.polySplitRing(mc.ls(sl=True),ch=True,splitType=2,divisions=0,useEqualMultiplier=1,smoothingAngle=30,fixQuads=1)
splits = mc.getAttr(sel2[0]+'.splits')
if(splits == None):
splits = ""
mc.setAttr(sel2[0]+'.splits',("%s"%splits+"%s,"%split[0]),type="string")
mc.connectAttr(sel2[0]+'.div', (split[0]+'.divisions'))
mc.setAttr(sel2[0]+'.thickness',dist)
mc.connectAttr(sel2[0]+'.thickness',shape[0]+'.shThickness')
mc.connectAttr(sel2[0]+'.uvOffset',shape[0]+'.shUvThickness')
mc.connectAttr(sel2[0]+'.div',shape[0]+'.shDiv')
else:
print('This mesh have a shellModifier allready!!!!!')
else:
mc.error("please select some mesh")
def hfSplitBadShaded(self, engines):
modifiedShapes = []
for sg in engines:
print('checking shading group: '+sg)
cmds.hyperShade(objects=sg)
components = cmds.ls(sl=1)
uniqueShapes = []
for entry in components:
uniqueShapes.append(entry.split('.')[0])
# remove whole shapes (not components) from the list.
if entry.rfind('.f') == -1:
components.remove(entry)
if len(components) > 0:
components.sort()
# remove duplicates from uniqueShapes.
uniqueShapes = list(set(uniqueShapes))
modifiedShapes.extend(uniqueShapes)
# print('\nunique shapes under shading group: ')
# print(uniqueShapes)
for shape in uniqueShapes:
cmds.select(cl=1)
# get the total num of faces for the shape for later use.
totalFaces = cmds.polyEvaluate(shape, f=1)
for comp in components:
testStr = shape+'.f['
if testStr in comp:
# the current component is a member of the current mesh we're splitting and it has the shader we want.
cmds.select(comp, add=1)
selFaces = cmds.ls(sl=1)
# print 'selection:'
# print selFaces
# extract the selected faces if we aren't selecting every face of the current mesh.
if len(selFaces) < int(totalFaces) and len(selFaces) > 0:
cmds.polyChipOff(selFaces, kft=1, dup=0)
cmds.delete(shape,ch=1)
# now the mesh is broken into shells. separate it if possible.
if cmds.polyEvaluate(shape, s=1) > 1:
newObjects = cmds.polySeparate(shape, ch=0)
modifiedShapes.extend(newObjects)
# print('split new shapes: ')
# print(newObjects)
cmds.select(newObjects)
# print(cmds.ls(sl=1))
cmds.delete(ch=1)
cmds.select(cl=1)
# now in order to return all the new meshes we made, we should sort through uniqueShapes and remove anything that no longer
# exists. anything that's been split, etc.
modifiedShapes = list(set(modifiedShapes))
returnShapes = []
for shape in modifiedShapes:
if cmds.objExists(shape) == 0:
modifiedShapes.remove(shape)
else:
meshNodes = cmds.listRelatives(shape, s=1)
if meshNodes != None:
# if we are not testing an xform, meshNodes will be a 'NoneType' object so we should include an exception.
returnShapes.extend(meshNodes)
return returnShapes
def setObjectAsCanvas(name): cmds.polyEvaluate(f=True) subdivSurface = cmds.polyToSubdiv(maxPolyCount=cmds.polyEvaluate(f=True), maxEdgesPerVert=32, ch=False)[0] liveSurface = cmds.subdToNurbs(subdivSurface, ot=0, ch=False) cmds.delete(subdivSurface) cmds.hide(liveSurface) cmds.makeLive(liveSurface) return liveSurface
def rec(object_name, volume_total, cut_planes, volume_ratios, threshold, result, loop_num):
# base cases
if loop_num == 0:
print 'insert more coins to continue'
return False
elif mc.polyEvaluate(object_name, shell = True) > 1:
# more than one shell in object named 'object_name'
print 'NO REDEMPTION'
return False
elif len(volume_ratios) == 1:
# check ratio matches
this_ratio = mm.eval('meshVolume(\"' + object_name + '\")') / volume_total
# since its last one, might have more errors
if abs(this_ratio - volume_ratios[0]) < threshold * 4:
# duplicate the object
temp = mc.duplicate(object_name)
mc.select(temp[0], r = True)
# move away the duplication
mc.move(kMoveAwayXDistance, 0, 0, temp[0])
# remove the current object
mc.delete(object_name)
print 'DONE with last object!'
result.append(temp[0])
print result
return True
else:
print 'last object did NOT match last ratio!', this_ratio, volume_ratios[0]
return False
# recursive step
random.shuffle(cut_planes)
result_from_cutting = cut_object_with_planes_and_ratios(object_name, volume_total, cut_planes, volume_ratios, threshold)
if isinstance(result_from_cutting, list):
# this list contains all successfully cut objects and we are done
result.extend(result_from_cutting)
print 'lucky!'
print result
return True
else:
print 'Enter recursive step'
# dictionary returned
# extend result list with what we have now
result.extend(result_from_cutting['good_cut_objs'])
# merge the remaining objects into one
bad_cut_objs = result_from_cutting['bad_cut_objs']
if mc.polyEvaluate(bad_cut_objs, shell = True) > 1:
united_objects = mc.polyUnite(bad_cut_objs)[0]
mc.polyMergeVertex(united_objects)
else:
united_objects = bad_cut_objs[0]
# get list of ratios un-resolved
ratios_remaining = result_from_cutting['ratios_remaining']
recursion_result = rec(united_objects, volume_total, cut_planes, ratios_remaining, threshold, result, loop_num-1)
return recursion_result
def initMeshFromMayaMesh(self, meshName): _vs = [] _faces = [] numV = mc.polyEvaluate(meshName, v=True) numF = mc.polyEvaluate(meshName, f=True) for i in range(numV): _vs.append(mc.pointPosition(meshName+".vtx["+str(i)+"]")) for i in range(numF): _faces.append(self.faceVtxList(meshName+".f["+str(i)+"]")) self.vs = _vs self.faces = _faces
def cutCell(obj, mat, pos, rot, shardsGRP):
#do the cut procedure
tocut = mc.polyEvaluate(obj, face = True)
mc.polyCut( ('%s.f[0:%d]'% (obj,tocut)), pc = (pos[0], pos[1], pos[2]), ro = (rot[0], rot[1], rot[2]), ch = False, df = True)
cutFaces = mc.polyEvaluate(obj, face = True)
mc.polyCloseBorder(obj, ch = False)
newFaces = mc.polyEvaluate(obj, face = True)
newFaces = newFaces - cutFaces
#assign material to faces
for face in range(newFaces):
mc.sets( ( '%s.f[ %d ]' % (obj, (cutFaces + newFaces - 1))), forceElement = ('%sSG' % (mat)), e = True)
def create(self):
"""create hairsystem for lock"""
numFace = mc.polyEvaluate( self.mesh.shape.name, f = True )
numVert = mc.polyEvaluate( self.mesh.shape.name, v = True )
if not self.hairSystem:
print 'There is no hairSystem assigned to this HairLock --> init with one or assign one.... '
if not numFace % 2 or not numVert == ( numFace + 3 ):
print 'This mesh dosen\'t have odd number of faces', self.mesh.name, 'SKYPING'
return
self._curveMesh = mn.createNode('curvesFromMesh' )
self._curveMesh.name = self.mesh.name + '_curveMesh'
self.mesh.shape.a.outMesh >> self._curveMesh.a.inMesh
self.mesh.shape.a.worldMatrix >> self._curveMesh.a.inWorldMatrix
for i in range(5):
hairCurve = mn.createNode('nurbsCurve' )
hairCurveParent = hairCurve.parent
hairCurveParent.name = self.mesh.name + '_%i'%i + '_crv'
hairCurve = hairCurveParent.shape
self._curveMesh.attr( 'outCurve[%i'%i + ']' ) >> hairCurve.a.create
follicle = mn.createNode('follicle')
folliclePar = follicle.parent
folliclePar.name = self.mesh.name + '_%i'%i + '_foll'
follicle = folliclePar.shape
hairSustemOutHairSize = self.hairSystem.a.outputHair.size
follicle.a.outHair >> self.hairSystem.attr( 'inputHair[%i'%hairSustemOutHairSize + ']' )
#follicle.a.outHair >> self.hairSystem.attr( 'inputHair[%i'%i + ']' )
hairCurve.a.worldSpace >> follicle.a.startPosition
self.hairSystem.attr( 'outputHair[%i'%hairSustemOutHairSize + ']' ) >> follicle.a.currentPosition
self._follicles.append(follicle)
self._curves.append(hairCurve)
#if there is a scalp mesh use that for the position of the follicle
if self.scalp:
self.scalp.shape.a.outMesh >> follicle.a.inputMesh
self.scalp.a.worldMatrix >> follicle.a.inputWorldMatrix
u,v = self._getUVCoordFromScalpForFollicle( hairCurve )
follicle.a.parameterV.v = v
follicle.a.parameterU.v = u
#hairCurveParent.parent = folliclePar
else:
self.mesh.shape.a.outMesh >> follicle.a.inputMesh
self.mesh.a.worldMatrix >> follicle.a.inputWorldMatrix
follicle.a.parameterV.v = 0.5
follicle.a.parameterU.v = 0.5
follicle.a.overrideDynamics.v = 0
follicle.a.startDirection.v = 1
follicle.a.clumpWidthMult.v = 1.5
follicle.a.densityMult.v = 0.5
follicle.a.sampleDensity.v = 1.5
follicle.a.outTranslate >> follicle.parent.a.translate
follicle.a.outRotate >> follicle.parent.a.rotate
def flipWeights(sourceDeformer,targetDeformer,sourceInfluence,targetInfluence,axis='x'):
'''
'''
# Check dnBurlyDeformer
if not glTools.utils.dnBurlyDeformer.isBurlyDeformer(sourceDeformer):
raise Exception('A valid source dnBurlyDeformer must be provided!')
if not isBurlyDeformer(targetDeformer):
raise Exception('A valid target dnBurlyDeformer must be provided!')
# Get influence indices
sourceInfluenceIndex = glTools.utils.dnBurlyDeformer.getInfluenceIndex(sourceDeformer,sourceInfluence)
targetInfluenceIndex = glTools.utils.dnBurlyDeformer.getInfluenceIndex(targetDeformer,targetInfluence)
# Get affected geometry
sourceGeo = glTools.utils.deformer.getAffectedGeometry(sourceDeformer).keys()[0]
targetGeo = glTools.utils.deformer.getAffectedGeometry(targetDeformer).keys()[0]
sourceGeoPntNum = mc.polyEvaluate(sourceGeo,v=True)
targetGeoPntNum = mc.polyEvaluate(targetGeo,v=True)
# Get source influence weights
sourceInfluenceWeights = glTools.utils.dnBurlyDeformer.getInfluenceWeights(dnBurlyDeformer,sourceInfluence)
# Get affected geometry
targetInfluenceWeights = [0.0 for i in range(targetGeoPntNum)]
# Build vertex correspondence table
vtxTable = []
for i in range(sourceGeoPntNum):
# Get source vertex position
pos = glTools.utils.base.getPosition(sourceGeo+'.vtx['+str(i)+']')
# Get mirror position
mPos = pos
mPos[axisInd] *= -1.0
# Get closest vertex to mirror position
mVtx = glTools.utils.mesh.closestVertex(targetGeo,mPos)
vtxTable.append(mVtx)
# Build target influence weights
for i in range(len(sourceInfluenceWeights)):
targetInfluenceWeights[vtxTable[i]] = sourceInfluenceWeights[i]
# Set influence weights
glTools.utils.dnBurlyDeformer.setInfluenceWeights(targetDeformer,targetInfluence,targetInfluenceWeights)
# Rebind influence
mm.eval('dnBurlyDeformer -rebindMuscle "'+targetDeformer+'" "'+targetInfluence+'"')
def isComponent(shape):
result = None
cmds.select(shape)
vert = cmds.polyEvaluate(vertexComponent=True)
face = cmds.polyEvaluate(faceComponent=True)
edge = cmds.polyEvaluate(edgeComponent=True)
if vert > 0:
result = "vert"
elif face > 0:
result = "face"
elif edge > 0:
result = "edge"
else:
result = False
return result
def on_loadUpVert_pushButton_released(self):
sel = cmds.ls(selection=True,flatten=True)
if len(sel) > 0:
shape = cmds.ls(selection=True, objectsOnly=True)[0]
if cmds.nodeType(shape) == 'mesh':
if cmds.polyEvaluate()['vertexComponent']>0:
verts = []
for vert in sel:
verts.append(vert)
self.upVert = verts
self.upVert_label.setText('Vert loaded!')
self.loadUpVert_pushButton.setStyleSheet(self.loadedStyleSheet)
else:
cmds.warning('No vert selected!')
else:
cmds.warning('Selection is not a vertex!')
else:
cmds.warning('Nothing is selected!')
def getObjEdgeCount( self ):
if (len(self)>0):
if('objEdgeCount' not in self.__dict__) or self.objEdgeCount==-1:
self.objEdgeCount = mc.polyEvaluate( self.obj, e=True )
return self.objEdgeCount
else:
return
def getShells(self, obj):
"""
@param[in] obj: object full name
@type obj: string
@returns: list of shells that is included in the passed in object in format [ [[obj.f[0], obj.f[1], obj.f[2]], [obj.f[3], obj.f[4], obj.f[5]], [another shell]], [another object]]
"""
output = []
# total data
numOfShells = cmds.polyEvaluate(obj, s=1)
faceList = cmds.ls(cmds.polyListComponentConversion(obj, tf=True), l=1, fl=1)
for i in range(numOfShells):
# cmds.select(obj)
idx = int(faceList[0].split(".f[")[-1].split("]")[0])
shellFaces = cmds.polySelect(obj, q=1, ets=idx)
shellFacesFormat = [] # obj.f[0], obj.f[1] ...
if shellFaces:
for j in shellFaces:
__faceData = obj + ".f[" + str(j) + "]"
shellFacesFormat.append(__faceData)
faceList = self.comprehensionList(faceList, shellFacesFormat)
output.append(shellFacesFormat)
return output
def __init__(self, model):
BaseStructure.__init__(self, model)
print "-------------------"
print "importing Vertex"
self.vtx_names = GetVerticesList(model)
self.uv_names = self.GetUVNameList()
self.uv_maps = self.GetUVMapList()
self.uv_count = len(self.uv_names)
self.vertex_count = cmds.polyEvaluate(model, v=True)
print "vertex count: ", self.vertex_count
self.uvs = self.ToUVs()
self.map_to_vtx = self.BuildVertexIndicesFromMaps()
self.vtx_to_map = self.BuildMapIndicesFromVertexNames()
# self.indices = self.ToIndices()
self.positions = self.ToPositions()
self.normals = self.ToNormals()
print "normal count: ", len(self.normals)
self.bone_weights = self.InitBoneWeight()
self.bone_num = self.InitBoneNum()
self.edge_flag = self.InitEdgeFlag()
self.count = len(self.positions)
def checkMaxSkinInfluences(self, node, maxInf, debug=1, select=0):
'''Takes node name string and max influences int.
From CG talk thread (MEL converted to Python, then added some things)'''
cmds.select(cl=1)
skinClust = self.findRelatedSkinCluster(node)
if skinClust == "": cmds.error("checkSkinInfluences: can't find skinCluster connected to '" + node + "'.\n");
verts = cmds.polyEvaluate(node, v=1)
returnVerts = []
for i in range(0,int(verts)):
inf= cmds.skinPercent(skinClust, (node + ".vtx[" + str(i) + "]"), q=1, v=1)
activeInf = []
for j in range(0,len(inf)):
if inf[j] > 0.0: activeInf.append(inf[j])
if len(activeInf) > maxInf:
returnVerts.append(i)
if select:
for vert in returnVerts:
cmds.select((node + '.vtx[' + str(vert) + ']'), add=1)
if debug:
print 'checkMaxSkinInfluences>>> Total Verts:', verts
print 'checkMaxSkinInfluences>>> Vertices Over Threshold:', len(returnVerts)
print 'checkMaxSkinInfluences>>> Indices:', str(returnVerts)
return returnVerts
def on_loadPositionVerts_pushButton_released(self):
sel = cmds.ls(selection=True, flatten=True)
if len(sel) > 0:
shape = cmds.ls(selection=True, objectsOnly=True)[0]
if cmds.nodeType(shape) == 'mesh':
if cmds.polyEvaluate()['vertexComponent'] > 0:
verts = []
for vert in sel:
verts.append(vert)
if len(verts) == 2:
self.posVerts = verts
self.positionVerts_label.setText('Verts loaded!')
self.loadPositionVerts_pushButton.setStyleSheet(self.loadedStyleSheet)
else:
cmds.warning('More or Less than two verts selected. Please select only 2 verts.')
else:
cmds.warning('No verts selected!')
else:
cmds.warning('Selection is not a vertex!')
else:
cmds.warning('Nothing is selected!')
def ShapeInverterCmdold(base=None, corrective=None, name=None):
mc.undoInfo(openChunk=True)
if not base or not corrective:
sel = mc.ls(sl=True)
base, corrective = sel
shapes = mc.listRelatives(base, children=True, shapes=True)
for s in shapes:
if mc.getAttr("%s.intermediateObject" % s) and mc.listConnections("%s.worldMesh" % s, source=False):
origMesh = s
break
deformed = mc.polyPlane(ch=False)[0]
mc.connectAttr("%s.worldMesh" % origMesh, "%s.inMesh" % deformed)
mc.setAttr("%s.intermediateObject" % origMesh, 0)
mc.delete(deformed, ch=True)
mc.setAttr("%s.intermediateObject" % origMesh, 1)
if not name:
name = "%s_inverted#" % corrective
invertedShape = duplicateMesh(base, name=name)
deformer = mc.deformer(invertedShape, type="ShapeInverter")[0]
mc.ShapeInverterCmd(baseMesh=base, invertedShape=invertedShape, ShapeInverterdeformer=deformer, origMesh=deformed)
# correctiveShape = duplicateMesh(base,name=corrective+"_corrective#")
# mc.connectAttr('%s.outMesh' % getShape(correctiveShape), '%s.correctiveMesh' % deformer)
# transferMesh(corrective,[correctiveShape])
mc.connectAttr("%s.outMesh" % getShape(corrective), "%s.correctiveMesh" % deformer)
mc.setAttr("%s.activate" % deformer, True)
mc.delete(deformed)
bdingBx = mc.polyEvaluate(corrective, boundingBox=True)
xDifVal = bdingBx[0][1] - bdingBx[0][0]
# mc.move(xDifVal*1.10,correctiveShape,r=True,moveX=True)
mc.move(xDifVal * 2.20, invertedShape, r=True, moveX=True)
mc.undoInfo(closeChunk=True)
return invertedShape # ,correctiveShape
def deformCharacterShapeSel(self, value):
RN = mc.referenceQuery(self.core.skCharacter[int(value)-1], referenceNode=1)
Nodes = mc.referenceQuery(RN, nodes=1)
self.characterdeformShape = []
self.allCharacterRightdeformShape = []
for item in Nodes:
if self.nodeTypeSelf(item) in self.shapeType:
self.characterdeformShape.append(item)
for each in self.characterdeformShape:
itemP = mc.listRelatives(each, p=1)[0]
itemPP = mc.listRelatives(itemP, p=1)
if itemPP != None and mc.getAttr('%s.v'%itemP) != 0 and mc.getAttr('%s.v'%itemPP[0]) != 0:
self.allCharacterRightdeformShape.append(each)
self.allCharacterRightdeformShape.reverse()
#for item in self.allCharacterRightdeformShape:
#if mc.filterExpand( item, sm=(10,12)) == None:
#self.allCharacterRightdeformShape.remove(item)
for i in range(10):
for item in self.allCharacterRightdeformShape:
if self.checkStaticCache(item) == False:
self.allCharacterRightdeformShape.remove(item)
for item in self.allCharacterRightdeformShape:
if mc.polyEvaluate( item, v=True ) == 0:
self.allCharacterRightdeformShape.remove(item)
return self.allCharacterRightdeformShape
def buildSymTable(mesh):
symDict = {}
posDict = {}
negDict = {}
# store positions in separate positive and negative dictionaries
vtxCount = mc.polyEvaluate(mesh, v=1)
for vtxvertId in range(vtxCount):
posX, posY, posZ = mc.xform('%s.vtx[%d]'%(mesh,vtxvertId), q=1, t=1, os=1)
if posX > 0:
posDict[(posX,posY,posZ)] = vtxvertId
elif posX < 0:
negDict[(posX,posY,posZ)] = vtxvertId
# match positive to negative verts in symmetry table
for posKey, vtxvertId in posDict.items():
negKey = (-posKey[0], posKey[1], posKey[2])
if negKey in negDict:
symDict[vtxvertId] = negDict[negKey]
# select assymetrical verts
asymVerts = ['%s.vtx[%d]'%(mesh, vertId) for vertId in range(vtxCount) if vertId not in symDict.keys() and vertId not in symDict.values()]
mc.select(asymVerts)
return symDict
def isEmpty(mesh):
try:
numfaces = cmds.polyEvaluate(mesh,face=True)
except IndexError:
numfaces=0
pass
return False or numfaces == 0
def getObjVertCount(self): if len(self)>0: if 'objVertCount' not in self.__dict__ or self.objVertCount==-1: self.objVertCount = mc.polyEvaluate( self.obj, v=True ) return self.objVertCount else: return
def main(log=None):
if not log:
import logging
log = logging.getLogger()
edge5 = set()
dagNode = cmds.ls(dag = True, l=True, lf=True, type = 'mesh')
for dag in dagNode:
cmds.select(dag)
numFace = cmds.polyEvaluate(f = True)
for f in range(0, numFace):
allEdge = []
cmds.select(cl = True)
cmds.select(dag + '.f[' + str(f) + ']')
edgeNum = cmds.polyInfo(fe = True)
eSplit1 = edgeNum[0].split(':')
eSplit2 = eSplit1[1].split(' ')
for e in eSplit2:
if(e != ''):
allEdge.append(e)
if(len(allEdge) > 5):
edge5.add('%s.f[%s]' %(dag, f))
if edge5:
log.warning("more than four edge:\n%s" % (' '.join(edge5)) )
def modify_surface():
perlin = True
sel = mc.ls(selection=True,long=True)
for verts in sel:
totalVerts = mc.polyEvaluate(verts, vertex=True)
for number in xrange(totalVerts):
if perlin == True:
frequency = 1.0
amplitude = 1.5
octaves = 8
for o in xrange(octaves):
randX = random.triangular(-0.2 , 0.0, 0.2)
posX = perlinNoise(randX ,0,0)
randY = random.triangular(-0.4 , 0.0, 0.6)
posY = perlinNoise(0,randY,0)
randZ = random.triangular(-0.2 , 0.0, 0.2)
posZ = perlinNoise(0,0,randZ)
posX *= frequency
posY *= frequency
posZ *= frequency
mc.select(verts+'.vtx[{number}]'.format(number=number))
mc.move(posX,posY*amplitude,posZ,relative=True)
mc.rotate(posY*amplitude,y=True)
mc.select(sel, replace=True)
mc.makeIdentity(s=True, a=True, t=True,r=True)
def exportWeight (objs, path) :
xmlFile = open(path,'w')
root_node = xml.Element('exportedSkinWeight')
for obj in objs:
skinCluster = getSkinClusterNode(obj)
vertexCount = cmds.polyEvaluate(obj, v=True)
jointDicts = getJointDicts(skinCluster)
obj_node = xml.Element('objectName')
obj_node.text = obj
root_node.append(obj_node)
# PROGRESS BAR START
gMainProgressBar = mel.eval('$tmp = $gMainProgressBar')
cmds.progressBar( gMainProgressBar, edit=True, beginProgress=True, status="PROCESS // Exporting Weight : %s (count = %d)" %(obj,vertexCount), maxValue=vertexCount)
for vertex in range(vertexCount):
for jointDict in jointDicts:
value = cmds.getAttr(skinCluster+'.wl[%d].w[%d]' %(int(vertex), int(jointDict['jointIndex'])))
if not value == 0:
vtx_node = xml.Element('skinWeightInfo')
obj_node.append(vtx_node)
vtx_node.attrib['vertex'] = str(vertex)
vtx_node.attrib['jointName'] = jointDict['jointName']
vtx_node.attrib['value'] = str(value)
#PROGRESS BAR STEP
cmds.progressBar(gMainProgressBar, edit=True, step=1)
# PROGESS BAR END
cmds.progressBar(gMainProgressBar, edit=True, endProgress=True)
indent(root_node)
xml.ElementTree(root_node).write(xmlFile)
xmlFile.close()
def copyPaintAttr(mesh, attr, sourceAttr, attrType="doubleArray"):
"""
Copy the value of one paintable attribute to another
@param mesh: Mesh that contains the attribute to copy values to
@type mesh: str
@param attr: The name of the attribute to copy the values to
@type attr: str
@param sourceAttr: The attribute to copy values from
@type sourceAttr: str
@param attrType: The attribute type to set
@type attrType: str
"""
# Check Mesh
if not glTools.utils.mesh.isMesh(mesh):
raise Exception('Mesh "' + mesh + '" does not exist!!')
# Check Mesh Attribute
if not mc.objExists(mesh + "." + attr):
addPaintAttr(mesh, attr, attrType)
# Copy Attribute Values
vtxCount = mc.polyEvaluate(mesh, v=True)
attrVal = []
for i in range(vtxCount):
val = mc.getAttr(sourceAttr + "[" + str(i) + "]")
attrVal.append(val)
# Set Attribute Value
mc.setAttr(mesh + "." + attr, attrVal, type=attrType)
def instantMeshes_remesh(self, face_count=None):
inst_mesh_path = LDMTPATH + "/ldmt_exe/instantMesh.exe"
if not os.path.exists(inst_mesh_path):
cmds.warning('Instant Mesh path not found!')
return
# Get current selection
sel_obj = cmds.ls(sl=True)
if sel_obj:
print 'Processing Instant Mesh...'
# if no polycount set just double the amount of the source object
if not face_count:
face_count = int(cmds.polyEvaluate(sel_obj, f=True))
face_count *= 2
face_count /= 2
# Create temp file for OBJ export
temp = tempfile.NamedTemporaryFile(prefix='instantMesh_',
suffix='.obj',
delete=False)
temp_path = temp.name
# Save the currently selected object as an OBJ
cmds.file(temp_path, force=True, exportSelected=True, type="OBJ")
# run instamesh command on the OBJ
print temp_path
print "Instant Mesh start"
some_command = inst_mesh_path + " " + temp_path + " -o " + temp_path + " -f " + str(
face_count) + " -D" + " -b"
p = subprocess.Popen(some_command,
stdout=subprocess.PIPE,
shell=True)
p.communicate()
p.wait()
print "Instant Mesh end"
print some_command
# import back the temp OBJ file
returnedNodes = cmds.file(temp_path,
i=True,
type="OBJ",
rnn=True,
ignoreVersion=True,
options="mo=0",
loadReferenceDepth="all")
# delete the temp file
temp.close()
# Select the imported nodes
if returnedNodes:
cmds.select(returnedNodes, r=True)
print 'Instant Mesh done...'
else:
cmds.warning('No objects selected...')
def badNGons(self):
sel = cmds.ls(sl=1)
cmds.selectMode(q=1, co=1)
cmds.polySelectConstraint(m=3, t=0x0008, sz=3)
cmds.polySelectConstraint(dis=1)
numPolys = cmds.polyEvaluate(fc=1)
try:
self.polyCountLabel.setText('Poly Counts: %s N-Gon(s)' %
str(int(numPolys)))
except:
self.polyCountLabel.setText('Please Select a Mesh!')
def get_closest_vtx(self, element, obj):
vtxs = cmds.polyEvaluate(obj, v=True)
check_value = float('inf')
current_vtx = ''
element_pos = self.get_pos(element)
for vtx in range(0, vtxs + 1):
l = self.get_length(element_pos,
self.get_pos(obj + '.vtx[%s]' % vtx))
if l < check_value:
check_value = l
match_l = vtx
return match_l
def find_same_poly(sel = True) :
# find similar polygon by count faces
sels = mc.ls(sl = True)
if sels :
numFace = mc.polyEvaluate(sels[0], f = True, fmt = True)
matchPoly = []
matchPoly.append(sels[0])
mc.select(cl = True)
allPlys = mc.ls(type = 'mesh', l = True)
for each in allPlys :
transform = mc.listRelatives(each, p = True, f = True)[0]
currentFaceCount = mc.polyEvaluate(each, f = True, fmt = True)
if currentFaceCount == numFace :
matchPoly.append(transform)
if sel :
mc.select(matchPoly)
return matchPoly
def vtxInRange(mesh, pos, dist):
'''
returns a list of vertices which are near the
supplied position within the given distance param
'''
vtxList = []
for i in range(0, cmds.polyEvaluate(mesh, vertex=True)):
vtxPos = cmds.xform('{}.vtx[{}]'.format(mesh, i),
q=True,
ws=True,
t=True)
currDist = self.distance(vtxPos, pos)
if currDist > dist: continue
vtxList.append(i)
return vtxList
def uvOrientationCheck():
sel = cmds.ls(sl=True, l=True)
offenders = []
for s in sel:
uvs = cmds.ls(cmds.polyListComponentConversion(s, toUV=True), fl=True)
vMax = cmds.polyEvaluate(s, b2=True)[1][0]
vMin = cmds.polyEvaluate(s, b2=True)[1][1]
highestUV = ''
lowestUV = ''
for u in uvs:
vValue = cmds.polyEditUV(u, q=True)[1]
if vValue > vMax:
vMax = vValue
highestUV = u
if vValue < vMin:
vMin = vValue
lowestUV = u
highestVert = cmds.polyListComponentConversion(highestUV,
toVertex=True)
lowestVert = cmds.polyListComponentConversion(lowestUV, toVertex=True)
highestVertY = cmds.xform(highestVert, t=True, q=True, ws=True)[1]
lowsetVertY = cmds.xform(lowestVert, t=True, q=True, ws=True)[1]
if lowsetVertY < highestVertY:
pass
else:
offenders.append(s)
if len(offenders) > 0:
cmds.select(offenders, r=True)
else:
print "All good so far."
def udim_range():
bake_sets = list(bake_set for bake_set in cmds.ls(type='VRayBakeOptions') \
if bake_set != 'vrayDefaultBakeOptions')
u_max = 0
v_max = 0
for bake_set in bake_sets:
conn_list = cmds.listConnections(bake_set)
if conn_list == None or len(conn_list) == 0:
continue
uv_info = cmds.polyEvaluate(conn_list[0], b2=True)
if uv_info[0][1] > u_max:
u_max = int(math.ceil(uv_info[0][1]))
if uv_info[1][1] > v_max:
v_max = int(math.ceil(uv_info[1][1]))
return '1001-%d' % (1001 + u_max + (10 * v_max))
def estimate_num_samples(self, node):
""" estimate how many random samples we need for grid or disk sampling """
self._node = node
emit_type = cmds.getAttr('{}.emitType'.format(node))
if emit_type == 1:
cell_size = cmds.getAttr(self._node + '.cellSize')
elif emit_type == 2:
cell_size = cmds.getAttr(self._node + '.minRadius') / math.sqrt(3)
else:
return
in_mesh = node_utils.get_connected_in_mesh(self._node)
area = cmds.polyEvaluate(in_mesh, worldArea=True)
cmds.setAttr(self._node + '.numSamples', int(area/cell_size) * 5)
def chkTopoOldNewMdl(*args):
# Check Topology Difference Between Old Model and New Model #
selLs = cmds.ls(sl=True)
oldMdlLod03Grp = selLs[0]
newMdlLod03Grp = selLs[1]
oldMdlLs = cmds.listRelatives(oldMdlLod03Grp, ad=True, fullPath=True, type='mesh')
newMdlLs = cmds.listRelatives(newMdlLod03Grp, ad=True, fullPath=True, type='mesh')
difMdlLs = []
for i in xrange(len(oldMdlLs)):
oldMdlNumVertex = cmds.polyEvaluate(oldMdlLs[i], vertex=True)
newMdlNumVertex = cmds.polyEvaluate(newMdlLs[i], vertex=True)
if oldMdlNumVertex != newMdlNumVertex:
difMdlLs.append(oldMdlLs[i])
difMdlLs.append(newMdlLs[i])
if difMdlLs:
cmds.select(difMdlLs, r=True)
cmds.warning('Selected objecs are have different topology.')
else:
cmds.select(cl=True)
def remesh(self):
targetCount = self.text_targetCount.toPlainText()
try:
if targetCount.endswith('%'):
sel = cmds.ls(sl=1, o=1)
sel = sel[0]
currentFaceCount = int(cmds.polyEvaluate(sel, f=True))
targetCount = 2 * int(
currentFaceCount * float(targetCount[:-1]) / 100)
else:
targetCount = int(targetCount)
except:
ld.msg('Please input a number or ratio!')
return
self.instantMeshes_remesh(targetCount)
def softSelectToCluster(mesh):
# Get the manipulator position for the selection
cmds.setToolTo('Move')
currentMoveMode = cmds.manipMoveContext('Move', query=True, mode=True) #Get the original mode
cmds.manipMoveContext('Move', edit=True, mode=0) #set to the correct mode
pos = cmds.manipMoveContext('Move', query=True, position=True) # get the position
cmds.manipMoveContext('Move', edit=True, mode=currentMoveMode) # and reset
# Grab the soft selection values using the API
selection = om.MSelectionList()
ssel = om.MRichSelection()
ssel.getSelection(selection)
dagPath = om.MDagPath()
component = om.MObject()
vertIter = om.MItSelectionList(selection, om.MFn.kMeshVertComponent)
elements, weights = [], []
# TODO Be a bit more explicit here with the mesh, its shapeNode, and the dagPath
# so we can make sure we don't have multiple meshes with verts selected
softSel = {}
while not vertIter.isDone():
vertIter.getDagPath(dagPath, component)
dagPath.pop() #Grab the parent of the shape node
node = dagPath.fullPathName()
fnComp = om.MFnSingleIndexedComponent(component)
getWeight = lambda i: fnComp.weight(i).influence() if fnComp.hasWeights() else 1.0
for i in range(fnComp.elementCount()):
softSel[fnComp.element(i)] = getWeight(i)
vertIter.next()
if not softSel:
print "No Soft Selection"
return
# Build the Cluster and set the weights
clusterNode, clusterHandle = cmds.cluster(mesh, name='softSel')
vnum = cmds.polyEvaluate(mesh, vertex=1)
weights = [softSel.get(i, 0.0) for i in range(vnum)]
cmds.setAttr('{0}.weightList[0].weights[0:{1}]'.format(clusterNode, vnum-1), *weights, size=vnum)
# Reposition the cluster
cmds.xform(clusterHandle, a=True, ws=True, piv=(pos[0], pos[1], pos[2]))
clusterShape = cmds.listRelatives(clusterHandle, c=True, s=True)
cmds.setAttr(clusterShape[0] + '.origin', pos[0], pos[1], pos[2])
def validateMeshArg(self, mesh=None):
'''
Validates a mesh and returns a dict of data
:param mesh: mesh to evaluate
'''
_mesh = None
_skin = None
if mesh is None:
#if self.d_kws.get('sourceMesh'):
#log.info("Using stored sourceMesh data")
#sourceMesh = self.d_kws.get('sourceMesh')
#else:
log.info("No source specified, checking if selection found")
_bfr = mc.ls(sl=True)
if not _bfr:
raise ValueError, "No selection found and no source arg"
mesh = _bfr[0]
_type = search.returnObjectType(mesh)
if _type in ['mesh', 'nurbsCurve', 'nurbsSurface']:
if _type in ['nurbsCurve', 'nurbsSurface']:
raise NotImplementedError, "Haven't implemented nurbsCurve or nurbsSurface yet"
log.info("Skinnable object '{0}', checking skin".format(mesh))
_mesh = mesh
_skin = skinning.querySkinCluster(_mesh) or False
if _skin:
log.info("Found skin '{0}' on '{1}'".format(_skin, _mesh))
elif _type in ['skinCluster']:
log.info("skinCluster '{0}' passed...".format(mesh))
_skin = mesh
_mesh = attributes.doGetAttr(_skin, 'outputGeometry')[0]
log.info("Found: {0}".format(_mesh))
else:
raise ValueError, "Not a usable mesh type : {0}".format(_type)
_shape = mc.listRelatives(_mesh, shapes=True, fullPath=False)[0]
_return = {
'mesh': _mesh,
'meshType': _type,
'shape': _shape,
'skin': _skin,
'component': data._geoToComponent.get(_type, False),
'pointCount': mc.polyEvaluate(_shape, vertex=True)
}
return _return
def shaders_export(id, shape, path):
attributes = cmds.listAttr(shape)
shadingGrp = cmds.listConnections(shape, type='shadingEngine')
if shadingGrp != None:
lenShadingGrp = ''
lenShadingGrp = len(shadingGrp)
ShapeListSG = []
if lenShadingGrp > 1:
if "Face_id" in attributes:
print "ok"
else:
cmds.addAttr(shape, longName='Face_id', dt="string")
shadingGrp = list(set(shadingGrp))
for j in shadingGrp:
cmds.hyperShade(o=j)
assignSelected = cmds.ls(sl=1)
SuperAttr = j + id + "#"
for t in assignSelected:
if ".f" in t:
t_tmp = t.split(".f")
t = t_tmp[0].rpartition(':')[2]
t = t + ".f" + t_tmp[1]
vertexes = cmds.polyEvaluate(shape, v=True)
t = t + "$vertexes" + str(vertexes) + "$"
# t = "{}.f" + t_tmp[1]
SuperAttr = SuperAttr + t + ","
ShapeAttr = cmds.getAttr(shape + '.Face_id')
if ShapeAttr == None:
ShapeAttr = ''
cmds.setAttr(shape + '.Face_id', ShapeAttr + "@" + SuperAttr, type="string")
shader = cmds.ls(cmds.listConnections(shadingGrp), materials=1)
shaderSG = shadingGrp + shader
cmds.select(shaderSG, r=True, ne=True)
cmds.file (path + id + ".mb", es=True, type='mayaBinary')
if lenShadingGrp == 1:
shader = cmds.ls(cmds.listConnections(shadingGrp), materials=1)
shaderSG = shadingGrp + shader
cmds.select(shaderSG, r=True, ne=True)
cmds.file (path + id + ".mb", es=True, type='mayaBinary')
def adaptPoly():
selected = mc.ls(sl=True)
comp_listRetopo = []
for a in selected:
listMesh = cmds.ls(a, dag=True, tl=1, type='mesh')
listRetopo = cmds.listConnections(listMesh, type='polyRetopo')
comp_listRetopo.append(listRetopo)
flattened_Comp_listRetopo = []
for x in comp_listRetopo:
for y in x:
flattened_Comp_listRetopo.append(y)
srfAreaList = []
for i in selected:
srfObj = mc.polyEvaluate(str(i), a=True)
srfAreaList.append(srfObj)
objFCountList = []
tObjFCountList = []
bigValue = max(srfAreaList)
minValue = min(srfAreaList)
ratio = bigValue / minValue
#if one of selected pieces is smaller then required ratio - increase FaceCount
if ratio > 210:
iterObj = iter(srfAreaList)
for t in srfAreaList:
objFCount = (10 * t) / minValue
objFCountList.append(objFCount)
iterObj = iter(objFCountList)
for e in flattened_Comp_listRetopo:
mc.setAttr((e + '.targetFaceCount'), next(iterObj))
#reset Slider value to 0 and delete all list members
mc.intSlider('slider', edit=True, value=0)
del listas[:]
else:
for u in srfAreaList:
objProc = (u * 100) / bigValue
objFCount = (2000 * objProc) / 100
objFCountList.append(objFCount)
iterObj = iter(objFCountList)
for e in flattened_Comp_listRetopo:
mc.setAttr((e + '.targetFaceCount'), next(iterObj))
#reset Slider value to 0 and delete all list members
mc.intSlider('slider', edit=True, value=0)
del listas[:]
def edo_addSkinClusterAfterSkinCluster(m, zj, sk, weight):
#m=m
#weight=1
#sk=sk
if cmds.objExists(sk):
return False
cmds.select(m, r=1)
sk = cmds.deformer(type='skinCluster', n=sk)[0]
cmds.connectAttr(zj + '.worldMatrix[0]', sk + '.matrix[0]')
mt = cmds.getAttr(zj + '.worldInverseMatrix[0]')
cmds.setAttr(sk + '.bindPreMatrix[0]', mt, type='matrix')
#cmds.getAttr(sk+'.bindPreMatrix[0]')
cw = cmds.polyEvaluate(m, v=1)
for i in range(0, cw):
#print 'set '+sk+'.weightList['+str(i)+'].weights[0] .... 1'
cmds.setAttr(sk + '.weightList[' + str(i) + '].weights[0]', 1)
def getPosTable(mesh, **kwargs):
'''
returns dictionary
{vertId : dt.Point(x,y,z)}
'''
vertCount = mc.polyEvaluate(mesh, v=True)
retDict = {}
for vertId in range(vertCount):
retDict[vertId] = dt.Point(
*mc.pointPosition('%s.vtx[%d]' % (mesh, vertId), **kwargs))
return retDict
def run(self):
selected = mc.ls(sl=1)
if not selected:
self.fail_check(u"先手动选中模型大组")
return
selected = mc.ls(sl=1)[0]
meshes = mc.listRelatives(selected, ad=1, type="mesh")
for mesh in meshes:
vtx_num = mc.polyEvaluate(mesh, vertex=1)
if not vtx_num:
continue
vertexes = "%s.vtx[0:%s]" % (mesh, vtx_num - 1)
mc.polyMoveVertex(vertexes, ld=(0, 0, 0))
mc.select(clear=1)
mc.select(selected, r=1)
self.pass_check(u"所有的点已清零")
def getInfo(sel):
edgeCount = cmds.polyEvaluate(sel, e=True)
cmds.select(str(sel[0]) + '.e[0:' + str(edgeCount) + ']')
'''limit selection to hard edges with poly constraint'''
cmds.polySelectConstraint(t=0x8000, sm=1, m=2)
getHardEdges = cmds.ls(sl=True)
cmds.select(r=True)
''' turns off poly constraint'''
cmds.polySelectConstraint(t=0x8000, sm=1, m=0)
cmds.select(sel, r=True)
'''seperating hard edge number'''
a = [x.split('[')[1] for x in getHardEdges]
hardEdges = [x.strip(']') for x in a]
return hardEdges, edgeCount
def get_invalid(cls, instance):
invalid = []
meshes = cmds.ls(instance, type="mesh", long=True)
for mesh in meshes:
num_vertices = cmds.polyEvaluate(mesh, vertex=True)
# Vertices from all edges
edges = "%s.e[*]" % mesh
vertices = cmds.polyListComponentConversion(edges, toVertex=True)
num_vertices_from_edges = len_flattened(vertices)
if num_vertices != num_vertices_from_edges:
invalid.append(mesh)
return invalid
def getUV():
# collection of uv coordinates
cmds.select(geometryName)
count = cmds.polyEvaluate(uv=True)
listUVCount = range(1, count)
c = 1
uvList = []
for i in listUVCount:
while c != count:
c += 1
cmds.select(str(geometryName[0]) + '.map[' + str(c) + ']')
positions = cmds.polyEditUV(q=True)
uvList.append(positions)
if c == count:
return uvList
def XYZ_to_vtx(coordinate):
# takes in coordinate [x,y,z] and returns the minimum distance
min_dist = -1
min_vtx = 0
cmds.select("shirt")
num_points = cmds.polyEvaluate(v=True)
for n in range(num_points):
v = get_position('shirt.vtx[' + str(n) + ']')
dist = math.sqrt((coordinate[0]-v[0])**2 + (coordinate[2]-v[2])**2)
if (min_dist < 0):
min_dist = dist
min_vtx = n
if (min_dist > dist):
min_dist = dist
min_vtx = n
return min_vtx
def selectCreasesEdges(object):
"""
This definition cleans Maya hierarchical polygonal conversion.
:param object: Object to select creases edges. ( String )
"""
edges = cmds.ls(object + ".e[0:" +
str(cmds.polyEvaluate(object, edge=True) - 1) + "]",
fl=True)
creaseEdges = [
edge for edge in edges
if cmds.polyCrease(edge, q=True, v=True)[0] > 0.0
]
if creaseEdges:
cmds.select(creaseEdges)
def dm2skin_getVertexPositionsOverRange(mesh, startFrame=0, endFrame=1):
"""Gets a list of lists of vertex positions for the given mesh. One list for
each frame between startFrame and endFrame."""
numVerts = cmds.polyEvaluate(mesh, v=True)
resultList = []
for i in range(startFrame, endFrame + 1):
tempList = []
cmds.currentTime(i)
for j in range(0, numVerts):
tempPos = cmds.xform(mesh + '.vtx[' + str(j) + ']',
q=True,
ws=True,
t=True)
tempList.append(np.array([tempPos[0], tempPos[1], tempPos[2]]))
resultList.append(tempList)
return resultList
def pre_meshMirror(original, target, axis, position, search, replace):
listTarget = target.split(', ')
if len(original) == 0 or len(target) == 0:
return
type = mc.objectType(mc.listRelatives(original, c=1, s=1)[0])
origCompCount = 0
if type == 'mesh':
origCompCount = mc.polyEvaluate(original, v=1)
elif type == 'nurbsSurface':
origShape = mc.listRelatives(original, c=1, s=1)
origCompCount = mc.getAttr(origShape[0] +
'.spansU') + mc.getAttr(origShape[0] +
'.spansV')
for obj in listTarget:
meshMirror(original, obj, type, origCompCount, axis, position, search,
replace)
def __init__(self, numberOfVertices=10):
if not funnyPlane.plane:
funnyPlane.plane = mc.polyPlane(sx=10, sy=10, w=10, h=10)[0]
numVertices = mc.polyEvaluate(funnyPlane.plane, vertex=True)
self.vertexList = []
self.positions = []
if numberOfVertices < numVertices:
self.vertexList = random.sample(range(numVertices),
numberOfVertices)
for vertex in self.vertexList:
position = mc.pointPosition(funnyPlane.plane + ".vtx[" +
str(vertex) + "]")
self.positions.append(position)
mc.polyMoveVertex(funnyPlane.plane + ".vtx[" + str(vertex) +
"]",
translateY=2)
def bGQuads(self, _=False):
bGsel = cmds.ls(sl=True)
cmds.selectMode(q=True, co=True)
cmds.polySelectConstraint(m=3, t=0x0008, sz=2)
cmds.polySelectConstraint(dis=True)
bGPolys = cmds.polyEvaluate(fc=True)
try:
cmds.textField(self.bG_output,
e=True,
tx=("%s 个四边面" % int(bGPolys)))
except:
cmds.textField(self.bG_output, e=True, tx=("请选择模型"))
def findFaces(mesh):
faces = []
faceCount = cmds.polyEvaluate(mesh, face=True)
meshTransform = cmds.xform(mesh, query=True, matrix=True, worldSpace=True)
for face in range(0, faceCount):
faceName = mesh + ".f[" + str(face) + "]"
vtxLst = cmds.polyInfo(faceName, faceToVertex=True)
vtxIdx = str(vtxLst[0]).split()
vtxIdx = vtxIdx[2:]
""" Vertex positions """
vtxA = cmds.getAttr(mesh + ".vt[" + vtxIdx[0] + "]")
vtxB = cmds.getAttr(mesh + ".vt[" + vtxIdx[1] + "]")
vtxC = cmds.getAttr(mesh + ".vt[" + vtxIdx[2] + "]")
vtxD = cmds.getAttr(mesh + ".vt[" + vtxIdx[3] + "]")
""" Make each vertex a list """
vtxA = list(vtxA[0])
vtxB = list(vtxB[0])
vtxC = list(vtxC[0])
vtxD = list(vtxD[0])
""" Multiply verticies by transform matrix (convert to world space) """
vtxA = matrixMult(meshTransform, vtxA)
vtxB = matrixMult(meshTransform, vtxB)
vtxC = matrixMult(meshTransform, vtxC)
vtxD = matrixMult(meshTransform, vtxD)
vertices = [vtxA, vtxB, vtxC, vtxD]
normal = getNormal(vtxA, vtxB, vtxC)
""" Getting center of the face by querying the position of the move manipulator """
cmds.select(faceName)
cmds.setToolTo('moveSuperContext')
centerPos = cmds.manipMoveContext('Move', q=True, p=True)
""" Get radius around center to place start/end point at """
radius = [0.0, 0.0, 0.0]
vecAB = convertToVec(vtxA, vtxB)
vecAC = convertToVec(vtxA, vtxC)
for axes in range(0, len(vecAB)):
radius[axes] = ((vecAB[axes] + vecAC[axes]) / 2.0)
faceInfo = {
'normal': normal,
'center': centerPos,
'radius': radius,
'vertices': vertices,
}
faces.append(faceInfo)
return faces
def set_UV_ratio(obj):
try:
print active_ratio
except:
om.MGlobal.displayError("Please pick a checker size first")
return
orig_sele = cmds.ls(sl=True, fl=True)
if len(orig_sele) == 0:
om.MGlobal.displayError("Select at least one object")
return
prog = 0.00
cmds.progressBar(progressControl, edit=True, visible=True)
cmds.progressBar(progressControl, edit=True, beginProgress=True)
for i in range(0, len(orig_sele)):
if (len(orig_sele) != 0):
if (obj == 1):
prog += (i * 1.000 / len(orig_sele) * 1.000) * 20
cmds.progressBar(progressControl, edit=True, pr=prog)
else:
prog += (i * 1.000 / len(orig_sele) * 1.000) * 15
cmds.progressBar(progressControl, edit=True, pr=4 + prog)
cmds.select(cl=True)
mel.eval("select " + orig_sele[i])
current_ratio = get_sel_faces_UV_ratio(0)
if current_ratio == 0:
current_ratio = 1
scale_factor = active_ratio / current_ratio
scale_factor = math.sqrt(scale_factor)
mel.eval("PolySelectConvert 4")
UV_bounds = cmds.polyEvaluate(bc2=True)
u_pivot = (UV_bounds[0][0] + UV_bounds[0][1]) / 2
v_pivot = (UV_bounds[1][0] + UV_bounds[1][1]) / 2
cmds.polyEditUV(pu=u_pivot,
pv=v_pivot,
su=scale_factor,
sv=scale_factor)
cmds.select(cl=True)
for i in range(0, len(orig_sele)):
mel.eval("select -add " + orig_sele[i])
cmds.progressBar(progressControl, edit=True, endProgress=True)
cmds.progressBar(progressControl, edit=True, visible=False)
om.MGlobal.displayInfo("Done")
def get(sel, what):
if what == "uvid_uv":
selMesh = MFnMesh(sel)
uvid_uv = []
uvArray = selMesh.getUVs()
for i in xrange(len(uvArray[0])):
uvid_uv.append([uvArray[0][i], uvArray[1][i]])
return uvid_uv
elif what == "vtxid_uvid":
vtxid_uvid = []
selVtxIter = MItMeshVertex(sel)
while not selVtxIter.isDone():
vtxid_uvid.append(list(set(selVtxIter.getUVIndices()))[0])
selVtxIter.next()
return vtxid_uvid
elif what == "bb":
return cmds.polyEvaluate(sel, b=1)
def return_max_vertex_skin_infs(skin_cluster, skin_mesh):
"""
return_max_vertex_skin_infs('skinCluster1', 'Octopus_LOD0_Mesh')
"""
vert_count = cmds.polyEvaluate(skin_mesh, v=1) - 1
max_vert_infs = 0
for i in range(0, vert_count):
vert_name = "{}.vtx[{}]".format(skin_mesh, i)
vert_infs = cmds.skinPercent(skin_cluster,
vert_name,
ignoreBelow=.001,
q=1,
t=None)
if len(vert_infs) > max_vert_infs:
max_vert_infs = len(vert_infs)
return max_vert_infs
