Maya API Extension’s

In zoo we use mayas api quite extensively for operations which have a rather noticeable performance impact ie. rigging and animation.

While our front end api Zapi is still being extended as we go when need to contain more functionality with a OOP interface. What lies here as our library code which wraps maya api(mainly om2) into a set of raw Maya api functions and classes where required.

Attrtypes

This module contains a centralized way of handling the many maya attribute types which are spread across many attribute classes and these constant values tend to conflict with each other. By using the kConstant type in this module in conjunction with zoo.libs.maya.api.plugs and zoo.libs.maya.api.nodes.addAttribute() functions you will have a single entry point in manipulating maya attributes.

kMFnNumericBoolean = 0

kMFnNumericBoolean

kMFnNumericShort = 1

kMFnNumericShort

kMFnNumericInt = 2

kMFnNumericInt

kMFnNumericLong = 2

kMFnNumericLong

kMFnNumericByte = 4

kMFnNumericByte

kMFnNumericFloat = 5

kMFnNumericFloat

kMFnNumericDouble = 6

kMFnNumericDouble

kMFnNumericAddr = 7

kMFnNumericAddr

kMFnNumericChar = 8

kMFnNumericChar

kMFnUnitAttributeDistance = 9

kMFnUnitAttributeDistance

kMFnUnitAttributeAngle = 10

kMFnUnitAttributeAngle

kMFnUnitAttributeTime = 11

kMFnUnitAttributeTime

kMFnkEnumAttribute = 12

kMFnkEnumAttribute

kMFnDataString = 13

kMFnDataString

kMFnDataMatrix = 14

kMFnDataMatrix

kMFnDataFloatArray = 15

kMFnDataFloatArray

kMFnDataDoubleArray = 16

kMFnDataDoubleArray

kMFnDataIntArray = 17

kMFnDataIntArray

kMFnDataPointArray = 18

kMFnDataPointArray

kMFnDataVectorArray = 19

kMFnDataVectorArray

kMFnDataStringArray = 20

kMFnDataStringArray

kMFnDataMatrixArray = 21

kMFnDataMatrixArray

kMFnCompoundAttribute = 22

kMFnCompoundAttribute

kMFnNumericInt64 = 23

kMFnNumericInt64

kMFnNumericLast = 24

kMFnNumericLast

kMFnNumeric2Double = 25

kMFnNumeric2Double

kMFnNumeric2Float = 26

kMFnNumeric2Float

kMFnNumeric2Int = 27

kMFnNumeric2Int

kMFnNumeric2Long = 27

kMFnNumeric2Long

kMFnNumeric2Short = 29

kMFnNumeric2Short

kMFnNumeric3Double = 30

kMFnNumeric3Double

kMFnNumeric3Float = 31

kMFnNumeric3Float

kMFnNumeric3Int = 32

kMFnNumeric3Int

kMFnNumeric3Long = 32

kMFnNumeric3Long

kMFnNumeric3Short = 34

kMFnNumeric3Short

kMFnNumeric4Double = 35

kMFnNumeric4Double

kMFnMessageAttribute = 36

kMFnMessageAttribute

mayaNumericTypeToInternalType(mayaType)

Returns the zoo internal attribute type for the maya numeric type

Parameters:

mayaType (om2.MFnNumericData.kBoolean) – The maya attribute type

Returns:

One of our internal types ie. kMFnNumericBoolean

Return type:

int

numericTypeToMayaFnType(Type)

Returns the numeric attribute function object and the data type numericData.ktype for the provided zoo type or None,None.

Parameters:

Type (int) – attr types constant

Returns:

variation of om2.MFnNumericAttribute, om2.MFnNumericData.k2Int

Return type:

tuple[None or callable, None or int]

mayaUnitTypeToInternalType(mayaType)

Returns the zoo internal attribute type for the maya unit attribute type

Parameters:

mayaType (om2.MFnUnitAttribute.kDistance) – The maya attribute type

Returns:

One of our internal types ie. kMFnUnitAttributeDistance

Return type:

int

mayaMFnDataTypeToInternalType(mayaType)

Returns the zoo internal attribute type for the maya TypeAttribute type.

Parameters:

mayaType (om2.MFnData.kString) – The maya attribute type

Returns:

One of our internal types ie. kMFnDataString

Return type:

int

mayaTypeToInternalType(mayaType)

Returns the zoo internal attribute type for the maya attribute type

Parameters:

mayaType (om2.MFn.kEnumAttribute, om2.MFn.kMessageAttribute , om2.MFn.kMatrixAttribute) – The maya attribute type

Returns:

One of our internal types ie. kMFnkEnumAttribute, kMFnMessageAttribute, kMFnDataMatrix

Return type:

int

typeToString(attrType, default=None)

Returns the zoo attribute type as as a string name .. example:

typeToString(attrtypes.kMFnNumericBoolean) # “kMFnNumericBoolean”

mayaTypeFromType(Type)

Converts the zoo attribute constant type to the maya type.

Parameters:

Type (int) – the zooType eg. kMFnMessageAttribute

Returns:

the maya attribute object and maya data kConstant

Return type:

tuple(Maya Attribute, int)

mayaTypeToPythonType(mayaType)

From the maya data type return the same type but as a python type ie. MMatrix -> list

Parameters:

mayaType (any maya attribute data type) – The maya attribute data type ie. om2.MDistance, om2.MMatrix

Return type:

list, float, int, string

pythonTypeToMayaType(dataType, value)

Converts a Python data type to a Maya data type.

Parameters:
  • dataType (int) – The type of the data in the Maya API format.

  • value (Any) – The value to convert.

Returns:

The converted value.

Return type:

Any

Anim

currentTimeInfo()

Returns a dict of all the current timeline settings

Return type:

dict

currentTimeInfo()
# result {"currentTime": om2.MTime,
        "start": 0,
        "end": 1,
        "unit": 12,
        "fps": 25}
setCurrentRange(start, end, newCurrentFrame)

Set’s maya’s frame range and the current time number.

Parameters:
  • start (int) – The start of the frame range to set

  • end (int) – The end of the frame range to set

  • newCurrentFrame (ints) – The frame number to set maya’s current time to.

formatFrameRange()

Return’s mayas current frame range as a format string.

Returns:

“0:100” startframe:endFrame

Return type:

str

formatFrame()

Returns the current frame rate as a formatted string.

Returns:

“0:100(30 FPS)” startFrame:endFrame(FPS)

Return type:

str

formatCurrentTime()
maintainTime()

Context manager for preserving (resetting) the time after the context

iterFrameRangeDGContext(start, end, step=1)

Generator function to iterate over a time range returning a MDGContext for the current frame.

Parameters:
  • start – the start frame :type start: int

  • end (int) – the end frame

  • step (int) – The amount of frames to skip between frames.

Returns:

Returns a generator function with each element being a MDGContext with the current frame applied

Return type:

Generator(om2.MDGContext)

iterFramesDGContext(frames, step=1)

Generator function to iterate over a time range returning a MDGContext for the current frame.

Parameters:
  • frames (list[int or float]) – A iterable of frame numbers to iterate

  • step (int) – The amount of frames to skip between frames.

Returns:

Returns a generator function with each element being a MDGContext with the current frame applied

Return type:

Generator(om2.MDGContext)

serializeAnimCurve(animCurveNode)

Callbacks

class MCallbackIdWrapper(callbackId)

Bases: object

Wrapper class to handle cleaning up of MCallbackIds from registered MMessage

removeCallbacksFromNode(mobject)
Parameters:

mobject (om2.MObject) – The node to remote all node callbacks from

Returns:

the number of callbacks removed

Return type:

int

