def boundingBox(self):
"""Return the boundingBox"""
thisMob = self.thisMObject()
size = om2.MPlug(thisMob, TestLocator.inSize).asDouble()
corner1 = om2.MPoint(1.0, 0.0, -1.0) * size
corner2 = om2.MPoint(-1.0, 0.0, 1.0) * size
return om2.MBoundingBox(corner1, corner2)
def boundingBox(self, objPath, cameraPath):
""" Return the boundingBox """
# pylint: disable=unused-argument
node = objPath.node()
size = om2.MPlug(node, TestLocator.inSize).asDouble()
corner1 = om2.MPoint(1.0, 0.0, -1.0) * size
corner2 = om2.MPoint(-1.0, 0.0, 1.0) * size
return om2.MBoundingBox(corner1, corner2)
class DebugGeometry(om2.MPxSurfaceShape):
""" Main class of gfDebugGeometry node. """
kNodeName = ""
kNodeClassify = ""
kNodeRegistrantID = ""
kNodeID = ""
kPnts = om2.MPointArray([
om2.MPoint(0.0, 0.0, 0.0),
om2.MPoint(0.0, 0.0, -4.0),
om2.MPoint(-4.0, 0.0, -4.0),
om2.MPoint(-4.0, 0.0, 0.0)
])
def __init__(self):
""" Constructor. """
om2.MPxSurfaceShape.__init__(self)
def postConstructor(self):
""" Post Constructor. """
thisMob = self.thisMObject()
om2.MFnDependencyNode(thisMob).setName("%sShape#" %
DebugGeometry.kNodeName)
@staticmethod
def creator():
""" Maya creator function. """
return DebugGeometry()
@staticmethod
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to DebugGeometry class. Instances of DebugGeometry will use these attributes to create plugs
for use in the compute() method.
"""
return True
def isBounded(self):
"""isBounded?"""
return True
def boundingBox(self):
"""Return the boundingBox"""
bBox = om2.MBoundingBox()
for i in range(len(DebugGeometry.kPnts)):
bBox.expand(DebugGeometry.kPnts[i])
return bBox
def getShapeSelectionMask(self):
"""Returns the selection mask of the shape."""
mask = om2.MSelectionMask(om2.MSelectionMask.kSelectIkHandles)
return mask
def mPointFromPlugSource(plug):
"""
similar to mtxFromPlugSource but will retrieve a translate compound source
:param plug: [MPlug] a plug connected to a translate compound triplet source
:return: [MPoing | None]
"""
if plug.isDestination:
sourcePlug = plug.source()
if not sourcePlug.isCompound or not sourcePlug.numChildren() == 3:
return None
mp = om2.MPoint()
returnPoint = [False, False, False]
for i in xrange(sourcePlug.numChildren()):
realName = sourcePlug.child(i).partialName(includeNodeName=False,
useAlias=False)
if realName == 'tx':
mp.x = sourcePlug.child(i).asFloat()
returnPoint[0] = True
elif realName == 'ty':
mp.y = sourcePlug.child(i).asFloat()
returnPoint[1] = True
elif realName == 'tz':
mp.z = sourcePlug.child(i).asFloat()
returnPoint[2] = True
if all(returnPoint):
return mp
return None
def update(self):
super(TrianglePrim, self).update()
self._points = []
matrix = self.transform.asMatrix()
for i in xrange(len(self._prePoints)):
point = om2.MPoint(self._prePoints[i])
point *= matrix
self._points.append(point)
def boundingBox(self, objPath, cameraPath):
""" Return the boundingBox """
# pylint: disable=unused-argument
node = objPath.node()
operation = om2.MPlug(node, DebugVector.inOperation).asShort()
vVector1 = om2.MPlug(
node, DebugVector.inVec1).asMDataHandle().asFloatVector()
vVector2 = om2.MPlug(
node, DebugVector.inVec2).asMDataHandle().asFloatVector()
normalize = om2.MPlug(node, DebugVector.inNormalize).asBool()
if operation == 0:
vEnd = vVector1
elif operation == 1:
vFinal = vVector1 + vVector2
vEnd = vFinal
elif operation == 2:
vFinal = vVector1 - vVector2
vEnd = vFinal
elif operation == 3:
vFinal = vVector1 ^ vVector2
vEnd = vFinal
elif operation == 4:
if vVector2.length() < 0.001:
vFinal = om2.MFloatVector(0.0, 0.0, 0.0)
else:
vFinal = ((vVector1 * vVector2) /
math.pow(vVector2.length(), 2.0)) * vVector2
vEnd = vFinal
vStart = om2.MFloatVector()
if normalize:
vEnd.normalize()
corner1 = om2.MPoint(vStart.x, vStart.y, vStart.z)
corner2 = om2.MPoint(vEnd.x, vEnd.y, vEnd.z)
return om2.MBoundingBox(corner1, corner2)
def __init__(self):
""" Constructor. """
om2.MUserData.__init__(self, False) # Don't delete after draw
self.fDormantColor = om2.MColor()
self.fActiveColor = om2.MColor()
self.fLeadColor = om2.MColor()
self.fPntPos = om2.MPoint()
self.fRow0 = ""
self.fRow1 = ""
self.fRow2 = ""
self.fRow3 = ""
self.fRow4 = ""
self.fDist = 2.0
def prepareForDraw(self, objPath, cameraPath, frameContext, oldData):
"""
Called by Maya each time the object needs to be drawn.
Any data needed from the Maya dependency graph must be retrieved and cached in this stage.
Returns the data to be passed to the draw callback method.
* objPath [MDagPath] is the path to the object being drawn.
* cameraPath [MDagPath] is the path to the camera that is being used to draw.
* frameContext [MFrameContext] is the frame level context information.
* oldData [MUserData] is the data cached by the previous draw of the instance.
"""
# pylint: disable=unused-argument
data = oldData
if not isinstance(data, DebugMatrixData):
data = DebugMatrixData()
node = objPath.node()
mInput = om2.MPlug(node,
DebugMatrix.inMatrix).asMDataHandle().asMatrix()
color = om2.MPlug(
node, DebugMatrix.inNameColor).asMDataHandle().asFloatVector()
dist = om2.MPlug(node, DebugMatrix.inDistance).asFloat()
pntPos = om2.MPoint(mInput[12], mInput[13], mInput[14])
pntRow1 = om2.MPoint(mInput[0], mInput[1], mInput[2], mInput[3])
row1 = "%s | %s | %s | %s" % (str(pntRow1.x), str(
pntRow1.y), str(pntRow1.z), str(pntRow1.w))
data.fDormantColor = om2.MColor([color.x, color.y, color.z])
data.fActiveColor = om2.MColor([0.3, 1.0, 1.0])
data.fLeadColor = om2.MColor([1.0, 1.0, 1.0])
data.fDist = dist
data.fPntPos = pntPos
data.fRow1 = row1
return data
def prepareForDraw(self, objPath, cameraPath, frameContext, oldData):
"""
Called by Maya each time the object needs to be drawn.
Any data needed from the Maya dependency graph must be retrieved and cached in this stage.
Returns the data to be passed to the draw callback method.
* objPath [MDagPath] is the path to the object being drawn.
* cameraPath [MDagPath] is the path to the camera that is being used to draw.
* frameContext [MFrameContext] is the frame level context information.
* oldData [MUserData] is the data cached by the previous draw of the instance.
"""
# pylint: disable=unused-argument
data = oldData
if not isinstance(data, TestLocatorData):
data = TestLocatorData()
node = objPath.node()
size = om2.MPlug(node, TestLocator.inSize).asDouble()
data.fDormantColor = om2.MColor([1.0, 1.0, 0.0])
data.fActiveColor = om2.MColor([0.3, 1.0, 1.0])
data.fLeadColor = om2.MColor([1.0, 1.0, 1.0])
data.fSize = size
vPoint1 = om2.MVector(1.0, 0.0, -1.0) * size
vPoint2 = om2.MVector(-1.0, 0.0, -1.0) * size
vPoint3 = om2.MVector(-1.0, 0.0, 1.0) * size
vPoint4 = om2.MVector(1.0, 0.0, 1.0) * size
data.fQuadList.clear()
data.fQuadList.append(om2.MPoint(vPoint1))
data.fQuadList.append(om2.MPoint(vPoint2))
data.fQuadList.append(om2.MPoint(vPoint3))
data.fQuadList.append(om2.MPoint(vPoint4))
data.fQuadList.append(om2.MPoint(vPoint1))
return data
def update(self):
super(CurvePrim, self).update()
self._points = []
matrix = self.transform.asMatrix()
for i in xrange(len(self._prePoints)):
point = om2.MPoint(self._prePoints[i])
point *= matrix
self._points.append(point)
if self.degree == CURVE_LINEAR:
self._drawPoints = [x for x in self._points]
elif self.degree == CURVE_BEZIER:
num_points = len(self._points)
segs = (num_points - 1) * 16
self._drawPoints = list()
for i in range(segs):
t = i / float(segs - 1)
p = bezierInterpolate(t, self._points)
self._drawPoints.append(p)
def drawArrow(startPnt,
endPnt,
size,
radius,
subd,
lineW,
vp2=False,
glFT=None,
lineList=None):
"""Draw an aim arrow
Args:
startPnt (MFloatVector): The base of the vector.
endPnt (MFloatVector): The end of the vector.
size (float): The size of the arrow.
radius (float): The radius of the arrow.
subd (int): The number of subdivisions of the arrow.
lineW (float): The width of the lines.
vp2 (bool: False [Optional]): Draw inside of drawing override for viewport 2.0.
glFT (instance: None [Optional]): The GL Function Table to draw in viewport 1.0.
lineList (MPointArray: None [Optional]): The line list to append for drawing override.
"""
tipSize = 1.0 - size
step = 2.0 * math.pi / subd
vAim = endPnt - startPnt
vBaseOrigin = vAim * tipSize
nAim = vAim.normal()
nWorld = om2.MFloatVector(0.0, 1.0, 0.0)
nBinormal = nWorld ^ nAim
nBinormal.normalize()
nNormal = nAim ^ nBinormal
nNormal.normalize()
aim = [
nAim.x, nAim.y, nAim.z, 0.0, nNormal.x, nNormal.y, nNormal.z, 0.0,
nBinormal.x, nBinormal.y, nBinormal.z, 0.0, startPnt.x, startPnt.y,
startPnt.z, 1.0
]
mBase = om2.MMatrix(aim)
mOrigin = om2.MMatrix()
mOrigin[12] = vBaseOrigin.length()
mBaseOrigin = mOrigin * mBase
if vp2:
lineList.append(om2.MPoint(startPnt))
lineList.append(om2.MPoint(endPnt))
else:
glFT.glLineWidth(lineW)
glFT.glBegin(omr1.MGL_LINES)
glFT.glVertex3f(startPnt.x, startPnt.y, startPnt.z)
glFT.glVertex3f(endPnt.x, endPnt.y, endPnt.z)
glFT.glEnd()
for i in range(subd):
theta = step * i
mPoint = om2.MMatrix()
mPoint[13] = math.cos(theta) * radius
mPoint[14] = math.sin(theta) * radius
mArrow = mPoint * mBaseOrigin
if vp2:
lineList.append(
om2.MPoint(mBaseOrigin[12], mBaseOrigin[13],
mBaseOrigin[14]))
lineList.append(om2.MPoint(mArrow[12], mArrow[13], mArrow[14]))
lineList.append(om2.MPoint(mArrow[12], mArrow[13], mArrow[14]))
lineList.append(om2.MPoint(endPnt))
else:
glFT.glBegin(omr1.MGL_LINES)
glFT.glVertex3f(mBaseOrigin[12], mBaseOrigin[13],
mBaseOrigin[14])
glFT.glVertex3f(mArrow[12], mArrow[13], mArrow[14])
glFT.glVertex3f(mArrow[12], mArrow[13], mArrow[14])
glFT.glVertex3f(endPnt.x, endPnt.y, endPnt.z)
glFT.glEnd()
return None
def compute(self, plug, dataBlock):
"""
Node computation method:
* plug is a connection point related to one of our node attributes (either an input or an output).
* dataBlock contains the data on which we will base our computations.
"""
# pylint: disable=no-self-use
ctrlPntsHandle = dataBlock.inputArrayValue(
QuadraticCurve.inControlPoints)
ctrlPnts = om2.MPointArray()
if len(ctrlPntsHandle) < 3:
return
for i in range(3):
ctrlPntsHandle.jumpToLogicalElement(i)
mCtrlPnt = ctrlPntsHandle.inputValue().asMatrix()
ctrlPnt = om2.MPoint(mCtrlPnt[12], mCtrlPnt[13], mCtrlPnt[14])
ctrlPnts.append(ctrlPnt)
crvKnots = om2.MDoubleArray([0, 0, 1, 1])
crvDegree = 2
crvForm = om2.MFnNurbsCurve.kOpen
crvIs2d = False
crvRational = False
crvData = om2.MFnNurbsCurveData().create()
crvFn = om2.MFnNurbsCurve(crvData)
crvFn.create(ctrlPnts, crvKnots, crvDegree, crvForm, crvIs2d,
crvRational, crvData)
crvFn.updateCurve()
if plug == QuadraticCurve.outCurve:
outCurveHandle = dataBlock.outputValue(QuadraticCurve.outCurve)
outCurveHandle.setMObject(crvData)
outCurveHandle.setClean()
elif plug == QuadraticCurve.outTransforms:
outTransHandle = dataBlock.outputArrayValue(
QuadraticCurve.outTransforms)
lockLength = dataBlock.inputValue(
QuadraticCurve.inLockLength).asFloat()
restLength = dataBlock.inputValue(
QuadraticCurve.inRestLength).asFloat()
slide = dataBlock.inputValue(QuadraticCurve.inSlide).asFloat()
numOutputs = len(outTransHandle)
crvLength = crvFn.length()
parRejected = crvFn.findParamFromLength(crvLength - restLength)
stepFull = 1.0 / (numOutputs - 1) if numOutputs > 1 else 0.0
stepLock = crvFn.findParamFromLength(restLength) / (
numOutputs - 1) if numOutputs > 1 else 0.0
step = (1.0 - lockLength) * stepFull + lockLength * stepLock
parSlide = parRejected * slide * lockLength
for i in range(numOutputs):
parameter = (step * i) # + parSlide
pos = crvFn.getPointAtParam(parameter, om2.MSpace.kObject)
vPos = om2.MVector(pos.x, pos.y, pos.z)
mtx = [
1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
vPos.x, vPos.y, vPos.z, 1.0
]
mOut = om2.MMatrix(mtx)
outTransHandle.jumpToLogicalElement(i)
resultHandle = outTransHandle.outputValue()
resultHandle.setMMatrix(mOut)
outTransHandle.setAllClean()
else:
return om2.kUnknownParameter
def drawText(self,
mtx,
dist,
colorList,
status,
cameraPath,
lineH,
view=None,
drawManager=None):
"""Draw the matrix text.
"""
mCamera = cameraPath.inclusiveMatrix()
camFn = om2.MFnCamera(cameraPath)
thisMob = self.thisMObject()
worldMtxPlug = om2.MPlug(thisMob, DebugMatrix.inMatrix)
destPlugList = worldMtxPlug.connectedTo(True, False)
if len(destPlugList) >= 1:
node = destPlugList[0].node()
attr = destPlugList[0].attribute()
dagFn = om2.MFnDagNode(node)
name = dagFn.name()
attrName = "%s (%s)" % (" " * len(name),
om2.MFnAttribute(attr).name)
bBox = dagFn.boundingBox
else:
attrName = ""
name = "NO MATRIX INPUT"
bBox = om2.MBoundingBox()
offsetY = bBox.height / 2.0
pntCamera = om2.MPoint(mCamera[12], mCamera[13], mCamera[14])
pntPos = om2.MPoint(mtx[12] + dist, mtx[13] + offsetY, mtx[14])
vCamera = pntCamera - pntPos
distFromCamera = vCamera.length()
pntLineOffset = om2.MPoint(0.0, (distFromCamera / camFn.focalLength) *
lineH, 0.0)
rowList = []
pntRow1 = om2.MPoint(mtx[0], mtx[1], mtx[2], mtx[3])
row1 = "%s | %s | %s | %s" % ("%.3f" % pntRow1.x, "%.3f" % pntRow1.y,
"%.3f" % pntRow1.z, "%.3f" % pntRow1.w)
rowList.append(row1)
pntRow2 = om2.MPoint(mtx[4], mtx[5], mtx[6], mtx[7])
row2 = "%s | %s | %s | %s" % ("%.3f" % pntRow2.x, "%.3f" % pntRow2.y,
"%.3f" % pntRow2.z, "%.3f" % pntRow2.w)
rowList.append(row2)
pntRow3 = om2.MPoint(mtx[8], mtx[9], mtx[10], mtx[11])
row3 = "%s | %s | %s | %s" % ("%.3f" % pntRow3.x, "%.3f" % pntRow3.y,
"%.3f" % pntRow3.z, "%.3f" % pntRow3.w)
rowList.append(row3)
pntRow4 = om2.MPoint(mtx[12], mtx[13], mtx[14], mtx[15])
row4 = "%s | %s | %s | %s" % ("%.3f" % pntRow4.x, "%.3f" % pntRow4.y,
"%.3f" % pntRow4.z, "%.3f" % pntRow4.w)
rowList.append(row4)
if status == omui2.M3dView.kActive:
view.setDrawColor(om2.MColor([0.3, 1.0, 1.0]))
elif status == omui2.M3dView.kLead:
view.setDrawColor(om2.MColor([1.0, 1.0, 1.0]))
if status == omui2.M3dView.kDormant:
view.setDrawColor(colorList[0])
view.drawText(name, pntPos, omui2.M3dView.kLeft)
if status == omui2.M3dView.kDormant:
view.setDrawColor(colorList[1])
view.drawText(attrName, pntPos, omui2.M3dView.kLeft)
if worldMtxPlug.isConnected:
for i in range(1, 5):
pos = om2.MPoint(pntPos - (pntLineOffset * i))
view.drawText(rowList[i - 1], pos, omui2.M3dView.kLeft)
