def __init__(self, parent=get_maya_window()):
"""
Initialize the class and connect all the functions to the ui.
:param parent: object to parent the window to
:type parent: Qt object
"""
super(MLAModifyMesh, self).__init__(parent)
self.setupUi(self)
self.setObjectName('mlModifyMesh_UI')
# Attributes
self.base_table = {
'obj_path': om2.MDagPath(),
'points_pos': om2.MPointArray()
}
self.target_table = {
'obj_path': om2.MDagPath(),
'points_pos': om2.MPointArray()
}
self.current_table = {
'obj_path': om2.MDagPath(),
'points_pos': om2.MPointArray()
}
self.sel_vtces_idcs = {
'obj_path': om2.MDagPath(),
'indices': om2.MIntArray()
}
self.vtcs_selection = {
'obj_path': om2.MDagPath(),
'indices': om2.MIntArray()
}
self.revert_value = 100
self.space = om2.MSpace.kObject
# UNDO LIST
self.undo = list()
# Connections to ui
# Get data functions
# Meshes
self.get_base_pB.clicked.connect(self.get_base)
self.get_target_pB.clicked.connect(self.get_target)
# Vtces indices
self.get_selected_vtcs_pB.clicked.connect(self.store_vtcs_selection)
self.reset_selected_vtcs_pB.clicked.connect(self.reset_vtcs_selection)
# Revert value
self.revert_to_base_slider.valueChanged.connect(self.get_revert_value)
self.revert_to_base_sB.valueChanged.connect(self.get_revert_value)
# Move vertices functions
self.bake_diff_pB.clicked.connect(self.bake_difference_on_selected)
self.revert_to_base_pB.clicked.connect(self.revert_selected_to_base)
self.revert_to_base_live_pB.clicked.connect(
self.revert_selected_to_base_live)
self.undo_pB.clicked.connect(self.undo_last_action)
def __init__(self):
om.MPxCommand.__init__(self)
self.mesh_name=''
self.mesh_dagPath = om.MDagPath()
self.joint_name=''
self.nextJoint_name=''
self.Joint_dagPath = om.MDagPath()
self.nextJoint_dagPath = om.MDagPath()
self.u_parameter=0.0 #default value
self.division=20
def __init__(self):
ompy.MUserData.__init__(self, False)
self.setDeleteAfterUse(False) # don;t delete after draw
self.shapes = [] #vector<int>
self.coords = ompy.MFloatVectorArray() #MFloatVectorArray
self.screenSpaceOffsets = ompy.MFloatVectorArray() #MFloatVectorArray
self.sizes = [] #vector<float>
self.thicknesses = [] #vector<float>
self.colors = ompy.MFloatPointArray() #MFloatPointArray
self.pColors = [] #vector<MFloatPointArray>
self.names = [] #vector<MString>
self.fills = [] #vector<bool>
self.spaces = [] #vector<int>
self.maxMemorys = [] #vector<int>
self.projPlanes = [] #vector<int>
self.drawPlaneMode = 0 #int
self.cameraPath = ompy.MDagPath() #MDagPath
self.attrMatrix = ompy.MFloatMatrix() #MFloatMatrix
self.attrNames = [] #vector<MString>
self.attrValueType = [] #vector<MString>
self.attrValueInt = [] #vector<int>
self.attrValueFloat = [] #vector<float>
self.attrValueDouble = [] #vector<double>
self.attrValueEnum = [] #vector<MString>
def createLocator(name, selType, mDagMod):
"""
create a locator with vertexID in the name
:param componentID: str/int
:param selType: str
:param mDagMod: MDagModifier
:return: MObjectHandle
"""
locLocalScale = 0.2
mDagPath = om2.MDagPath()
loc = mDagMod.createNode("locator")
newName = "LOC_{}_{}".format(selType, name)
mDagMod.renameNode(loc, newName)
locMObjHandle = om2.MObjectHandle(loc)
mDagMod.doIt()
dagPath = mDagPath.getAPathTo(loc)
shapeDagPath = dagPath.extendToShape()
shapeMObj = shapeDagPath.node()
shapeMFn = om2.MFnDependencyNode(shapeMObj)
shapeLocalScaleX = shapeMFn.findPlug("localScaleX", False)
shapeLocalScaleY = shapeMFn.findPlug("localScaleY", False)
shapeLocalScaleZ = shapeMFn.findPlug("localScaleZ", False)
shapeLocalScaleX.setFloat(locLocalScale)
shapeLocalScaleY.setFloat(locLocalScale)
shapeLocalScaleZ.setFloat(locLocalScale)
return locMObjHandle
def reset_vtcs_selection(self):
self.vtcs_selection = {
'obj_path': om2.MDagPath(),
'indices': om2.MIntArray()
}
self.get_selected_vtcs_pB.setStyleSheet('background-color: dark gray')
def get_softselection():
""" Get a list of all paths to transforms affected by current soft selection, """
items = list()
# Get the active 'rich selecttion' ie soft select
softSelection = om.MGlobal.getRichSelection()
sel = softSelection.getSelection()
# Create and iterator and run through the selection list,
iter = om.MItSelectionList(sel)
while not iter.isDone():
# Get dag path for current item and it's lowest transform,
dagPath = iter.getDagPath()
transform = dagPath.transform()
# append the minimum unique string representation for the path to transform
# to result list,
items.append(
om.MDagPath().getAPathTo(transform).partialPathName()
)
iter.next()
# Return all items which were affected by soft select.
return items
def warpPickControlPoints(self, *args):
selectionList = om.MGlobal.getActiveSelectionList()
iterator = om.MItSelectionList(selectionList, om.MFn.kDagNode)
# Check if nothing is selected
if iterator.isDone():
print "Error. Nothing selected."
self.warpControlPoints = []
else:
# Create a set of items so duplicates are not added
selectedItems = set()
dagPath = om.MDagPath()
dagFn = om.MFnDagNode()
# Loop through the selection
while not iterator.isDone():
dagPath = iterator.getDagPath()
node = dagPath.node()
dagFn.setObject(node)
# 110 is a transform node. This checks if the node type is not a transform node
if dagPath.apiType() != 110:
# Get the parent node, which should be a transform node
parentObj = dagFn.parent(0)
dagFn.setObject(parentObj)
selectedItems.add(dagFn.name())
iterator.next()
# Convert the set to a list as it is easier to use
self.warpControlPoints = list(selectedItems)
# Update the UI with the number of selected control points
mc.intFieldGrp(self.m_warpNumControlPoints,
edit=True,
value1=len(self.warpControlPoints))
def findFromSelection(self, selectionList):
iterator = om.MItSelectionList(selectionList, om.MFn.kDagNode)
# Check if nothing is selected
if iterator.isDone():
print "Error nothing selected"
# Return failure as nothing was selected
return False
else:
dagPath = om.MDagPath()
dagFn = om.MFnDagNode()
curveName = None
meshName = None
# Loop through the iterator
while (not iterator.isDone()):
dagPath = iterator.getDagPath()
# Try to get the shape node, not the transform node
try:
dagPath.extendToShape()
except:
pass
node = dagPath.node()
dagFn.setObject(node)
# Check the type of node
if (dagFn.typeName == "nurbsCurve"):
self.curve = dagFn.name()
elif (dagFn.typeName == "mesh"):
self.mesh = dagFn.name()
else:
print "Invalid selection, ignoring"
iterator.next()
# If the loop was successful, return True (i.e. success)
return True
def getSkinInfluences(self, scList):
"""
:param scList:
:return:
"""
if scList:
outputDict = dict()
for sc in scList:
mFnSkin = om2anim.MFnSkinCluster(sc)
infObj = mFnSkin.influenceObjects()
scName = mFnSkin.name()
scNameNoNS = scName.split(':')[-1]
jntList = list()
for jnt in infObj:
jntName = om2.MDagPath(jnt).fullPathName().split(':')[-1]
if not jntName in jntList:
jntList.append(jntName)
else:
continue
outputDict.update({scNameNoNS: jntList})
return outputDict
def toMDagPath(nodeName):
""" Get an API MDagPAth to the node, given the name of an existing dag node """
obj = toMObject(nodeName)
if obj:
dagFn = om.MFnDagNode(obj)
dagPath = om.MDagPath()
dagFn.getPath(dagPath)
return dagPath
def J_createDynJointChain():
sel = cmds.ls(sl=True, type='joint')
if len(sel) < 3:
return
path = om.MDagPath()
mesh = om.MFnMesh()
J_dynJointChainAddPolyFace(sel, mesh)
def mdagpath_from_name(name):
if not pm.objExists(name):
raise MayaNodeError, name
slist = OpenMaya.MSelectionList()
slist.add(name)
dagpath = OpenMaya.MDagPath()
dagpath = slist.getDagPath(0)
return dagpath
def createCTLgroupsList(self, pSelectionListIterator, ctlIdString):
''' Create a List of CTL group classes '''
# Create an MDagPath object which will be populated on each iteration.
if pSelectionListIterator.isDone():
sys.stderr.write(
"ERROR: No CTL groups selected. Select in Outliner View\n")
CTL_GROUP_OPTIONS = [
'eye', 'brow', 'mouth', 'lower', 'upper', 'nose', 'ear', 'neck',
'chin', 'lip'
]
dagPath = om.MDagPath()
CTL_TREE = {}
while (not pSelectionListIterator.isDone()):
# Populate our MDagPath object. This will likely provide
# us with a Transform node.
dagPath = pSelectionListIterator.getDagPath()
print dagPath
dagPathStr = str(dagPath)
print dagPathStr
# self.printDagNodeInfo(dagPath)
# Change Group name to a shorter name
for cName in CTL_GROUP_OPTIONS:
if cName in dagPathStr:
selectedGroupShort = cName
else:
selectedGroupShort = dagPathStr[dagPathStr.rfind('|') + 1:]
print "New group name:%s" % selectedGroupShort
# Get all Controllers
leafTransformsLong = cmds.ls(dagPathStr,
long=True,
dag=True,
allPaths=True,
leaf=True)
CTLgroup = {}
for leaf in leafTransformsLong:
longName = leaf[:leaf.rfind('|')]
shortName = leaf[leaf.rfind('|') + 1:leaf.find('Shape')]
if ctlIdString in shortName:
tempNode = CTLnode.createCTLNodePerTranslate(
longName, selectedGroupShort)
for node in tempNode:
print node
keyName = node.translateName
CTLgroup[keyName] = node
# Add to Tree and advance to the next item
CTL_TREE[selectedGroupShort] = CTLgroup
pSelectionListIterator.next()
return CTL_TREE
def API_getMDagPath(obj):
selection = ompy.MSelectionList()
selection.add(obj)
dagPath = ompy.MDagPath()
dagPath = selection.getDagPath(0)
return dagPath
def getDagPathForNode(nodeName):
sel = om.MSelectionList()
sel.add(nodeName)
result = om.MDagPath()
result = sel.getDagPath(0)
if not result.isValid():
raise MessageException("node %s does not exist" % nodeName)
return result
def createMesh(pointArray=((0, 0, -2.5), (5, 0, -2.5), (8, 0, 0), (5, 0, 2.5),
(0, 0, 2.5)),
polygons=(4, 3),
polyConects=(4, 3, 1, 0, 3, 2, 1)):
"""
TODO: Return transform
Create a mesh with initialShadingGroup conected
Args:
pointArray: Vertex positions by index
polygons: Number of vertex per face index
polyConects: Index vertices that define a polygon
Returns:
MObject with the mesh
MDagPAth transform
"""
# get initial shading group
mselectionList = OpenMaya.MSelectionList()
mselectionList.add('initialShadingGroup')
shadingGrp_MObj = mselectionList.getDependNode(0)
shadingGrp_MFn = OpenMaya.MFnDependencyNode(shadingGrp_MObj)
shGrpPlug = shadingGrp_MFn.findPlug('dagSetMembers', True)
shGrpPlugNumElements = shGrpPlug.evaluateNumElements()
logger.debug('createMesh: %s num elements: %s' %
(shGrpPlug.name(), shGrpPlugNumElements))
# documentation: get the free element of the attr array
existingIndices = set(shGrpPlug.getExistingArrayAttributeIndices())
rangeExistingIndices = set(range(len(existingIndices) + 1))
rangeExistingIndices.difference_update(existingIndices)
shGrpPlugElement = shGrpPlug.elementByLogicalIndex(
rangeExistingIndices.pop())
logger.debug('createMesh: %s is element: %s' %
(shGrpPlugElement.name(), shGrpPlugElement.isElement))
# create Mesh function to operate with polygonal meshes
mFnMesh = OpenMaya.MFnMesh()
# vertices
mPointArray = OpenMaya.MPointArray(pointArray)
# polyConnects. is important the order for the face normal, antihorario
# create mesh
mesh_Object = mFnMesh.create(mPointArray, polygons, polyConects)
transform_Obj = OpenMaya.MDagPath().getAPathTo(mesh_Object)
meshPlug = mFnMesh.findPlug('instObjGroups', False)
meshPlugElement = meshPlug.elementByLogicalIndex(meshPlug.numElements())
# connect attribute
mdgModifier = OpenMaya.MDGModifier()
mdgModifier.connect(meshPlugElement, shGrpPlugElement)
mdgModifier.doIt()
return mesh_Object, transform_Obj
def isPathSelected(objPath):
sel = om.MGlobal.getActiveSelectionList()
if sel.hasItem(objPath):
return True
objPath = om.MDagPath(objPath)
objPath.pop()
if sel.hasItem(objPath):
return True
return False
def get_dag_node(xform):
selectionList = OpenMaya.MSelectionList()
try:
selectionList.add(xform)
except:
return None
dagPath = OpenMaya.MDagPath()
dagPath = selectionList.getDagPath(0)
return dagPath
def shape(self):
# type: () -> Shape
mdagpath = _om2.MDagPath(self.mdagpath)
try:
mdagpath.extendToShape()
except RuntimeError:
return None
return _graphs.to_node_instance(
_om2.MFnDependencyNode(mdagpath.node()), mdagpath)
def __init__(self, node):
"""
"""
self.m_obj = OM.MObject()
self.dag_path = OM.MDagPath()
selection_list = OM.MSelectionList()
selection_list.add(node)
self.m_obj = selection_list.getDependNode(0)
self.dag_path = selection_list.getDagPath(0)
def shapeAtIndex(path, index):
"""Finds and returns the shape DagPath under the specified path for the index
:param path: the MDagPath to the parent node that you wish to search under
:type path: om2.MDagPath
:param index: the shape index
:type index: int
:rtype: om2.MDagPath or None
"""
if index in range(path.numberOfShapesDirectlyBelow()):
return om2.MDagPath(path).extendToShape(index)
def parentPath(path):
"""Returns the parent nodes MDagPath
:param path: child DagPath
:type path: MDagpath
:return: MDagPath, parent of path or None if path is in the scene root.
"""
parent = om2.MDagPath(path)
parent.pop(1)
if parent.length() == 0: # ignore world !
return
return parent
def _getShapePath(self):
'''
Returns:
- A MDagPath copy of self.dagPath if self.dagPath is already a path to a shape node.
- A MDagPath to the only shape parented directly beneath self.dagPath if self.dagPath is a path to a transform node.
- None otherwise.
'''
dagPath = OpenMaya.MDagPath(self.dagPath)
try: dagPath.extendToShape()
except RuntimeError: return None
return dagPath
def _insert(self, node):
if node.path.length() == 0:
raise RuntimeError('should not include world')
try: parent, status = self._insert2(Node(OpenMaya.MDagPath(node.path).pop()), node.status)
except AlreadyHasStatus: return
parent.add(node)
if status == node.status:
# remove meaningless tail of neutral elements (they implicitly have the same status as their parent)
node.status = NEUTRAL
while parent and node.status == NEUTRAL:
parent.remove(node)
parent, node = parent.parent, parent
def API_getMDagPath(obj):
'''
convert maya name into dagPath , very use to manipulate obj in API
'''
selection = ompy.MSelectionList()
selection.add(obj)
dagPath = ompy.MDagPath()
dagPath = selection.getDagPath(0)
return dagPath
def __init__(self):
super(AverageVertexWeightsCommand, self).__init__()
self._index_arg = ''
self._weight_arg = None
self._skin_cluster_arg = ''
self._skin_fn = None
self._components = None
self._influence_indices = None
self._dag_path = OpenMaya.MDagPath()
self._old_weights = OpenMaya.MDoubleArray()
def shapes(path):
"""Returns all the shape dagpaths directly below this dagpath
:param path: The MDagPath to search
:return: list(MDagPath)
"""
paths = []
for i in xrange(path.numberOfShapesDirectlyBelow()):
dagPath = om2.MDagPath(path)
dagPath.extendToShape(i)
paths.append(dagPath)
return paths
def compute(self, plug, data):
assert (isinstance(data.context(), om.MDGContext))
assert (data.setContext(data.context()) == data)
# DO THE COMPUTE ONLY FOR THE *OUTPUT* PLUGS THAT ARE DIRTIED:
if plug == pointOnMeshInfoNode.aPosition or plug == pointOnMeshInfoNode.aPositionX or plug == pointOnMeshInfoNode.aPositionY or plug == pointOnMeshInfoNode.aPositionZ or plug == pointOnMeshInfoNode.aNormal or plug == pointOnMeshInfoNode.aNormalX or plug == pointOnMeshInfoNode.aNormalY or plug == pointOnMeshInfoNode.aNormalZ:
# READ IN ".inMesh" DATA:
inMeshDataHandle = data.inputValue(pointOnMeshInfoNode.aInMesh)
inMesh = inMeshDataHandle.asMesh()
# READ IN ".faceIndex" DATA:
faceIndexDataHandle = data.inputValue(
pointOnMeshInfoNode.aFaceIndex)
faceIndex = faceIndexDataHandle.asInt()
# READ IN ".relative" DATA:
relativeDataHandle = data.inputValue(pointOnMeshInfoNode.aRelative)
relative = relativeDataHandle.asBool()
# READ IN ".parameterU" DATA:
parameterUDataHandle = data.inputValue(
pointOnMeshInfoNode.aParameterU)
parameterU = parameterUDataHandle.asDouble()
# READ IN ".parameterV" DATA:
parameterVDataHandle = data.inputValue(
pointOnMeshInfoNode.aParameterV)
parameterV = parameterVDataHandle.asDouble()
# GET THE POINT AND NORMAL:
point = om.MPoint()
normal = om.MVector()
dummyDagPath = om.MDagPath()
getPointAndNormal(dummyDagPath, faceIndex, relative, parameterU,
parameterV, point, normal, inMesh)
# WRITE OUT ".position" DATA:
pointDataHandle = data.outputValue(pointOnMeshInfoNode.aPosition)
pointDataHandle.set3Double(point.x, point.y, point.z)
data.setClean(plug)
# WRITE OUT ".normal" DATA:
normalDataHandle = data.outputValue(pointOnMeshInfoNode.aNormal)
normalDataHandle.set3Double(normal.x, normal.y, normal.z)
data.setClean(plug)
# The plug was successfully computed
return self
# Let the Maya parent class compute the plug
return None
def childPathAtIndex(path, index):
"""From the given MDagPath return a new MDagPath for the child node at the given index.
:param path: MDagPath
:type index: int
:return: MDagPath, this path's child at the given index"""
existingChildCount = path.childCount()
if existingChildCount < 1:
return None
if index < 0:
index = path.childCount() - abs(index)
copy = om2.MDagPath(path)
copy.push(path.child(index))
return copy
def btnA_click(self):
print('btnA_click')
#cmds.mCmd1()
sel = OpenMaya.MSelectionList()
# OpenMaya.MGlobal.getSelectionListByName('persp', sel) # API 1.0
sel = OpenMaya.MGlobal.getSelectionListByName('persp')
dagPath = OpenMaya.MDagPath()
# sel.getDagPath(0, dagPath)
dagPath = sel.getDagPath(0) # API 2.0
print(dagPath.fullPathName())
myStrings = []
# sel.getSelectionStrings(myStrings)
myStrings = sel.getSelectionStrings()
print(myStrings)
