def addAttribute(self, name, value, Type, isArray=False, lock=True):
mfn = self._mfn
mobj = mfn.object()
if mfn.hasAttribute(name):
return mfn.findPlug(name, False)
try:
attr = nodes.addAttribute(mobj,
name,
name,
Type,
isArray=isArray,
apply=True)
except RuntimeError:
raise ValueError(
"Failed to create attribute with name: {}".format(name))
newPlug = None
if attr is not None:
newPlug = om2.MPlug(mobj, attr.object())
if value is not None and newPlug is not None:
# if mobject expect it to be a node
if isinstance(value, om2.MObject):
self.connectTo(name, value)
else:
plugs.setPlugValue(newPlug, value)
newPlug.isLocked = lock
return newPlug
def createPlusMinusAverage2D(name, inputs, output=None, operation=1):
""" Create's a plusMinusAverage node and connects the 2D inputs and outputs.
:param name: the plus minus average node name
:type name: str
:param inputs: tuple of MPlugs and/or float values, each value will be applied to /
a new Input2D element. If the value is MPlug then it will be connected
:type inputs: iterable(plug or float)
:param output: A tuple of downstream MPlugs to connect to.
:type output: iterable(plug)
:return: The plus minus average MObject
:rtype: om2.MObject
"""
pma = nodes.createDGNode(name, "plusMinusAverage")
fn = om2.MFnDependencyNode(pma)
inPlug = fn.findPlug("input2D", False)
fn.findPlug("operation", False).setInt(operation)
for i, p in enumerate(inputs):
if p is None:
continue
child = plugs.nextAvailableElementPlug(inPlug)
if isinstance(p, om2.MPlug):
plugs.connectPlugs(p, child)
continue
plugs.setPlugValue(child, p)
if output is not None:
ouPlug = fn.findPlug("output2D", False)
for index, out in enumerate(output):
if out is None:
continue
plugs.connectPlugs(ouPlug, out)
return pma
def conditionVector(firstTerm, secondTerm, colorIfTrue, colorIfFalse,
operation, name):
"""
:param firstTerm:
:type firstTerm: om2.MPlug or float
:param secondTerm:
:type secondTerm: om2.MPlug or float
:param colorIfTrue: seq of MPlugs or a single MPlug(compound)
:type colorIfTrue: om2.MPlug or list(om2.Plug) or om2.MVector
:param colorIfFalse: seq of MPlugs or a single MPlug(compound)
:type colorIfFalse: om2.MPlug or list(om2.Plug) or om2.MVector
:param operation: the comparsion operator
:type operation: int
:param name: the new name for the node
:type name: str
:return:
:rtype: om2.MObject
"""
condNode = om2.MFnDependencyNode(nodes.createDGNode(name, "condition"))
if isinstance(firstTerm, float):
plugs.setPlugValue(condNode.findPlug("firstTerm", False), firstTerm)
else:
plugs.connectPlugs(firstTerm, condNode.findPlug("firstTerm", False))
if isinstance(operation, int):
plugs.setPlugValue(condNode.findPlug("operation", False), operation)
else:
plugs.connectPlugs(operation, condNode.findPlug("operation", False))
if isinstance(secondTerm, float):
plugs.setPlugValue(condNode.findPlug("secondTerm", False), firstTerm)
else:
plugs.connectPlugs(secondTerm, condNode.findPlug("secondTerm", False))
if isinstance(colorIfTrue, om2.MPlug):
plugs.connectPlugs(colorIfTrue,
condNode.findPlug("colorIfTrue", False))
elif isinstance(colorIfTrue, om2.MVector):
plugs.setPlugValue(condNode.findPlug("colorIfTrue", False),
colorIfTrue)
else:
color = condNode.findPlug("colorIfTrue", False)
# expecting seq of plugs
for i, p in enumerate(colorIfTrue):
child = color.child(i)
plugs.connectPlugs(p, child)
if isinstance(colorIfFalse, om2.MPlug):
plugs.connectPlugs(colorIfFalse,
condNode.findPlug("colorIfFalse", False))
elif isinstance(colorIfFalse, om2.MVector):
plugs.setPlugValue(condNode.findPlug("colorIfFalse", False),
colorIfFalse)
else:
color = condNode.findPlug("colorIfFalse", False)
# expecting seq of plugs
for i, p in enumerate(colorIfFalse):
child = color.child(i)
plugs.connectPlugs(p, child)
return condNode.object()
def setAttribute(self, attr, value):
if isinstance(attr, om2.MPlug):
with plugs.setLockedContext(attr):
plugs.setPlugValue(attr, value)
return
if self.hasAttribute(attr):
plug = self._mfn.findPlug(attr, False)
with plugs.setLockedContext(plug):
plugs.setPlugValue(plug, value)
def addConstraintMap(node, driven, utilities, kwargsMap=None):
"""Adds a mapping of drivers and utilities to the constraint compound array attribute
:param node: The node to add or has the constraint map , typically this would be the driver node \
of the constraint.
:type node: om2.MObject
:param driven: a list of driven transform nodes.
:type driven: tuple(om2.MObject)
:param utilities: a list of utilities/support nodes that make up the constraint, this could be the \
constraint node itself or any math node etc.
:type utilities: tuple(om2.MObject)
"""
kwargsmap = kwargsMap or ""
mfn = om2.MFnDependencyNode(node)
if not mfn.hasAttribute("constraints"):
compoundPlug = addConstraintAttribute(node)
else:
compoundPlug = mfn.findPlug("constraints", False)
availPlug = plugs.nextAvailableElementPlug(compoundPlug)
drivenPlug = availPlug.child(0)
# lets add the driven nodes to the xth of the element compound
for drive in iter(driven):
if drive is None:
continue
drivenFn = om2.MFnDependencyNode(drive)
if drivenFn.hasAttribute("constraint"):
p = drivenFn.findPlug("constraint", False)
elementP = plugs.nextAvailableElementPlug(p)
plugs.connectPlugs(drivenPlug, elementP)
continue
attr = nodes.addAttribute(drive,
"constraint",
"constraint",
attrtypes.kMFnMessageAttribute,
isArray=True)
attrP = om2.MPlug(drive, attr.object())
plugs.connectPlugs(drivenPlug, attrP.elementByLogicalIndex(0))
utilPlug = availPlug.child(1)
# add all the utilities
for i in iter(utilities):
if i is None:
continue
utilFn = om2.MFnDependencyNode(i)
if utilFn.hasAttribute("constraint"):
p = utilFn.findPlug("constraint", False)
if p.isDestination:
continue
plugs.connectPlugs(utilPlug, p)
continue
attr = nodes.addAttribute(i, "constraint", "constraint",
attrtypes.kMFnMessageAttribute)
plugs.connectPlugs(utilPlug, om2.MPlug(i, attr.object()))
# set the kwargs map plug, so we know how the constraint was created
plugs.setPlugValue(availPlug.child(2), kwargsmap)
return compoundPlug
def addAttributesFromList(node, data):
"""Creates an attribute on the node given a list(dict) of attribute data
:param data: The serialized form of the attribute
[{
"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
}]
:type data: dict
:return: A list of create MPlugs
:rtype: list(om2.MPlug)
"""
created = []
for attrData in iter(data):
Type = attrData["Type"]
default = attrData["default"]
value = attrData["value"]
name = attrData["name"]
if Type == attrtypes.kMFnDataString:
default = om2.MFnStringData().create(default)
elif Type == attrtypes.kMFnDataMatrix:
default = om2.MFnMatrixData().create(om2.MMatrix(default))
elif Type == attrtypes.kMFnUnitAttributeAngle:
default = om2.MAngle(default, om2.MAngle.kDegrees)
value = om2.MAngle(value, om2.MAngle.kDegrees)
plug = om2.MPlug(node, addAttribute(node, name, name, Type, isArray=data.get("array", False), apply=True))
plugs.setPlugDefault(plug, default)
plug.isChannelBox = attrData["value"]
plug.isKeyable = attrData["keyable"]
plugs.setLockState(plug, attrData["locked"])
plugs.setMin(plug, attrData["min"])
plugs.setMax(plug, attrData["max"])
plugs.setSoftMin(plug, attrData["softMin"])
plugs.setSoftMax(plug, attrData["softMax"])
if not plug.attribute().hasFn(om2.MFn.kMessageAttribute):
plugs.setPlugValue(plug, value)
created.append(plug)
return created
def createMultMatrix(name, inputs, output):
multMatrix = nodes.createDGNode(name, "multMatrix")
fn = om2.MFnDependencyNode(multMatrix)
plugs.connectPlugs(fn.findPlug("matrixSum", False), output)
compound = fn.findPlug("matrixIn", False)
compound.evaluateNumElements()
for i in xrange(len(inputs)):
inp = inputs[i]
if isinstance(inp, om2.MPlug):
plugs.connectPlugs(inp, compound.elementByLogicalIndex(i))
continue
plugs.setPlugValue(compound.elementByLogicalIndex(i), inp)
return multMatrix
def exportContext(rootNode):
changed = []
for i in nodes.iterChildren(rootNode, recursive=True):
dp = om2.MFnDependencyNode(i)
plug = dp.findPlug("visibility", False)
with plugs.setLockedContext(plug):
if plug.asFloat() != 1.0:
plugs.setPlugValue(plug, 1.0)
changed.append(dp)
yield
for i in iter(changed):
plug = i.findPlug("visibility", False)
with plugs.setLockedContext(plug):
plugs.setPlugValue(plug, 0.0)
def createPlusMinusAverage3D(name, inputs, output=None, operation=1):
""" Create's a plusMinusAverage node and connects the 3D inputs and outputs.
:param name: the plus minus average node name.
:type name: str
:param inputs: tuple of MPlugs and/or float values, each value will be applied to /
a new Input3D element. If the value is MPlug then it will be connected.
:type inputs: iterable(plug or float)
:param output: A tuple of downstream MPlugs to connect to.
:type output: iterable(plug) or None
:return: The plus minus average MObject.
:rtype: om2.MObject
.. code-block:: python
one = nodes.createDagNode("one", "transform")
two = nodes.createDagNode("two", "transform")
end = nodes.createDagNode("end", "transform")
oneFn = om2.MFnDagNode(one)
twoFn = om2.MFnDagNode(two)
endFn = om2.MFnDagNode(end)
inputs = [oneFn.findPlug("translate", False), twoFn.findPlug("translate", False)]
outputs = [endFn.findPlug("translate", False)]
pma = creation.createPlusMinusAverage3D("test_pma", inputs, outputs)
# Result: <OpenMaya.MObject object at 0x000002AECB23AE50> #
"""
pma = nodes.createDGNode(name, "plusMinusAverage")
fn = om2.MFnDependencyNode(pma)
inPlug = fn.findPlug("input3D", False)
fn.findPlug("operation", False).setInt(operation)
for i, p in enumerate(inputs):
if p is None:
continue
child = plugs.nextAvailableElementPlug(inPlug)
if isinstance(p, om2.MPlug):
plugs.connectPlugs(p, child)
continue
plugs.setPlugValue(child, p)
if output is not None:
ouPlug = fn.findPlug("output3D", False)
for index, out in enumerate(output):
if out is None:
continue
plugs.connectPlugs(ouPlug, out)
return pma
def createAnnotation(rootObj, endObj, text=None, name=None):
name = name or "annotation"
rootDag = om2.MFnDagNode(rootObj)
boundingBox = rootDag.boundingBox
center = om2.MVector(boundingBox.center)
locator = asMObject(cmds.createNode("locator"))
locatorTransform = getParent(locator)
rename(locatorTransform, "_".join([name, "loc"]))
setTranslation(locatorTransform, getTranslation(rootObj, om2.MSpace.kWorld), om2.MSpace.kWorld)
annotationNode = asMObject(cmds.annotate(nameFromMObject(locatorTransform), tx=text))
annParent = getParent(annotationNode)
rename(annParent, name)
plugs.setPlugValue(om2.MFnDagNode(annotationNode).findPlug("position", False), center)
setParent(locatorTransform, rootObj, True)
setParent(annParent, endObj, False)
return annotationNode, locatorTransform
def createCurveShape(parent, data):
"""Create a specified nurbs curves based on the data
:param parent: The transform that takes ownership of the shapes, if None is supplied then one will be created
:type parent: MObject
:param data: {"shapeName": {"cvs": [], "knots":[], "degree": int, "form": int, "matrix": []}}
:type data: dict
:return: A 2 tuple the first element is the MObject of the parent and the second is a list /
of mobjects represents the shapes created.
:rtype: tuple(MObject, list(MObject))
"""
parentInverseMatrix = om2.MMatrix()
if parent is None:
parent = om2.MObject.kNullObj
elif parent != om2.MObject.kNullObj:
parentInverseMatrix = nodes.getWorldInverseMatrix(parent)
newCurve = om2.MFnNurbsCurve()
newShapes = []
for shapeName, curveData in iter(data.items()):
cvs = om2.MPointArray(
curveData["cvs"]
) # om2 allows a list of lists which converts to om2.Point per element
knots = curveData["knots"]
degree = curveData["degree"]
form = curveData["form"]
enabled = curveData["overrideEnabled"]
matrix = curveData.get("matrix")
if matrix is not None:
mat = om2.MMatrix(matrix)
for i in range(len(cvs)):
cvs[i] *= mat * parentInverseMatrix
shape = newCurve.create(cvs, knots, degree, form, False, False, parent)
newShapes.append(shape)
if parent == om2.MObject.kNullObj and shape.apiType(
) == om2.MFn.kTransform:
parent = shape
if enabled:
plugs.setPlugValue(newCurve.findPlug("overrideEnabled", False),
int(curveData["overrideEnabled"]))
colours = curveData["overrideColorRGB"]
outlinerColour = curveData.get("outlinerColor")
nodes.setNodeColour(newCurve.object(),
colours,
outlinerColour=outlinerColour)
return parent, newShapes
def createCurveShape(parent, data):
"""Create a specified nurbs curves based on the data
:param parent: The transform that takes ownership of the shapes, if None is supplied then one will be created
:type parent: MObject
:param data: {"shapeName": {"cvs": [], "knots":[], "degree": int, "form": int, "matrix": []}}
:type data: dict
:return: the parent node
:rtype: MObject
"""
if parent is None:
parent = om2.MObject.kNullObj
newCurve = om2.MFnNurbsCurve()
cvData = []
for shapeName, curveData in iter(data.items()):
cvs = om2.MPointArray(
curveData["cvs"]
) # om2 allows a list of lists which converts to om2.Point per element
knots = curveData["knots"]
degree = curveData["degree"]
form = curveData["form"]
enabled = curveData["overrideEnabled"]
shape = newCurve.create(cvs, knots, degree, form, False, False, parent)
mat = curveData.get("matrix")
if parent == om2.MObject.kNullObj and shape.apiType(
) == om2.MFn.kTransform:
parent = shape
if enabled:
plugs.setPlugValue(newCurve.findPlug("overrideEnabled", False),
int(curveData["overrideEnabled"]))
colours = curveData["overrideColorRGB"]
nodes.setNodeColour(newCurve.object(), colours)
if mat:
cvData.append((newCurve.getPath(), mat, cvs))
# apparently must use object space to create and calling setCVPosition with the forloop causing an maya error
# this could be because maya has yet to refresh meaning the MObject is invalid , hence the need to loop
# back over and multiple the cvs by the worldMatrix
for p, mat, cvs in cvData:
mat = om2.MMatrix(mat)
newCurve.setObject(p)
for i in range(len(cvs)):
cvs[i] *= mat
newCurve.setCVPositions(cvs, om2.MSpace.kWorld)
newCurve.updateCurve()
return parent
def createAnnotation(rootObj, endObj, text=None, name=None):
name = name or "annotation"
rootDag = om2.MFnDagNode(rootObj)
boundingBox = rootDag.boundingBox
center = om2.MVector(boundingBox.center)
transform = nodes.createDagNode("_".join([name, "loc"]),
"transform",
parent=rootObj)
nodes.setTranslation(transform,
nodes.getTranslation(rootObj, om2.MSpace.kWorld),
om2.MSpace.kWorld)
annotationNode = nodes.asMObject(
cmds.annotate(nodes.nameFromMObject(transform), tx=text))
annParent = nodes.getParent(annotationNode)
nodes.rename(annParent, name)
plugs.setPlugValue(
om2.MFnDagNode(annotationNode).findPlug("position", False), center)
nodes.setParent(annParent, endObj, False)
return annotationNode, transform
def convertToNode(node, parent, prefix, nodeType="joint"):
"""Converts a node into a joint but does not delete the node ,
transfers matrix over as well
:param node: mobject, the node that will be converted
:param parent: mobject to the transform to parent to
:param prefix: str, the str value to give to the start of the node name
:param nodeType: str, the node type to convert to. must be a dag type node
:return: mObject, the mobject of the joint
"""
mod = om2.DagModifier("createJoint")
jnt = mod.createNode(nodeType)
mod.doIt()
nodes.rename(jnt, prefix + nodes.nameFromMObject(node, partialName=True))
nodes.setParent(jnt, parent)
plugs.setPlugValue(
om2.MFnDagNode(jnt).findPlug("worldMatrix", False),
nodes.getWorldMatrix(node))
return jnt
def addTarget(self, driver):
"""Adds the given driver transform to the constraint
:param driver: The driver mobject transform
:type driver: MObject
@note having to use maya commands here due to api not able to resize the plugs array outside the datablock
"""
driven = self.drivenObject()
driverName = nodes.nameFromMObject(driver) # so we have the fullPath
driverShortName = om2.MNamespace.stripNamespaceFromName(driverName).split("|")[-1]
nextWeightIndex = self.numTargets() # starts at zero so the return is the next element
drivenFn = om2.MFnDependencyNode(driven)
offsetMatrix = om2.MTransformationMatrix(nodes.getOffsetMatrix(driver, driven))
translation = offsetMatrix.translation(om2.MSpace.kTransform)
rotation = generic.eulerToDegrees(
offsetMatrix.rotation().reorder(plugs.getPlugValue(drivenFn.findPlug("rotateOrder", False))))
# create the weight attribute
weightName = "W".join([driverShortName, str(nextWeightIndex)])
weightAttr = nodes.addAttribute(self.node.object(), weightName, weightName,
attrType=attrtypes.kMFnNumericDouble)
weightAttr.setMin(0.0)
weightAttr.setMax(1.0)
weightAttr.default = 1.0
weightAttr.keyable = True
driverFn = om2.MFnDependencyNode(driver)
targetPlug = self.mfn.findPlug("target", False).elementByLogicalIndex(nextWeightIndex)
cmds.connectAttr(driverFn.findPlug("parentMatrix", False).elementByPhysicalIndex(0).name(),
targetPlug.child(0).name()) # targetParentMatrix
cmds.connectAttr(driverFn.findPlug("scale", False).name(), targetPlug.child(13).name()) # targetScale
cmds.connectAttr(driverFn.findPlug("rotateOrder", False).name(),
targetPlug.child(8).name()) # targetRotateOrder
cmds.connectAttr(driverFn.findPlug("rotate", False).name(), targetPlug.child(7).name()) # targetRotate
cmds.connectAttr(driverFn.findPlug("rotatePivotTranslate", False).name(),
targetPlug.child(5).name()) # targetRotateTranslate
cmds.connectAttr(driverFn.findPlug("rotatePivot", False).name(),
targetPlug.child(4).name()) # targetRotatePivot
cmds.connectAttr(driverFn.findPlug("translate", False).name(), targetPlug.child(3).name()) # targetTranslate
cmds.connectAttr(om2.MPlug(self.mfn.object(), weightAttr.object()).name(),
targetPlug.child(1).name()) # targetWeight
# setting offset value
plugs.setPlugValue(targetPlug.child(6), translation) # targetOffsetTranslate
plugs.setPlugValue(targetPlug.child(10), rotation) # targetOffsetRotate
def multiplyDivide(input1, input2, operation, name):
"""Creates a multiply divide node with the given and setups the input connections.
List of operations::
no operation = 0,
multipy = 1,
divide = 2,
power = 3
:param input1:the node attribute to connect to the input1 value or use int for value
:type input1: MPlug or MVector
:param input2:the node attribute to connect to the input2 value or use int for value
:type input2: MPlug or MVector
:param operation: the int value for operation
:type operation: int
:return, the multiplyDivide node MObject
:rtype: MObject
"""
mult = om2.MFnDependencyNode(nodes.createDGNode(name, "multiplyDivide"))
# assume connection type
if isinstance(input1, om2.MPlug):
plugs.connectPlugs(input1, mult.findPlug("input1", False))
# plug set
else:
plugs.setPlugValue(mult.findPlug("input1", False), input1)
if isinstance(input2, om2.MPlug):
plugs.connectPlugs(input2, mult.findPlug("input2", False))
else:
plugs.setPlugValue(mult.findPlug("input2", False), input1)
plugs.setPlugValue(mult.findPlug("operation", False), operation)
return mult.object()
def floatMath(floatA, floatB, operation, name):
"""Creates a floatMath node from the lookdev kit builtin plugin
:param floatA: If the type is a MPlug then the floatA plug on the new node\
will be connected the given plug.
:type floatA: float or om2.MPlug
:param floatB: If the type is a MPlug then the floatB plug on the new node\
will be connected the given plug.
:type floatB: float or om2.MPlug
:param operation: The operation attributes value
:type operation: int
:param name: The new floatMath node name.
:type name: str
:return: The floatMath node MObject
:rtype: om2.MObject
"""
floatMathFn = om2.MFnDependencyNode(nodes.createDGNode(name, "floatMath"))
if isinstance(floatA, om2.MPlug):
plugs.connectPlugs(floatA, floatMathFn.findPlug("floatA", False))
else:
plugs.setPlugValue(floatMathFn.findPlug("floatA", False), floatA)
if isinstance(floatB, om2.MPlug):
plugs.connectPlugs(floatB, floatMathFn.findPlug("floatB", False))
else:
plugs.setPlugValue(floatMathFn.findPlug("floatB", False), floatB)
plugs.setPlugValue(floatMathFn.findPlug("operation", False), operation)
return floatMathFn.object()
def blendColors(color1, color2, name, blender):
"""Creates a blend colors node.
:param color1: If the type is a MPlug then the color1 plug on the new node\
will be connected the given plug.
:type color1: om2.MColor or om2.MPlug
:param color2: If the type is a MPlug then the color2 plug on the new node\
will be connected the given plug.
:type color2: om2.MColor or om2.MPlug
:param name: The new floatMath node name.
:type name: str
:param blender: If the type is a MPlug then the blender plug on the new node\
will be connected the given plug.
:type blender: float or om2.MPlug
:return: The new colorBlend node as a MObject
:rtype: om2.MObject
"""
blendFn = om2.MFnDependencyNode(nodes.createDGNode(name, "blendColors"))
if isinstance(color1, om2.MPlug):
plugs.connectPlugs(color1, blendFn.findPlug("color1", False))
else:
plugs.setPlugValue(blendFn.findPlug("color1", False), color1)
if isinstance(color2, om2.MPlug):
plugs.connectPlugs(color2, blendFn.findPlug("color2", False))
else:
plugs.setPlugValue(blendFn.findPlug("color2", False), color2)
if isinstance(blender, om2.MPlug):
plugs.connectPlugs(blender, blendFn.findPlug("blender", False))
else:
plugs.setPlugValue(blendFn.findPlug("blender", False), blender)
return blendFn.object()
def addAttribute(self, name, value, Type, isArray=False, lock=True):
mobj = self._handle.object()
mfn = om2.MFnDependencyNode(mobj)
if mfn.hasAttribute(name):
return
try:
attr = nodes.addAttribute(mobj, name, name, Type)
attr.array = isArray
except RuntimeError:
return
newPlug = None
if attr is not None:
newPlug = om2.MPlug(mobj, attr.object())
if value is not None and newPlug is not None:
# if mobject expect it to be a node
if isinstance(value, om2.MObject):
self.connectTo(name, value)
else:
plugs.setPlugValue(newPlug, value)
newPlug.isLocked = lock
return attr
def pairBlend(name,
inRotateA=None,
inRotateB=None,
inTranslateA=None,
inTranslateB=None,
weight=None,
rotInterpolation=None):
blendPairNode = om2.MFnDependencyNode(nodes.createDGNode(
name, "pairBlend"))
if inRotateA is not None:
plugs.connectPlugs(inRotateA,
blendPairNode.findPlug("inRotate1", False))
if inRotateB is not None:
plugs.connectPlugs(inRotateB,
blendPairNode.findPlug("inRotate2", False))
if inTranslateA is not None:
plugs.connectPlugs(inTranslateA,
blendPairNode.findPlug("inTranslate1", False))
if inTranslateB is not None:
plugs.connectPlugs(inTranslateB,
blendPairNode.findPlug("inTranslate2", False))
if weight is not None:
if isinstance(weight, om2.MPlug):
plugs.connectPlugs(weight, blendPairNode.findPlug("weight", False))
else:
plugs.setPlugValue(blendPairNode.findPlug("weight", False), weight)
if rotInterpolation is not None:
if isinstance(rotInterpolation, om2.MPlug):
plugs.connectPlugs(
rotInterpolation,
blendPairNode.findPlug("rotInterpolation", False))
else:
plugs.setPlugValue(
blendPairNode.findPlug("rotInterpolation", False),
rotInterpolation)
return blendPairNode.object()
def floatMath(floatA, floatB, operation, name):
floatMathFn = om2.MFnDependencyNode(nodes.createDGNode(name, "floatMath"))
if isinstance(floatA, om2.MPlug):
plugs.connectPlugs(floatA, floatMathFn.findPlug("floatA", False))
else:
plugs.setPlugValue(floatMathFn.findPlug("floatA", False), floatA)
if isinstance(floatB, om2.MPlug):
plugs.connectPlugs(floatB, floatMathFn.findPlug("floatB", False))
else:
plugs.setPlugValue(floatMathFn.findPlug("floatB", False), floatB)
plugs.setPlugValue(floatMathFn.findPlug("operation", False), operation)
return floatMathFn.object()
def blendColors(color1, color2, name, blender):
blendFn = om2.MFnDependencyNode(nodes.createDGNode(name, "blendColors"))
if isinstance(color1, om2.MPlug):
plugs.connectPlugs(color1, blendFn.findPlug("color1", False))
else:
plugs.setPlugValue(blendFn.findPlug("color1", False), color1)
if isinstance(color2, om2.MPlug):
plugs.connectPlugs(color2, blendFn.findPlug("color2", False))
else:
plugs.setPlugValue(blendFn.findPlug("color2", False), color2)
if isinstance(blender, om2.MPlug):
plugs.connectPlugs(blender, blendFn.findPlug("blender", False))
else:
plugs.setPlugValue(blendFn.findPlug("blender", False), blender)
return blendFn.object()
def setNodeColour(node, colour):
"""Set the given node mobject override color can be a mobject representing a transform or shape
:param node: the node which you want to change the override colour of
:type node: mobject
:param colour: The RGB colour to set
:type colour: MColor or tuple
"""
dependNode = om2.MFnDagNode(om2.MFnDagNode(node).getPath())
plug = dependNode.findPlug("overrideColorRGB", False)
enabledPlug = dependNode.findPlug("overrideEnabled", False)
overrideRGBColors = dependNode.findPlug("overrideRGBColors", False)
if not plugs.getPlugValue(enabledPlug):
plugs.setPlugValue(enabledPlug, True)
if not plugs.getPlugValue(overrideRGBColors):
plugs.setPlugValue(dependNode.findPlug("overrideRGBColors", False), True)
plugs.setPlugValue(plug, colour)
def createSetRange(name, value, min_, max_, oldMin, oldMax, outValue=None):
""" Generates and connects a setRange node.
input/output arguments take an iterable, possibles values are om2.MPlug,
float or None.
if a value is None it will be skipped this is useful when you want
some not connected or set to a value but the other is left to the
default state.
If MPlug is passed and its a compound it'll be connected.
:param name: the new name for the set Range node
:type name: str
:param value:
:type value: iterable(om2.MPlug or float or None)
:param min_:
:type min_: iterable(om2.MPlug or float or None)
:param max_:
:type max_: iterable(om2.MPlug or float or None)
:param oldMin:
:type oldMin: iterable(om2.MPlug or float or None)
:param oldMax:
:type oldMax: iterable(om2.MPlug or float or None)
:param outValue:
:type outValue: iterable(om2.MPlug or float or None)
:return: the created setRange node
:rtype: om2.MObject
.. code-block:: python
one = nodes.createDagNode("one", "transform")
two = nodes.createDagNode("two", "transform")
end = nodes.createDagNode("end", "transform")
oneFn = om2.MFnDagNode(one)
twoFn = om2.MFnDagNode(two)
endFn = om2.MFnDagNode(end)
values = [oneFn.findPlug("translate", False)]
min_ = [twoFn.findPlug("translate", False)]
max_ = [twoFn.findPlug("translate", False)]
oldMax = [0.0,180,360]
oldMin = [-10,-720,-360]
reload(creation)
outValues = [endFn.findPlug("translateX", False), endFn.findPlug("translateY", False), None]
pma = creation.createSetRange("test_pma", values, min_, max_, oldMin, oldMax, outValues)
"""
setRange = nodes.createDGNode(name, "setRange")
fn = om2.MFnDependencyNode(setRange)
valuePlug = fn.findPlug("value", False)
oldMinPlug = fn.findPlug("oldMin", False)
oldMaxPlug = fn.findPlug("oldMax", False)
minPlug = fn.findPlug("min", False)
maxPlug = fn.findPlug("max", False)
# deal with all the inputs
# source list, destination plug
for source, destination in ((value, valuePlug), (min_, minPlug), (max_,
maxPlug),
(oldMin, oldMinPlug), (oldMax, oldMaxPlug)):
if source is None:
continue
for index, inner in enumerate(source):
if inner is None:
continue
elif isinstance(inner, om2.MPlug):
if inner.isCompound:
plugs.connectPlugs(inner, destination)
break
child = destination.child(index)
plugs.connectPlugs(inner, child)
continue
child = destination.child(index)
plugs.setPlugValue(child, inner)
if outValue is None:
return setRange
outPlug = fn.findPlug("outValue", False)
# now the outputs
for index, out in enumerate(outValue):
if out is None:
continue
if isinstance(out, om2.MPlug):
if out.isCompound:
plugs.connectPlugs(outPlug, out)
break
child = outPlug.child(index)
plugs.connectPlugs(child, out)
continue
child = outPlug.child(index)
# not a plug must be a plug value
plugs.setPlugValue(child, out)
return setRange
