def doIt(self, args):
# gather the values from args
argParser = om.MArgParser(self.syntax(), args)
plugString = argParser.commandArgumentString(0)
sel = om.MSelectionList()
sel.add(plugString)
self.plug = sel.getPlug(0)
attributeMObj = self.plug.attribute()
fnAttr = om.MFnAttribute(attributeMObj)
if fnAttr.affectsWorldSpace:
self.modifier = om.MDGModifier()
# self.modifier = om.MDagModifier()
else:
self.modifier = om.MDGModifier()
if not self.plug.source().isNull:
self.displayError('{} is connected and cannot be set.'.format(
self.plug.name()))
return
if argParser.isFlagSet('double') or argParser.isFlagSet('d'):
self.plugType = 'double'
self.value = argParser.flagArgumentDouble('d', 0)
self.redoIt()
elif argParser.isFlagSet('boolean') or argParser.isFlagSet('b'):
self.plugType = 'boolean'
self.value = argParser.flagArgumentBool('b', 0)
self.redoIt()
elif argParser.isFlagSet('string') or argParser.isFlagSet('s'):
self.plugType = 'string'
self.value = argParser.flagArgumentString('s', 0)
self.redoIt()
elif argParser.isFlagSet('float') or argParser.isFlagSet('f'):
self.plugType = 'float'
self.value = argParser.flagArgumentFloat('f', 0)
self.redoIt()
elif argParser.isFlagSet('int') or argParser.isFlagSet('i'):
self.plugType = 'int'
self.value = argParser.flagArgumentInt('i', 0)
self.redoIt()
elif argParser.isFlagSet('angle') or argParser.isFlagSet('a'):
self.plugType = 'angle'
self.value = argParser.flagArgumentMAngle('a', 0)
self.redoIt()
def _buildCmd(self):
dgMod = None
if self._imported != self._node.getImportedStatus():
if self._imported is None or not self._imported:
if self._node._hasImportedPlug():
dgMod = OpenMaya.MDGModifier()
dgMod.removeAttribute(
self._node.thisMObject(),
self._node._getImportedPlug().attribute())
else:
attr = OpenMaya.MFnNumericAttribute().create(jsonTranslatorGlobals.IMPORTED_ATTRIBUTE_NAME, \
_IMPORTED_ATTRIBUTE_SHORT_NAME, OpenMaya.MFnNumericData.kBoolean, self._imported)
dgMod = OpenMaya.MDGModifier()
dgMod.addAttribute(self._node.thisMObject(), attr)
return dgMod
def removeElementPlug(plug, elementNumber, mod=None, apply=False):
"""Functional wrapper for removing a element plug(multiinstance)
:param plug: The plug array object
:type plug: om2.MPlug
:param elementNumber: the element number
:type elementNumber: int
:param mod: If None then a om2.MDGModifier object will be created and returned else the one thats passed will be used.
:type mod: om2.MDGModifier or None
:param apply: If False then mod.doIt() will not be called, it is the clients reponsiblity to call doIt,
useful for batch operations.
:type apply: bool
:return: The MDGModifier instance which contains the operation stack.
:rtype: om2.MDGModifier
"""
# keep the compound plug unlocked for elements to be deleted
with setLockedContext(plug):
mod = mod or om2.MDGModifier()
# make sure the client has passed an invalid elementIndex.
if elementNumber in plug.getExistingArrayAttributeIndices():
# add the op to the stack and let maya handle connections for us.
mod.removeMultiInstance(plug.elementByLogicalIndex(elementNumber),
True)
# allow the user to batch delete elements if apply is False, this is more efficient.
if apply:
try:
mod.doIt()
except RuntimeError:
logger.error(
"Failed to remove element: {} from plug: {}".format(
str(elementNumber), plug.name()),
exc_info=True)
raise
return mod
def createWarp(self, *args):
terrain = mc.textFieldGrp(self.m_warpTerrainText, query=True, tx=True)
if (terrain == "") or (self.warpControlPoints == []):
print "Error. Missing info for the input objects"
else:
nodeName = mc.textFieldGrp(self.m_warpNameTextField,
query=True,
tx=True)
if nodeName == "":
nodeName = "WarpNode"
maxCPRadius = mc.floatSliderGrp(self.m_warpMaxRadius,
query=True,
value=True)
# Create the warp node
dgModifier = om.MDGModifier()
warpNode = dgModifier.createNode("WarpNode")
# Get the name of the node
dgModifier.doIt()
nodeName = om.MFnDependencyNode(warpNode).name()
# Connect the terrain
mc.connectAttr(terrain + ".worldMesh[0]", nodeName + ".terrain")
# Set the max radius
mc.setAttr(nodeName + ".maxRadius", maxCPRadius)
# Connect all of the control points
numControlPoints = len(self.warpControlPoints)
for i in range(numControlPoints):
mc.connectAttr(self.warpControlPoints[i] + ".translate",
nodeName + ".controlPoints[" + str(i) + "]")
mc.connectAttr(
self.warpControlPoints[i] + ".translate",
nodeName + ".controlPointsOriginal[" + str(i) + "]")
mc.disconnectAttr(
self.warpControlPoints[i] + ".translate",
nodeName + ".controlPointsOriginal[" + str(i) + "]")
def addCompoundAttribute(node, longName, shortName, attrMap, isArray=False):
"""
:param node: the node to add the compound attribute too.
:type node: om2.MObject
:param longName: the compound longName
:type longName: str
:param shortName: the compound shortName
:type shortName: str
:param attrMap: [{"name":str, "type": attrtypes.kType, "isArray": bool}]
:type attrMap: list(dict())
:return: the MObject attached to the compound attribute
:rtype: om2.MObject
::example:
>>>attrMap = [{"name":"something", "type": attrtypes.kMFnMessageAttribute, "isArray": False}]
>>> print attrMap
# result <OpenMaya.MObject object at 0x00000000678CA790> #
"""
compound = om2.MFnCompoundAttribute()
compObj = compound.create(longName, shortName)
compound.array = isArray
for attrData in attrMap:
child = addAttribute(node, shortName=attrData["name"], longName=attrData["name"], attrType=attrData["type"],
isArray=attrData["isArray"], apply=False)
compound.addChild(child.object())
mod = om2.MDGModifier()
mod.addAttribute(node, compObj)
mod.doIt()
return compObj
def connectWithDecompMtx(srcMobj, trgMobj):
"""
Connect and two DAG nodes using matrixDecompose
:param srcMobj: MObject
:param trgMobj: MObject
:return: None
"""
assert srcMobj, "Please select a source"
assert trgMobj, "Please select a target"
dgMod = om2.MDGModifier()
srcMFn = om2.MFnDependencyNode(srcMobj)
trgMFn = om2.MFnDependencyNode(trgMobj)
decompMobj = cUtils.createDGNode(tConst.DECOMPOSEMATRIX, nodeName="")
srcPlug = srcMFn.findPlug("worldMatrix", False)
srcWorldMtxPlug = srcPlug.elementByLogicalIndex(0)
decompMfn = om2.MFnDependencyNode(decompMobj)
decompMfnPlug = decompMfn.findPlug("inputMatrix", False)
for srcAttr, trgAttr in [("outputRotate", "rotate"),
("outputTranslate", "translate"),
("outputScale", "scale")]:
srcPlug = decompMfn.findPlug(srcAttr, False)
trgPlug = trgMFn.findPlug(trgAttr, False)
dgMod.connect(srcPlug, trgPlug)
dgMod.connect(srcWorldMtxPlug, decompMfnPlug)
dgMod.doIt()
def unapply(self):
""" Restore the override. """
dgMod = OpenMaya.MDGModifier()
for applyNode in self.getApplyOverrides():
applyNode.extract()
dgMod.deleteNode(applyNode.thisMObject())
dgMod.doIt()
def redoIt(self):
# Create a dg modifier
dgModifier = om.MDGModifier()
# Create the river node
self.riverNode = dgModifier.createNode("RiverNode")
dgModifier.renameNode(self.riverNode, self.name)
# Get the name of the node
dgModifier.doIt()
nodeName = om.MFnDependencyNode(self.riverNode).name()
# Create the loft node
self.loftNode = dgModifier.createNode("loft")
dgModifier.renameNode(self.loftNode, nodeName + "Loft")
# Create the nurbs tesselate node
self.nurbsTesselateNode = dgModifier.createNode("nurbsTessellate")
dgModifier.renameNode(self.nurbsTesselateNode,
nodeName + "NurbsTesselate")
# Execute the dg modifier queues to create the nodes
dgModifier.doIt()
# Connect attributes
mc.connectAttr(self.curve + ".worldSpace[0]", nodeName + ".inputCurve")
mc.connectAttr(self.mesh + ".outMesh", nodeName + ".terrain")
mc.connectAttr(nodeName + ".curveL", nodeName + "Loft.inputCurve[0]")
mc.connectAttr(nodeName + ".curveB", nodeName + "Loft.inputCurve[1]")
mc.connectAttr(nodeName + ".curveR", nodeName + "Loft.inputCurve[2]")
mc.connectAttr(nodeName + "Loft.outputSurface",
nodeName + "NurbsTesselate.inputSurface")
# Set the nurbs tesselate to quads
mc.setAttr(nodeName + "NurbsTesselate.polygonType", 1)
def getContainerHyperLayout(container, create=True):
"""
Gets the hyperlayout that is connected to the container. If the container has not got one, and create is set to True,
a hyperlayout will be created and joined to the container.
@param MObject container: The container object that you want to return its hyperlayout.
@return: The hyperlayout connected to the container
@rtype: MObject
"""
_dgContainer = om2.MFnDependencyNode(container)
_hyperLPlug = _dgContainer.findPlug('hyperLayout', True)
_hyperLayoutMo = None
# check if container has a hyperlayout, is not creates one
if not _hyperLPlug.isConnected and not _hyperLPlug.isDestination:
if create:
_dgMod = om2.MDGModifier()
_hyperLayoutMo = _dgMod.createNode('hyperLayout')
_dgMod.doIt()
_hyperLayoutMfn = om2.MFnDependencyNode(_hyperLayoutMo)
_hyperLayoutMfn.setName(_dgContainer.name() + "_hyperLayout")
_dgMod.connect(_hyperLayoutMfn.findPlug("message", True), _hyperLPlug)
_dgMod.doIt()
else:
_hyperLayoutMo = _hyperLPlug.source().node()
return _hyperLayoutMo
def disconnectPlug(plug, source=True, destination=True, modifier=None):
"""Disconnect the plug connections, if 'source' is True and the 'plug' is a destination then disconnect the source
from this plug. If 'destination' True and plug is a source then disconnect this plug from the destination.
This function will also lock the plugs otherwise maya raises an error
:param plug: the plug to disconnect
:type plug: om2.MPlug
:param source: if true disconnect from the connected source plug if it has one
:type source: bool
:param destination: if true disconnect from the connected destination plug if it has one
:type destination: bool
:return: True if succeed with the disconnection
:rtype: bool
:raises: maya api error
"""
if plug.isLocked:
plug.isLocked = False
mod = modifier or om2.MDGModifier()
if source and plug.isDestination:
sourcePlug = plug.source()
if sourcePlug.isLocked:
sourcePlug.isLocked = False
mod.disconnect(sourcePlug, plug)
if destination and plug.isSource:
for conn in plug.destinations():
if conn.isLocked:
conn.isLocked = False
mod.disconnect(plug, conn)
if not modifier:
mod.doIt()
return True, mod
def addToContainer(mobj, containerObj):
"""
Add an object to a container.
@param mobj: Object you wish to add to the container
@param om2.MObject containerObj: container that have the object added to it
"""
_hyperLayoutDG = getContainerHyperLayout(containerObj)
_hyperLayoutMfn = om2.MFnDependencyNode(_hyperLayoutDG)
_hyperLayoutMessagePlug = _hyperLayoutMfn.findPlug('hyperPosition', True)
_nextPlugIndex = _hyperLayoutMessagePlug.numElements()
_dagMod = om2.MDGModifier()
_mfnNode = om2.MFnDependencyNode()
_hyperposPlug = _hyperLayoutMessagePlug.elementByLogicalIndex(_nextPlugIndex)
_availableDependNodePlug = node.getNextAvailablePlugInPlug(_hyperposPlug, 'dependNode')
print("NEXT AVAILABLE dependNode : {0}".format(_availableDependNodePlug))
_mfnNode.setObject(mobj)
_msgPlug = _mfnNode.findPlug('message', True)
_badConnection = node.isSourceConnectedTo(_msgPlug, nodeType='hyperLayout')
# TODO: check if you are trying to add the object to the container it is already added to
if _availableDependNodePlug and not _badConnection:
_dagMod.connect(_msgPlug, _availableDependNodePlug)
_dagMod.doIt()
_nextPlugIndex += 1
else:
print("ERROR: Object not added to container!")
def _setSkinInputData(inPoints, skinCluster):
fn = om.MFnDependencyNode(skinCluster)
inputPlug = fn.findPlug("input", True).elementByLogicalIndex(0).child(0)
meshPlug = inputPlug.source()
if meshPlug.isNull:
return
mesh = meshPlug.asMObject()
fnMesh = om.MFnMesh(mesh)
# this probably isnt the best way to do this, but it works fine
fnMesh.copy(mesh)
fnMesh.setPoints(inPoints, om.MSpace.kObject)
outMeshPlug = fnMesh.findPlug('outMesh', True)
source = _detachInputObjectFromSkin(skinCluster)
dgMod = om.MDGModifier()
dgMod.connect(outMeshPlug, inputPlug)
dgMod.doIt()
posePoints = _getMeshDataPoints(_getSkinOutMeshData(skinCluster))
_attachInputObjectToSkin(source, skinCluster)
p = fnMesh.parent(0)
# I dont know why the api crashes when trying to delete 'p'
cmds.delete(om.MDagPath.getAPathTo(p).fullPathName())
return posePoints
def doIt(self, nodes=None):
modifier = om2.MDGModifier()
for n, name in iter(nodes):
modifier.renameNode(n.object(), name)
modifier.doIt()
self._modifier = modifier
return nodes
def deleteNode(node):
"""
Delete the node that is passed in
@param node:
"""
_dgMod = om2.MDGModifier()
_dgMod.deleteNode(node)
_dgMod.doIt()
def execute(node, attribute):
AddDynamicAttribute.node = node
AddDynamicAttribute.attribute = attribute
AddDynamicAttribute.mdgModifier = OpenMaya.MDGModifier()
cmds.addDynamicAttribute()
AddDynamicAttribute.node = None
AddDynamicAttribute.attribute = None
AddDynamicAttribute.mdgModifier = None
def rename(mobject, newName):
"""Renames the given mobject node, this is undoable
:param mobject: MObject
:param newName: str
"""
dag = om2.MDGModifier()
dag.renameNode(mobject, newName)
dag.doIt()
def _attachInputObjectToSkin(inPlug, skinCluster):
dgMod = om.MDGModifier()
fn = om.MFnDependencyNode(skinCluster)
inDataPlug = fn.findPlug("input", True).elementByLogicalIndex(0).child(0)
src = inDataPlug.source()
if not src.isNull:
dgMod.disconnect(src, inDataPlug)
dgMod.connect(inPlug, inDataPlug)
dgMod.doIt()
def undoIt(self):
# Create a dg and dag modifier
dgModifier = om.MDGModifier()
# Delete the nodes
dgModifier.deleteNode(self.riverNode)
dgModifier.deleteNode(self.loftNode)
dgModifier.deleteNode(self.nurbsTesselateNode)
# Execute the dag and dg modifier queues
dgModifier.doIt()
def __init__(self):
om2.MPxCommand.__init__(self)
self.dagModifier = om2.MDagModifier()
self.dgModifier = om2.MDGModifier()
self.selList = om2.MSelectionList()
self.matchScale = True
self.matchRotation = True
self.matchTranslation = True
self.origTransforms = []
def __init__(self):
super(NodeConvertCmd, self).__init__()
self.undo = True
self.modi = api2.MDGModifier()
self.new_src_dest_items = ct.LinkedList()
self.old_src_dest_items = ct.LinkedList()
self.connected_attrs = ct.LinkedList()
self.plugs = None
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 deleteApplyOverrideChain(last):
'''Delete a chain of apply override nodes.
The argument is the last apply override node in the chain.'''
aoObjs = [ao.thisMObject() for ao in ApplyConnectionOverride.reverseGenerator(last)]
dgMod = OpenMaya.MDGModifier()
for obj in aoObjs:
dgMod.deleteNode(obj)
dgMod.doIt()
def _detachInputObjectFromSkin(skinCluster):
fn = om.MFnDependencyNode(skinCluster)
inDataPlug = fn.findPlug("input", True).elementByLogicalIndex(0).child(0)
meshPlug = inDataPlug.source()
if meshPlug.isNull:
return
dgMod = om.MDGModifier()
dgMod.disconnect(meshPlug, inDataPlug)
dgMod.doIt()
return om.MPlug(meshPlug)
def renameAttribute(self, name, newName):
try:
plug = self._mfn.findPlug(name, False)
except RuntimeError:
raise AttributeError("No attribute named {} on metaNode->{}".format(name, self.fullPathName()))
with plugs.setLockedContext(plug):
mod = om2.MDGModifier()
mod.renameAttribute(self.mobject(), plug.attribute(), newName, newName)
mod.doIt()
return True
def disconnectPlugFromNode(self, source, node):
for i in source.destinations():
if i.node() == node:
mod = om2.MDGModifier()
mod.disconnect(source, i)
mod.doIt()
mod.removeAttribute(i.node(), i.attribute())
mod.doIt()
return True
return False
def __exit__(self, exc_type, exc_val, exc_tb):
mod = om2.MDGModifier()
weightPlug = self.blendshapeNode.findPlug("weight", False)
for plugIdx, value, in self.plugs:
mod.newPlugValueFloat(weightPlug.elementByLogicalIndex(plugIdx),
value)
for connectedPlug in self.connectedPlugs:
for source in connectedPlug[1]:
mod.connect(source, connectedPlug[0])
mod.doIt()
def undoIt(self): dgModifier = om.MDGModifier() dagModifier = om.MDagModifier() dgModifier.deleteNode(self.caveNode) dgModifier.deleteNode(self.loftNode) dgModifier.deleteNode(self.loftTessellateNode) dgModifier.deleteNode(self.planarNode) dgModifier.deleteNode(self.planarTesselateNode) dagModifier.deleteNode(self.loftMeshTransformNode) dgModifier.doIt() dagModifier.doIt()
def removeAllParents(self):
parentPlug = self._mfn.findPlug(MPARENT_ATTR_NAME, False)
mod = om2.MDGModifier()
with plugs.setLockedContext(parentPlug):
for index in iter(parentPlug.getExistingArrayAttributeIndices()):
childrenElement = parentPlug.elementByLogicalIndex(index)
if childrenElement.isConnected:
mod.disconnect(childrenElement.source(), childrenElement)
mod.removeMultiInstance(childrenElement, False)
mod.doIt()
return True
def undoIt(self):
if len(self.transformNodesList) == 0 and len(
self.inputComponentsList) == 0:
return
for i in range(len(self.transformNodesList)):
MSelectionList = OpenMaya.MSelectionList()
MSelectionList.add(self.transformNodesList[i])
MSelectionList.add(self.inputMeshList[i])
MTransformNodeObj = MSelectionList.getDependNode(0)
MInputMeshObj = MSelectionList.getDependNode(1)
inputComponentsListStr = self.inputComponentsList[i]
inputMeshDGFn = OpenMaya.MFnDependencyNode(MInputMeshObj)
# Creates poseScope Node
poseScopeDagNodeFn = OpenMaya.MFnDagNode()
poseScopeDagNodeObj = poseScopeDagNodeFn.create('mnt_poseScope')
poseScopeNodePath = OpenMaya.MFnDagNode(
poseScopeDagNodeObj).getPath().extendToShape()
poseScopeNode = OpenMaya.MFnDependencyNode(
poseScopeNodePath.node())
poseScopeNode.findPlug('colorR', False).setDouble(1.0)
poseScopeNode.findPlug('colorG', False).setDouble(0.75)
poseScopeNode.findPlug('colorB', False).setDouble(0.0)
poseScopeNode.findPlug('opacity', False).setFloat(0.1)
# ______________________
# Parents poseScope shape to transformNode
transformDagNode = OpenMaya.MFnDagNode(MTransformNodeObj)
transformDagNode.addChild(poseScopeNodePath.node(), 0, False)
OpenMaya.MGlobal.deleteNode(poseScopeDagNodeObj)
# ________________________________________
# Recreates group Node
DGModifier = OpenMaya.MDGModifier()
groupNodeObj = DGModifier.createNode('mnt_groupNode')
groupNodeDGNode = OpenMaya.MFnDependencyNode(groupNodeObj)
groupNodeDGNode.findPlug('mode', False).setInt(1)
groupNodeDGNode.findPlug('componentsList', False).setString(
self.inputComponentsList[i])
# ____________________
# Creates node connections
DGModifier.connect(
groupNodeDGNode.findPlug('outputsComponent', False),
poseScopeNode.findPlug('inputFaceComponents', False))
DGModifier.connect(inputMeshDGFn.findPlug('outMesh', False),
poseScopeNode.findPlug('inputMesh', False))
DGModifier.doIt()
# ________________________
return
def removeParent(self):
parent = self.metaParent()
if parent is None:
return False
mod = om2.MDGModifier()
source = parent.findPlug(MCHILDREN_ATTR_NAME, False)
destination = self.findPlug(MPARENT_ATTR_NAME, False)
with plugs.setLockedContext(source):
destination.isLocked = False
mod.disconnect(source, destination)
mod.doIt()
return True