removeCallbacksFromNodes(mobjects)

Will remove all callbacks from each node.

Parameters:

mobjects (sequence(MObject)) – The nodes to remove callbacks from

Returns:

total count of all callbacks removed

Return type:

int

class CallbackSelection(func, *args, **kwargs)

Bases: object

Class handles the management of a single selection callback which can be stored in a GUI.

To activate the callback use start() To cleanup run stop()

Note:

Selected objects are passed to the callback as a keyword argument “selection”

from zoo.libs.maya.api import nodes

def myCallbackFunction(selection):
    # do stuff to the selection which is a list of OpenMaya.MObjectHandle
    for MObjectHandle in selection:
        if not i.isValid() or not i.isAlive():
            continue
        # print the fullPathName of the selected, FYI: this has arguments for stripping namespace etc too.
        print(nodes.nameFromMObject(i.object()))

callbackInstance = CallbackSelection(myCallbackFunction)  # add the function here
callbackInstance.start()
callbackInstance.stop()
mayaSelectionChanged(*args, **kwargs)

The Open Maya 2 code for monitoring a selection callback with a short and longname list of strings

start()

Creates and stores the selection callback on this instance.

stop()

Cleans up the instance by removing the maya api callback

Curves

getCurveData(shape, space=MockExt.OpenMaya.MSpace.kObject, includeColours=True)

From a given NurbsCurve shape node serialize the cvs positions, knots, degree, form rgb colours

Parameters:
  • shape – MObject that represents the NurbsCurve shape

  • space (om2.MSpace) –

Returns:

dict

nurbsCurve = cmds.circle()[1]
# requires an MObject of the shape node
data = curve_utils.getCurveData(api.asMObject(nurbsCurve))
createCurveShape(parent, data, space=MockExt.OpenMaya.MSpace.kObject, mod=None)

Create a specified nurbs curves based on the data.

Parameters:
  • parent (MObject) – The transform that takes ownership of the shapes, if None is supplied then one will be created

  • data (dict) – {“shapeName”: {“cvs”: [], “knots”:[], “degree”: 0, “form”: int, “matrix”: []}}

  • space (int) – om2.MSpace

Returns:

A 2 tuple the first element is the MObject of the parent and the second is a list of mobjects represents the shapes created.

Return type:

iterable[om2.MObject, list[om2.MObject]]

createCurveFromPoints(name, points, shapeDict=None, parent=None)
createBezierCurve(name, points, degree=3, knots=None, parent=None)

Creates a Bezier curve from the provided points and degree and returns an om2.MObject.

Parameters:
  • name (str) – The name for the curve

  • points (list[list[float, float, float]]) – 2D list of point positions.

  • degree (int) – The curve degree, default is 3.

  • knots (list[float] or None) – point knots, must be len(points) + degree -1. If None knots will be auto generated.

  • parent (om2.MObject or None) – The parent transform for the curve, if None a new transform is created.

Returns:

The curve as a MObject.

Return type:

om2.MObject

serializeCurve(node, space=MockExt.OpenMaya.MSpace.kObject, includeColours=True)

From a given transform serialize the shapes curve data and return a dict compatible with Json.

Parameters:

node (MObject) – The MObject that represents the transform above the nurbsCurves

Returns:

returns the dict of data from the shapes

Return type:

dict

mirrorCurveCvs(curveObj, axis='x', space=None)

Mirrors the the curves transform shape cvs by a axis in a specified space

Parameters:
  • curveObj (mobject) – The curves transform to mirror

  • axis (str) – the axis the mirror on, accepts: ‘x’, ‘y’, ‘z’

  • space (int) – the space to mirror by, accepts: MSpace.kObject, MSpace.kWorld, default: MSpace.kObject

Example:

nurbsCurve = cmds.circle()[0] mirrorCurveCvs(api.asMObject(nurbsCurve), axis=’y’, space=om.MSpace.kObject)

iterCurvePoints(dagPath, count, space=MockExt.OpenMaya.MSpace.kObject)

Generator Function to iterate and return the position, normal and tangent for the curve with the given point count.

Parameters:
  • dagPath (om2.MDagPath) – the dagPath to the curve shape node

  • count (int) – the point count to generate

  • space (om2.MSpace) – the coordinate space to query the point data

Returns:

The first element is the Position, second is the normal, third is the tangent

Return type:

tuple(MVector, MVector, MVector)

matchCurves(driver, targets, space=MockExt.OpenMaya.MSpace.kObject)

Function that matches the curves from the driver to all the targets.

Parameters:
  • driver (om2.MObject) – the transform node of the shape to match

  • targets (list(om2.MObject) or tuple(om2.MObject)) – A list of transform that will have the shapes replaced

curveCvs(dagPath, space=MockExt.OpenMaya.MSpace.kObject)

Generator Function to iterate and return the position, normal and tangent for the curve with the given point count.

Parameters:
  • dagPath (om2.MDagPath) – the dagPath to the curve shape node

  • space (om2.MSpace) – the coordinate space to query the point data

Returns:

The first element is the Position, second is the normal, third is the tangent

Return type:

tuple(om2.MPoint)

iterCurveParams(dagPath, count)

Generator Function to iterate and return the Parameter

Parameters:
  • dagPath (om2.MDagPath) – the dagPath to the curve shape node

  • count (int) – the Number of params to loop

Returns:

The curve param value

Return type:

list[float]

attachNodeToCurveAtParam(curve, node, param, name, rotate=True, fractionMode=False)

Attaches the given node to the curve using a motion path node.

Parameters:
  • curve (om2.MObject) – nurbsCurve Shape to attach to

  • node (om2.MObject) – the node to attach to the curve

  • param (float) – the parameter float value along the curve

  • name (str) – the motion path node name to use

  • rotate (bool) – Whether to connect rotation from the motion path to the node.

  • fractionMode (bool) – True if the motion path should use fractionMode(0.1) vs False(0-2)

Returns:

motion path node

Return type:

om2.MObject

iterGenerateSrtAlongCurve(dagPath, count, name, rotate=True, fractionMode=False)

Generator function to iterate the curve and attach transform nodes to the curve using a motionPath

Parameters:
  • dagPath (om2.MDagPath) – the dagpath to the nurbscurve shape node

  • count (int) – the number of transforms

  • name (str) – the name for the transform, the motionpath will have the same name plus “_mp”

  • rotate (bool) – Whether to connect rotation from the motion path to the SRT.

  • fractionMode (bool) – True if the motion path should use fractionMode(0.1) vs False(0-2)

Returns:

Python Generator first element is the created transform node, the second is the motionpath node

Return type:

Generate(tuple(om2.MObject, om2.MObject))

rotationsAlongCurve(curveShape, count, aimVector, upVector, worldUpVector)

Returns the position and rotation along the curve incrementally based on the jointCount provided.

Parameters:
  • curveShape (om2.MDagPath) – The NurbsCurve shape DagPath to use.

  • count (int) – The number of points along the curve to use.

  • aimVector (om2.MVector) – The primary axis to align along the curve. ie. om2.MVector(1.0,0.0,0.0)

  • upVector (om2.MVector) – The upVector axis to use. ie. om2.MVector(0.0,1.0,0.0)

  • worldUpVector (om2.MVector) – The secondary world up Vector to use. ie. om2.MVector(0.0,0.0,1.0)

Returns:

Returns a generator containing the position and rotation.

Return type:

tuple[om2.MVector, om2.MQuaternion]

Deformers

This modules handles maya native deformer queries including serializing weights etc.

class SkinCluster(cluster)

Bases: object

Thin wrapper class around getting and setting skin weights

influenceWeights()

