def prepareForDraw(self, objPath, cameraPath, frameContext, oldData):
data = oldData
if not isinstance(data, GuideHandleData):
data = GuideHandleData()
controlNode = objPath.node()
data.childPositions = OpenMaya.MPointArray()
plug = OpenMaya.MPlug(controlNode, self.GuideClass.childPosition)
fnData = OpenMaya.MFnNumericData()
for i in xrange(plug.numElements()):
handle = plug.elementByPhysicalIndex(i)
fnData.setObject(handle.asMObject())
pt = OpenMaya.MPoint(fnData.getData())
data.childPositions.append(pt)
plug.setAttribute(self.GuideClass.handleMatrix)
handleMatrix = OpenMaya.MFnMatrixData(plug.asMObject()).matrix()
data.inverseMatrix = handleMatrix.inverse()
plug.setAttribute(self.GuideClass.handleColor)
colorData = OpenMaya.MFnNumericData(plug.asMObject())
data.handleColor = OpenMaya.MColor(colorData.getData())
plug.setAttribute(self.GuideClass.jointMatrix)
jointMatrix = OpenMaya.MFnMatrixData(plug.asMObject()).matrix()
data.jointMatrix = jointMatrix * data.inverseMatrix
plug.setAttribute(self.GuideClass.guide)
data.hasGuide = plug.isConnected
return data
def getLocalRotationHoldMatrix(wsTransform, wsInvTransform, name):
"""Creates a holdMatrix node, and sets the local rotateMatrix
returns holdMatrix node
"""
holdmat = cmds.createNode('holdMatrix', n='_%s_HMAT'%name)
MList = om.MSelectionList()
MList.add(wsTransform)
mplug = om.MFnDependencyNode(MList.getDependNode(0)).findPlug('worldMatrix', 0)
mat = om.MFnMatrixData(mplug.elementByLogicalIndex( 0 ).asMObject()).matrix()
if wsInvTransform:
MList.add(wsInvTransform)
mplug = om.MFnDependencyNode(MList.getDependNode(1)).findPlug('worldInverseMatrix', 0)
invmat = om.MFnMatrixData(mplug.elementByLogicalIndex( 0 ).asMObject()).matrix()
mtmat = om.MTransformationMatrix(mat * invmat)
cmds.setAttr(holdmat + '.inMatrix', mtmat.asRotateMatrix(), type='matrix')
else:
mtmat = om.MTransformationMatrix(mat)
cmds.setAttr(holdmat + '.inMatrix', mtmat.asRotateMatrix(), type='matrix')
return holdmat
def getWorldMatrix(self):
try:
inputMeshParent = OpenMaya.MFnDagNode(self.shape).parent(0)
except:
return
fnInputMeshParent = OpenMaya.MFnDependencyNode(inputMeshParent)
inputMeshWorldMatrixAttr = fnInputMeshParent.attribute('worldMatrix')
inputMeshWorldMatrixPlug = OpenMaya.MPlug(inputMeshParent,
inputMeshWorldMatrixAttr)
inputMeshWorldMatrixPlug = inputMeshWorldMatrixPlug.elementByLogicalIndex(
0)
inputMeshWorldMatrixObj = inputMeshWorldMatrixPlug.asMObject()
inputMeshWorldMatrixData = OpenMaya.MFnMatrixData(
inputMeshWorldMatrixObj)
inputMeshWorldMatrix = inputMeshWorldMatrixData.matrix()
MObjFn = OpenMaya.MFnDagNode(self.MObj)
MObjParent = MObjFn.parent(0)
fnMObjParent = OpenMaya.MFnDependencyNode(MObjParent)
worldMatrixAttr = fnMObjParent.attribute('worldMatrix')
matrixPlug = OpenMaya.MPlug(MObjParent, worldMatrixAttr)
matrixPlug = matrixPlug.elementByLogicalIndex(0)
worldMatrixObject = matrixPlug.asMObject()
worldMatrixData = OpenMaya.MFnMatrixData(worldMatrixObject)
worldMatrix = worldMatrixData.matrix().inverse()
outputMatrix = inputMeshWorldMatrix.__mul__(worldMatrix)
return outputMatrix
def get_kMatrix(plug):
mobj = plug.asMObject()
if mobj.apiType() != 0:
return api2.MFnMatrixData(plug.asMObject()).matrix()
return [
api2.MFnMatrixData(
plug.elementByLogicalIndex(i).asMObject()).matrix()
for i in range(plug.evaluateNumElements())
]
def test_getObjectMatrix(self):
node = nodes.asMObject(self.node)
matrix = nodes.getMatrix(node)
self.assertIsInstance(matrix, om2.MMatrix)
matPl = om2.MFnDagNode(node).findPlug("matrix", False)
self.assertEquals(matrix,
om2.MFnMatrixData(matPl.asMObject()).matrix())
def parseMatrixAttribute(self, name, shortName, attrInfo):
"""
Given a JSON subsection describing a matrix attribute create the
attribute and set all of the provided flags/members for it.
name = Attribute long name
shortName = Attribute short name
attrInfo = JSON object containing the main attribute information
"""
jsonDebug('parseMatrixAttribute(%s)' % name)
matrixType = JsonKeys.kTypeMatrixTypes[attrInfo[JsonKeys.kKeyAttrType]]
if JsonKeys.kKeyDefault in attrInfo:
jsonDebug('Setting the matrix default to "%s"' %
attrInfo[JsonKeys.kKeyDefault])
mDefault = omAPI.MFnMatrixData()
defaultValue = mDefault.create(
omAPI.MMatrix(attrInfo[JsonKeys.kKeyDefault]))
mAttr = omAPI.MFnMatrixAttribute(defaultValue)
attr = mAttr.create(name, shortName, matrixType)
else:
jsonDebug('Creating matrix attribute with no default')
mAttr = omAPI.MFnMatrixAttribute()
attr = mAttr.create(name, shortName, matrixType)
return attr
def set(self, inf):
self.inf = inf
self.skin_id = self.skinInfo.get(inf)
self.bpmPlugId = self.bpmPlug.elementByLogicalIndex(self.skin_id)
self.init_mx_obj = self.bpmPlugId.asMObject()
init_mx = om.MFnMatrixData(self.init_mx_obj).matrix()
self.move_mx = init_mx * MOVE_MATRIX
def getMatrixAttributeInTimeRange(node, attribute, timeRange=None):
"""get matrix atributtes on a range of frames wir maya DGContext
Args:
node (str): node name
attribute (str): attribute name like worldMatrix or parentInverseMatrix
timeRange (tuple, optional): start and end frames, if si not defined
it will get the current active animation range. Defaults to None.
Returns:
list: list of matrices
"""
fn = mUtils.getFn(node)
plug = fn.findPlug(attribute, 0)
if plug.isArray:
plug.evaluateNumElements()
plug = plug.elementByPhysicalIndex(0)
if not timeRange:
timeRange=getCurrentAnimRange()
result = list()
for x in range(int(timeRange[0]), int(timeRange[1])):
timeContext = om.MDGContext(om.MTime(x, TIMEUNIT))
matrixO = plug.asMObject(timeContext)
fnMat = om.MFnMatrixData(matrixO)
matrix = fnMat.matrix()
result.append(matrix)
return result
def parentAPI(source, target, absolute=True):
# TODO: implement undo
mSource = nodeToMObject(source)
if absolute:
srcFnDependencyNode = om.MFnDependencyNode(mSource)
worldMatrixPlug = srcFnDependencyNode.findPlug('worldMatrix', False).elementByLogicalIndex(0)
matrixMObj = worldMatrixPlug.asMObject()
fnMatrixData = om.MFnMatrixData(matrixMObj)
srcWMtx = fnMatrixData.transformation()
mDagMod = om.MDagModifier()
if target:
mTarget = nodeToMObject(target)
mDagMod.reparentNode(mSource, mTarget)
else:
mDagMod.reparentNode(mSource)
mDagMod.doIt()
fnDagNode = om.MFnDagNode(mSource)
if absolute:
srcFnTransform = om.MFnTransform(fnDagNode.getPath())
# srcFnTransform = om.MFnTransform(mSource)
# noinspection PyUnboundLocalVariable
srcFnTransform.setTranslation(srcWMtx.translation(om.MSpace.kWorld), om.MSpace.kWorld)
srcFnTransform.setRotation(srcWMtx.rotation(asQuaternion=True), om.MSpace.kWorld)
srcFnTransform.setScale(srcWMtx.scale(om.MSpace.kWorld))
srcFnTransform.setShear(srcWMtx.shear(om.MSpace.kWorld))
return fnDagNode.fullPathName()
def _getLocalTransform(self):
node = self.thisMObject()
transformPlug = om.MPlug(node, self.transformAttr)
transform = om.MFnMatrixData(transformPlug.asMObject()).matrix()
mat = om.MTransformationMatrix(transform)
# Apply local translation.
localTranslatePlug = om.MPlug(node, self.localTranslateAttr)
localTranslation = om.MVector(
*[localTranslatePlug.child(idx).asFloat() for idx in range(3)])
mat.translateBy(localTranslation, om.MSpace.kObject)
# Apply local rotation.
localRotatePlug = om.MPlug(node, self.localRotateAttr)
localRotatePlugs = [localRotatePlug.child(idx) for idx in range(3)]
localRotate = om.MVector(
*
[localRotatePlugs[idx].asMAngle().asRadians() for idx in range(3)])
mat.rotateBy(om.MEulerRotation(localRotate), om.MSpace.kObject)
# Apply local scale.
scalePlug = om.MPlug(node, self.localScaleAttr)
scale = om.MFnNumericData(scalePlug.asMObject()).getData()
mat.scaleBy(scale, om.MSpace.kObject)
return mat.asMatrix()
def set_kMatrix(plug, value):
mfnMatrix = api2.MFnMatrixData(plug.asMObject())
newMatrix = api2.MMatrix(value)
mfnMatrix.set(newMatrix)
return plug.setMObject(mfnMatrix.object())
def test_getWorldInverseMatrix(self):
node = nodes.asMObject(self.node)
matrix = nodes.getWorldInverseMatrix(node)
self.assertIsInstance(matrix, om2.MMatrix)
parentPlug = om2.MFnDagNode(node).findPlug("worldInverseMatrix", False)
parentPlug.evaluateNumElements()
matPl = parentPlug.elementByPhysicalIndex(0)
self.assertEquals(matrix, om2.MFnMatrixData(matPl.asMObject()).matrix())
def createLocAtVertex(selList, componentIDs, mDagMod):
"""
Create an locator on vertex aligned with the vertex normal
:param selList: MSelectionList
:param componentID: int
:param mDagMod: MDagModifier
:return: None
"""
for componentID in componentIDs:
# Get vertex normal/position
meshDagPath = selList.getDagPath(0)
mFnMesh = om2.MFnMesh(meshDagPath)
vtxNormal = mFnMesh.getVertexNormal(componentID, False,
om2.MSpace.kObject)
vtxPoint = mFnMesh.getPoint(componentID, om2.MSpace.kObject)
mObj = selList.getDependNode(0)
mFn = om2.MFnDependencyNode(mObj)
getMtxPlug = mFn.findPlug("worldMatrix", False)
mtxPlug = getMtxPlug.elementByLogicalIndex(0)
plugMObj = mtxPlug.asMObject()
mFnMtxData = om2.MFnMatrixData(plugMObj)
offsetMtx = mFnMtxData.matrix()
# Construct a matrix
mtxConstruct = (vtxNormal.x, vtxNormal.y, vtxNormal.z, 0, 0, 1, 0, 0,
0, 0, 1, 0, vtxPoint.x, vtxPoint.y, vtxPoint.z,
vtxPoint.w)
vtxMMatrix = om2.MMatrix(
mtxConstruct) * offsetMtx # Convert to Maya MMatrix
vtxMtransMtx = om2.MTransformationMatrix(vtxMMatrix)
# Get rotation/translation
rot = vtxMtransMtx.rotation()
trans = vtxMtransMtx.translation(om2.MSpace.kWorld)
loc = createLocator(componentID, "vtx", mDagMod)
if loc.isValid():
locMObj = loc.object()
mFn = om2.MFnDependencyNode(locMObj)
transX = mFn.findPlug("translateX", False)
transY = mFn.findPlug("translateY", False)
transZ = mFn.findPlug("translateZ", False)
transX.setFloat(trans.x)
transY.setFloat(trans.y)
transZ.setFloat(trans.z)
rotX = mFn.findPlug("rotateX", False)
rotY = mFn.findPlug("rotateY", False)
rotZ = mFn.findPlug("rotateZ", False)
rotX.setFloat(rot.x)
rotY.setFloat(rot.y)
rotZ.setFloat(rot.z)
def prepareForDraw(self, objPath, cameraPath, frameContext, oldData):
data = oldData
if not isinstance(data, GuideLimbData):
data = GuideLimbData()
controlNode = objPath.node()
controlNode = objPath.node()
plug = OpenMaya.MPlug(controlNode, self.GuideClass.boundingBoxCorner1)
plugData = OpenMaya.MFnNumericData(plug.asMObject())
corner1 = plugData.getData()
plug = OpenMaya.MPlug(controlNode, self.GuideClass.boundingBoxCorner2)
plugData.setObject(plug.asMObject())
corner2 = plugData.getData()
data.boundingBoxCorner1 = OpenMaya.MPoint(corner1[0], corner1[1], corner1[2])
data.boundingBoxCorner2 = OpenMaya.MPoint(corner2[0], corner2[1], corner2[2])
plug.setAttribute(self.GuideClass.guideMatrix)
guideMatrix = OpenMaya.MFnMatrixData(plug.asMObject()).matrix()
guideInverse = guideMatrix.inverse()
plug.setAttribute(self.GuideClass.baseMatrix)
baseMatrix = OpenMaya.MFnMatrixData(plug.asMObject()).matrix()
baseMatrix *= guideInverse
data.basePosition = OpenMaya.MPoint(
OpenMaya.MTransformationMatrix(baseMatrix).translation(OpenMaya.MSpace.kPostTransform)
)
plug.setAttribute(self.GuideClass.hingeMatrix)
hingeMatrix = OpenMaya.MFnMatrixData(plug.asMObject()).matrix()
hingeMatrix *= guideInverse
data.midPosition = OpenMaya.MPoint(
OpenMaya.MTransformationMatrix(hingeMatrix).translation(
OpenMaya.MSpace.kPostTransform))
plug.setAttribute(self.GuideClass.endMatrix)
endMatrix = OpenMaya.MFnMatrixData(plug.asMObject()).matrix()
endMatrix *= guideInverse
data.endPosition = OpenMaya.MPoint(
OpenMaya.MTransformationMatrix(endMatrix).translation(OpenMaya.MSpace.kPostTransform)
)
return data
def getLocalMatrix(node):
if not node.hasFn(OpenMaya.MFn.kTransform):
return
depNode = OpenMaya.MFnDependencyNode(node)
localMatrixPlug = depNode.findPlug('matrix', False)
matrixAttrMObject = localMatrixPlug.asMObject()
matrixData = OpenMaya.MFnMatrixData(matrixAttrMObject)
return matrixData.matrix()
def getPlugAndType(plug):
"""Given an MPlug, get its value
:param plug: MPlug
:return: the dataType of the given plug. Will return standard python types where necessary eg. float else maya type
:rtype: tuple(int, plugValue)
"""
obj = plug.attribute()
if plug.isArray:
count = plug.evaluateNumElements()
res = [None] * count, [None] * count
data = [
getPlugAndType(plug.elementByPhysicalIndex(i))
for i in xrange(count)
]
for i in xrange(len(data)):
res[0][i] = data[i][0]
res[1][i] = data[i][1]
return res
if obj.hasFn(om2.MFn.kNumericAttribute):
return getNumericValue(plug)
elif obj.hasFn(om2.MFn.kUnitAttribute):
uAttr = om2.MFnUnitAttribute(obj)
ut = uAttr.unitType()
if ut == om2.MFnUnitAttribute.kDistance:
return attrtypes.kMFnUnitAttributeDistance, plug.asMDistance()
elif ut == om2.MFnUnitAttribute.kAngle:
return attrtypes.kMFnUnitAttributeAngle, plug.asMAngle()
elif ut == om2.MFnUnitAttribute.kTime:
return attrtypes.kMFnUnitAttributeTime, plug.asMTime()
elif obj.hasFn(om2.MFn.kEnumAttribute):
return attrtypes.kMFnkEnumAttribute, plug.asInt()
elif obj.hasFn(om2.MFn.kTypedAttribute):
return getTypedValue(plug)
elif obj.hasFn(om2.MFn.kMessageAttribute):
return attrtypes.kMFnMessageAttribute, None
elif obj.hasFn(om2.MFn.kMatrixAttribute):
return attrtypes.kMFnDataMatrix, om2.MFnMatrixData(
plug.asMObject()).matrix()
if plug.isCompound:
count = plug.numChildren()
res = [None] * count, [None] * count
data = [getPlugAndType(plug.child(i)) for i in xrange(count)]
for i in xrange(len(data)):
res[0][i] = data[i][0]
res[1][i] = data[i][1]
return res
return None, None
def _worldMatrix(self, obj):
"""Return the world matrix of the given MObject.
:param obj: The transform node MObject.
:type obj: om2.MObject
:return: The world matrix.
:rtype: om2.MMatrix
"""
mfn = om2.MFnDependencyNode(obj)
matrixObject = mfn.findPlug(
"worldMatrix", False).elementByLogicalIndex(0).asMObject()
return om2.MFnMatrixData(matrixObject).matrix()
def wMtxFromMObj(self, node_mob):
if not node_mob.hasFn(om2.MFn.kDagNode):
return None
dagNode = om2.MFnDagNode(node_mob)
worldMatrixPlug = dagNode.findPlug('worldMatrix', False)
wmElementPlug = worldMatrixPlug.elementByLogicalIndex(0)
wmElementPlugMObj = wmElementPlug.asMObject()
matrixData = om2.MFnMatrixData(wmElementPlugMObj)
return matrixData.transformation()
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 get_matrix_from_plug(plug, context):
"""Get the matrix from the plug using the given context.
Args:
plug (OpenMaya.MPlug): plug to get matrix from.
context (OpenMaya.MDGContext): context for mobject to query.
Returns:
OpenMaya.MMatrix: matrix object from the plug.
"""
matrix_object = plug.asMObject(context)
fn_matrix_data = OpenMaya.MFnMatrixData(matrix_object)
matrix = fn_matrix_data.matrix()
return matrix
def prepareForDraw(self, objPath, cameraPath, frameContext, oldData):
# verify data cache
data = oldData
if not isinstance(data, ReflectionLocatorNodeData):
data = ReflectionLocatorNodeData()
# access shape type
ui_type = OpenMaya.MPlug(objPath.node(), ReflectionLocatorNode.ui_type)
data.ui_type = ui_type.asInt()
# access plane matrix
plane_matrix = OpenMaya.MPlug(objPath.node(),
ReflectionLocatorNode.plane_matrix)
data.plane_matrix = OpenMaya.MFnMatrixData(
plane_matrix.asMObject()).matrix()
# access input point
input_point = OpenMaya.MPlug(objPath.node(),
ReflectionLocatorNode.input_point)
data.input_point = get_vector_value(input_point)
# access output point
output_point = OpenMaya.MPlug(objPath.node(),
ReflectionLocatorNode.output_point)
data.output_point = get_vector_value(output_point)
# access line width
line_width = OpenMaya.MPlug(objPath.node(),
ReflectionLocatorNode.line_width)
data.line_width = line_width.asFloat()
# access the parent inverse
# parent_inverse = OpenMaya.MPlug(objPath.node(), ReflectionLocatorNode.parent_inverse)
# data.parent_inverse = OpenMaya.MFnMatrixData(parent_inverse.asMObject()).matrix()
# access plane color
plane_color = OpenMaya.MPlug(objPath.node(),
ReflectionLocatorNode.plane_color)
data.plane_color = get_vector_value(plane_color)
# access the objects' position
data.plane_position = OpenMaya.MTransformationMatrix(
data.plane_matrix).translation(OpenMaya.MSpace.kPostTransform)
# access the scale
scale = OpenMaya.MPlug(objPath.node(), ReflectionLocatorNode.scale)
data.scale = scale.asFloat()
return data
def get_world_rot_as_quat(m_obj):
"""
Extracts the rotation from the worldMatrix of the MObject.
Args:
m_obj
Return:
rot
"""
plug = get_world_matrix_plug(m_obj, 0)
matrix_obj = plug.asMObject()
matrix_data = oMa.MFnMatrixData(matrix_obj)
matrix = matrix_data.matrix()
trans_matrix = oMa.MTransformationMatrix(matrix)
rot = trans_matrix.rotation(asQuaternion=True)
return rot
def get_world_trans(m_obj):
"""
Extracts the translation from the worldMatrix of the MObject.
Args:
m_obj
Return:
trans
"""
plug = get_world_matrix_plug(m_obj, 0)
matrix_obj = plug.asMObject()
matrix_data = oMa.MFnMatrixData(matrix_obj)
matrix = matrix_data.matrix()
trans_matrix = oMa.MTransformationMatrix(matrix)
trans = trans_matrix.translation(oMa.MSpace.kWorld)
return trans
def get_matrix(node):
selection = OpenMaya.MSelectionList()
matrix_obj = OpenMaya.MObject()
selection.add(node)
# New api is nice since it will just return an MObject instead of taking two arguments.
MObjectA = selection.getDependNode(0)
# Dependency node so we can get the worldMatrix attribute
fnThisNode = OpenMaya.MFnDependencyNode(MObjectA)
# Get it's world matrix plug
world_matrix_attr = fnThisNode.attribute("worldMatrix")
# Getting mPlug by plugging in our MObject and attribute
matrix_plug = OpenMaya.MPlug(MObjectA, world_matrix_attr)
matrix_plug = matrix_plug.elementByLogicalIndex(0)
# Get matrix plug as MObject so we can get it's data.
matrix_obj = matrix_plug.asMObject()
#Finally get the data
world_matrix_data = OpenMaya.MFnMatrixData(matrix_obj)
world_matrix = world_matrix_data.matrix()
return world_matrix
def getMatrix(mObjectHandle, matrixPlug="worldMatrix"):
"""
Get matrix, if plug is an array it will return index 0 of that plug
:param mObjectHandle: MObjectHandle
:return: matrix
"""
if mObjectHandle.isValid():
mObj = mObjectHandle.object()
mFn = om2.MFnDependencyNode(mObj)
mtxPlug = mFn.findPlug(matrixPlug, False)
if mtxPlug.isArray:
mtxPlug = mtxPlug.elementByLogicalIndex(0)
plugMObj = mtxPlug.asMObject()
mFnMtxData = om2.MFnMatrixData(plugMObj)
mtx = mFnMtxData.matrix()
serializableMtx = tuple(mtx)
return serializableMtx
def redoIt(self):
srcWMtx = self.wMtxFromMObj(
self.selList.getDependNode(self.selList.length() - 1))
srcWSc = srcWMtx.scale(om2.MSpace.kWorld)
srcWRo = srcWMtx.rotation(asQuaternion=True)
srcWTr = srcWMtx.translation(om2.MSpace.kWorld)
for i in xrange(self.selList.length() - 1):
tgtMFnXfo = om2.MFnTransform(self.selList.getDagPath(i))
tgtDagNode = om2.MFnDagNode(self.selList.getDagPath(i))
tgtTransform = tgtMFnXfo.transformation()
self.origTransforms.append(tgtTransform)
newTrans = tgtTransform
if self.matchScale is True:
newTrans.setScale(srcWSc, om2.MSpace.kWorld)
if self.matchRotation is True:
newTrans.setRotation(srcWRo)
if self.matchTranslation is True:
newTrans.setTranslation(srcWTr, om2.MSpace.kWorld)
tgtParentMObj = tgtDagNode.parent(0)
if tgtParentMObj.hasFn(
om2.MFn.kTransform) and self.matchTranslation is True:
parentDepNode = om2.MFnDependencyNode(tgtParentMObj)
parentInvMatrixPlug = parentDepNode.findPlug(
'worldInverseMatrix', False)
parentInvMatrixPlugEl = parentInvMatrixPlug.elementByLogicalIndex(
0)
parentInvMatrixMObj = parentInvMatrixPlugEl.asMObject()
parentInvMatrix = om2.MFnMatrixData(
parentInvMatrixMObj).matrix()
newTransMatrix = newTrans.asMatrix()
newMatrix = newTransMatrix * parentInvMatrix
newTrans = om2.MTransformationMatrix(newMatrix)
tgtMFnXfo.setTransformation(newTrans)
def createLocAtSelection():
selList = om2.MGlobal.getActiveSelectionList()
mObjs = [selList.getDependNode(idx) for idx in range(selList.length())]
mDagMod = om2.MDagModifier()
for mObj in mObjs:
mObjHandle = om2.MObjectHandle(mObj)
mFn = om2.MFnDependencyNode(mObj)
locMObj = createNode("locator", "{}_LOC".format(mFn.name()), mDagMod)
locMObjHandle = om2.MObjectHandle(locMObj)
mPlug = findPlug(mObjHandle, "worldMatrix")
if mPlug.isArray:
mtxIdxZero = mPlug.elementByLogicalIndex(0)
plugMObj = mtxIdxZero.asMObject()
mFnMtxData = om2.MFnMatrixData(plugMObj)
mMtx = mFnMtxData.matrix()
setAtters(locMObjHandle, mMtx)
def get_world_matrix(m_obj, i):
"""
Returns the worldMatrix MMatrix of the given MObject.
Args:
m_obj
i
Return:
matrix
"""
if not m_obj.hasFn(oMa.MFn.kTransform):
return
fn_obj = oMa.MFnDependencyNode(m_obj)
plug = fn_obj.findPlug('worldMatrix', False).elementByLogicalIndex(i)
matrix_obj = plug.asMObject()
matrix_data = oMa.MFnMatrixData(matrix_obj)
matrix = matrix_data.matrix()
return matrix
def getMMatrixFromAttr(mObj, attrStr):
""" util script to grab matrix from attribute
:param mObj: MObject with matrix attribute
:type mObj: MObject
:param attrStr: name of attribute
:param attrStr: str
:return: MMatrix
"""
mfnDn = om.MFnDependencyNode(mObj)
matrixattr = mfnDn.attribute(attrStr)
matrixPlug = om.MPlug(mObj, matrixattr)
matrixPlug = matrixPlug.elementByLogicalIndex(0)
matrixMObj = matrixPlug.asMObject()
mfMatrixData = om.MFnMatrixData(matrixMObj)
return mfMatrixData.matrix()
def get_matrix_from_plug_apitwo(plug, ctx):
"""
Get a matrix plug value at a given DG (time) context.
http://chrisdevito.blogspot.com/2013/04/getting-dat-matrix-maya-python-api-20.html
:param plug: The node.attribute to query.
:type plug: maya.api.OpenMaya.MPlug
:param ctx: Time DG Context to query at.
:type ctx: maya.api.OpenMaya.MDGContext
:returns: The 4x4 matrix value at the given DG context.
:rtype: maya.api.OpenMaya.MMatrix
"""
assert isinstance(plug, OpenMaya2.MPlug)
assert isinstance(ctx, OpenMaya2.MDGContext)
mobject = plug.asMObject(ctx)
data = OpenMaya2.MFnMatrixData(mobject)
matrix = data.matrix()
return matrix
