def createWeigthListFromTransform(mesh,transform):
meshPath = GenAPI.getDagPath(mesh)
transformPath = GenAPI.getDagPath(transform)
transformFn = om.MFnTransform(transformPath)
origTransform = transformFn.transformation()
transformFn.set(om.MTransformationMatrix.identity)
geoItr = om.MItGeometry(meshPath)
origPositions = om.MPointArray()
geoItr.allPositions(origPositions,om.MSpace.kWorld)
translateVector = om.MVector(1,0,0)
transformFn.translateBy(translateVector,om.MSpace.kWorld)
geoItr = om.MItGeometry(meshPath)
deltaPositions = om.MPointArray()
geoItr.allPositions(deltaPositions,om.MSpace.kWorld)
weightList = []
for i in range(origPositions.length()):
weight = MeasuringTool.getVectorLengthBetween(origPositions[i],deltaPositions[i])
weightList.append(weight)
transformFn.set(origTransform)
return weightList
def transferReverseWeightList(geo, fromDeformer, toDeformer):
'''
method for quickly transfering reversed weightList
input python string (mesh)
input pythin string (fromDeformer)
input python string (toDeformer)
'''
geoPath = GenAPI.getDagPath(geo)
deformerObjectFrom = GenAPI.getMObject(fromDeformer)
deformerObjectTo = GenAPI.getMObject(toDeformer)
vertItr = om.MItMeshVertex(geoPath)
deformerWeightFn = oma.MFnWeightGeometryFilter()
while not vertItr.isDone():
componentObject = vertItr.currentItem()
weights = om.MFloatArray()
deformerWeightFn.setObject(deformerObjectFrom)
deformerWeightFn.getWeights(geoPath, componentObject, weights)
if weights[0] > 0.000:
weights[0] = abs(weights[0] - 1.0)
deformerWeightFn.setObject(deformerObjectTo)
deformerWeightFn.setWeight(geoPath, componentObject, weights)
vertItr.next()
def createWeightListFromMesh(fromMesh,toMesh):
fromMeshPath = GenAPI.getDagPath(fromMesh)
toMeshPath = GenAPI.getDagPath(toMesh)
fromVertItr = om.MItMeshVertex(fromMeshPath)
toVertItr = om.MItMeshVertex(toMeshPath)
util = om.MScriptUtil()
intPtr = util.asIntPtr()
weightList = []
progressWin = UILib.ProgressWin()
progressWin.itr = fromVertItr.count()
while not fromVertItr.isDone():
toVertItr.setIndex(fromVertItr.index(),intPtr)
currentFromVertPoint = fromVertItr.position()
currentToVertPoint = toVertItr.position()
length = MeasuringTool.getVectorLengthBetween(currentFromVertPoint, currentToVertPoint)
weight = max(min(length, 1), 0)
weightList.append(weight)
progressWin.message = '%s.vtx[%i]'%(fromMesh, fromVertItr.index())
progressWin.inc = fromVertItr.index()
progressWin.progress()
fromVertItr.next()
progressWin.end()
return weightList
def getInfluencesAffectingPointsFromLists(self,selectionList):
'''
returns influences that affect components
input MSelectionList
output MSelectionList
'''
array = []
selectionList.getSelectionStrings(array)
flattenedArray = GenAPI.flattenList(array)
influences = self.getInfluencesFromSkincluster()
influencdSelectionList = om.MSelectionList()
weights = om.MDoubleArray()
outputSelectionList = om.MSelectionList()
for component in flattenedArray:
for i in range(influences.length()):
self.skinclusterFn.getPointsAffectedByInfluence(influences[i],influencdSelectionList,weights)
tempArray = []
influencdSelectionList.getSelectionStrings(tempArray)
tempFlattenedArray = GenAPI.flattenList(tempArray)
for tempComponent in tempFlattenedArray:
if tempComponent == component:
outputSelectionList.add(influences[i])
return outputSelectionList
def getInfluencesAffectingPointsFromLists(self, selectionList):
'''
returns influences that affect components
input MSelectionList
output MSelectionList
'''
array = []
selectionList.getSelectionStrings(array)
flattenedArray = GenAPI.flattenList(array)
influences = self.getInfluencesFromSkincluster()
influencdSelectionList = om.MSelectionList()
weights = om.MDoubleArray()
outputSelectionList = om.MSelectionList()
for component in flattenedArray:
for i in range(influences.length()):
self.skinclusterFn.getPointsAffectedByInfluence(
influences[i], influencdSelectionList, weights)
tempArray = []
influencdSelectionList.getSelectionStrings(tempArray)
tempFlattenedArray = GenAPI.flattenList(tempArray)
for tempComponent in tempFlattenedArray:
if tempComponent == component:
outputSelectionList.add(influences[i])
return outputSelectionList
def createWeigthListFromInfluence(mesh,transform):
meshPath = GenAPI.getDagPath(mesh)
transformPath = GenAPI.getDagPath(transform)
transformFn = om.MFnTransform(transformPath)
geoItr = om.MItGeometry(meshPath)
weightList = []
translateVector = om.MVector(1,0,0)
while not geoItr.isDone():
transformFn.set(om.MTransformationMatrix.identity)
vertStartPos = geoItr.position(om.MSpace.kWorld)
transformFn.translateBy(translateVector,om.MSpace.kWorld)
vertEndPos = geoItr.position(om.MSpace.kWorld)
length = MeasuringTool.getVectorLengthBetween(vertStartPos, vertEndPos)
weightList.append(length)
transformFn.set(om.MTransformationMatrix.identity)
geoItr.next()
return weightList
def transferReverseWeightList(geo,fromDeformer,toDeformer):
'''
method for quickly transfering reversed weightList
input python string (mesh)
input pythin string (fromDeformer)
input python string (toDeformer)
'''
geoPath = GenAPI.getDagPath(geo)
deformerObjectFrom = GenAPI.getMObject(fromDeformer)
deformerObjectTo = GenAPI.getMObject(toDeformer)
vertItr = om.MItMeshVertex(geoPath)
deformerWeightFn = oma.MFnWeightGeometryFilter()
while not vertItr.isDone():
componentObject = vertItr.currentItem()
weights = om.MFloatArray()
deformerWeightFn.setObject(deformerObjectFrom)
deformerWeightFn.getWeights(geoPath,componentObject,weights)
if weights[0] > 0.000:
weights[0] = abs(weights[0] - 1.0)
deformerWeightFn.setObject(deformerObjectTo)
deformerWeightFn.setWeight(geoPath,componentObject,weights)
vertItr.next()
def loadClusters(clusterDicts):
for clusterDict in clusterDicts:
clusterHandleName = clusterDict.get('clusterHandle')
clusterName = clusterDict.get('clusterName')
pos = clusterDict.get('pos')
dagMembers = clusterDict.get('dagMembers')
selectionList = om.MSelectionList()
for member in dagMembers:
meshPath = GenAPI.getDagPath(member)
verts = GenAPI.getMObjectAllVerts(member)
selectionList.add(meshPath, verts)
om.MGlobal.setActiveSelectionList(selectionList)
#creating cluster
cluster = cmds.cluster()
clusterShape = cmds.listRelatives(cluster[1], type='shape')
cmds.setAttr('%s.originX' % clusterShape[0], pos[0])
cmds.setAttr('%s.originY' % clusterShape[0], pos[1])
cmds.setAttr('%s.originZ' % clusterShape[0], pos[2])
cmds.setAttr('%s.rotatePivotX' % cluster[1], pos[0])
cmds.setAttr('%s.rotatePivotY' % cluster[1], pos[1])
cmds.setAttr('%s.rotatePivotZ' % cluster[1], pos[2])
cmds.setAttr('%s.scalePivotX' % cluster[1], pos[0])
cmds.setAttr('%s.scalePivotY' % cluster[1], pos[1])
cmds.setAttr('%s.scalePivotZ' % cluster[1], pos[2])
inc = 0
progressWin = UILib.ProgressWin()
progressWin.itr = len(dagMembers)
progressWin.setTitle('Loading Clusters')
for member in dagMembers:
deformerTool = WeightListTool(member, cluster[0])
weightList = clusterDict.get('weightList')[inc]
membershipList = clusterDict.get('membershipList')[inc]
deformerTool.setMembershipList(membershipList)
deformerTool.setWeightList(weightList)
inc += 1
progressWin.message = member
progressWin.inc = inc
progressWin.progress()
cmds.rename(cluster[0], clusterName)
cmds.rename(cluster[1], clusterHandleName)
progressWin.end()
om.MGlobal.displayInfo('Successfully loaded clusters.')
def __init__(self, transformNodes=[]):
self.transformNodes = transformNodes
for node in self.transformNodes:
self.transformObjects.append(GenAPI.getMObject(node))
self.transformDagPaths.append(GenAPI.getDagPath(node))
def __init__(self,transformNodes = []):
self.transformNodes = transformNodes
for node in self.transformNodes:
self.transformObjects.append(GenAPI.getMObject(node))
self.transformDagPaths.append(GenAPI.getDagPath(node))
def skinclusterFromMesh(meshFrom,meshTo,joints):
floatingJointList = []
constraintList = []
weightLists = []
progressWin = UILib.ProgressWin()
progressWin.setTitle('Mesh To Skincluster')
cmds.select(cl = True)
for joint in joints:
transformFn = om.MFnTransform(GenAPI.getDagPath(joint))
position = transformFn.getTranslation(om.MSpace.kWorld)
floatingJoint = cmds.joint()
floatingJointPath = GenAPI.getDagPath(floatingJoint)
transformFn.setObject(floatingJointPath)
transformFn.setTranslation(position,om.MSpace.kWorld)
floatingJointList.append(floatingJoint)
parentConstraint = cmds.parentConstraint(floatingJoint,joint,mo = True)
constraintList.append(parentConstraint)
cmds.select(cl = True)
baseJoint = cmds.joint()
skincluster = cmds.skinCluster(meshTo,baseJoint)[0]
skinningTool = SkinningTool(skincluster,meshTo)
cmds.setAttr('%s.liw'%baseJoint, 0)
progressWin.itr = len(joints)
inc = 0
for i in range(len(floatingJointList)):
weightList = MeasuringLib.MeasuringTool.createWeigthListFromInfluence2(meshFrom, floatingJointList[i])
cmds.skinCluster(skincluster,e = True , weight = 0,addInfluence = joints[i])
weightLists.append(weightList)
cmds.setAttr('%s.liw'%joints[i], 0)
skinningTool.setWeights(GenAPI.getDagPath(joints[i]), weightList)
cmds.setAttr('%s.liw'%joints[i], 1)
inc += 1
progressWin.inc = inc
progressWin.progress()
for i in range(len(floatingJointList)):
cmds.delete(constraintList[i])
cmds.delete(floatingJointList[i])
progressWin.end()
def __init__(self, startJoint='', endJoint=''):
self.startJoint = startJoint
self.endJoint = endJoint
self.startJointObject = GenAPI.getMObject(startJoint)
self.startJointPath = GenAPI.getDagPath(startJoint)
self.endJointObject = GenAPI.getMObject(endJoint)
self.endJointPath = GenAPI.getDagPath(endJoint)
def __init__(self,startJoint = '',endJoint = ''):
self.startJoint = startJoint
self.endJoint = endJoint
self.startJointObject = GenAPI.getMObject(startJoint)
self.startJointPath = GenAPI.getDagPath(startJoint)
self.endJointObject = GenAPI.getMObject(endJoint)
self.endJointPath = GenAPI.getDagPath(endJoint)
def __init__(self,mesh = '',deformer = ''):
self.mesh = mesh
self.deformer = deformer
self.meshPath = GenAPI.getDagPath(mesh)
self.meshObject = GenAPI.getMObject(mesh)
self.deformerObject = GenAPI.getMObject(deformer)
if self.meshObject.apiTypeStr() == 'kTransform':
shape = cmds.listRelatives(mesh,type = 'shape')[0]
self.meshPath = GenAPI.getDagPath(shape)
self.meshObject = GenAPI.getMObject(shape)
def __init__(self, mesh='', deformer=''):
self.mesh = mesh
self.deformer = deformer
self.meshPath = GenAPI.getDagPath(mesh)
self.meshObject = GenAPI.getMObject(mesh)
self.deformerObject = GenAPI.getMObject(deformer)
if self.meshObject.apiTypeStr() == 'kTransform':
shape = cmds.listRelatives(mesh, type='shape')[0]
self.meshPath = GenAPI.getDagPath(shape)
self.meshObject = GenAPI.getMObject(shape)
def __init__(self, skincluster='', shape=''):
self.skincluster = skincluster
self.shape = shape
if not self.skincluster == '':
self.skinclusterObject = GenAPI.getMObject(skincluster)
self.skinclusterFn = oma.MFnSkinCluster(self.skinclusterObject)
if not self.shape == '':
self.shapePath = GenAPI.getDagPath(self.shape)
self.shapeObject = GenAPI.getMObject(self.shape)
def __init__(self,skincluster = '',shape = ''):
self.skincluster = skincluster
self.shape = shape
if not self.skincluster == '':
self.skinclusterObject = GenAPI.getMObject(skincluster)
self.skinclusterFn = oma.MFnSkinCluster(self.skinclusterObject)
if not self.shape == '':
self.shapePath = GenAPI.getDagPath(self.shape)
self.shapeObject = GenAPI.getMObject(self.shape)
def getQuaternionRotation(dagObject,space = 'world'):
mDagPath = GenAPI.getDagPath(dagObject)
transformFn = om.MFnTransform(mDagPath)
mSpace = om.MSpace()
quatSpace = ''
if(space == 'world'):
quatSpace = mSpace.kWorld
else:
quatSpace = mSpace.kObject
utilX = om.MScriptUtil()
ptrX = utilX.asDoublePtr()
utilY = om.MScriptUtil()
ptrY = utilY.asDoublePtr()
utilZ = om.MScriptUtil()
ptrZ = utilZ.asDoublePtr()
utilW = om.MScriptUtil()
ptrW = utilW.asDoublePtr()
transformFn.getRotationQuaternion(ptrX,ptrY,ptrZ,ptrW,quatSpace)
quatX = utilX.getDouble(ptrX)
quatY = utilY.getDouble(ptrY)
quatZ = utilZ.getDouble(ptrZ)
quatW = utilW.getDouble(ptrW)
return [quatX,quatY,quatZ,quatW]
def getWeightsFromLattice(self,influence):
'''
method for returning weightlist of given influence from a lattice
input MDagPath (influence)
output python list (weights)
'''
weightList = []
latticePntSelection = GenAPI.getLatticePoints(self.shapePath)
selectionItr = om.MItSelectionList(latticePntSelection)
index = self.skinclusterFn.indexForInfluenceObject(influence)
weights = om.MFloatArray()
intArray = om.MIntArray()
intArray.append(index)
mdagPath = om.MDagPath()
component = om.MObject()
while not selectionItr.isDone():
selectionItr.getDagPath(mdagPath,component)
self.skinclusterFn.getWeights(self.shapePath,component,index,weights)
weightList.append(weights[0])
selectionItr.next()
return weightList
def setWeightsForLattice(self, influence, weightList):
'''
method for setting skinWeight value for lattice points
input MDagPath (influence)
input python float list (weightList)
'''
latticePntSelection = GenAPI.getLatticePoints(self.shapePath)
selectionItr = om.MItSelectionList(latticePntSelection)
index = self.skinclusterFn.indexForInfluenceObject(influence)
oldValues = om.MFloatArray()
mdagPath = om.MDagPath()
component = om.MObject()
itrIndex = 0
while not selectionItr.isDone():
selectionItr.getDagPath(mdagPath, component)
self.skinclusterFn.setWeights(self.shapePath, component, index,
weightList[itrIndex], True,
oldValues)
itrIndex += 1
selectionItr.next()
def getSkinCluster(shape):
'''
get skinCluster from shape
input python string (shape)
out mObject (skincluster)
'''
shapeObject = GenAPI.getMObject(shape)
depItr = om.MItDependencyGraph(shapeObject,om.MFn.kSkinClusterFilter,
om.MItDependencyGraph.kUpstream,om.MItDependencyGraph.kDepthFirst,
om.MItDependencyGraph.kNodeLevel)
return depItr.currentItem(),GenAPI.getStringFromMObject(depItr.currentItem())
def getWeightsFromLattice(self, influence):
'''
method for returning weightlist of given influence from a lattice
input MDagPath (influence)
output python list (weights)
'''
weightList = []
latticePntSelection = GenAPI.getLatticePoints(self.shapePath)
selectionItr = om.MItSelectionList(latticePntSelection)
index = self.skinclusterFn.indexForInfluenceObject(influence)
weights = om.MFloatArray()
intArray = om.MIntArray()
intArray.append(index)
mdagPath = om.MDagPath()
component = om.MObject()
while not selectionItr.isDone():
selectionItr.getDagPath(mdagPath, component)
self.skinclusterFn.getWeights(self.shapePath, component, index,
weights)
weightList.append(weights[0])
selectionItr.next()
return weightList
def getSkinCluster(shape):
'''
get skinCluster from shape
input python string (shape)
out mObject (skincluster)
'''
shapeObject = GenAPI.getMObject(shape)
depItr = om.MItDependencyGraph(shapeObject, om.MFn.kSkinClusterFilter,
om.MItDependencyGraph.kUpstream,
om.MItDependencyGraph.kDepthFirst,
om.MItDependencyGraph.kNodeLevel)
return depItr.currentItem(), GenAPI.getStringFromMObject(
depItr.currentItem())
def pointOnCurveLocCV(name,curve):
if not cmds.nodeType(curve) == 'shape':
curve = cmds.listRelatives(curve, type = 'shape')[0]
mobject = GenAPI.getMObject(curve)
iterCVs = om.MItCurveCV(mobject)
while not iterCVs.isDone():
index = iterCVs.index()
nameIndex = index + 1
moPath = cmds.createNode('motionPath')
moPath = cmds.createNode('motionPath',n = '%s_0%i_MotionPath'%(name,nameIndex))
cmds.connectAttr('%s.worldSpace[0]'%curve,'%s.geometryPath'%moPath)
locator = cmds.spaceLocator(n = '%s_0%i_MP_Loc'%(name,nameIndex))
cmds.addAttr(locator[0],ln = "Offset" ,at = 'double')
cmds.setAttr('%s.Offset'%locator[0], e = True, keyable = True)
upLocator = cmds.spaceLocator(n = '%s_0%i_MP_Up_Loc'%(name,nameIndex))
cmds.connectAttr('%s.allCoordinates'%moPath,'%s.translate'%locator[0])
cmds.connectAttr('%s.rotate'%moPath,'%s.rotate'%locator[0])
cmds.connectAttr('%s.rotateOrder'%moPath, '%s.rotateOrder'%locator[0])
uValue = MeasuringTool.curveCVtoU(curve,index)
cmds.setAttr('%s.uValue'%moPath, uValue)
cmds.setAttr('%s.worldUpType'%moPath, 2)
cmds.setAttr ('%s.frontAxis'%moPath,0)
cmds.setAttr ('%s.upAxis'%moPath,2)
offsetMD = cmds.createNode('multiplyDivide', n = '%s_0%i_Offset_MD'%(locator[0],nameIndex))
cmds.connectAttr('%s.Offset'%locator[0],'%s.input1X'%offsetMD)
cmds.setAttr('%s.input2X'%offsetMD, 0.1)
offsetPMA = cmds.createNode('plusMinusAverage', n = '%s_0%i_Offset_PMA'%(locator[0],nameIndex))
cmds.connectAttr('%s.outputX'%offsetMD,'%s.input1D[0]'%offsetPMA )
cmds.setAttr('%s.input1D[1]'%offsetPMA,uValue)
cmds.connectAttr('%s.output1D'%offsetPMA, '%s.uValue'%moPath)
locPos = cmds.xform(locator[0], q = True, ws = True, translation = True)
locOrient = cmds.xform(locator[0], q = True, ws = True, rotation = True)
cmds.setAttr ('%s.worldUpVectorX'%moPath,0)
cmds.setAttr ('%s.worldUpVectorY'%moPath,0)
cmds.setAttr ('%s.worldUpVectorZ'%moPath,1)
cmds.connectAttr('%s.worldMatrix[0]'%upLocator[0], '%s.worldUpMatrix'%moPath)
nullGroup = cmds.group(empty = True, n = '%s_Group'%upLocator[0])
cmds.move(locPos[0], locPos[1],locPos[2],nullGroup)
cmds.rotate(locOrient[0],locOrient[1],locOrient[2], nullGroup)
cmds.parent(upLocator[0], nullGroup,r = True)
cmds.move(0,0,10,upLocator[0], a = True, os = True)
cmds.group(locator[0],nullGroup,n = '%s_0%i_MP_Loc_Group'%(name,nameIndex))
iterCVs.next()
def getDagMembers(deformer):
'''
method for gathering dag members from a deformer
output members (pythonList[python string])
'''
dagList = []
deformerObject = GenAPI.getMObject(deformer)
geoFilter = oma.MFnGeometryFilter(deformerObject)
deformerSet = geoFilter.deformerSet()
deformerSetFn = om.MFnSet(deformerSet)
selectionList = om.MSelectionList()
deformerSetFn.getMembers(selectionList, False)
selectionItr = om.MItSelectionList(selectionList)
while not selectionItr.isDone():
dagPath = om.MDagPath()
selectionItr.getDagPath(dagPath)
dagList.append(dagPath.partialPathName())
selectionItr.next()
return dagList
def getDagMembers(deformer):
'''
method for gathering dag members from a deformer
output members (pythonList[python string])
'''
dagList = []
deformerObject = GenAPI.getMObject(deformer)
geoFilter = oma.MFnGeometryFilter(deformerObject)
deformerSet = geoFilter.deformerSet()
deformerSetFn = om.MFnSet(deformerSet)
selectionList = om.MSelectionList()
deformerSetFn.getMembers(selectionList, False)
selectionItr = om.MItSelectionList(selectionList)
while not selectionItr.isDone():
dagPath = om.MDagPath()
selectionItr.getDagPath(dagPath)
dagList.append(dagPath.partialPathName())
selectionItr.next()
return dagList
def getTranslationVectors(self, fromMesh):
'''
method build an array of vectors for translation
input fromMesh (python string)
'''
fromMeshPath = GenAPI.getDagPath(fromMesh)
geoItr = om.MItGeometry(fromMeshPath)
pointArrayA = om.MPointArray()
geoItr.allPositions(pointArrayA, om.MSpace.kObject)
if cmds.nodeType(self.baseMesh) == 'transform':
shape = cmds.listRelatives(shape, type='shape')[0]
else:
shape = self.baseMesh
pointArrayB = ShapeTool.getPointArray(self.baseMesh)
if pointArrayA.length() == pointArrayB.length():
outVectorArray = om.MVectorArray()
itr = 0
while itr <= pointArrayA.length():
vectorA = pointArrayA[itr]
vectorB = pointArrayB[itr]
vectorC = vectorA - vectorB
outVectorArray.append(vectorC)
itr += 1
return outVectorArray
def setWeightsForLattice(self,influence,weightList):
'''
method for setting skinWeight value for lattice points
input MDagPath (influence)
input python float list (weightList)
'''
latticePntSelection = GenAPI.getLatticePoints(self.shapePath)
selectionItr = om.MItSelectionList(latticePntSelection)
index = self.skinclusterFn.indexForInfluenceObject(influence)
oldValues = om.MFloatArray()
mdagPath = om.MDagPath()
component = om.MObject()
itrIndex = 0
while not selectionItr.isDone():
selectionItr.getDagPath(mdagPath,component)
self.skinclusterFn.setWeights(self.shapePath,component,index,weightList[itrIndex],True,oldValues)
itrIndex += 1
selectionItr.next()
def getTranslationVectors(self,fromMesh):
'''
method build an array of vectors for trnaslation
input fromMesh (python string)
'''
fromMeshPath = GenAPI.getDagPath(fromMesh)
geoItr = om.MItGeometry(fromMeshPath)
pointArrayA = om.MPointArray()
geoItr.allPositions(pointArrayA, om.MSpace.kWorld)
pointArrayB = self.getPointArray()
if pointArrayA.length() == pointArrayB.length():
outVectorArray = om.MVectorArray()
itr = 0
while itr <= pointArrayA.length():
vectorA = pointArrayA[itr]
vectorB = pointArrayB[itr]
vectorC = vectorA - vectorB
outVectorArray.append(vectorC)
itr += 1
return outVectorArray
def optimizeMembership(deformer, prune=0.001):
deformerObject = GenAPI.getMObject(deformer)
geoFilter = oma.MFnGeometryFilter(deformerObject)
deformerSet = geoFilter.deformerSet()
deformerSetFn = om.MFnSet(deformerSet)
addSelectionList = om.MSelectionList()
removeSelectionList = om.MSelectionList()
dagMembers = WeightListTool.getDagMembers(deformer)
progressWindow = UILib.ProgressWin()
progressWindow.setTitle('Optimizing Deformer')
progressWindow.itr = len(dagMembers)
for i in range(len(dagMembers)):
dagPath = GenAPI.getDagPath(dagMembers[i])
vertItr = om.MItGeometry(dagPath)
weightListTool = WeightListTool(dagPath.fullPathName(), deformer)
weightList = weightListTool.getWeightList()
while not vertItr.isDone():
index = vertItr.index()
component = vertItr.currentItem()
if weightList[index] < prune:
removeSelectionList.add(dagPath, component)
else:
addSelectionList.add(dagPath, component)
vertItr.next()
if not addSelectionList.isEmpty():
deformerSetFn.addMembers(addSelectionList)
if not removeSelectionList.isEmpty():
deformerSetFn.removeMembers(removeSelectionList)
progressWindow.inc = i
progressWindow.message = '%s...%s' % (deformer, dagMembers[i])
progressWindow.progress()
progressWindow.end()
def curveCVtoU (curveShape,curveCVIndex):
curveFn = om.MFnNurbsCurve(GenAPI.getMObject(curveShape))
mpoint = om.MPoint()
curveFn.getCV(curveCVIndex,mpoint)
uValue = om.MScriptUtil()
uValueNull = uValue.asDoublePtr()
curveFn.closestPoint(mpoint,uValueNull)
return uValue.getDouble(uValueNull)
def getMPoint(dagObject):
mDagPath = GenAPI.getDagPath(dagObject)
transformFn = om.MFnTransform(mDagPath)
space = om.MSpace()
mpoint = transformFn.rotatePivot(space.kWorld)
return mpoint
def addDagMember(mesh, deformer):
'''
method for adding dagObject to deformer
input meshPath (python string)
input defrormer(python string)
'''
deformerObject = GenAPI.getMObject(deformer)
meshPath = GenAPI.getDagPath(mesh)
vertObjects = GenAPI.getMObjectAllVerts(mesh)
geoFilter = oma.MFnGeometryFilter(deformerObject)
deformerSet = geoFilter.deformerSet()
deformerSetFn = om.MFnSet(deformerSet)
for vert in vertObjects:
deformerSetFn.addMember(meshPath, vert)
def __init__(self,shape):
self.shape = shape
self.shapePath = GenAPI.getDagPath(shape)
geoItr = om.MItGeometry(self.shapePath)
pointArray = om.MPointArray()
geoItr.allPositions(pointArray, om.MSpace.kWorld)
self.origPointArray = pointArray
def addDagMember(mesh,deformer):
'''
method for adding dagObject to deformer
input meshPath (python string)
input defrormer(python string)
'''
deformerObject = GenAPI.getMObject(deformer)
meshPath = GenAPI.getDagPath(mesh)
vertObjects = GenAPI.getMObjectAllVerts(mesh)
geoFilter = oma.MFnGeometryFilter(deformerObject)
deformerSet = geoFilter.deformerSet()
deformerSetFn = om.MFnSet(deformerSet)
for vert in vertObjects:
deformerSetFn.addMember(meshPath,vert)
def getVertNormal(geo,vert,name):
#find dag path
polyPath = GenAPI.getDagPath(geo)
vertexObject = GenAPI.getComponentsFromList(geo,[vert])
#create vector instance for vert iterator
vertNormalVector = om.MVector()
vertIterator = om.MItMeshVertex(polyPath,vertexObject)
#MIntArray for face indexes
faceIndexArray = om.MIntArray()
vertIterator.getNormalIndices(faceIndexArray)
faceIndexList = []
for i in faceIndexArray:
faceIndexList.append(i)
#store normal vector in MVector instance
vertIterator.getNormal(vertNormalVector,faceIndexList[0],om.MSpace.kObject)
vertPos = vertIterator.position(om.MSpace.kWorld)
#create new vectors form queries
v1 = om.MVector(vertNormalVector.x,vertNormalVector.y,vertNormalVector.z)
v2 = om.MVector(vertPos.x,vertPos.y,vertPos.z)
#add vector1 to vector2 for offset
v3 = v1 + v2
#create locators
vertLoc = cmds.spaceLocator(n = '%s_VertPos_Loc'%(name))
normalVectorLoc = cmds.spaceLocator(n = '%s_VertNormalVec_Loc'%(name))
tempLoc = cmds.spaceLocator()
#move locators into position
cmds.move(v1.x,v1.y,v1.z,tempLoc[0],ws = True)
cmds.move(v2.x,v2.y,v2.z,vertLoc[0],ws = True)
cmds.move(v3.x,v3.y,v3.z,normalVectorLoc[0],ws = True)
#aim locator2 at locator1
cmds.aimConstraint(normalVectorLoc,vertLoc, aimVector = (1,0,0), upVector = (0,1,0))
def setTranslation(mesh,vectorArray):
meshPath = GenAPI.getDagPath(mesh)
vertItr = om.MItMeshVertex(meshPath)
while not vertItr.isDone():
index = vertItr.index()
vertItr.translateBy(vectorArray[index],om.MSpace.kWorld)
vertItr.next()
def getMemberSet(self, filePath):
output = open(filePath, 'wb')
setsToDump = []
for objectSet in self.sets:
print 'saving %s set...' % objectSet
setObject = GenAPI.getMObject(objectSet)
self.__setFn.setObject(setObject)
selectionList = om.MSelectionList()
self.__setFn.getMembers(selectionList, True)
selectionListItr = om.MItSelectionList(selectionList)
members = dict()
members['setName'] = objectSet
members['dagMembers'] = []
members['components'] = []
while not selectionListItr.isDone():
dagPath = om.MDagPath()
component = om.MObject()
selectionListItr.getDagPath(dagPath, component)
pathName = dagPath.partialPathName()
if not component.isNull():
if component.apiTypeStr() == 'kMeshPolygonComponent':
componentFn = om.MFnSingleIndexedComponent(component)
elementArray = om.MIntArray()
componentFn.getElements(elementArray)
for element in elementArray:
members['components'].append('%s.f[%i]' %
(pathName, element))
else:
members['dagMembers'].append(pathName)
selectionListItr.next()
setsToDump.append(members)
pickle.dump(setsToDump, output)
output.close()
print 'I\'m Done!'
def createWeigthListFromInfluence2(mesh,transform):
meshPath = GenAPI.getDagPath(mesh)
transformPath = GenAPI.getDagPath(transform)
transformFn = om.MFnTransform(transformPath)
origTransform = transformFn.transformation()
transformFn.set(om.MTransformationMatrix.identity)
vertItr = om.MItMeshVertex(meshPath)
startPoints = []
translateVector = om.MVector(1,0,0)
while not vertItr.isDone():
vertStartPos = vertItr.position(om.MSpace.kWorld)
startPoints.append(vertStartPos)
vertItr.next()
vertItr.reset()
transformFn.translateBy(translateVector,om.MSpace.kObject)
weightList = []
index = 0
while not vertItr.isDone():
vertEndPos = vertItr.position(om.MSpace.kWorld)
length = MeasuringTool.getVectorLengthBetween(startPoints[index], vertEndPos)
weightList.append(length)
index += 1
vertItr.next()
transformFn.set(origTransform)
return weightList
def createClusterFromMesh(fromMesh,toMesh):
'''
Function for creating cluster from another duplicate modified mesh
input fromMesh (python string)
input toMesh (python string)
'''
toMeshPath = GenAPI.getDagPath(toMesh)
fromVerts = GenAPI.getMObjectAllVerts(toMesh)
selectionList = om.MSelectionList()
selectionList.add(toMeshPath,fromVerts)
om.MGlobal.setActiveSelectionList(selectionList)
#creating cluster
cluster = cmds.cluster()
transformPosition = cmds.xform(fromMesh,q = True,ws = True, rp = True)
clusterShape = cmds.listRelatives(cluster[1],type = 'shape')
cmds.setAttr('%s.originX'%clusterShape[0],transformPosition[0])
cmds.setAttr('%s.originY'%clusterShape[0],transformPosition[1])
cmds.setAttr('%s.originZ'%clusterShape[0],transformPosition[2])
cmds.setAttr('%s.rotatePivotX'%cluster[1],transformPosition[0])
cmds.setAttr('%s.rotatePivotY'%cluster[1],transformPosition[1])
cmds.setAttr('%s.rotatePivotZ'%cluster[1],transformPosition[2])
cmds.setAttr('%s.scalePivotX'%cluster[1],transformPosition[0])
cmds.setAttr('%s.scalePivotY'%cluster[1],transformPosition[1])
cmds.setAttr('%s.scalePivotZ'%cluster[1],transformPosition[2])
weightList = MeasuringLib.MeasuringTool.createWeightListFromMesh(fromMesh, toMesh)
deformerTool = WeightListTool(toMesh,cluster[0])
deformerTool.setWeightList(weightList)
om.MGlobal.displayInfo('Created cluster from %s'%fromMesh)
def getWeights(self,verts,influence):
'''
get influence value
input MObject (verts)
input MDagPath (influence)
returns MDoubleArray (weights)
'''
index = self.indexForInfluenceObject(influence)
weights = om.MDoubleArray()
self.skinclusterFn.getWeights(GenAPI.getDagPath(self.shape),verts,index,weights)
return weights
def createClusterFromMesh(fromMesh, toMesh):
'''
Function for creating cluster from another duplicate modified mesh
input fromMesh (python string)
input toMesh (python string)
'''
toMeshPath = GenAPI.getDagPath(toMesh)
fromVerts = GenAPI.getMObjectAllVerts(toMesh)
selectionList = om.MSelectionList()
selectionList.add(toMeshPath, fromVerts)
om.MGlobal.setActiveSelectionList(selectionList)
#creating cluster
cluster = cmds.cluster()
transformPosition = cmds.xform(fromMesh, q=True, ws=True, rp=True)
clusterShape = cmds.listRelatives(cluster[1], type='shape')
cmds.setAttr('%s.originX' % clusterShape[0], transformPosition[0])
cmds.setAttr('%s.originY' % clusterShape[0], transformPosition[1])
cmds.setAttr('%s.originZ' % clusterShape[0], transformPosition[2])
cmds.setAttr('%s.rotatePivotX' % cluster[1], transformPosition[0])
cmds.setAttr('%s.rotatePivotY' % cluster[1], transformPosition[1])
cmds.setAttr('%s.rotatePivotZ' % cluster[1], transformPosition[2])
cmds.setAttr('%s.scalePivotX' % cluster[1], transformPosition[0])
cmds.setAttr('%s.scalePivotY' % cluster[1], transformPosition[1])
cmds.setAttr('%s.scalePivotZ' % cluster[1], transformPosition[2])
weightList = MeasuringLib.MeasuringTool.createWeightListFromMesh(
fromMesh, toMesh)
deformerTool = WeightListTool(toMesh, cluster[0])
deformerTool.setWeightList(weightList)
om.MGlobal.displayInfo('Created cluster from %s' % fromMesh)
def matchSpace(dagObject,name):
translation = MeasuringTool.getWorldTranslation(dagObject)
rotation = MeasuringTool.getWorldEulerRotation(dagObject)
rotationOrder = MeasuringTool.getRotationOrder(dagObject)
newTransform = cmds.group(empty = True, n = '%s_Group'%(name))
dagPath = GenAPI.getDagPath(newTransform)
transformFn = om.MFnTransform(dagPath)
transformFn.setTranslation(translation,om.MSpace.kWorld)
transformFn.setRotation(rotation,rotationOrder)
transformFn.setRotationOrder(rotationOrder,1)
def getLatticePointPos(latticeShape):
dagPath = GenAPI.getDagPath(latticeShape)
geoItr = om.MItGeometry(dagPath)
latPointPos = []
while not geoItr.isDone():
position = geoItr.position(om.MSpace.kWorld)
latPointPos.append([position.x,position.y,position.z])
geoItr.next()
return latPointPos
def mirrorDeformerWeightMultiMesh(self, geoTo, axis='x', table=[-1, 1, 1]):
'''
method for mirroring deformer...only works on meshes mirrored across given axis
input python string (geoFrom)
imput python string (geoTo)
input python string (deformer)
input python string (axis)
input python int list (table)
'''
nodePathTo = GenAPI.getDagPath(geoTo)
vertItr = om.MItMeshVertex(self.meshPath)
deformerWeightFn = oma.MFnWeightGeometryFilter(self.deformerObject)
util = om.MScriptUtil()
progressWin = UILib.ProgressWin()
progressWin.itr = vertItr.count()
progressWin.setTitle('Mirror Deformer')
while not vertItr.isDone():
inComponent = vertItr.currentItem()
currentPosition = vertItr.position(om.MSpace.kWorld)
inComponent = vertItr.currentItem()
mirrorVert = MeasuringLib.MeasuringTool.getSymVertFromClosestPoint(
nodePathTo, currentPosition, table)
weights = om.MFloatArray()
tempItr = om.MItMeshVertex(nodePathTo)
intPtr = util.asIntPtr()
tempItr.setIndex(mirrorVert[0], intPtr)
outComponent = tempItr.currentItem()
if self.checkMembership(inComponent):
self.addComponentToMembershipList(outComponent)
deformerWeightFn.getWeights(self.meshPath, inComponent, weights)
deformerWeightFn.setWeight(nodePathTo, outComponent, weights)
progressWin.inc = vertItr.index()
progressWin.message = '%s.vtx[%i]' % (self.mesh, progressWin.inc)
progressWin.progress()
vertItr.next()
progressWin.end()
def mirrorDeformerWeightMultiMesh(self,geoTo,axis = 'x',table = [-1,1,1]):
'''
method for mirroring deformer...only works on meshes mirrored across given axis
input python string (geoFrom)
imput python string (geoTo)
input python string (deformer)
input python string (axis)
input python int list (table)
'''
nodePathTo = GenAPI.getDagPath(geoTo)
vertItr = om.MItMeshVertex(self.meshPath)
deformerWeightFn = oma.MFnWeightGeometryFilter(self.deformerObject)
util = om.MScriptUtil()
progressWin = UILib.ProgressWin()
progressWin.itr = vertItr.count()
progressWin.setTitle('Mirror Deformer')
while not vertItr.isDone():
inComponent = vertItr.currentItem()
currentPosition = vertItr.position(om.MSpace.kWorld)
inComponent = vertItr.currentItem()
mirrorVert = MeasuringLib.MeasuringTool.getSymVertFromClosestPoint(nodePathTo, currentPosition, table)
weights = om.MFloatArray()
tempItr = om.MItMeshVertex(nodePathTo)
intPtr = util.asIntPtr()
tempItr.setIndex(mirrorVert[0],intPtr)
outComponent = tempItr.currentItem()
if self.checkMembership(inComponent):
self.addComponentToMembershipList(outComponent)
deformerWeightFn.getWeights(self.meshPath,inComponent,weights)
deformerWeightFn.setWeight(nodePathTo,outComponent,weights)
progressWin.inc = vertItr.index()
progressWin.message = '%s.vtx[%i]'%(self.mesh,progressWin.inc)
progressWin.progress()
vertItr.next()
progressWin.end()
def setWeightList(self, weightList):
'''
method for setting wieght list to mesh
input python float list (weightList)
'''
floatArray = om.MFloatArray()
util = om.MScriptUtil()
util.createFloatArrayFromList(weightList, floatArray)
components = GenAPI.getMObjectAllVerts(self.meshPath)
deformerWeightFn = oma.MFnWeightGeometryFilter(self.deformerObject)
deformerWeightFn.setWeight(self.meshPath, components, floatArray)
def getComponentPoints(mesh):
meshPath = GenAPI.getDagPath(mesh)
vertItr = om.MItMeshVertex(meshPath)
pointArray = []
while not vertItr.isDone():
point = vertItr.position(om.MSpace.kWorld)
pointArray.append([point.x,point.y,point.z])
vertItr.next()
return pointArray
def getLatticePointPos(latticeShape):
dagPath = GenAPI.getDagPath(latticeShape)
geoItr = om.MItGeometry(dagPath)
latPointPos = []
while not geoItr.isDone():
position = geoItr.position(om.MSpace.kWorld)
latPointPos.append([position.x, position.y, position.z])
geoItr.next()
return latPointPos
def setLatticePointPos(latticeShape, positions):
dagPath = GenAPI.getDagPath(latticeShape)
geoItr = om.MItGeometry(dagPath)
latPointPos = []
while not geoItr.isDone():
index = geoItr.index()
position = positions[index]
mpoint = om.MPoint(position[0], position[1], position[2])
geoItr.setPosition(mpoint, om.MSpace.kWorld)
geoItr.next()
def setWeightList(self,weightList):
'''
method for setting wieght list to mesh
input python float list (weightList)
'''
floatArray = om.MFloatArray()
util = om.MScriptUtil()
util.createFloatArrayFromList(weightList,floatArray)
components = GenAPI.getMObjectAllVerts(self.meshPath)
deformerWeightFn = oma.MFnWeightGeometryFilter(self.deformerObject)
deformerWeightFn.setWeight(self.meshPath,components,floatArray)
def setLatticePointPos(latticeShape,positions):
dagPath = GenAPI.getDagPath(latticeShape)
geoItr = om.MItGeometry(dagPath)
latPointPos = []
while not geoItr.isDone():
index = geoItr.index()
position = positions[index]
mpoint = om.MPoint(position[0],position[1],position[2])
geoItr.setPosition(mpoint,om.MSpace.kWorld)
geoItr.next()
def getPointArray(shape):
'''
method gathers point array from verts
output pointArray(mPointArray)
'''
if cmds.nodeType(shape) == 'transform':
shape = cmds.listRelatives(shape, type='shape')[0]
geoPath = GenAPI.getDagPath(shape)
geoItr = om.MItGeometry(geoPath)
pointArray = om.MPointArray()
geoItr.allPositions(pointArray, om.MSpace.kObject)
return pointArray
def getAllAnimation():
animCurveTU = cmds.ls(type='animCurveTU')
animCurveTA = cmds.ls(type='animCurveTA')
animCurveTL = cmds.ls(type='animCurveTU')
animCurves = animCurveTU + animCurveTA + animCurveTL
objectArray = om.MObjectArray()
for curve in animCurves:
mobject = GenAPI.getMObject(curve)
objectArray.add(mobject)
return objectArray
def reverseWeightList(self):
'''method for reversing weighList on current mesh'''
deformerWeightFn = oma.MFnWeightGeometryFilter(self.deformerObject)
weightList = om.MFloatArray()
verts = GenAPI.getMObjectAllVerts(self.mesh)
deformerWeightFn.getWeights(self.meshPath, verts, weightList)
reverseWeightList = []
for i in range(weightList.length()):
reverseWeight = abs(weightList[i] - 1.00000)
reverseWeightList.append(reverseWeight)
return reverseWeightList
def setWeightList(self,influence,weightList):
'''
set influence value ONLY WORKS FOR POLY MESH
input MDagPath (influence)
input python float list (weightList)
'''
index = self.indexForInfluenceObject(influence)
mIntArray = om.MIntArray()
mIntArray.append(index)
util = om.MScriptUtil()
weights = om.MFloatArray()
util.createFloatArrayFromList(weightList,weights)
oldValues = om.MFloatArray()
verts = GenAPI.getMObjectAllVerts(self.shape)
self.skinclusterFn.setWeights(self.shapePath,verts,mIntArray,weights,True,oldValues)
def createBlankList(mesh, floatVal, boolVal):
'''
method for creating a blank weight and membershipList
output blankList (python list)
'''
meshPath = GenAPI.getDagPath(mesh)
vertItr = om.MItMeshVertex(meshPath)
blankWeightList = []
blankMemberList = []
while not vertItr.isDone():
blankWeightList.append(floatVal)
blankMemberList.append(boolVal)
vertItr.next()
return [blankWeightList, blankMemberList]