Returns a dictionary containing the influence objects data.

Returns:

A dictionary with the influence objects data, where the keys are the partial names of the influence objects and the values are lists of weights corresponding to each influence object.

Return type:

dict

blendWeights()

Returns the blend weights of the cluster as a tuple :return: :rtype:

serialize()

Serialize the skin cluster object as a dictionary.

Returns:

A dictionary containing the name, weights, blend weights, normalized status, skinning method, maximum number of influences, and maintain maximum influences status of the skin cluster object.

Return type:

dict

geometryComponentsFromSet(mobjectSet)

Returns the dagpath and geometry components from the maya set mobject

skinClustersFromJoints(joints)

From a set of joints, find and retrieve the skinClusters as om2.MObject

Parameters:

joints (list[zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode]) – a sequence of zapi DagNodes representing kJoint

Returns:

the retrieved skin clusters from the joints

Return type:

list[zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode]

skinClustersFromJoint(joint)

Skin clusters from joint

Parameters:

joint (zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode) – Joint as DagNode

Returns:

Return type:

list[zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode]

skinClustersConnectedMeshes(skinClusters)

Returns mesh list from skinClusters

Parameters:

skinClusters (list[zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode]) – skinClusters as dag/dg node

Return nodes:

The connected meshes

Rtype nodes:

list[zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode]

jointsConnectedMeshes(joints)
jointConnectedMeshes(joint)

Get connected meshes from joints

Parameters:

joint (zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode) – Joint as dag/dg node

Returns:

List of geometries connected

Return type:

list[zoo.libs.maya.zapi.base.DagNode or zoo.libs.maya.zapi.base.DGNode]

clusterUpstreamFromNode(node)

Find’s and returns the skin clusters upstream of the given node

Parameters:

node (om2.MObject) – the DGNode to query

Returns:

theA sequence of skin cluster nodes

Return type:

list(om2.MObject)

serializeClusters(clusters)

For the given skin clusters, serialize them to a dict

Parameters:

clusters (list(om2.MObject)) – A sequence of MObjects representing the skinClusters

Return type:

list(dict)

serializeSkinWeightsFromShapes(shapes)

Serializes the geometry shape skinCluster weights to a dict.

example:

