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
if plug != AngularScalarMath.outAngle:
return om2.kUnknownParameter
angle = dataBlock.inputValue(
AngularScalarMath.inAngle).asAngle().asDegrees()
scalar = dataBlock.inputValue(AngularScalarMath.inScalar).asDouble()
operation = dataBlock.inputValue(
AngularScalarMath.inOperation).asShort()
outAngleHandle = dataBlock.outputValue(AngularScalarMath.outAngle)
if operation == 0:
outAngleHandle.setMAngle(om2.MAngle(angle, om2.MAngle.kDegrees))
elif operation == 1:
outAngle = angle + scalar
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 2:
outAngle = angle - scalar
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 3:
outAngle = angle * scalar
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 4:
if scalar != 0.0:
outAngle = angle / scalar
else:
outAngle = 9999.999
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 5:
outAngle = math.pow(angle, scalar)
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 6:
outAngle = min(angle, scalar)
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 7:
outAngle = max(angle, scalar)
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
outAngleHandle.setClean()
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
if plug != DoubleToAngle.outAngle:
return om2.kUnknownParameter
double = dataBlock.inputValue(DoubleToAngle.inDouble).asDouble()
outAngleHandle = dataBlock.outputValue(DoubleToAngle.outAngle)
outAngleHandle.setMAngle(om2.MAngle(double, om2.MAngle.kDegrees))
outAngleHandle.setClean()
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
if plug != AngularTrigMath.outAngle:
return om2.kUnknownParameter
angle1 = dataBlock.inputValue(AngularTrigMath.inAngle1).asAngle()
operation = dataBlock.inputValue(AngularTrigMath.inOperation).asShort()
outAngleHandle = dataBlock.outputValue(AngularTrigMath.outAngle)
if operation == 0:
outAngleHandle.setMAngle(angle1)
elif operation == 1:
outAngle = math.cos(angle1.asRadians())
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 2:
outAngle = math.sin(angle1.asRadians())
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 3:
outAngle = math.tan(angle1.asRadians())
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kDegrees))
elif operation == 4:
resAngle = angle1.asDegrees()
if resAngle > 1.0:
resAngle = 1.0
elif resAngle < -1.0:
resAngle = -1.0
outAngle = math.acos(resAngle)
outAngleHandle.setMAngle(om2.MAngle(outAngle))
elif operation == 5:
resAngle = angle1.asDegrees()
if resAngle > 1.0:
resAngle = 1.0
elif resAngle < -1.0:
resAngle = -1.0
outAngle = math.asin(resAngle)
outAngleHandle.setMAngle(om2.MAngle(outAngle))
elif operation == 6:
outAngle = math.atan(angle1.asRadians())
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kRadians))
elif operation == 7:
angle2 = dataBlock.inputValue(AngularTrigMath.inAngle2).asAngle()
outAngle = math.atan2(angle1.asRadians(), angle2.asRadians())
outAngleHandle.setMAngle(om2.MAngle(outAngle, om2.MAngle.kRadians))
outAngleHandle.setClean()
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
if (plug != EulerScalarMath.outEuler
and plug != EulerScalarMath.outEulerX
and plug != EulerScalarMath.outEulerY
and plug != EulerScalarMath.outEulerZ):
return om2.kUnknownParameter
operation = dataBlock.inputValue(EulerScalarMath.inOperation).asShort()
euler = dataBlock.inputValue(EulerScalarMath.inEuler).asDouble3()
scalar = dataBlock.inputValue(EulerScalarMath.inScalar).asDouble()
eulerRotOder = dataBlock.inputValue(
EulerScalarMath.inEulerRotOrder).asShort()
outRotOrder = dataBlock.inputValue(
EulerScalarMath.inResRotOrder).asShort()
eEuler = om2.MEulerRotation(euler, eulerRotOder)
outEulerHandle = dataBlock.outputValue(EulerScalarMath.outEuler)
if operation == 0:
eEuler.reorderIt(outRotOrder)
outEulerHandle.set3Double(eEuler.x, eEuler.y, eEuler.z)
elif operation == 1:
eEuler.reorderIt(outRotOrder)
eScalar = om2.MEulerRotation(
om2.MAngle(scalar, om2.MAngle.kDegrees).asRadians(),
om2.MAngle(scalar, om2.MAngle.kDegrees).asRadians(),
om2.MAngle(scalar, om2.MAngle.kDegrees).asRadians(),
outRotOrder)
eOutEuler = eEuler + eScalar
outEulerHandle.set3Double(eOutEuler.x, eOutEuler.y, eOutEuler.z)
elif operation == 2:
eEuler.reorderIt(outRotOrder)
eScalar = om2.MEulerRotation(
om2.MAngle(scalar, om2.MAngle.kDegrees).asRadians(),
om2.MAngle(scalar, om2.MAngle.kDegrees).asRadians(),
om2.MAngle(scalar, om2.MAngle.kDegrees).asRadians(),
outRotOrder)
eOutEuler = eEuler - eScalar
outEulerHandle.set3Double(eOutEuler.x, eOutEuler.y, eOutEuler.z)
elif operation == 3:
eEuler.reorderIt(outRotOrder)
eOutEuler = eEuler * scalar
outEulerHandle.set3Double(eOutEuler.x, eOutEuler.y, eOutEuler.z)
outEulerHandle.setClean()
def getMRotFromNodeOutput(node_mob, rotOrder=om2.MEulerRotation.kXYZ):
"""
finds the angular output of the argument node and returns it
as a Euler rotation where that angle is the X element
:param node_mob: [MObject] the node to get the output port from
:param rotOrder: [int] the factory constant for the desired rotation order
the returned Euler rotation should be set to
:return: [MEulerRotation] the Euler rotation composition where the
angular output on the argument node is the X value
"""
mfn_dep = om2.MFnDependencyNode(node_mob)
angle = om2.MAngle(0.0)
if node_mob.hasFn(om2.MFn.kAnimBlend) and mfn_dep.hasAttribute(
_MAYA_OUTPUT_ATTRIBUTE_NAME):
plug = mfn_dep.findPlug(_MAYA_OUTPUT_ATTRIBUTE_NAME, False)
angle = plug.asMAngle()
rot = om2.MEulerRotation(angle.asRadians(), 0.0, 0.0, rotOrder)
return rot
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.
"""
rotation = dataBlock.inputValue(TwistExtractor.inRotation).asDouble3()
rotOrder = dataBlock.inputValue(
TwistExtractor.inRotationOrder).asShort()
eRoll = om2.MEulerRotation(rotation, rotOrder)
useUpObj = dataBlock.inputValue(TwistExtractor.inUseUpVec).asBool()
revTwist = dataBlock.inputValue(TwistExtractor.inInvTwist).asBool()
# Non flip ROO = XYZ
# Not working = XZY
twistOrder = om2.MEulerRotation.kXYZ
eRoll.reorderIt(twistOrder)
# Non-Roll orientation
mtxFn = om2.MTransformationMatrix()
mtxFn.rotateBy(eRoll, om2.MSpace.kWorld)
mRoll = mtxFn.asMatrix()
qNonRoll = om2.MQuaternion()
nAim = om2.MVector(mRoll[0], mRoll[1], mRoll[2])
nAim.normalize()
nAimAxis = om2.MVector.kXaxisVector
qAim = om2.MQuaternion(nAimAxis, nAim)
qNonRoll *= qAim
if useUpObj:
vUp = om2.MVector(
dataBlock.inputValue(TwistExtractor.inUpVec).asFloat3())
nNormal = vUp - ((vUp * nAim) * nAim)
nNormal.normalize()
nUp = om2.MVector.kYaxisVector.rotateBy(qAim)
angle = nUp.angle(nNormal)
qNormal = om2.MQuaternion(angle, nAim)
if not nNormal.isEquivalent(nUp.rotateBy(qNormal), 1.0e-5):
angle = 2.0 * kPI - angle
qNormal = om2.MQuaternion(angle, nAim)
qNonRoll *= qNormal
eNonRoll = qNonRoll.asEulerRotation()
eNonRoll = om2.MEulerRotation(eNonRoll.x, eNonRoll.y, eNonRoll.z,
twistOrder)
# Extract Twist from orientations
qRoll = eRoll.asQuaternion()
qExtract180 = qNonRoll * qRoll.inverse()
eExtract180 = qExtract180.asEulerRotation()
twist = -eExtract180.x
if revTwist:
twist *= -1.0
# Output Twist
if plug == TwistExtractor.outTwist:
outTwistHdle = dataBlock.outputValue(TwistExtractor.outTwist)
outTwistHdle.setMAngle(om2.MAngle(twist))
outTwistHdle.setClean()
# Output Twist Distribution
if plug == TwistExtractor.outTwistDist:
invDist = dataBlock.inputValue(TwistExtractor.inRevDist).asBool()
outTwistDistHdle = dataBlock.outputArrayValue(
TwistExtractor.outTwistDist)
outputs = len(outTwistDistHdle)
step = twist / (outputs - 1) if outputs > 1 else twist
outList = []
outList.extend(range(outputs))
if not invDist:
outList.reverse()
# pylint: disable=consider-using-enumerate
for i in range(len(outList)):
outTwistDistHdle.jumpToLogicalElement(i)
resultHdle = outTwistDistHdle.outputValue()
result = step * outList[i] if outputs > 1 else twist
resultHdle.setMAngle(om2.MAngle(result))
outTwistDistHdle.setAllClean()
return
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to QuadraticCurve class. Instances of QuadraticCurve will use these attributes to create plugs
for use in the compute() method.
"""
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
uAttr = om2.MFnUnitAttribute()
tAttr = om2.MFnTypedAttribute()
QuadraticCurve.inControlPoints = mAttr.create(
"controlPoints", "cp", om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
INPUT_ATTR(mAttr)
QuadraticCurve.inEnableTwist = nAttr.create(
"enableTwist", "etw", om2.MFnNumericData.kBoolean, False)
INPUT_ATTR(nAttr)
QuadraticCurve.inStartUpObj = mAttr.create(
"startUpObjectMatrix", "suom", om2.MFnMatrixAttribute.kFloat)
INPUT_ATTR(mAttr)
QuadraticCurve.inEndUpObj = mAttr.create("endUpObjectMatrix", "euom",
om2.MFnMatrixAttribute.kFloat)
INPUT_ATTR(mAttr)
QuadraticCurve.inLockLength = nAttr.create("lockLength", "locklen",
om2.MFnNumericData.kFloat,
0.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
QuadraticCurve.inRestLength = nAttr.create("restLength", "rlength",
om2.MFnNumericData.kFloat,
0.0)
nAttr.setMin(0.0)
INPUT_ATTR(nAttr)
QuadraticCurve.inSlide = nAttr.create("slide", "slide",
om2.MFnNumericData.kFloat, 0.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
QuadraticCurve.inPreferredAngle = uAttr.create(
"preferredAngle", "pangle", om2.MFnUnitAttribute.kAngle)
uAttr.setMin(0.0)
uAttr.setMax(om2.MAngle(360.0, om2.MAngle.kDegrees).asRadians())
INPUT_ATTR(uAttr)
QuadraticCurve.outTransforms = mAttr.create(
"outTransforms", "otrans", om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
OUTPUT_ATTR(mAttr)
QuadraticCurve.outCurve = tAttr.create("outCurve", "ocrv",
om2.MFnData.kNurbsCurve)
OUTPUT_ATTR(tAttr)
QuadraticCurve.addAttribute(QuadraticCurve.inControlPoints)
QuadraticCurve.addAttribute(QuadraticCurve.inEnableTwist)
QuadraticCurve.addAttribute(QuadraticCurve.inStartUpObj)
QuadraticCurve.addAttribute(QuadraticCurve.inEndUpObj)
QuadraticCurve.addAttribute(QuadraticCurve.inLockLength)
QuadraticCurve.addAttribute(QuadraticCurve.inRestLength)
QuadraticCurve.addAttribute(QuadraticCurve.inSlide)
QuadraticCurve.addAttribute(QuadraticCurve.inPreferredAngle)
QuadraticCurve.addAttribute(QuadraticCurve.outTransforms)
QuadraticCurve.addAttribute(QuadraticCurve.outCurve)
QuadraticCurve.attributeAffects(QuadraticCurve.inControlPoints,
QuadraticCurve.outCurve)
QuadraticCurve.attributeAffects(QuadraticCurve.inControlPoints,
QuadraticCurve.outTransforms)
QuadraticCurve.attributeAffects(QuadraticCurve.inEnableTwist,
QuadraticCurve.outTransforms)
QuadraticCurve.attributeAffects(QuadraticCurve.inStartUpObj,
QuadraticCurve.outTransforms)
QuadraticCurve.attributeAffects(QuadraticCurve.inEndUpObj,
QuadraticCurve.outTransforms)
QuadraticCurve.attributeAffects(QuadraticCurve.inLockLength,
QuadraticCurve.outTransforms)
QuadraticCurve.attributeAffects(QuadraticCurve.inRestLength,
QuadraticCurve.outTransforms)
QuadraticCurve.attributeAffects(QuadraticCurve.inSlide,
QuadraticCurve.outTransforms)
QuadraticCurve.attributeAffects(QuadraticCurve.inPreferredAngle,
QuadraticCurve.outTransforms)
