def test_getattrtime():
"""getAttr(time=)"""
transform = cmdx.createNode("transform")
for time, value in ((1, 1.0), (10, 10.0)):
cmds.setKeyframe(str(transform),
time=[time],
attribute="translateY",
value=value)
cmds.keyTangent(str(transform),
edit=True,
time=(1, 10),
attribute="translateY",
outTangentType="linear")
# These floating point values can differ ever so slightly
assert_almost_equals(transform["ty"].read(time=1), 1.0, places=5)
assert_almost_equals(transform["ty"].read(time=5), 5.0, places=5)
assert_almost_equals(transform["ty"].read(time=10), 10.0, places=5)
# From the current context (Maya 2018 and above)
if hasattr(om.MDGContext, "makeCurrent"):
context = om.MDGContext(om.MTime(1.0, om.MTime.uiUnit()))
context.makeCurrent()
assert_almost_equals(transform["ty"].read(), 1.0, places=5)
context = om.MDGContext(om.MTime(5.0, om.MTime.uiUnit()))
context.makeCurrent()
assert_almost_equals(transform["ty"].read(), 5.0, places=5)
context = om.MDGContext(om.MTime(10.0, om.MTime.uiUnit()))
context.makeCurrent()
assert_almost_equals(transform["ty"].read(), 10.0, places=5)
om.MDGContext.kNormal.makeCurrent()
def create_dg_context_apitwo(t):
"""
Create a Maya DG Context for querying values at time.
"""
assert t is None or isinstance(t, (int, float))
ctx = None
if t is None:
ctx = OpenMaya2.MDGContext()
else:
unit = OpenMaya2.MTime.uiUnit()
mtime = OpenMaya2.MTime(float(t), unit)
ctx = OpenMaya2.MDGContext(mtime)
return ctx
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 time_update(self, *args):
context = OpenMaya.MDGContext(OpenMayaAnim.MAnimControl.currentTime())
attr_dict = {
"old_width": self.old_width.asFloat(context),
"old_fp": self.old_fp.asFloat(context),
"fp": self.fp.asFloat(context),
"width": self.w.asFloat(context),
"near": self.n.asFloat(context),
"far": self.f.asFloat(context),
"fov": self.fov.asFloat(context)
}
self.convert_dict(attr_dict)
def iterFrameRangeDGContext(start, end):
"""Generator function to iterate over a time range returning a MDGContext for the current frame.
:param start: the start frame
:type start: int
:param end: the end frame
:type end: int
:return: Returns a generator function with each element being a MDGContext with the current frame applied
:rtype: Generator(om2.MDGContext)
"""
currentTime = om2Anim.MAnimControl.currentTime()
perFrame = om2.MTime(start, currentTime.unit)
for frame in range(start, end + 1):
context = om2.MDGContext(perFrame)
yield context
perFrame += 1
def compute(self, plug, data_block):
"""
Perform the computation.
"""
this_node = self.thisMObject()
if ((plug == VelocityNode.m_out_speed)
or (plug == VelocityNode.m_out_speed_text)
or (plug == VelocityNode.m_out_dummy_float)
or (plug == VelocityNode.m_out_dummy_string)):
# Get the translate plug creating the MDataHandle with a DG context.
point_plug = OpenMaya.MPlug(this_node, VelocityNode.m_input_point)
# Get Data Handles
time_handle = data_block.inputValue(VelocityNode.m_time)
time_interval_handle = data_block.inputValue(
VelocityNode.m_time_interval)
fps_handle = data_block.inputValue(
VelocityNode.m_frames_per_second)
precision_handle = data_block.inputValue(
VelocityNode.m_text_precision)
point_now_handle = data_block.inputValue(
VelocityNode.m_input_point)
# Get value
time = time_handle.asTime()
time_interval = time_interval_handle.asTime()
interval = time_interval.asUnits(OpenMaya.MTime.uiUnit()) * 2
fps = fps_handle.asDouble()
precision = precision_handle.asInt()
point_now = point_now_handle.asVector()
# Point at previous frame
dg_context_prev = OpenMaya.MDGContext(time - time_interval)
point_prev_handle = point_plug.asMDataHandle(dg_context_prev)
point_prev = point_prev_handle.asVector()
# Point at next frame
dg_context_next = OpenMaya.MDGContext(time + time_interval)
point_next_handle = point_plug.asMDataHandle(dg_context_next)
point_next = point_next_handle.asVector()
# Scene Scale
scale_handle = data_block.inputValue(VelocityNode.m_unit_scale)
scale_factor = 1.0
scale_index = scale_handle.asShort()
if scale_index == UNIT_SCALE_MILLIMETER_VALUE:
scale_factor = 0.001
elif scale_index == UNIT_SCALE_CENTIMETER_VALUE:
scale_factor = 0.01
elif scale_index == UNIT_SCALE_DECIMETER_VALUE:
scale_factor = 0.1
elif scale_index == UNIT_SCALE_METER_VALUE:
scale_factor = 1.0
elif scale_index == UNIT_SCALE_KILOMETER_VALUE:
scale_factor = 1000.0
# Display Unit
display_unit_handle = data_block.inputValue(
VelocityNode.m_display_unit)
display_unit_str = ""
display_unit_factor = 0.0
display_unit = display_unit_handle.asShort()
if display_unit == DISPLAY_UNIT_KM_PER_HOUR_VALUE:
display_unit_factor = fps * 60 * 60 * 0.001
display_unit_str = "km/h"
elif display_unit == DISPLAY_UNIT_MILES_PER_HOUR_VALUE:
display_unit_factor = fps * 60 * 60 * 0.000621371192
display_unit_str = "mph"
elif display_unit == DISPLAY_UNIT_METERS_PER_HOUR_VALUE:
display_unit_factor = fps * 60 * 60
display_unit_str = "m/h"
elif display_unit == DISPLAY_UNIT_METERS_PER_SECOND_VALUE:
display_unit_factor = fps
display_unit_str = "m/s"
elif display_unit == DISPLAY_UNIT_FEET_PER_HOUR_VALUE:
display_unit_factor = fps * 60 * 60 * 3.28084
display_unit_str = "ft/h"
elif display_unit == DISPLAY_UNIT_FEET_PER_SECOND_VALUE:
display_unit_factor = fps * 3.28084
display_unit_str = "ft/s"
# Distance
dx = point_now[0] - point_prev[0]
dy = point_now[1] - point_prev[1]
dz = point_now[2] - point_prev[2]
speed_raw = math.sqrt((dx * dx) + (dy * dy) + (dz * dz))
dx = point_now[0] - point_next[0]
dy = point_now[1] - point_next[1]
dz = point_now[2] - point_next[2]
speed_raw += math.sqrt((dx * dx) + (dy * dy) + (dz * dz))
speed = (speed_raw * scale_factor * display_unit_factor) / interval
speed_raw = speed_raw / interval
# Output Speed
out_speed_handle = data_block.outputValue(VelocityNode.m_out_speed)
out_speed_handle.setDouble(speed)
out_speed_handle.setClean()
# Output Speed Raw
out_speed_raw_handle = data_block.outputValue(
VelocityNode.m_out_speed_raw)
out_speed_raw_handle.setDouble(speed_raw)
out_speed_raw_handle.setClean()
# Output Speed String
speed_str = "{:" + str(precision) + "} " + display_unit_str
speed_str = speed_str.format(speed)
out_text_handle = data_block.outputValue(
VelocityNode.m_out_speed_text)
out_text_handle.setString(speed_str)
out_text_handle.setClean()
# Output Dummy attributes
out_dummy_float_handle = data_block.outputValue(
VelocityNode.m_out_dummy_float)
out_dummy_float_handle.setDouble(0.0)
out_dummy_float_handle.setClean()
# Output Speed String
out_dummy_string_handle = data_block.outputValue(
VelocityNode.m_out_dummy_string)
out_dummy_string_handle.setString('')
out_dummy_string_handle.setClean()
data_block.setClean(plug)
else:
return None
def prepareForDraw(self, objPath, cameraPath, frameContext, oldData):
## Retrieve data cache (create if does not exist)
data = oldData
if not isinstance(data, DrawNodeData):
data = DrawNodeData()
mtObj = self.getDepNode(str(objPath))
objMfn = OpenMaya.MFnDependencyNode(mtObj)
data.name = objMfn.findPlug('nodeName', False).asString()
data.startFrame = objMfn.findPlug('startTime', False).asInt()
data.endFrame = objMfn.findPlug('endTime', False).asInt()
thisNode = objPath.node()
timeBufferPlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.timeBuffer)
timeBuffer = timeBufferPlug.asInt()
modePlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.mode)
data.mode = modePlug.asInt()
relativePlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.isRelative)
data.isRelative = relativePlug.asBool()
keyFrames = []
if cmds.keyframe(data.name, q = True, tc = True):
keyFrames = list(set(cmds.keyframe(data.name, q = True, tc = True)))
keyFrames = [int(x) for x in keyFrames]
currentTime = OpenMayaAnim.MAnimControl.currentTime()
selectedNode = self.getDepNode(data.name)
fnThisNode = OpenMaya.MFnDependencyNode(selectedNode)
worldMatrixAttr = fnThisNode.attribute("worldMatrix")
pointPlug = OpenMaya.MPlug(selectedNode, worldMatrixAttr)
pointPlug = pointPlug.elementByLogicalIndex(0)
activeCam = util.getCam()
#check if translate attribute is changed
self.deleteCallbacks()
self.callbacks.append(OpenMayaAnim.MAnimMessage.addAnimKeyframeEditCheckCallback(self.keyFrameAddedCallback))
self.callbacks.append(OpenMayaAnim.MAnimMessage.addAnimKeyframeEditedCallback(self.keyFrameEditedCallback))
self.callbacks.append(OpenMaya.MEventMessage.addEventCallback('graphEditorChanged', self.graphEditorChangedCallback))
if not data.isRelative:
if not self.isPointCached or not self.allPoints.keys():
self.allPoints = {}
for i in range(data.startFrame, data.endFrame):
timeContext = OpenMaya.MDGContext(OpenMaya.MTime(i))
#Finally get the data
pointMMatrix = OpenMaya.MFnMatrixData(pointPlug.asMObject(timeContext)).matrix()
relativePoint = (pointMMatrix[12], pointMMatrix[13], pointMMatrix[14])
if i in keyFrames:
self.allPoints[i] = (relativePoint, 1)
else:
self.allPoints[i] = (relativePoint, 0)
self.isPointCached = True
else:
if not self.isPointCached or not self.allFramePoints.keys():
self.allFramePoints = {}
for currentFrame in range(data.startFrame, data.endFrame):
self.allFramePoints[currentFrame] = {}
for i in range(data.startFrame, data.endFrame):
timeContext = OpenMaya.MDGContext(OpenMaya.MTime(i))
#Finally get the data
pointMMatrix = OpenMaya.MFnMatrixData(pointPlug.asMObject(timeContext)).matrix()
relativePoint = util.makeCameraRelative(pointMMatrix, activeCam, i, currentFrame)
if i in keyFrames:
self.allFramePoints[currentFrame][i] = (relativePoint, 1)
else:
self.allFramePoints[currentFrame][i] = (relativePoint, 0)
points = {}
if not data.isRelative:
for i in range(int(currentTime.value - timeBuffer), int(currentTime.value + timeBuffer + 1)):
#Get matrix plug as MObject so we can get it's data.
try:
points[i] = self.allPoints[i]
except:
pass
else:
for i in range(int(currentTime.value - timeBuffer), int(currentTime.value + timeBuffer + 1)):
#Get matrix plug as MObject so we can get it's data.
try:
points[i] = self.allFramePoints[currentTime.value][i]
except:
pass
data.points = points
if not data.isRelative:
data.allPoints = self.allPoints
else:
try:
data.allPoints = self.allFramePoints[currentTime.value]
except:
pass
dotColorPlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.dotColor)
keyFrameColorPlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.keyFrameColor)
lineColorPlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.lineColor)
travelerColorPlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.travelerColor)
sizePlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.size)
keySizePlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.keySize)
lineWidthPlug = OpenMaya.MPlug(thisNode, DrawNodeDrawOverride.lineWidth)
dotColor = (dotColorPlug.child(0).asFloat(), dotColorPlug.child(1).asFloat(), dotColorPlug.child(2).asFloat(), 1.0)
keyFrameColor = (keyFrameColorPlug.child(0).asFloat(), keyFrameColorPlug.child(1).asFloat(), keyFrameColorPlug.child(2).asFloat(), 1.0)
lineColor = (lineColorPlug.child(0).asFloat(), lineColorPlug.child(1).asFloat(), lineColorPlug.child(2).asFloat(), 1.0)
travelerColor = (travelerColorPlug.child(0).asFloat(), travelerColorPlug.child(1).asFloat(), travelerColorPlug.child(2).asFloat(), 1.0)
data.dotColor = OpenMaya.MColor(dotColor)
data.lineColor = OpenMaya.MColor(lineColor)
data.travelerColor = OpenMaya.MColor(travelerColor)
data.keyFrameColor = OpenMaya.MColor(keyFrameColor)
allFrames = data.points.keys()
allFrames.sort()
#making dot absolute value
point = data.points[allFrames[0]][0]
sizeFactor = util.getDistance(point, activeCam)/1500
data.size = sizeFactor * round(sizePlug.asFloat(), 2)
data.keySize = sizeFactor * round(keySizePlug.asFloat(), 2)
data.lineWidth = round(lineWidthPlug.asFloat(), 2)
return data