{my|objectName: {"points":   [[11.720806121826172,11.951449566072865,0.47714900970458984,1]],
    "skinData": [{
        "name": "roboRig:skinCluster_hand01_L",
        "maxInfluence": 5,
        "maintainMaxInfluences": true,
        "skinningMethod": 0,
        "weights": {
            "|L_wrist": [1,0,1,0]
            }]
            }
}
Parameters:

shapes (om2.MObject) – The MObjects representing the shape nodes to serialize

Return type:

dict

applyWeightsFromData(data, shape)
createAndImportWeightsFromShapes(filePath, shapes)

Loads the skin data from the filePath and loads it on the shapeNodes.

If any of the shapes have existing skinClusters then the weights will be replaced. Otherwise a skin cluster will be created.

Parameters:
  • filePath (str) – The json file to load, must be in the same format as the return data of serialzieSkinWeightsFromShapes()

  • shapes ([type]) – list of om2.MObjects representing the geometry shape nodes to load the data onto

Generic

class MObjectHandleWrap(*args: Any, **kwargs: Any)

Bases: MObjectHandle

Simple class to do what Autodesk should of done, this class makes the MObjectHandle hashable so it can be used in sets and dicts correctly.

Note::

maya’s documentation says >, >=, <, <= but this isn’t true at all part from the errors the c++ docs don’t specify it so c++ is right, geez get your shit right.

isValidMObjectHandle(mObjHandle)

Checks whether the MObjectHandle is valid in the scene and still alive

Parameters:

mObjHandle – OpenMaya.MObjectHandle

isValidMObject(mObj)

Checks whether the MObject is valid in the scene.

Parameters:

mObj (OpenMaya.MObject.) – The mobject to validate.

Returns:

Whether or not this MObject is currently valid in the scene.

Return type:

bool.

compareMObjects(a, b)

Compares two nodes and returns whether they’re equivalent or not - the compare is done on MObjects not strings.

asMObject(name)
asEuler(rotation)

Converts tuple(float3) into a MEulerRotation

Parameters:

rotation (tuple(float)) – a tuple of 3 elements in degrees which will be converted to redians for the eulerRotation

Return type:

MEulerRotation

eulerToDegrees(euler)
softSelection()

Gets the current component softSelection

Returns:

a set of tuples with 2 elements, the first is the vertexId and second is the weight value of the selection

Return type:

set(tuple(id, float))

intToMTransformRotationOrder(rotateOrder)
stripNamespaceFromName(name)

Does what maya’s om2.MNamespace.stripNamespaceFromName(name) was suppose to do. Autodesk results:

name = u'|agagaa:NewNamespace1:joint1|agagaa:NewNamespace1:joint2|agagaa:NewNamespace1:joint3
om2.MNamespace.stripNamespaceFromName(name)
# 'joint3'
generic.stripNamespaceFromName(name)
# u'|joint1|joint2|joint3'
Parameters:

name (str) – the name to strip

Returns:

the name without the namespace while preserving the full path

Return type:

str

Nodes

exception MissingObjectByName

Bases: Exception

exception AttributeAlreadyExists

Bases: Exception

asMObject(name)

Returns the MObject from the given name

Parameters:

name (str or MObjectHandle or MDagPath) – The name to get from maya to convert to a mobject

Returns:

The mobject for the given str

Return type:

MObject

nameFromMObject(mobject, partialName=False, includeNamespace=True)

This returns the full name or partial name for a given mobject, the mobject must be valid.

Parameters:
  • mobject (MObject) –

  • partialName (bool) – if False then this function will return the fullpath of the mobject.

  • includeNamespace (bool) – if False the namespace will be stripped

Returns:

the name of the mobject

Return type:

str

from zoo.libs.maya.api import nodes
node = nodes.asMobject(cmds.polyCube())
print nodes.nameFromMObject(node, partial=False) # returns the fullpath, always prepends '|' eg '|polyCube'
print nodes.nameFromMObject(node, partial=True) # returns the partial name eg. polyCube1
toApiMFnSet(node)

Returns the appropriate mObject from the api 2.0

Parameters:

node (str, MObjectHandle) – str, the name of the node

Returns:

MFnDagNode, MPlug, MFnDependencyNode

Return type:

MPlug or MFnDag or MFnDependencyNode

from zoo.libs.maya.api import nodes
node = cmds.polyCube()[0] # str
nodes.toApiObject(node)
# Result MFnDagNode
node = cmds.createNode("multiplyDivide")
nodes.toApiObject(node)
# Result MFnDependencyNode
asDagPath(node)
setNodeColour(node, colour, outlinerColour=None, useOutlinerColour=False, mod=None)

Set the given node mobject override color can be a mobject representing a transform or shape

Parameters:
  • node (mobject) – the node which you want to change the override colour of

  • colour (MColor or tuple) – The RGB colour to set

getNodeColourData(node)
Parameters:

node (MObject) – The maya node mobject that you want to get the override colour from

Returns:

{“overrideEnabled”: bool, “overrideColorRGB”: plugs.getAttr(plug), “overrideRGBColors”: plugs.getAttr(overrideRGBColors)}

Return type:

dict

createDagNode(name, nodeType, parent=None, modifier=None, apply=True)

Creates a new dag node and if there’s a parent specified then parent the new node

Parameters:
  • name (str) – The new name of the created node

  • nodeType (str) – The node type to create

  • parent (MObject or MObject.kNullObj) – The node the parent the new node to, if the parent is none or MObject.kNullObj then it will parent to the world, defaults to world

Returns:

The newly create nodes mobject

Return type:

MObject

createDGNode(name, nodeType, mod=None, apply=True)

Creates and dependency graph node and returns the nodes mobject

Parameters:
  • name (str) – The new name of the node

  • nodeType (str) – the node type to create

Returns:

The mobject of the newly created node

Return type:

om2.MObject

lockNode(mobject, state=True, modifier=None)

Set the lock state of the node

Parameters:
  • mobject (MObject) – the node mobject to set the lock state on

  • state (bool) – the lock state for the node

lockNodeContext(mobject, state)
unlockConnectedAttributes(mobject)

Unlocks all connected attributes to this node

Parameters:

mobject (MObject) – MObject representing the DG node

unlockedAndDisconnectConnectedAttributes(mobject)

Unlcoks and disocnnects all attributes on the given node

Parameters:

mobject (MObject) – MObject respresenting the DG node

containerFromNode(mobj)

Finds and returns the AssetContainer mobject from the give node.

Parameters:

mobj (om2.MObject) – The om2.MObject representing the node to filter.

Returns:

The container MObject found from the mobject else None

Return type:

om2.MObject or None

childPathAtIndex(path, index)

From the given MDagPath return a new MDagPath for the child node at the given index.

Returns:

MDagPath, this path’s child at the given index

childPaths(path)

Returns all the MDagPaths that are a child of path.

Parameters:

path (maya.api.OpenMaya.MDagPath) –

Returns:

child MDagPaths which have path as parent

Return type:

list[maya.api.OpenMaya.MDagPath]

childPathsByFn(path, fn)

Get all children below path supporting the given MFn.type

Parameters:
  • path – MDagpath

  • fn – member of MFn

Returns:

list(MDagPath), all matched paths below this path

iterShapes(path, filterTypes=())

Generator function which all the shape dagpaths directly below this dagpath

Parameters:

path – The MDagPath to search

Returns:

list(MDagPath)

shapes(path, filterTypes=())

:Depreciated Use IterShapes()

shapeAtIndex(path, index)

Finds and returns the shape DagPath under the specified path for the index

Parameters:
  • path (om2.MDagPath) – the MDagPath to the parent node that you wish to search under

  • index (int) – the shape index

Return type:

om2.MDagPath or None

childTransforms(path)

Returns all the child transform from the given DagPath

Returns:

list(MDagPath) to all transforms below path

setParent(child, newParent, maintainOffset=False, mod=None, apply=True)

Sets the parent for the given child

Parameters:
  • child (om2.MObject) – the child node which will have its parent changed

  • newParent (om2.MObject) – The new parent for the child

  • maintainOffset (bool) – if True then the current transformation is maintained relative to the new parent

  • mod (om2.MDagModifier) – The MDagModifier to add to, if none it will create one

  • apply (bool) – Apply the modifier immediately if true, false otherwise

Return type:

bool

childContext(parent)
hasParent(mobject)

Determines if the given MObject has a mobject

Parameters:

mobject (MObject) – the MObject node to check

Return type:

bool

rename(mobject, newName, modifier=None, apply=True)

Renames the given mobject node, this is undoable.

Parameters:
  • mobject (om2.MObject) – the node to rename

  • newName (str) – the new unique name for the node

  • modifier (om2.MDGModifier or None) – if you pass a instance then the rename will be added to the queue then returned otherwise a new instance will be created and immediately executed.

  • apply (bool) – Apply the modifier immediately if true, false otherwise

Note

If you pass a MDGModifier then you should call doIt() after calling this function

parentPath(path)

Returns the parent nodes MDagPath

Parameters:

path (MDagpath) – child DagPath

Returns:

MDagPath, parent of path or None if path is in the scene root.

isValidMDagPath(dagPath)

Determines if the given MDagPath is valid

Parameters:

dagPath – MDagPath

Returns:

bool

iterParents(mobject)
isSceneRoot(node)
isUnderSceneRoot(node)

Determines if the specified node is currently parented to world.

Parameters:

node (om2.MObject) – The maya Dag MObject

Return type:

bool

iterChildren(mObject, recursive=False, filter=None)

Generator function that can recursive iterate over the children of the given MObject.

Parameters:
  • mObject (MObject) – The MObject to traverse must be a MObject that points to a transform

  • recursive (bool) – Whether to do a recursive search

  • filter (tuple or None) – tuple(om.MFn) or None, the node type to find, can be either ‘all’ for returning everything or a om.MFn type constant does not include shapes

Returns:

om.MObject

breadthFirstSearchDag(node, filter=None)
getChildren(mObject, recursive=False, filter=(MockExt.OpenMaya.MFn.kTransform,))
This function finds and returns all children mobjects under the given transform, if recursive then including

sub children.

Parameters:
  • mObject – om.MObject, the mObject of the transform to search under

  • recursive – bool

  • filter – tuple(om.MFn.kTransform, the node type to filter by

Returns:

list(MFnDagNode)

iterAttributes(node, skip=None, includeAttributes=())
iterExtraAttributes(node, skip=None, filteredTypes=None, includeAttributes=None)

Generator function to iterate over all extra plugs(dynamic) of a given node.

Parameters:
  • node (om2.MObject) – The DGNode or DagNode to iterate

  • filteredTypes (tuple(attrtypes.kType)) –

Returns:

Generator function with each item equaling a om2.MPlug

Return type:

iterable[om2.MPlug]

iterConnections(node, source=True, destination=True)

Returns a generator function containing a tuple of MPlugs

Parameters:
  • node (om2.MObject) – The node to search

  • source (bool) – If true then all upstream connections are returned

  • destination (bool) – If true all downstream connections are returned

Returns:

tuple of om2.MPlug instances, the first element is the connected MPlug of the given node(node) The second element is the connected MPlug from the other node.

Return type:

Generator(tuple(om2.MPlug, om2.MPlug))

iterKeyablePlugs(node)
iterChannelBoxPlugs(node)
getRoots(nodes)
getRoot(mobject)

Traversals the objects parent until the root node is found and returns the MObject

Parameters:

mobject – MObject

Returns:

MObject

getParent(mobject)

Returns the parent MFnDagNode if it has a parent else None

Parameters:

mobject – MObject

Returns:

MObject or None

isValidMObject(node)
delete(node)

Delete the given nodes

Parameters:

node

removeUnknownNodes()
getOffsetMatrix(startObj, endObj, space=MockExt.OpenMaya.MSpace.kWorld, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns The offset matrix between two objects.

Parameters:
  • startObj (om2.MObject) – Start Transform MObject.

  • endObj (om2.MObject) – End Transform MObject.

  • space (om2.MSpace.kSpace) – Coordinate space to use.

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

The resulting Offset MMatrix.

Return type:

om2.MMatrix

getMatrix(mobject, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the MMatrix of the given mobject

Parameters:
  • mobject (om2.MObject) – MObject

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

om2.MMatrix

worldMatrixPlug(mobject)
getWorldMatrix(mobject, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the worldMatrix value as an MMatrix.

Parameters:
  • mobject (om2.MObject) – the MObject that points the dagNode

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

MMatrix

decomposeMatrix(matrix, rotationOrder, space=MockExt.OpenMaya.MSpace.kWorld)
parentInverseMatrixPlug(mobject)
getWorldInverseMatrix(mobject, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the world inverse matrix of the given MObject

Parameters:
  • mobject (om2.MObject) – MObject

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

MMatrix

getParentMatrix(mobject, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the parent matrix of the given MObject

Parameters:
  • mobject (om2.MObject) – MObject

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

MMatrix

getParentInverseMatrix(mobject, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the parent inverse matrix from the MObject

Parameters:
  • mobject (om2.MObject) – MObject

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

MMatrix

hasAttribute(node, name)

Searches the node for a give a attribute name and returns True or False

Parameters:
  • node – MObject, the nodes MObject

  • name – str, the attribute name to find

Returns:

bool

setMatrix(mobject, matrix, space=MockExt.OpenMaya.MSpace.kTransform)

Sets the objects matrix using om2.MTransform.

Parameters:
  • mobject (om2.MObject) – The transform MObject to modify

  • matrix (om2.MMatrix) – The maya MMatrix to set

  • space (om2.MSpace.kWorld) – The coordinate space to set the matrix by

setTranslation(obj, position, space=None, sceneUnits=False)
getTranslation(obj, space=None, sceneUnits=False)
cvPositions(shape, space=None)
setCurvePositions(shape, points, space=None)
setRotation(node, rotation, space=MockExt.OpenMaya.MSpace.kTransform)
getRotation(obj, space, asQuaternion=False)
Parameters:
  • obj (om2.MObject or om2.MDagPath) –

  • space

  • asQuaternion

Returns:

Return type:

setCompoundAsProxy(compoundPlug, sourcePlug)
addProxyAttribute(node, sourcePlug, **kwargs)

This method adds a proxy attribute to the specified node.

Parameters:
  • node (str) – The node on which the proxy attribute will be added.

  • sourcePlug (str) – The plug from which the proxy attribute will be connected.

  • kwargs (dict) – Additional keyword arguments.

Returns:

The added attribute.

Return type:

om2.MObject

The kwargs parameter should contain the following keys: - “Type” (attrtypes.kMFnCompoundAttribute): The type of attribute to add. - “children” (dict): A dictionary containing the child attributes for a compound attribute.

Example usage:

node = "myNode"
sourcePlug = "myNode.sourceAttr"
kwargs = {
    "Type": attrtypes.kMFnCompoundAttribute,
    "children": {
        "attr1": {
            "Type": attrtypes.kMFnDoubleAttribute,
            ...
        },
        ...
    },
    ...
}

addedAttr = addProxyAttribute(node, sourcePlug, **kwargs)
addCompoundAttribute(node, longName, shortName=None, attrMap=None, isArray=False, apply=True, mod=None, **kwargs)

Add compound attribute.

Parameters:
  • node (om2.MObject) – the node to add the compound attribute too.

  • longName (str) – The compound longName

  • shortName (str) – The compound shortName

  • isArray (bool) – Whether

  • apply (bool) – If True then the value we be set on the Plug instance by calling doIt on the modifier.

  • mod (om2.MDGModifier) – Apply the modifier instantly or leave it to the caller.

  • attrMap (list(dict())) – [{“name”:str, “type”: attrtypes.kType, “isArray”: bool}]

Returns:

the MObject attached to the compound attribute

Return type:

om2.MFnCompoundAttribute

attrMap = [{"name":"something", "Type": attrtypes.kMFnMessageAttribute, "isArray": False}]
print attrMap
# result <OpenMaya.MObject object at 0x00000000678CA790> #
addAttributesFromList(node, data)

Creates an attribute on the node given a list(dict) of attribute data:

[{
    "channelBox": true,
    "default": 3,
    "isDynamic": true,
    "keyable": false,
    "locked": false,
    "max": 9999,
    "min": 1,
    "name": "jointCount",
    "softMax": null,
    "softMin": null,
    "Type": 2,
    "value": 3
    "isArray": True
}]
Parameters:

data (dict) – The serialized form of the attribute

Returns:

A list of create MPlugs

Return type:

list(om2.MPlug)

addAttribute(node, longName, shortName=None, attrType=6, isArray=False, apply=True, mod=None, **kwargs)

This function uses the api to create attributes on the given node, currently WIP but currently works for string,int, float, bool, message, matrix. if the attribute exists a ValueError will be raised.

Parameters:
  • node – MObject

  • longName (str) – The long name for the attribute.

  • shortName (str) – str, the shortName for the attribute.

  • attrType (attrtypes.kConstant) – attribute Type, attrtypes constants.

  • isArray (bool) – Is the attribute an array?.

  • mod (om2.MDGModifier) – The Undo Modifier to use.

  • apply (bool) – if False the attribute will be immediately created on the node else just return the attribute instance.

  • channelBox(bool) – Should the attribute be displayed in the Channel Box?.

  • keyable(bool) – Can keys be set on the attribute?.

  • default – The default value for the attribute.

  • value – The value for the attribute to use.

  • enums – List of fields which this attribute will have, only valid for EnumAttribute.

  • storable(bool) – Should attr value be stored when written to file?.

  • writable(bool) – Is the attribute writable?.

  • connectable(bool) – Can connections be made to the attribute?.

  • min(int,float) – Returns the attribute’s hard minimum value(s).

  • max(int,float) – Returns the attribute’s hard maximum value(s).

  • softMin(int,float) – Returns the attribute’s soft minimum value.

  • softMax(int,float) – Returns the attribute’s soft maximum value.

  • locked(bool) – True if plug is locked against changes.

Return type:

om2.MFnAttribute

# message attribute
attrMobj = addAttribute(myNode, "testMsg", "testMsg", attrType=attrtypes.kMFnMessageAttribute,
                         isArray=False, apply=True)
# double angle
attrMobj = addAttribute(myNode, "myAngle", "myAngle", attrType=attrtypes.kMFnUnitAttributeAngle,
                         keyable=True, channelBox=False)
# double angle
attrMobj = addAttribute(myNode, "myEnum", "myEnum", attrType=attrtypes.kMFnkEnumAttribute,
                         keyable=True, channelBox=True, enums=["one", "two", "three"])
serializeNode(node, skipAttributes=None, includeConnections=True, includeAttributes=(), extraAttributesOnly=False, useShortNames=False, includeNamespace=True)

This function takes an om2.MObject representing a maya node and serializes it into a dict, This iterates through all attributes, serializing any extra attributes found, any default attribute has not changed (defaultValue) and not connected or is an array attribute will be skipped. if arg includeConnections is True then all destination connections are serialized as a dict per connection.

Parameters:
  • node (om2.MObject) – The node to serialize

  • skipAttributes (list or None) – The list of attribute names to serialization.

  • includeConnections (bool) – If True find and serialize all connections where the destination is this node.

  • includeAttributes (iterable) – If Provided then only these attributes will be serialized

  • extraAttributesOnly (bool) – If True then only extra attributes will be serialized

  • useShortNames (bool) – If True only the short name of nodes will be used.

  • includeNamespace (bool) – Whether to include the namespace as part of the node.

Return type:

dict

Returns values:

{
            "attributes": [
            {
              "Type": 10,
              "channelBox": false,
              "default": 0.0,
              "isArray": false,
              "isDynamic": true,
              "keyable": true,
              "locked": false,
              "max": null,
              "min": null,
              "name": "toeRest",
              "softMax": 3.14,
              "softMin": -1.7,
              "value": 0.31353071143768485
            },
          ],
          "connections": [
            {
              "destination": "|legGlobal_L_cmpnt|control|configParameters",
              "destinationPlug": "plantLength",
              "source": "|legGlobal_L_guide_heel_ctrl|legGlobal_L_guide_tip_ctrl",
              "sourcePlug": "translateZ"
            },
          ],
          "name": "|legGlobal_L_cmpnt|control|configParameters",
          "parent": "|legGlobal_L_cmpnt|control",
          "type": "transform"
}
deserializeNode(data, parent=None, includeAttributes=True)

Given the data from serializeNode() this will create a new node and set the attributes and connections.

Parameters:
  • data (dict) – Same data as serializeNode()

  • parent (om2.MObject) – The parent of the newly created node if any defaults to None which is the same as the world node

  • includeAttributes (bool) – If True the attributes within the data struct will be created or updated, default True.

Returns:

The created node MObject, a list of created attributes

Return type:

tuple(MObject, list(om2.MPlug))

setLockStateOnAttributes(node, attributes, state=True)

Locks and unlocks the given attributes

Parameters:
  • node (MObject) – the node that have its attributes locked

  • attributes (seq(str)) – a list of attribute name to lock

  • state (bool) – True to lock and False to unlcck

Returns:

True is successful

Return type:

bool

showHideAttributes(node, attributes, state=True)

Shows or hides and attribute in the channelbox

Parameters:
  • node (MObject) – The MObject representing the DG node

  • attributes (seq(str)) – attribute names on the given node

  • state (bool) – True for show False for hide, defaults to True

Returns:

True if successful

Return type:

bool

mirrorJoint(node, parent, translate, rotate, mirrorFunction=0)

Mirror the joint’s translation and rotation attributes based on the mirrorFunction.

Parameters:
  • node (om2.MObject) – The joint to be mirrored.

  • parent (om2.MObject) – The parent joint of the joint being mirrored.

  • translate (tuple or list) – The translation values to be mirrored.

  • rotate (tuple or list) – The rotation values to be mirrored.

  • mirrorFunction (int) – The behavior of the mirroring operation. Defaults to mayamath.MIRROR_BEHAVIOUR.

mirrorTranslation(transformationMatrix, translateAxis)

Mirrors the translation of a transformation matrix.

Parameters:
  • transformationMatrix (om2.MMatrix) – The transformation matrix to mirror.

  • translateAxis (str or list[str]) – The axis or axes to mirror the translation along. Can be any combination of “x”, “y”, and “z”.

Returns:

The mirrored transformation matrix.

Return type:

om2.MMatrix

axisNamesToVector(axisNames, vector)

This method takes a list of axis names and a vector as parameters. It modifies the vector by setting the specified axis names to -1. If no vector is provided, a default zero vector is used. The modified vector is then returned.

Parameters:
  • axisNames (list[str]) – List of strings representing axis names. eg. [“x”, “y”, “z”]

  • vector (OpenMaya.MVector or None) – The vector to modify. If not provided, a default zero vector will be used.

Returns:

The modified vector with the specified axis names set to -1.

Return type:

OpenMaya.MVector

mirrorTransform(node, parent, translate, rotate, mirrorFunction=0)

Mirror’s the translation and rotation of a node relative to another unless the parent is specified as om2.MObject.kNullObj in which case world.

Parameters:
  • node (om2.MObject) – the node transform the mirror

  • parent (om2.MObject or om2.MObject.kNullObj) – the parent Transform to mirror relative too.

  • translate (tuple(str)) – the axis to mirror, can be one or more

  • rotate (str) – “xy”, “yz” or “xz”

  • mirrorFunction (int) –

Returns:

mirrored translation vector and the mirrored rotation matrix

Return type:

om2.MVector, om2.MMatrix

mirrorNode(node, parent, translate, rotate, mirrorFunction=0)

Mirrors the given node with respect to the specified parent, translation, and rotation parameters.

Parameters:
  • node (str) – The node to mirror.

  • parent (str) – The parent node of the node to mirror.

  • translate (bool) – Whether to mirror the translation of the node.

  • rotate (bool) – Whether to mirror the rotation of the node.

  • mirrorFunction (int) – The mirror function to use for mirroring. Defaults to mayamath.MIRROR_BEHAVIOUR.

matchTransformMulti(targetPaths, source, translation=True, rotation=True, scale=True, space=MockExt.OpenMaya.MSpace.kWorld, pivot=False)

Matches the transform(SRT) for a list of nodes to another node.

Parameters:
  • targetPaths (list(om2.MDagPath)) – A list om2.MDagPaths to snap to the source

  • source (om2.MObject) – The source transform node switch the target nodes will match

  • translation (bool) – True to match translation

  • rotation (bool) – True to match rotation

  • scale (bool) – True to match scale

  • space (int) – coordinate space

  • pivot (True to match pivot) –

Returns:

True if passed

Return type:

bool

matchTransformSingle(targetPath, source, translation=True, rotation=True, scale=True, space=MockExt.OpenMaya.MSpace.kWorld, pivot=False)

Matches the transform(SRT) for a list of nodes to another node.

Parameters:
  • targetPath (om2.MDagPath) – om2.MDagPath to snap to the source

  • source (om2.MObject) – The source transform node switch the target nodes will match

  • translation (bool) – True to match translation

  • rotation (bool) – True to match rotation

  • scale (bool) – True to match scale

  • space (int) – coordinate space

  • pivot (True to match pivot) –

Returns:

True if passed

Return type:

bool

swapOutgoingConnections(source, destination, plugs=None)

Swap outgoing connections from one node to another.

Parameters:
  • source (str) – The source node to swap outgoing connections from.

  • destination (str) – The destination node to swap outgoing connections to.

  • plugs (list[str]) – Optional list of plugs to filter connections. Only connections from these plugs will be swapped.

Returns:

The Maya dependency graph modifier object used to make the connections.

Return type:

maya.api.OpenMaya.MDGModifier

Plugs

asMPlug(name)

Returns the MPlug instance for the given name

Parameters:

name – The mobject to convert to MPlug

Rtype name:

str

Returns:

MPlug, or None

connectPlugs(source, destination, mod=None, force=True, apply=True)

Connects two MPlugs together

connectVectorPlugs(sourceCompound, destinationCompound, connectionValues, force=True, modifier=None, apply=True)
Parameters:
  • sourceCompound (om2.MPlug) – The source compound plug to connect from.

  • destinationCompound (om2.MPlug) – The destination compound plug to connect to.

  • connectionValues (List) – List of booleans indicating if each child plug should be connected or disconnected.

  • force (Bool, optional) – Flag indicating if the connection should be forced even if the plugs have different types.

  • modifier (om2.MDGModifier, optional) – Optional om2.MDGModifier object to store the modification if provided. Otherwise, a new om2.MDGModifier is created.

  • apply (Bool, optional) – Flag indicating if the modification should be applied immediately. If set to False, the modification can be stored in the modifier object and applied later.

Returns:

The om2.MDGModifier object containing the modifications.

Return type:

om2.MDGModifier

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

Parameters:
  • plug (om2.MPlug) – the plug to disconnect

  • source (bool) – if true disconnect from the connected source plug if it has one

  • destination (bool) – if true disconnect from the connected destination plug if it has one

Returns:

True if succeed with the disconnection

Return type:

bool

Raises:

maya api error

removeElementPlug(plug, elementNumber, mod=None, apply=False)

Functional wrapper for removing a element plug(multiinstance)

Parameters:
  • plug (om2.MPlug) – The plug array object

  • elementNumber (int) – the element number

  • mod (om2.MDGModifier or None) – If None then a om2.MDGModifier object will be created and returned else the one thats passed will be used.

  • apply (bool) – If False then mod.doIt() will not be called, it is the clients reponsiblity to call doIt, useful for batch operations.

Returns:

The MDGModifier instance which contains the operation stack.

Return type:

om2.MDGModifier

removeUnConnectedEmptyElements(plugArray, mod=None)

Removes all unconnected array plug elements.

This works by iterating through all plug elements and checking the isConnected flag, if the element plug is a compound then we can the children too.

Note

Currently only handles two dimensional arrays.

Parameters:
  • plugArray (om2.MPlug) – The plug array instance.

  • mod (om2.MDGModifier or None) – If passed then this modifier will be used instead of creating a new one.

Returns:

The MDGModifier instance, if one is passed in the mod argument then that will be returned.

Return type:

om2.MDGModifier

isValidMPlug(plug)

Checks whether the MPlug is valid in the scene

Parameters:

plug – OpenMaya.MPlug

Returns:

bool

setLockedContext(plug)

Context manager to set the ‘plug’ lock state to False then reset back to what the state was at the end

Parameters:

plug (om2.MPlug) – the MPlug to work on

setLockState(plug, state)

Sets the ‘plug’ lock state

Parameters:
  • plug (om2.MPlug) – the Plug to work on.

  • state (bool) – False to unlock , True to lock.

Returns:

True if the operation succeeded.

Return type:

bool

filterConnected(plug, filter)

Filters all connected plugs by name using a regex with the filter argument. The filter is applied to the plugs connected plug eg. if nodeA.translateX is connected to nodeB.translateX and this func is used on nodeA.translateX then nodeB.translateX will have the filter applied to the plug.name() :param plug: The plug to search the connections from. :type plug: om2.MPlug :param filter: the regex string :type filter: str :rtype: iterable(om2.MPlug)

filterConnectedNodes(plug, filterStr, source=True, destination=False)

Filter connected nodes based on a regex pattern and whether the desired connection is a source or a destination.

Parameters:
  • plug (maya.api.OpenMaya.MPlug) – The plug to filter connected nodes from.

  • filterStr (str) – The regular expression pattern to filter the connected nodes by.

  • source (bool) – Whether to filter nodes that are connected as a source to the plug. Default is True.

  • destination (bool) – Whether to filter nodes that are connected as a destination to the plug. Default is False.

Returns:

A list of connected nodes that match the filter pattern.

Return type:

list[maya.api.OpenMaya.MPlug]

iterDependencyGraph(plug, alternativeName='', depthLimit=256, transverseType='down')

Uses a depth-first search to traverse a dependency graph using Plug connections.

This function yields each plug (an object representing a connection point on Maya’s node) as it encounters them in the graph.

Parameters:
  • plug (om2.MPlug) – The input plug to traverse the dependency graph from.

  • alternativeName (Str) – An alternative name to use for searching the plug in the dependency graph. If not provided, the partial name of the input plug will be used.

  • depthLimit (Int) – The maximum depth to traverse in the dependency graph. Default is 256.

  • transverseType (Str) – The direction to transverse in the dependency graph. Possible values are “down” or “up”. Default is “down”.

Returns:

A generator that yields the plugs found in the dependency graph.

Return type:

Generator

serializePlug(plug)

Serialize the given plug to a dictionary.

Parameters:

plug (OpenMaya.MPlug) – The plug to serialize.

Returns:

The serialized plug as a dictionary.

Return type:

dict

serializeConnection(plug)

Take’s destination om2.MPlug and serializes the connection as a dict.

Parameters:

plug (om2.MPlug) – A om2.MPlug that is the destination of a connection

Returns:

{sourcePlug: str, destinationPlug: str, source: str, # source node destination: str} # destination node

Return type:

dict

enumNames(plug)

Returns the ‘plug’ enumeration field names.

Parameters:

plug (om2.MPlug) – The MPlug to query

Returns:

A sequence of enum names

Return type:

list(str)

enumIndices(plug)

Returns the ‘plug’ enums indices as a list.

Parameters:

plug (om2.MPlug) – The MPlug to query

Returns:

a sequence of enum indices

Return type:

list(int)

plugDefault(plug)

Returns the plugs default value, The plug doesn’t support defaults like the MessageAttribute then None will be returned.

Parameters:

plug (om2.MPlug) – The plug whose default value is to be returned.

Returns:

The default value of the plug.

Return type:

Any

setAttributeFnDefault(attribute, default)

Sets the default value for the given attribute using the appropriate MFn*Attribute function.

Parameters:
  • attribute (om2.MObject) – The attribute to set the default value for.

  • default (Any) – The default value to set.

Returns:

True if the default value was set successfully, False otherwise.

Return type:

bool

setPlugDefault(plug, default)

Sets the plugs default value, This function doesn’t support defaults like the MessageAttribute

Parameters:
  • plug (om2.MPlug) – The plug to set the default value for.

  • default (Any) – The default value to set for the plug.

Returns:

True if the default value was successfully set, False otherwise.

Return type:

bool

hasPlugMin(plug)

Check if a given plug has a minimum value.

Parameters:

plug (om2.MPlug) – The plug to check.

Returns:

True if the plug has a minimum value, False otherwise.

Return type:

bool

hasPlugMax(plug)

Check if a given plug has a maximum value.

Parameters:

plug (OpenMaya.MPlug) – The plug to check.

Returns:

Whether the plug has a maximum value or not.

Return type:

bool

hasPlugSoftMin(plug)

Check if the given plug has a soft minimum value.

Parameters:

plug (OpenMaya.MPlug) – The plug to check.

Returns:

True if the plug has a soft minimum value, False otherwise.

Return type:

bool

hasPlugSoftMax(plug)

Check if the given plug has a SoftMax attribute.

Parameters:

plug (Maya plug) – The plug to check.

Returns:

True if the plug has a SoftMax attribute, False otherwise.

Return type:

bool

getPlugMin(plug)

Returns the plug minimum value.

Parameters:

plug (OpenMaya.MPlug) – The plug to retrieve the minimum value from.

Returns:

The minimum value of the plug.

Return type:

float or int

getPlugMax(plug)

Returns the plug maximum value.

Parameters:

plug (om2.MPlug) – The plug to get the maximum value from.

Returns:

The maximum value of the plug.

Return type:

float or int or None

getSoftMin(plug)

Returns the soft minimum value of the given plug.

This method retrieves the soft minimum value of a plug. It first checks if the attribute of the plug is numeric or unit, then checks if the attribute has a soft minimum value. If it does, the method returns the soft minimum value. If the attribute’s data type does not support a minimum value, or if the soft minimum value does not exist

Parameters:

plug (om2.MPlug) – The plug to get the soft minimum value from.

Returns:

The soft minimum value if it exists, otherwise None.

Return type:

float or None

setSoftMin(plug, value)

Sets the soft minimum value for a given plug.

Parameters:
  • plug (om2.MPlug) – The plug to set the soft minimum value for.

  • value (float) – The value to set as the soft minimum for the plug.

Returns:

True if the soft minimum value was set successfully, False otherwise.

Return type:

bool

setAttrSoftMin(attribute, value)

Sets the soft minimum value for the given attribute.

Parameters:
  • attribute (om2.MObject) – The attribute to set the soft minimum value for.

  • value (float) – The soft minimum value to set.

Returns:

True if the soft minimum value was set successfully, False otherwise.

Return type:

bool

getSoftMax(plug)

Retrieves the soft maximum value of a given attribute.

Parameters:

plug (om2.MPlug) – The plug represents the attribute.

Returns:

The soft maximum value of the attribute. Returns None if the attribute does not have a soft maximum.

Return type:

float or None

Note

This method only works with numeric attributes (om2.MFnNumericAttribute) and unit attributes (om2.MFnUnitAttribute).

Note

If the attribute does not have a soft maximum, None is returned.

Note

If an error occurs while retrieving the soft maximum, None is returned.

setSoftMax(plug, value)

Sets the soft maximum value for the given plug.

Parameters:
  • plug (om2.MPlug) – The plug to set the soft maximum value for.

  • value (float) – The value to set as the soft maximum.

Returns:

Whether the soft maximum value was successfully

setAttrSoftMax(attribute, value)

Set the soft maximum value for the given attribute.

Parameters:
  • attribute (om2.MObject) – The attribute to set the soft maximum value for.

  • value (float) – The value to set as the soft maximum.

Returns:

True if the soft maximum value was set successfully, False otherwise.

Return type:

bool

setAttrMin(attribute, value)

Sets the minimum value for the given attribute.

Parameters:
  • attribute (om2.MObject) – The attribute to set the minimum value for.

  • value (float) – The minimum value to set.

Returns:

True if the minimum value was set successfully, False otherwise.

Return type:

bool

setMin(plug, value)

Set the minimum value for the given plug.

Parameters:
  • plug (OpenMaya.MPlug) – The plug to set the minimum value for.

  • value (float) – The minimum value to set.

Returns:

True if successful, False otherwise.

Return type:

bool

setAttrMax(attribute, value)

Sets the maximum value of the given attribute.

Parameters:
  • attribute (om2.MObject) – The attribute to set the maximum value for.

  • value (float) – The maximum value to set.

Returns:

True if the maximum value was successfully set, False otherwise.

Return type:

bool

setMax(plug, value)

Sets the maximum value for a given plug.

Parameters:
  • plug (om2.MPlug) – The plug to set the maximum value for.

  • value (Any) – The maximum value to set.

Returns:

True if the maximum value was successfully set, False otherwise.

Return type:

bool

getPlugValue(plug, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the Plug value for the MDGContext

Parameters:
  • plug (om2.MPlug) – The Maya Plug instance to query

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

getPlugAndType(plug, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Given an MPlug, get its value

Parameters:
  • plug (om2.MPlug) – MPlug

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

the dataType of the given plug. Will return standard python types where necessary eg. float else maya type

Return type:

tuple(int, plugValue)

getNumericValue(plug, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the maya numeric type and value from the given plug

Parameters:
  • plug (om2.MPlug) – The plug to get the value from

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Return type:

attrtypes.kType,

getTypedValue(plug, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the maya type from the given typedAttributePlug

Parameters:
  • plug – MPLug

  • ctx (om2.MDGContext) – The MDGContext to use. ie. the current frame.

Returns:

maya type

setPlugInfoFromDict(plug, **kwargs)

Sets the standard plug settings via a dict.

Parameters:
  • plug (om2.MPlug) – The Plug to change

  • kwargs (dict) – currently includes, default, min, max, softMin, softMin, value, Type, channelBox, keyable, locked.

data = {
    "Type": 5, # attrtypes.kType
    "channelBox": true,
    "default": 1.0,
    "isDynamic": true,
    "keyable": true,
    "locked": false,
    "max": 99999,
    "min": 0.0,
    "name": "scale",
    "softMax": None,
    "softMin": None,
    "value": 1.0,
    "children": [{}] # in the same format as the parent info
  }
somePLug = om2.MPlug()
setPlugInfoFromDict(somePlug, **data)
setPlugValue(plug, value, mod=None, apply=True)

Sets the given plug’s value to the passed in value.

Parameters:
  • plug (om2.MPlug) – MPlug, The node plug.

  • value – type, Any value of any data type.

  • mod (om2.MDGModifier) – Apply the modifier instantly or leave it to the caller.

  • apply (bool) – If True then the value we be set on the Plug instance by calling doIt on the modifier.

Returns:

if mod is not none then the created one will be returned.

Return type:

om2.MDGModifier

getPlugFn(obj)

Returns the MfunctionSet for the MObject

Parameters:

obj (MObject) – MObject that has the MFnAttribute functionset

hasChildPlugByName(parentPlug, childName)

Determines whether the given parent plug has a child plug with the given name.

Parameters:
  • parentPlug (OpenMaya.MPlug) – The parent plug to check for child plugs.

  • childName (str) – The name of the child plug to check for.

Returns:

True if the parent plug has a child plug with the given name, False otherwise.

Return type:

bool

iterChildren(plug)

Generator that yields the child plugs of the given plug and their sub-children.

Parameters:

plug (MPlug) – The plug to iterate over its children.

Returns:

Generator that yields the child plugs of the given plug and their sub-children.

Return type:

MPlug

plugType(plug)

Determine the type of the given attribute plug.

Parameters:

plug (Union[str, om2.MPlug]) – The attribute plug to determine the type of.

Returns:

The internal type of the attribute plug.

Return type:

str or None

getPythonTypeFromPlugValue(plug, ctx=MockExt.OpenMaya.MDGContext.kNormal)

Returns the Python standard type of the given plug’s value.

Parameters:
  • plug (OpenMaya.MPlug) – The plug to retrieve the python type from.

  • ctx (OpenMaya.MDGContext) – The MDG context to use. Defaults to MDGContext.kNormal.

Returns:

The value of the plug as the corresponding python type.

Return type:

None or float or int or str or tuple or list

nextAvailableElementPlug(arrayPlug)

Returns the next available element plug from th plug array, if the plugArray is a compoundArray, then the children of immediate children of the compound are searched.

How does it work? Loops through all current elements looking for a outgoing connection, if one doesn’t exist then this element plug is returned. if the element plug is a compound then if immediate children are searched and the element parent plug will be returned if there’s a connection.

Parameters:

arrayPlug (om2.MPlug) – the plugArray to search.

nextAvailableDestElementPlug(arrayPlug)

Scene

removeFromActiveSelection(node)

remove the node from the selection forcefully Otherwise maya can crash if someone deletes that node afterwards

getSelectedNodes(filter=None)

Returns the selected nodes

Returns:

list(MObject)

iterSelectedNodes(filter=None)
keepSelection()
getNodesCreatedBy(function, *args, **kwargs)

returns a 2-tuple containing all the nodes created by the passed function, and the return value of said function

Parameters:

function – func, the function to call and inspect

Return type:

tuple(MObject)

iterDag(root, includeRoot=True, nodeType=None)

Generator function to walk the node hierarchy, if a nodeType is provided then the function will only return that mobject apitype.

Parameters:
  • root (MObject) – the root dagnode to loop

  • includeRoot (bool) – if true include the root mobject

  • nodeType (int) – defaults to none which will return everything an example user specified type om2.MFn.kTransform

Returns:

yields the mobject

Return type:

Generator(mobject)

worldPositionToScreen(camera, point, width, height)
isPointInView(camera, point, width, height)
serializeNodes(graphNodes, skipAttributes=None, includeConnections=True)
serializeSelectedNodes(skipAttributes, includeConnections)
deserializeNodes(data)
class GraphDeserializer(data)

Bases: dict

process(nodeMap)
Parameters:

nodeMap (dict) – {nodeName: om2.MObject}

Returns:

Return type:

aimNodes(targetNode, driven, aimVector=None, upVector=None, worldUpVector=None)
aimSelected(aimVector=None, upVector=None)

Aim the the selected nodes to the last selected node.

Parameters:
  • aimVector (om2.MVector) – see mayamath.aimToNode for details

  • upVector (om2.MVector) – see mayamath.aimToNode for details

dgIterator(*args, **kwargs)

A more ideal python DGIterator for maya, this function just wraps the iterator in a try/finally statement so that we dont need to call iterator.next(). See maya.api.OpenMaya.MItDependencyGraph documentation for the arguments

Return type:

Generator(om2.MItDependencyGraph)

mesh = asMObject("pCube1")
for dgIter in dgIterator(mesh, om2.MFn.kSkinClusterFilter, om2.MItDependencyGraph.kUpstream):
    dgIter.currentNode()
iterReferences()

Generator function that returns a Mobject for each valid referene node.

Returns:

Generator function with each element representing the reference node

Return type:

Generator(om2.MObject)