def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to MeshController class. Instances of MeshController will use these attributes to create plugs
for use in the compute() method.
"""
tAttr = om2.MFnTypedAttribute()
nAttr = om2.MFnNumericAttribute()
MeshController.inIndexList = tAttr.create("indexList", "index",
om2.MFnData.kString)
INPUT_ATTR(tAttr)
MeshController.inOffset = nAttr.create("offset", "offset",
om2.MFnNumericData.kFloat, 0.0)
INPUT_ATTR(nAttr)
MeshController.inMesh = tAttr.create("controlMesh", "controlMesh",
om2.MFnData.kMesh)
INPUT_ATTR(tAttr)
MeshController.inColor = nAttr.createColor("color", "color")
nAttr.default = (1.0, 0.455, 0.086)
INPUT_ATTR(nAttr)
MeshController.addAttribute(MeshController.inIndexList)
MeshController.addAttribute(MeshController.inOffset)
MeshController.addAttribute(MeshController.inMesh)
MeshController.addAttribute(MeshController.inColor)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to VectorToEuler class. Instances of VectorToEuler will use these attributes to create plugs
for use in the compute() method.
"""
uAttr = om2.MFnUnitAttribute()
nAttr = om2.MFnNumericAttribute()
VectorToEuler.inVector = nAttr.createPoint("vector", "vec")
INPUT_ATTR(nAttr)
VectorToEuler.outEulerX = uAttr.create("outEulerX", "oex",
om2.MFnUnitAttribute.kAngle,
0.0)
VectorToEuler.outEulerY = uAttr.create("outEulerY", "oey",
om2.MFnUnitAttribute.kAngle,
0.0)
VectorToEuler.outEulerZ = uAttr.create("outEulerZ", "oez",
om2.MFnUnitAttribute.kAngle,
0.0)
VectorToEuler.outEuler = nAttr.create("outEuler", "oe",
VectorToEuler.outEulerX,
VectorToEuler.outEulerY,
VectorToEuler.outEulerZ)
OUTPUT_ATTR(nAttr)
VectorToEuler.addAttribute(VectorToEuler.inVector)
VectorToEuler.addAttribute(VectorToEuler.outEuler)
VectorToEuler.attributeAffects(VectorToEuler.inVector,
VectorToEuler.outEuler)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to DistributeAlongSurface class. Instances of DistributeAlongSurface will use these attributes to create plugs
for use in the compute() method.
"""
tAttr = om2.MFnTypedAttribute()
nAttr = om2.MFnNumericAttribute()
uAttr = om2.MFnUnitAttribute()
FindParamFromLength.inCurve = tAttr.create("inputCurve", "icrv",
om2.MFnData.kNurbsCurve)
INPUT_ATTR(tAttr)
FindParamFromLength.inArcLength = uAttr.create(
"arcLength", "length", om2.MFnUnitAttribute.kDistance, 0.0)
INPUT_ATTR(uAttr)
FindParamFromLength.outParam = nAttr.create("outParam", "param",
om2.MFnNumericData.kFloat,
0.0)
OUTPUT_ATTR(nAttr)
FindParamFromLength.addAttribute(FindParamFromLength.inCurve)
FindParamFromLength.addAttribute(FindParamFromLength.inArcLength)
FindParamFromLength.addAttribute(FindParamFromLength.outParam)
FindParamFromLength.attributeAffects(FindParamFromLength.inCurve,
FindParamFromLength.outParam)
FindParamFromLength.attributeAffects(FindParamFromLength.inArcLength,
FindParamFromLength.outParam)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to DecomposeRowMatrix class. Instances of DecomposeRowMatrix will use these attributes to create plugs
for use in the compute() method.
"""
nAttr = om2.MFnNumericAttribute()
mAttr = om2.MFnMatrixAttribute()
DecomposeRowMatrix.inMatrix = mAttr.create(
"inputMatrix", "im", om2.MFnMatrixAttribute.kFloat)
INPUT_ATTR(mAttr)
DecomposeRowMatrix.inNormalizeOutput = nAttr.create(
"normalizeOutput", "no", om2.MFnNumericData.kBoolean, False)
INPUT_ATTR(nAttr)
DecomposeRowMatrix.outRow1 = nAttr.createPoint("row1", "r1")
OUTPUT_ATTR(nAttr)
DecomposeRowMatrix.outRow2 = nAttr.createPoint("row2", "r2")
OUTPUT_ATTR(nAttr)
DecomposeRowMatrix.outRow3 = nAttr.createPoint("row3", "r3")
OUTPUT_ATTR(nAttr)
DecomposeRowMatrix.outRow4 = nAttr.createPoint("row4", "r4")
OUTPUT_ATTR(nAttr)
DecomposeRowMatrix.addAttribute(DecomposeRowMatrix.inMatrix)
DecomposeRowMatrix.addAttribute(DecomposeRowMatrix.inNormalizeOutput)
DecomposeRowMatrix.addAttribute(DecomposeRowMatrix.outRow1)
DecomposeRowMatrix.addAttribute(DecomposeRowMatrix.outRow2)
DecomposeRowMatrix.addAttribute(DecomposeRowMatrix.outRow3)
DecomposeRowMatrix.addAttribute(DecomposeRowMatrix.outRow4)
DecomposeRowMatrix.attributeAffects(DecomposeRowMatrix.inMatrix,
DecomposeRowMatrix.outRow1)
DecomposeRowMatrix.attributeAffects(
DecomposeRowMatrix.inNormalizeOutput, DecomposeRowMatrix.outRow1)
DecomposeRowMatrix.attributeAffects(DecomposeRowMatrix.inMatrix,
DecomposeRowMatrix.outRow2)
DecomposeRowMatrix.attributeAffects(
DecomposeRowMatrix.inNormalizeOutput, DecomposeRowMatrix.outRow2)
DecomposeRowMatrix.attributeAffects(DecomposeRowMatrix.inMatrix,
DecomposeRowMatrix.outRow3)
DecomposeRowMatrix.attributeAffects(
DecomposeRowMatrix.inNormalizeOutput, DecomposeRowMatrix.outRow3)
DecomposeRowMatrix.attributeAffects(DecomposeRowMatrix.inMatrix,
DecomposeRowMatrix.outRow4)
DecomposeRowMatrix.attributeAffects(
DecomposeRowMatrix.inNormalizeOutput, DecomposeRowMatrix.outRow4)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to AngularScalarMath class. Instances of AngularScalarMath will use these attributes to create plugs
for use in the compute() method.
"""
uAttr = om2.MFnUnitAttribute()
nAttr = om2.MFnNumericAttribute()
eAttr = om2.MFnEnumAttribute()
AngularScalarMath.inAngle = uAttr.create("angle", "angle",
om2.MFnUnitAttribute.kAngle,
0.0)
INPUT_ATTR(uAttr)
AngularScalarMath.inScalar = nAttr.create("scalar", "scalar",
om2.MFnNumericData.kDouble,
0.0)
INPUT_ATTR(nAttr)
AngularScalarMath.inOperation = eAttr.create("operation", "operation",
0)
eAttr.addField("No Operation", 0)
eAttr.addField("Add", 1)
eAttr.addField("Subtract", 2)
eAttr.addField("Multiply", 3)
eAttr.addField("Divide", 4)
eAttr.addField("Power", 5)
eAttr.addField("Min", 6)
eAttr.addField("Max", 7)
INPUT_ATTR(eAttr)
AngularScalarMath.outAngle = uAttr.create("outAngle", "oa",
om2.MFnUnitAttribute.kAngle,
0.0)
OUTPUT_ATTR(uAttr)
AngularScalarMath.addAttribute(AngularScalarMath.inOperation)
AngularScalarMath.addAttribute(AngularScalarMath.inAngle)
AngularScalarMath.addAttribute(AngularScalarMath.inScalar)
AngularScalarMath.addAttribute(AngularScalarMath.outAngle)
AngularScalarMath.attributeAffects(AngularScalarMath.inAngle,
AngularScalarMath.outAngle)
AngularScalarMath.attributeAffects(AngularScalarMath.inScalar,
AngularScalarMath.outAngle)
AngularScalarMath.attributeAffects(AngularScalarMath.inOperation,
AngularScalarMath.outAngle)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to TestNode class. Instances of TestNode will use these attributes to create plugs
for use in the compute() method.
"""
nAttr = om2.MFnNumericAttribute()
TestNode.inAttr = nAttr.createPoint("inAttr", "ina")
INPUT_ATTR(nAttr)
TestNode.outAttr = nAttr.createPoint("outAttr", "outa")
OUTPUT_ATTR(nAttr)
TestNode.addAttribute(TestNode.inAttr)
TestNode.addAttribute(TestNode.outAttr)
TestNode.attributeAffects(TestNode.inAttr, TestNode.outAttr)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to DoubleToAngle class. Instances of DoubleToAngle will use these attributes to create plugs
for use in the compute() method.
"""
nAttr = om2.MFnNumericAttribute()
uAttr = om2.MFnUnitAttribute()
DoubleToAngle.inDouble = nAttr.create("double", "double",
om2.MFnNumericData.kDouble, 0.0)
INPUT_ATTR(nAttr)
DoubleToAngle.outAngle = uAttr.create("outAngle", "oa",
om2.MFnUnitAttribute.kAngle, 0.0)
OUTPUT_ATTR(uAttr)
DoubleToAngle.addAttribute(DoubleToAngle.inDouble)
DoubleToAngle.addAttribute(DoubleToAngle.outAngle)
DoubleToAngle.attributeAffects(DoubleToAngle.inDouble,
DoubleToAngle.outAngle)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to TestLocator class. Instances of TestLocator will use these attributes to create plugs
for use in the compute() method.
"""
nAttr = om2.MFnNumericAttribute()
TestLocator.inSize = nAttr.create("size", "size", om2.MFnNumericData.kDouble, 1.0)
INPUT_ATTR(nAttr)
TestLocator.inAttr = nAttr.createPoint("inAttr", "inAttr")
INPUT_ATTR(nAttr)
TestLocator.outAttr = nAttr.createPoint("outAttr", "outAttr")
OUTPUT_ATTR(nAttr)
TestLocator.addAttribute(TestLocator.inSize)
TestLocator.addAttribute(TestLocator.inAttr)
TestLocator.addAttribute(TestLocator.outAttr)
TestLocator.attributeAffects(TestLocator.inAttr, TestLocator.outAttr)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to DebugMatrix class. Instances of DebugMatrix will use these attributes to create plugs
for use in the compute() method.
"""
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
DebugMatrix.inMatrix = mAttr.create("matrixInput", "mtxi",
om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
mAttr.storable = False
mAttr.keyable = True
DebugMatrix.inNameColor = nAttr.createColor("nameColor", "nColor")
nAttr.default = (DebugMatrix.fNameColor.r, DebugMatrix.fNameColor.g,
DebugMatrix.fNameColor.b)
INPUT_ATTR(nAttr)
DebugMatrix.inMtxColor = nAttr.createColor("matrixColor", "mColor")
nAttr.default = (DebugMatrix.fMtxColor.r, DebugMatrix.fMtxColor.g,
DebugMatrix.fMtxColor.b)
INPUT_ATTR(nAttr)
DebugMatrix.inDistance = nAttr.create("distance", "dist",
om2.MFnNumericData.kFloat, 0.0)
INPUT_ATTR(nAttr)
DebugMatrix.inLineHeight = nAttr.create("lineHeight", "lHeight",
om2.MFnNumericData.kFloat, 0.7)
nAttr.setMin(0.001)
nAttr.setMax(2.0)
INPUT_ATTR(nAttr)
DebugMatrix.addAttribute(DebugMatrix.inMatrix)
DebugMatrix.addAttribute(DebugMatrix.inNameColor)
DebugMatrix.addAttribute(DebugMatrix.inMtxColor)
DebugMatrix.addAttribute(DebugMatrix.inDistance)
DebugMatrix.addAttribute(DebugMatrix.inLineHeight)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to DistributeAlongSurface class. Instances of DistributeAlongSurface will use these attributes to create plugs
for use in the compute() method.
"""
tAttr = om2.MFnTypedAttribute()
eAttr = om2.MFnEnumAttribute()
nAttr = om2.MFnNumericAttribute()
mAttr = om2.MFnMatrixAttribute()
DistributeAlongSurface.inSurface = tAttr.create("inputSurface", "isurf", om2.MFnData.kNurbsSurface)
INPUT_ATTR(tAttr)
DistributeAlongSurface.inDistributeAlong = eAttr.create("distributeAlong", "da", 0)
eAttr.addField("U", 0)
eAttr.addField("V", 1)
INPUT_ATTR(eAttr)
DistributeAlongSurface.inDisplace = nAttr.create("displaceTangent", "dtan", om2.MFnNumericData.kFloat, 0.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
DistributeAlongSurface.inAlwaysUniform = nAttr.create("alwaysUniform", "auni", om2.MFnNumericData.kBoolean, False)
INPUT_ATTR(nAttr)
DistributeAlongSurface.outTransform = mAttr.create("outputTransform", "ot", om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
OUTPUT_ATTR(mAttr)
DistributeAlongSurface.addAttribute(DistributeAlongSurface.inSurface)
DistributeAlongSurface.addAttribute(DistributeAlongSurface.inDistributeAlong)
DistributeAlongSurface.addAttribute(DistributeAlongSurface.inDisplace)
DistributeAlongSurface.addAttribute(DistributeAlongSurface.inAlwaysUniform)
DistributeAlongSurface.addAttribute(DistributeAlongSurface.outTransform)
DistributeAlongSurface.attributeAffects(DistributeAlongSurface.inSurface, DistributeAlongSurface.outTransform)
DistributeAlongSurface.attributeAffects(DistributeAlongSurface.inDistributeAlong, DistributeAlongSurface.outTransform)
DistributeAlongSurface.attributeAffects(DistributeAlongSurface.inDisplace, DistributeAlongSurface.outTransform)
DistributeAlongSurface.attributeAffects(DistributeAlongSurface.inAlwaysUniform, DistributeAlongSurface.outTransform)
def initialize(cls):
numeric_attr = om.MFnNumericAttribute()
cls.multiplier_obj = numeric_attr.create("multiplier", "mul",
om.MFnNumericData.kInt, 2)
numeric_attr.keyable = True
numeric_attr.readable = False
cls.multiplicand_obj = numeric_attr.create("multiplicand", "mulc",
om.MFnNumericData.kDouble,
0.0)
numeric_attr.keyable = True
numeric_attr.readable = False
cls.product_obj = numeric_attr.create("product", "prod",
om.MFnNumericData.kDouble, 0.0)
numeric_attr.writable = False
cls.addAttribute(cls.multiplier_obj)
cls.addAttribute(cls.multiplicand_obj)
cls.addAttribute(cls.product_obj)
cls.attributeAffects(cls.multiplier_obj, cls.product_obj)
cls.attributeAffects(cls.multiplicand_obj, cls.product_obj)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to EulerToVector class. Instances of EulerToVector will use these attributes to create plugs
for use in the compute() method.
"""
uAttr = om2.MFnUnitAttribute()
nAttr = om2.MFnNumericAttribute()
EulerToVector.inEulerX = uAttr.create("eulerX", "ex",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerToVector.inEulerY = uAttr.create("eulerY", "ey",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerToVector.inEulerZ = uAttr.create("eulerZ", "ez",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerToVector.inEuler = nAttr.create("euler", "e",
EulerToVector.inEulerX,
EulerToVector.inEulerY,
EulerToVector.inEulerZ)
INPUT_ATTR(nAttr)
EulerToVector.inToDegrees = nAttr.create("convertToDegrees", "todeg",
om2.MFnNumericData.kBoolean,
True)
INPUT_ATTR(nAttr)
EulerToVector.outVector = nAttr.createPoint("outVector", "ov")
OUTPUT_ATTR(nAttr)
EulerToVector.addAttribute(EulerToVector.inEuler)
EulerToVector.addAttribute(EulerToVector.inToDegrees)
EulerToVector.addAttribute(EulerToVector.outVector)
EulerToVector.attributeAffects(EulerToVector.inEuler,
EulerToVector.outVector)
EulerToVector.attributeAffects(EulerToVector.inToDegrees,
EulerToVector.outVector)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to SpaceConstraint class. Instances of SpaceConstraint will use these attributes to create plugs
for use in the compute() method.
"""
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
uAttr = om2.MFnUnitAttribute()
SpaceConstraint.inSpace = nAttr.create("space", "space",
om2.MFnNumericData.kShort, 0)
nAttr.setMin(0)
INPUT_ATTR(nAttr)
SpaceConstraint.inOffset = mAttr.create("offset", "offset",
om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
INPUT_ATTR(mAttr)
SpaceConstraint.inOffsetMatches = mAttr.create(
"offsetMatch", "offm", om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
INPUT_ATTR(mAttr)
SpaceConstraint.inTarget = mAttr.create("target", "target",
om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
INPUT_ATTR(mAttr)
SpaceConstraint.inAutoFillOff = nAttr.create(
"autoFillOffsets", "afoff", om2.MFnNumericData.kBoolean, True)
INPUT_ATTR(nAttr)
SpaceConstraint.inSpaceMatch = nAttr.create(
"spaceMatch", "spaceMatch", om2.MFnNumericData.kBoolean, True)
INPUT_ATTR(nAttr)
SpaceConstraint.outConstTrans = nAttr.createPoint(
"constraintTranslate", "ctrans")
OUTPUT_ATTR(nAttr)
rotX = uAttr.create("constraintRotateX", "crotx",
om2.MFnUnitAttribute.kAngle, 0.0)
rotY = uAttr.create("constraintRotateY", "croty",
om2.MFnUnitAttribute.kAngle, 0.0)
rotZ = uAttr.create("constraintRotateZ", "crotz",
om2.MFnUnitAttribute.kAngle, 0.0)
SpaceConstraint.outConstRot = nAttr.create("constraintRotate", "crot",
rotX, rotY, rotZ)
OUTPUT_ATTR(nAttr)
SpaceConstraint.outConstSca = nAttr.createPoint(
"constraintScale", "csca")
nAttr.default = (1.0, 1.0, 1.0)
OUTPUT_ATTR(nAttr)
SpaceConstraint.addAttribute(SpaceConstraint.inSpace)
SpaceConstraint.addAttribute(SpaceConstraint.inAutoFillOff)
SpaceConstraint.addAttribute(SpaceConstraint.inSpaceMatch)
SpaceConstraint.addAttribute(SpaceConstraint.inOffset)
SpaceConstraint.addAttribute(SpaceConstraint.inOffsetMatches)
SpaceConstraint.addAttribute(SpaceConstraint.inTarget)
SpaceConstraint.addAttribute(SpaceConstraint.outConstTrans)
SpaceConstraint.addAttribute(SpaceConstraint.outConstRot)
SpaceConstraint.addAttribute(SpaceConstraint.outConstSca)
SpaceConstraint.attributeAffects(SpaceConstraint.inSpace,
SpaceConstraint.outConstTrans)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffset,
SpaceConstraint.outConstTrans)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffsetMatches,
SpaceConstraint.outConstTrans)
SpaceConstraint.attributeAffects(SpaceConstraint.inTarget,
SpaceConstraint.outConstTrans)
SpaceConstraint.attributeAffects(SpaceConstraint.inSpace,
SpaceConstraint.outConstRot)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffset,
SpaceConstraint.outConstRot)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffsetMatches,
SpaceConstraint.outConstRot)
SpaceConstraint.attributeAffects(SpaceConstraint.inTarget,
SpaceConstraint.outConstRot)
SpaceConstraint.attributeAffects(SpaceConstraint.inSpace, rotX)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffset, rotX)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffsetMatches, rotX)
SpaceConstraint.attributeAffects(SpaceConstraint.inTarget, rotX)
SpaceConstraint.attributeAffects(SpaceConstraint.inSpace, rotY)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffset, rotY)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffsetMatches, rotY)
SpaceConstraint.attributeAffects(SpaceConstraint.inTarget, rotY)
SpaceConstraint.attributeAffects(SpaceConstraint.inSpace, rotZ)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffset, rotZ)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffsetMatches, rotZ)
SpaceConstraint.attributeAffects(SpaceConstraint.inTarget, rotZ)
SpaceConstraint.attributeAffects(SpaceConstraint.inSpace,
SpaceConstraint.outConstSca)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffset,
SpaceConstraint.outConstSca)
SpaceConstraint.attributeAffects(SpaceConstraint.inOffsetMatches,
SpaceConstraint.outConstSca)
SpaceConstraint.attributeAffects(SpaceConstraint.inTarget,
SpaceConstraint.outConstSca)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to PoleVectorConstraint class. Instances of PoleVectorConstraint will use these attributes to create plugs
for use in the compute() method.
"""
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
PoleVectorConstraint.inRootWMtx = mAttr.create(
"rootWorldMatrix", "rootm", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
PoleVectorConstraint.inTargetWMtx = mAttr.create(
"targetWorldMatrix", "tgtm", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
PoleVectorConstraint.inTargetWeight = nAttr.create(
"targetWeight", "tw", om2.MFnNumericData.kDouble, 1.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
PoleVectorConstraint.inConstParInvMtx = mAttr.create(
"constraintParentInverseMatrix", "cpim",
om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
PoleVectorConstraint.inRestPosition = nAttr.createPoint(
"restPosition", "rest")
nAttr.writable = True
nAttr.readable = True
nAttr.storable = True
nAttr.keyable = False
PoleVectorConstraint.inNormalizeOutput = nAttr.create(
"normalizeOutput", "normalize", om2.MFnNumericData.kBoolean, False)
INPUT_ATTR(nAttr)
PoleVectorConstraint.outConstraint = nAttr.createPoint(
"constraint", "const")
OUTPUT_ATTR(nAttr)
PoleVectorConstraint.addAttribute(PoleVectorConstraint.inRootWMtx)
PoleVectorConstraint.addAttribute(PoleVectorConstraint.inTargetWMtx)
PoleVectorConstraint.addAttribute(PoleVectorConstraint.inTargetWeight)
PoleVectorConstraint.addAttribute(
PoleVectorConstraint.inConstParInvMtx)
PoleVectorConstraint.addAttribute(PoleVectorConstraint.inRestPosition)
PoleVectorConstraint.addAttribute(
PoleVectorConstraint.inNormalizeOutput)
PoleVectorConstraint.addAttribute(PoleVectorConstraint.outConstraint)
PoleVectorConstraint.attributeAffects(
PoleVectorConstraint.inRootWMtx,
PoleVectorConstraint.outConstraint)
PoleVectorConstraint.attributeAffects(
PoleVectorConstraint.inTargetWMtx,
PoleVectorConstraint.outConstraint)
PoleVectorConstraint.attributeAffects(
PoleVectorConstraint.inTargetWeight,
PoleVectorConstraint.outConstraint)
PoleVectorConstraint.attributeAffects(
PoleVectorConstraint.inConstParInvMtx,
PoleVectorConstraint.outConstraint)
PoleVectorConstraint.attributeAffects(
PoleVectorConstraint.inRestPosition,
PoleVectorConstraint.outConstraint)
PoleVectorConstraint.attributeAffects(
PoleVectorConstraint.inNormalizeOutput,
PoleVectorConstraint.outConstraint)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to TwistExtractor class. Instances of TwistExtractor will use these attributes to create plugs
for use in the compute() method.
"""
uAttr = om2.MFnUnitAttribute()
nAttr = om2.MFnNumericAttribute()
eAttr = om2.MFnEnumAttribute()
rotX = uAttr.create("rotationX", "rotx", om2.MFnUnitAttribute.kAngle,
0.0)
rotY = uAttr.create("rotationY", "roty", om2.MFnUnitAttribute.kAngle,
0.0)
rotZ = uAttr.create("rotationZ", "rotz", om2.MFnUnitAttribute.kAngle,
0.0)
TwistExtractor.inRotation = nAttr.create("rotation", "rot", rotX, rotY,
rotZ)
INPUT_ATTR(nAttr)
TwistExtractor.inRotationOrder = eAttr.create("rotationOrder", "roo",
0)
# eAttr.addField("Twist First (zyx)", 5)
# eAttr.addField("Twist Last (xyz)", 0)
# INPUT_ATTR(eAttr)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
INPUT_ATTR(eAttr)
TwistExtractor.inUseUpVec = nAttr.create("useUpVector", "useup",
om2.MFnNumericData.kBoolean,
False)
INPUT_ATTR(nAttr)
TwistExtractor.inUpVec = nAttr.createPoint("upVector", "upVector")
nAttr.default = (0.0, 1.0, 0.0)
INPUT_ATTR(nAttr)
TwistExtractor.inInvTwist = nAttr.create("inverseTwist", "itwist",
om2.MFnNumericData.kBoolean,
False)
INPUT_ATTR(nAttr)
TwistExtractor.inRevDist = nAttr.create("reverseDistribution", "rdist",
om2.MFnNumericData.kBoolean,
False)
INPUT_ATTR(nAttr)
TwistExtractor.outTwist = uAttr.create("twist", "twist",
om2.MFnUnitAttribute.kAngle,
0.0)
OUTPUT_ATTR(uAttr)
TwistExtractor.outTwistDist = uAttr.create("twistDistribution",
"twistd",
om2.MFnUnitAttribute.kAngle,
0.0)
uAttr.array = True
OUTPUT_ATTR(uAttr)
TwistExtractor.addAttribute(TwistExtractor.inRotation)
TwistExtractor.addAttribute(TwistExtractor.inRotationOrder)
TwistExtractor.addAttribute(TwistExtractor.inUseUpVec)
TwistExtractor.addAttribute(TwistExtractor.inUpVec)
TwistExtractor.addAttribute(TwistExtractor.inInvTwist)
TwistExtractor.addAttribute(TwistExtractor.inRevDist)
TwistExtractor.addAttribute(TwistExtractor.outTwist)
TwistExtractor.addAttribute(TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(rotX, TwistExtractor.outTwist)
TwistExtractor.attributeAffects(rotY, TwistExtractor.outTwist)
TwistExtractor.attributeAffects(rotZ, TwistExtractor.outTwist)
TwistExtractor.attributeAffects(TwistExtractor.inRotationOrder,
TwistExtractor.outTwist)
TwistExtractor.attributeAffects(TwistExtractor.inUseUpVec,
TwistExtractor.outTwist)
TwistExtractor.attributeAffects(TwistExtractor.inUpVec,
TwistExtractor.outTwist)
TwistExtractor.attributeAffects(TwistExtractor.inInvTwist,
TwistExtractor.outTwist)
TwistExtractor.attributeAffects(rotX, TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(rotY, TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(rotZ, TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(TwistExtractor.inRotationOrder,
TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(TwistExtractor.inUseUpVec,
TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(TwistExtractor.inUpVec,
TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(TwistExtractor.inInvTwist,
TwistExtractor.outTwistDist)
TwistExtractor.attributeAffects(TwistExtractor.inRevDist,
TwistExtractor.outTwistDist)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to DebugVector class. Instances of DebugVector will use these attributes to create plugs
for use in the compute() method.
"""
eAttr = om2.MFnEnumAttribute()
nAttr = om2.MFnNumericAttribute()
DebugVector.inLineWidth = nAttr.create("lineWidth", "lw",
om2.MFnNumericData.kFloat, 3.0)
nAttr.setMin(1.0)
nAttr.setSoftMax(5.0)
INPUT_ATTR(nAttr)
DebugVector.inColor = nAttr.createColor("color", "color")
nAttr.default = (1.0, 1.0, 0.0)
INPUT_ATTR(nAttr)
DebugVector.inTipSize = nAttr.create("tipSize", "tipSize",
om2.MFnNumericData.kFloat, 0.1)
nAttr.setMin(0.1)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
DebugVector.inSubdivisions = nAttr.create("subdivisions", "subd",
om2.MFnNumericData.kInt, 4)
nAttr.setMin(2)
nAttr.setMax(12)
INPUT_ATTR(nAttr)
DebugVector.inRadius = nAttr.create("radius", "radius",
om2.MFnNumericData.kFloat, 1.0)
nAttr.setMin(0.0)
nAttr.setSoftMax(5.0)
INPUT_ATTR(nAttr)
DebugVector.inXRay = nAttr.create("XRay", "xray",
om2.MFnNumericData.kBoolean, False)
INPUT_ATTR(nAttr)
DebugVector.inDashed = nAttr.create("dashed", "dashed",
om2.MFnNumericData.kBoolean, False)
INPUT_ATTR(nAttr)
DebugVector.inOperation = eAttr.create("operation", "op", 0)
eAttr.addField("No Operation", 0)
eAttr.addField("Add", 1)
eAttr.addField("Subtract", 2)
eAttr.addField("Cross Product", 3)
eAttr.addField("Vector Project", 4)
INPUT_ATTR(eAttr)
DebugVector.inVec1 = nAttr.createPoint("vector1", "v1")
INPUT_ATTR(nAttr)
DebugVector.inVec2 = nAttr.createPoint("vector2", "v2")
INPUT_ATTR(nAttr)
DebugVector.inNormalize = nAttr.create("normalizeOutput", "no",
om2.MFnNumericData.kBoolean,
False)
INPUT_ATTR(nAttr)
DebugVector.outVector = nAttr.createPoint("outVector", "ov")
OUTPUT_ATTR(nAttr)
DebugVector.addAttribute(DebugVector.inLineWidth)
DebugVector.addAttribute(DebugVector.inColor)
DebugVector.addAttribute(DebugVector.inTipSize)
DebugVector.addAttribute(DebugVector.inSubdivisions)
DebugVector.addAttribute(DebugVector.inRadius)
DebugVector.addAttribute(DebugVector.inXRay)
DebugVector.addAttribute(DebugVector.inDashed)
DebugVector.addAttribute(DebugVector.inOperation)
DebugVector.addAttribute(DebugVector.inVec1)
DebugVector.addAttribute(DebugVector.inVec2)
DebugVector.addAttribute(DebugVector.inNormalize)
DebugVector.addAttribute(DebugVector.outVector)
DebugVector.attributeAffects(DebugVector.inOperation,
DebugVector.outVector)
DebugVector.attributeAffects(DebugVector.inVec1, DebugVector.outVector)
DebugVector.attributeAffects(DebugVector.inVec2, DebugVector.outVector)
DebugVector.attributeAffects(DebugVector.inNormalize,
DebugVector.outVector)
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)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to BlendTransform class. Instances of BlendTransform will use these attributes to create plugs
for use in the compute() method.
"""
nAttr = om2.MFnNumericAttribute()
uAttr = om2.MFnUnitAttribute()
cAttr = om2.MFnCompoundAttribute()
eAttr = om2.MFnEnumAttribute()
BlendTransform.inBlender = nAttr.create("blender", "blender",
om2.MFnNumericData.kFloat, 0.5)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
BlendTransform.inRotInterp = eAttr.create("rotationInterpolation",
"roti", 0)
eAttr.addField("Euler Lerp", 0)
eAttr.addField("Quaternion Slerp", 1)
INPUT_ATTR(eAttr)
BlendTransform.inTrans1 = nAttr.createPoint("translate1", "t1")
nAttr.array = True
INPUT_ATTR(nAttr)
rot1X = uAttr.create("rotate1X", "ro1x", om2.MFnUnitAttribute.kAngle,
0.0)
rot1Y = uAttr.create("rotate1Y", "ro1y", om2.MFnUnitAttribute.kAngle,
0.0)
rot1Z = uAttr.create("rotate1Z", "ro1z", om2.MFnUnitAttribute.kAngle,
0.0)
BlendTransform.inRot1 = nAttr.create("rotate1", "ro1", rot1X, rot1Y,
rot1Z)
nAttr.array = True
INPUT_ATTR(nAttr)
BlendTransform.inSca1 = nAttr.createPoint("scale1", "sca1")
nAttr.array = True
INPUT_ATTR(nAttr)
BlendTransform.inRot1Order = eAttr.create("rotateOrder1", "rro1", 0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
eAttr.array = True
INPUT_ATTR(eAttr)
BlendTransform.inTransform1 = cAttr.create("transform1", "tr1")
cAttr.addChild(BlendTransform.inTrans1)
cAttr.addChild(BlendTransform.inRot1)
cAttr.addChild(BlendTransform.inSca1)
cAttr.addChild(BlendTransform.inRot1Order)
BlendTransform.inTrans2 = nAttr.createPoint("translate2", "t2")
nAttr.array = True
INPUT_ATTR(nAttr)
rot2X = uAttr.create("rotate2X", "ro2x", om2.MFnUnitAttribute.kAngle,
0.0)
rot2Y = uAttr.create("rotate2Y", "ro2y", om2.MFnUnitAttribute.kAngle,
0.0)
rot2Z = uAttr.create("rotate2Z", "ro2z", om2.MFnUnitAttribute.kAngle,
0.0)
BlendTransform.inRot2 = nAttr.create("rotate2", "ro2", rot2X, rot2Y,
rot2Z)
nAttr.array = True
INPUT_ATTR(nAttr)
BlendTransform.inSca2 = nAttr.createPoint("scale2", "sca2")
nAttr.array = True
INPUT_ATTR(nAttr)
BlendTransform.inRot2Order = eAttr.create("rotateOrder2", "rro2", 0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
eAttr.array = True
INPUT_ATTR(eAttr)
BlendTransform.inTransform2 = cAttr.create("transform2", "tr2")
cAttr.addChild(BlendTransform.inTrans2)
cAttr.addChild(BlendTransform.inRot2)
cAttr.addChild(BlendTransform.inSca2)
cAttr.addChild(BlendTransform.inRot2Order)
BlendTransform.inOutRotOrder = eAttr.create("outRotateOrder", "orro",
0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
eAttr.array = True
INPUT_ATTR(eAttr)
BlendTransform.outTrans = nAttr.createPoint("outTranslate", "ot")
nAttr.array = True
OUTPUT_ATTR(nAttr)
oRotX = uAttr.create("outRotateX", "orox", om2.MFnUnitAttribute.kAngle,
0.0)
oRotY = uAttr.create("outRotateY", "oroy", om2.MFnUnitAttribute.kAngle,
0.0)
oRotZ = uAttr.create("outRotateZ", "oroz", om2.MFnUnitAttribute.kAngle,
0.0)
BlendTransform.outRot = nAttr.create("outRotate", "oro", oRotX, oRotY,
oRotZ)
nAttr.array = True
OUTPUT_ATTR(nAttr)
BlendTransform.outSca = nAttr.createPoint("outScale", "osca")
nAttr.array = True
OUTPUT_ATTR(nAttr)
BlendTransform.outVis = nAttr.create("visibility", "vis",
om2.MFnNumericData.kBoolean, True)
OUTPUT_ATTR(nAttr)
BlendTransform.outRevVis = nAttr.create("reverseVisibility", "rvis",
om2.MFnNumericData.kBoolean,
False)
OUTPUT_ATTR(nAttr)
BlendTransform.addAttribute(BlendTransform.inBlender)
BlendTransform.addAttribute(BlendTransform.inRotInterp)
BlendTransform.addAttribute(BlendTransform.inTransform1)
BlendTransform.addAttribute(BlendTransform.inTransform2)
BlendTransform.addAttribute(BlendTransform.inOutRotOrder)
BlendTransform.addAttribute(BlendTransform.outTrans)
BlendTransform.addAttribute(BlendTransform.outRot)
BlendTransform.addAttribute(BlendTransform.outSca)
BlendTransform.addAttribute(BlendTransform.outVis)
BlendTransform.addAttribute(BlendTransform.outRevVis)
BlendTransform.attributeAffects(BlendTransform.inBlender,
BlendTransform.outTrans)
BlendTransform.attributeAffects(BlendTransform.inTrans1,
BlendTransform.outTrans)
BlendTransform.attributeAffects(BlendTransform.inTrans2,
BlendTransform.outTrans)
BlendTransform.attributeAffects(BlendTransform.inBlender,
BlendTransform.outRot)
BlendTransform.attributeAffects(BlendTransform.inRotInterp,
BlendTransform.outRot)
BlendTransform.attributeAffects(BlendTransform.inRot1,
BlendTransform.outRot)
BlendTransform.attributeAffects(BlendTransform.inRot1Order,
BlendTransform.outRot)
BlendTransform.attributeAffects(BlendTransform.inRot2,
BlendTransform.outRot)
BlendTransform.attributeAffects(BlendTransform.inRot2Order,
BlendTransform.outRot)
BlendTransform.attributeAffects(BlendTransform.inOutRotOrder,
BlendTransform.outRot)
BlendTransform.attributeAffects(BlendTransform.inBlender,
BlendTransform.outSca)
BlendTransform.attributeAffects(BlendTransform.inSca1,
BlendTransform.outSca)
BlendTransform.attributeAffects(BlendTransform.inSca2,
BlendTransform.outSca)
BlendTransform.attributeAffects(BlendTransform.inBlender,
BlendTransform.outVis)
BlendTransform.attributeAffects(BlendTransform.inBlender,
BlendTransform.outRevVis)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to ParentConstraint class. Instances of ParentConstraint will use these attributes to create plugs
for use in the compute() method.
"""
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
uAttr = om2.MFnUnitAttribute()
eAttr = om2.MFnEnumAttribute()
cAttr = om2.MFnCompoundAttribute()
constJntOriX = uAttr.create("constraintJointOrientX", "cjorx",
om2.MFnUnitAttribute.kAngle, 0.0)
constJntOriY = uAttr.create("constraintJointOrientY", "cjory",
om2.MFnUnitAttribute.kAngle, 0.0)
constJntOriZ = uAttr.create("constraintJointOrientZ", "cjorz",
om2.MFnUnitAttribute.kAngle, 0.0)
ParentConstraint.inConstraintJntOri = nAttr.create(
"constraintJointOrient", "cjor", constJntOriX, constJntOriY,
constJntOriZ)
INPUT_ATTR(nAttr)
ParentConstraint.inConstraintRotOrder = eAttr.create(
"constraintRotateOrder", "croo", 0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
INPUT_ATTR(eAttr)
ParentConstraint.inConstraintParInvMtx = mAttr.create(
"constraintParentInverseMatrix", "cpim",
om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
ParentConstraint.inConstraintParSca = nAttr.createPoint(
"constraintParentScale", "cps")
nAttr.default = (1.0, 1.0, 1.0)
INPUT_ATTR(nAttr)
ParentConstraint.inTargetWorldMatrix = mAttr.create(
"targetWorldMatrix", "twmtx", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
ParentConstraint.inTargetOffset = mAttr.create(
"targetOffset", "toff", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
# targetJntOriX = uAttr.create("targetJointOrientX", "tjorx", om2.MFnUnitAttribute.kAngle, 0.0)
# targetJntOriY = uAttr.create("targetJointOrientY", "tjory", om2.MFnUnitAttribute.kAngle, 0.0)
# targetJntOriZ = uAttr.create("targetJointOrientZ", "tjorz", om2.MFnUnitAttribute.kAngle, 0.0)
# ParentConstraint.inTargetJntOri = nAttr.create("targetJointOrient", "tjor", targetJntOriX, targetJntOriY, targetJntOriZ)
# INPUT_ATTR(nAttr)
# ParentConstraint.inTargetRotOrder = eAttr.create("targetRotateOrder", "troo", 0)
# eAttr.addField("xyz", 0)
# eAttr.addField("yzx", 1)
# eAttr.addField("zxy", 2)
# eAttr.addField("xzy", 3)
# eAttr.addField("yxz", 4)
# eAttr.addField("zyx", 5)
# INPUT_ATTR(eAttr)
ParentConstraint.inTargetWeight = nAttr.create(
"targetWeight", "twght", om2.MFnNumericData.kFloat, 1.0)
INPUT_ATTR(nAttr)
ParentConstraint.inTargetList = cAttr.create("targetList", "tlist")
cAttr.addChild(ParentConstraint.inTargetWorldMatrix)
cAttr.addChild(ParentConstraint.inTargetOffset)
# cAttr.addChild(ParentConstraint.inTargetJntOri)
# cAttr.addChild(ParentConstraint.inTargetRotOrder)
cAttr.addChild(ParentConstraint.inTargetWeight)
cAttr.array = True
ParentConstraint.outConstTrans = nAttr.createPoint(
"constraintTranslate", "ctrans")
OUTPUT_ATTR(nAttr)
outConstRotX = uAttr.create("constraintRotateX", "crox",
om2.MFnUnitAttribute.kAngle, 0.0)
outConstRotY = uAttr.create("constraintRotateY", "croy",
om2.MFnUnitAttribute.kAngle, 0.0)
outConstRotZ = uAttr.create("constraintRotateZ", "croz",
om2.MFnUnitAttribute.kAngle, 0.0)
ParentConstraint.outConstRot = nAttr.create("constraintRotate", "cro",
outConstRotX, outConstRotY,
outConstRotZ)
OUTPUT_ATTR(nAttr)
ParentConstraint.outConstSca = nAttr.createPoint(
"constraintScale", "csca")
nAttr.default = (1.0, 1.0, 1.0)
OUTPUT_ATTR(nAttr)
ParentConstraint.addAttribute(ParentConstraint.inConstraintJntOri)
ParentConstraint.addAttribute(ParentConstraint.inConstraintRotOrder)
ParentConstraint.addAttribute(ParentConstraint.inConstraintParInvMtx)
ParentConstraint.addAttribute(ParentConstraint.inConstraintParSca)
ParentConstraint.addAttribute(ParentConstraint.inTargetList)
ParentConstraint.addAttribute(ParentConstraint.outConstTrans)
ParentConstraint.addAttribute(ParentConstraint.outConstRot)
ParentConstraint.addAttribute(ParentConstraint.outConstSca)
ParentConstraint.attributeAffects(ParentConstraint.inConstraintJntOri,
ParentConstraint.outConstTrans)
ParentConstraint.attributeAffects(
ParentConstraint.inConstraintRotOrder,
ParentConstraint.outConstTrans)
ParentConstraint.attributeAffects(
ParentConstraint.inConstraintParInvMtx,
ParentConstraint.outConstTrans)
ParentConstraint.attributeAffects(ParentConstraint.inConstraintParSca,
ParentConstraint.outConstTrans)
ParentConstraint.attributeAffects(ParentConstraint.inTargetWorldMatrix,
ParentConstraint.outConstTrans)
ParentConstraint.attributeAffects(ParentConstraint.inTargetOffset,
ParentConstraint.outConstTrans)
# ParentConstraint.attributeAffects(ParentConstraint.inTargetJntOri, ParentConstraint.outConstTrans)
# ParentConstraint.attributeAffects(ParentConstraint.inTargetRotOrder, ParentConstraint.outConstTrans)
ParentConstraint.attributeAffects(ParentConstraint.inTargetWeight,
ParentConstraint.outConstTrans)
ParentConstraint.attributeAffects(ParentConstraint.inConstraintJntOri,
ParentConstraint.outConstRot)
ParentConstraint.attributeAffects(
ParentConstraint.inConstraintRotOrder,
ParentConstraint.outConstRot)
ParentConstraint.attributeAffects(
ParentConstraint.inConstraintParInvMtx,
ParentConstraint.outConstRot)
ParentConstraint.attributeAffects(ParentConstraint.inConstraintParSca,
ParentConstraint.outConstRot)
ParentConstraint.attributeAffects(ParentConstraint.inTargetWorldMatrix,
ParentConstraint.outConstRot)
ParentConstraint.attributeAffects(ParentConstraint.inTargetOffset,
ParentConstraint.outConstRot)
# ParentConstraint.attributeAffects(ParentConstraint.inTargetJntOri, ParentConstraint.outConstRot)
# ParentConstraint.attributeAffects(ParentConstraint.inTargetRotOrder, ParentConstraint.outConstRot)
ParentConstraint.attributeAffects(ParentConstraint.inTargetWeight,
ParentConstraint.outConstRot)
ParentConstraint.attributeAffects(ParentConstraint.inConstraintJntOri,
ParentConstraint.outConstSca)
ParentConstraint.attributeAffects(
ParentConstraint.inConstraintRotOrder,
ParentConstraint.outConstSca)
ParentConstraint.attributeAffects(
ParentConstraint.inConstraintParInvMtx,
ParentConstraint.outConstSca)
ParentConstraint.attributeAffects(ParentConstraint.inConstraintParSca,
ParentConstraint.outConstSca)
ParentConstraint.attributeAffects(ParentConstraint.inTargetWorldMatrix,
ParentConstraint.outConstSca)
ParentConstraint.attributeAffects(ParentConstraint.inTargetOffset,
ParentConstraint.outConstSca)
# ParentConstraint.attributeAffects(ParentConstraint.inTargetJntOri, ParentConstraint.outConstSca)
# ParentConstraint.attributeAffects(ParentConstraint.inTargetRotOrder, ParentConstraint.outConstSca)
ParentConstraint.attributeAffects(ParentConstraint.inTargetWeight,
ParentConstraint.outConstSca)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to IKVChain class. Instances of IKVChain will use these attributes to create plugs
for use in the compute() method.
"""
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
rAttr = om2.MRampAttribute()
VectorAnglePSD.inBase = mAttr.create("base", "base",
om2.MFnMatrixAttribute.kFloat)
INPUT_ATTR(mAttr)
VectorAnglePSD.inSource = mAttr.create("source", "source",
om2.MFnMatrixAttribute.kFloat)
INPUT_ATTR(mAttr)
VectorAnglePSD.inTarget = mAttr.create("target", "target",
om2.MFnMatrixAttribute.kFloat)
mAttr.array = True
INPUT_ATTR(mAttr)
VectorAnglePSD.inTargetEnvelope = nAttr.create(
"targetEnvelope", "te", om2.MFnNumericData.kFloat, 1.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
nAttr.array = True
INPUT_ATTR(nAttr)
VectorAnglePSD.inTargetFalloff = nAttr.create(
"targetFalloff", "tf", om2.MFnNumericData.kFloat, 90.0)
nAttr.setMin(0.0)
nAttr.setMax(180.0)
nAttr.array = True
INPUT_ATTR(nAttr)
VectorAnglePSD.inRampWeights = rAttr.createCurveRamp(
"rampWeights", "rw")
VectorAnglePSD.outWeights = nAttr.create("outWeights", "ow",
om2.MFnNumericData.kFloat,
0.0)
nAttr.array = True
OUTPUT_ATTR(nAttr)
VectorAnglePSD.addAttribute(VectorAnglePSD.inBase)
VectorAnglePSD.addAttribute(VectorAnglePSD.inSource)
VectorAnglePSD.addAttribute(VectorAnglePSD.inTarget)
VectorAnglePSD.addAttribute(VectorAnglePSD.inTargetEnvelope)
VectorAnglePSD.addAttribute(VectorAnglePSD.inTargetFalloff)
VectorAnglePSD.addAttribute(VectorAnglePSD.inRampWeights)
VectorAnglePSD.addAttribute(VectorAnglePSD.outWeights)
VectorAnglePSD.attributeAffects(VectorAnglePSD.inBase,
VectorAnglePSD.outWeights)
VectorAnglePSD.attributeAffects(VectorAnglePSD.inSource,
VectorAnglePSD.outWeights)
VectorAnglePSD.attributeAffects(VectorAnglePSD.inTarget,
VectorAnglePSD.outWeights)
VectorAnglePSD.attributeAffects(VectorAnglePSD.inTargetEnvelope,
VectorAnglePSD.outWeights)
VectorAnglePSD.attributeAffects(VectorAnglePSD.inTargetFalloff,
VectorAnglePSD.outWeights)
VectorAnglePSD.attributeAffects(VectorAnglePSD.inRampWeights,
VectorAnglePSD.outWeights)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to IKVChainSolver class. Instances of IKVChainSolver will use these attributes to create plugs
for use in the compute() method.
"""
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
eAttr = om2.MFnEnumAttribute()
uAttr = om2.MFnUnitAttribute()
IKVChainSolver.inRoot = mAttr.create("root", "root",
om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
IKVChainSolver.inHandle = mAttr.create("handle", "handle",
om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
IKVChainSolver.inPoleVector = mAttr.create(
"poleVector", "pole", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
offX = uAttr.create("offsetX", "offx", om2.MFnUnitAttribute.kAngle,
0.0)
offY = uAttr.create("offsetY", "offy", om2.MFnUnitAttribute.kAngle,
0.0)
offZ = uAttr.create("offsetZ", "offz", om2.MFnUnitAttribute.kAngle,
0.0)
IKVChainSolver.inOffset = nAttr.create("offset", "off", offX, offY,
offZ)
nAttr.array = True
INPUT_ATTR(nAttr)
jntOriX = uAttr.create("jointOrientX", "jox",
om2.MFnUnitAttribute.kAngle, 0.0)
jntOriY = uAttr.create("jointOrientY", "joy",
om2.MFnUnitAttribute.kAngle, 0.0)
jntOriZ = uAttr.create("jointOrientZ", "joz",
om2.MFnUnitAttribute.kAngle, 0.0)
IKVChainSolver.inJntOri = nAttr.create("jointOrient", "jo", jntOriX,
jntOriY, jntOriZ)
nAttr.array = True
INPUT_ATTR(nAttr)
IKVChainSolver.inParInvMtx = mAttr.create(
"parentInverseMatrix", "pim", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
IKVChainSolver.inRestLenStart = nAttr.create("restLengthStart", "rls",
om2.MFnNumericData.kFloat,
1.0)
# nAttr.setMin(0.001)
INPUT_ATTR(nAttr)
nAttr.channelBox = True
IKVChainSolver.inRestLenEnd = nAttr.create("restLengthEnd", "rle",
om2.MFnNumericData.kFloat,
1.0)
# nAttr.setMin(0.001)
INPUT_ATTR(nAttr)
nAttr.channelBox = True
IKVChainSolver.inPreferredAngle = uAttr.create(
"preferredAngle", "pa", om2.MFnUnitAttribute.kAngle, 0.0)
uAttr.setMin(0.0)
uAttr.setMax(2.0 * math.pi)
INPUT_ATTR(uAttr)
uAttr.channelBox = True
IKVChainSolver.inTwist = uAttr.create("twist", "twist",
om2.MFnUnitAttribute.kAngle, 0.0)
INPUT_ATTR(uAttr)
IKVChainSolver.inPvMode = eAttr.create("pvMode", "pvm", 0)
eAttr.addField("Manual", 0)
eAttr.addField("Auto", 1)
INPUT_ATTR(eAttr)
IKVChainSolver.inHierarchyMode = nAttr.create(
"hierarchyMode", "hm", om2.MFnNumericData.kBoolean, True)
INPUT_ATTR(nAttr)
IKVChainSolver.inFlip = nAttr.create("flipOrientation", "fori",
om2.MFnNumericData.kBoolean,
False)
INPUT_ATTR(nAttr)
nAttr.channelBox = True
IKVChainSolver.inUseScale = nAttr.create("useStretchAsScale", "usca",
om2.MFnNumericData.kBoolean,
False)
INPUT_ATTR(nAttr)
IKVChainSolver.inCompressionLimit = nAttr.create(
"compressionLimit", "cl", om2.MFnNumericData.kFloat, 0.1)
nAttr.setMin(0.001)
nAttr.setMax(0.4)
INPUT_ATTR(nAttr)
IKVChainSolver.inSnapUpVector = nAttr.create("snapUpVector", "supv",
om2.MFnNumericData.kFloat,
0.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
IKVChainSolver.inSnap = mAttr.create("snap", "snap",
om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
IKVChainSolver.inSoftness = nAttr.create("softness", "soft",
om2.MFnNumericData.kFloat,
0.0)
nAttr.setMin(0.0)
nAttr.setSoftMax(0.2)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
IKVChainSolver.inStretch = nAttr.create("stretch", "st",
om2.MFnNumericData.kDouble,
0.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
IKVChainSolver.inClampStretch = nAttr.create(
"clampStretch", "cst", om2.MFnNumericData.kDouble, 0.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
IKVChainSolver.inClampValue = nAttr.create("clampValue", "cstv",
om2.MFnNumericData.kDouble,
1.5)
nAttr.setMin(1.0)
nAttr.setSoftMax(1.8)
INPUT_ATTR(nAttr)
# IKVChainSolver.inStretchMultStart = nAttr.create("stretchMultStart", "stms", om2.MFnNumericData.kFloat, 1.0)
# nAttr.setMin(0.001)
# INPUT_ATTR(nAttr)
# IKVChainSolver.inStretchMultEnd = nAttr.create("stretchMultEnd", "stme", om2.MFnNumericData.kFloat, 1.0)
# nAttr.setMin(0.001)
# INPUT_ATTR(nAttr)
IKVChainSolver.inSquash = nAttr.create("squash", "sq",
om2.MFnNumericData.kDouble, 0.0)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
startSqX = nAttr.create("squashMultStartX", "sqmsx",
om2.MFnNumericData.kFloat, 1.0)
startSqY = nAttr.create("squashMultStartY", "sqmsy",
om2.MFnNumericData.kFloat, 1.0)
IKVChainSolver.inSquashMultStart = nAttr.create(
"squashMultStart", "sqms", startSqX, startSqY)
nAttr.setMin([0.001, 0.001])
INPUT_ATTR(nAttr)
endSqX = nAttr.create("squashMultEndX", "sqmex",
om2.MFnNumericData.kFloat, 1.0)
endSqY = nAttr.create("squashMultEndY", "sqmey",
om2.MFnNumericData.kFloat, 1.0)
IKVChainSolver.inSquashMultEnd = nAttr.create("squashMultEnd", "sqme",
endSqX, endSqY)
nAttr.setMin([0.001, 0.001])
INPUT_ATTR(nAttr)
IKVChainSolver.outChain = mAttr.create("outChain", "oc",
om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
OUTPUT_ATTR(mAttr)
IKVChainSolver.addAttribute(IKVChainSolver.inRoot)
IKVChainSolver.addAttribute(IKVChainSolver.inHandle)
IKVChainSolver.addAttribute(IKVChainSolver.inPoleVector)
IKVChainSolver.addAttribute(IKVChainSolver.inOffset)
IKVChainSolver.addAttribute(IKVChainSolver.inJntOri)
IKVChainSolver.addAttribute(IKVChainSolver.inParInvMtx)
IKVChainSolver.addAttribute(IKVChainSolver.inRestLenStart)
IKVChainSolver.addAttribute(IKVChainSolver.inRestLenEnd)
IKVChainSolver.addAttribute(IKVChainSolver.inPreferredAngle)
IKVChainSolver.addAttribute(IKVChainSolver.inTwist)
IKVChainSolver.addAttribute(IKVChainSolver.inPvMode)
IKVChainSolver.addAttribute(IKVChainSolver.inHierarchyMode)
IKVChainSolver.addAttribute(IKVChainSolver.inFlip)
IKVChainSolver.addAttribute(IKVChainSolver.inUseScale)
IKVChainSolver.addAttribute(IKVChainSolver.inCompressionLimit)
IKVChainSolver.addAttribute(IKVChainSolver.inSnapUpVector)
IKVChainSolver.addAttribute(IKVChainSolver.inSnap)
IKVChainSolver.addAttribute(IKVChainSolver.inSoftness)
IKVChainSolver.addAttribute(IKVChainSolver.inStretch)
IKVChainSolver.addAttribute(IKVChainSolver.inClampStretch)
IKVChainSolver.addAttribute(IKVChainSolver.inClampValue)
# IKVChainSolver.addAttribute(IKVChainSolver.inStretchMultStart)
# IKVChainSolver.addAttribute(IKVChainSolver.inStretchMultEnd)
IKVChainSolver.addAttribute(IKVChainSolver.inSquash)
IKVChainSolver.addAttribute(IKVChainSolver.inSquashMultStart)
IKVChainSolver.addAttribute(IKVChainSolver.inSquashMultEnd)
IKVChainSolver.addAttribute(IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inRoot,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inHandle,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inPoleVector,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inOffset,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inJntOri,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inParInvMtx,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inRestLenStart,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inRestLenEnd,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inPreferredAngle,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inTwist,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inPvMode,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inHierarchyMode,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inFlip,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inUseScale,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inCompressionLimit,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inSnapUpVector,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inSnap,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inSoftness,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inStretch,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inClampStretch,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inClampValue,
IKVChainSolver.outChain)
# IKVChainSolver.attributeAffects(IKVChainSolver.inStretchMultStart, IKVChainSolver.outChain)
# IKVChainSolver.attributeAffects(IKVChainSolver.inStretchMultEnd, IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inSquash,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inSquashMultStart,
IKVChainSolver.outChain)
IKVChainSolver.attributeAffects(IKVChainSolver.inSquashMultEnd,
IKVChainSolver.outChain)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to HelperJoint class. Instances of HelperJoint will use these attributes to create plugs
for use in the compute() method.
"""
nAttr = om2.MFnNumericAttribute()
mAttr = om2.MFnMatrixAttribute()
uAttr = om2.MFnUnitAttribute()
cAttr = om2.MFnCompoundAttribute()
HelperJoint.inSource = mAttr.create("source", "s", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
HelperJoint.inSourceParent = mAttr.create("sourceParent", "sp", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
HelperJoint.inParInvMtx = mAttr.create("targetParentInverseMatrix", "tpimtx", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
HelperJoint.inSourceParSca = nAttr.createPoint("sourceParentScale", "spsca")
nAttr.default = (1.0, 1.0, 1.0)
INPUT_ATTR(nAttr)
HelperJoint.inPositionOffset = nAttr.createPoint("positionOffset", "posoff")
INPUT_ATTR(nAttr)
rotOffX = uAttr.create("rotationOffsetX", "rotoffx", om2.MFnUnitAttribute.kAngle, 0.0)
rotOffY = uAttr.create("rotationOffsetY", "rotoffy", om2.MFnUnitAttribute.kAngle, 0.0)
rotOffZ = uAttr.create("rotationOffsetZ", "rotoffz", om2.MFnUnitAttribute.kAngle, 0.0)
HelperJoint.inRotationOffset = nAttr.create("rotationOffset", "rotoff", rotOffX, rotOffY, rotOffZ)
INPUT_ATTR(nAttr)
HelperJoint.inRotAngle = uAttr.create("rotationAngle", "rotangle", om2.MFnUnitAttribute.kAngle, 0.0)
INPUT_ATTR(uAttr)
HelperJoint.inRestAngle = uAttr.create("restAngle", "rang", om2.MFnUnitAttribute.kAngle, 0.0)
INPUT_ATTR(uAttr)
HelperJoint.inRotInterp = nAttr.create("rotationInterpolation", "roti", om2.MFnNumericData.kFloat, 0.5)
nAttr.setMin(0.0)
nAttr.setMax(1.0)
INPUT_ATTR(nAttr)
HelperJoint.inPosMult = nAttr.create("positiveMultiplier", "posmult", om2.MFnNumericData.kFloat, 0.0)
INPUT_ATTR(nAttr)
HelperJoint.inNegMult = nAttr.create("negativeMultiplier", "negmult", om2.MFnNumericData.kFloat, 0.0)
INPUT_ATTR(nAttr)
HelperJoint.inTargetList = cAttr.create("targetList", "tgtl")
cAttr.addChild(HelperJoint.inPositionOffset)
cAttr.addChild(HelperJoint.inRotationOffset)
cAttr.addChild(HelperJoint.inRotAngle)
cAttr.addChild(HelperJoint.inRestAngle)
cAttr.addChild(HelperJoint.inRotInterp)
cAttr.addChild(HelperJoint.inPosMult)
cAttr.addChild(HelperJoint.inNegMult)
cAttr.array = True
HelperJoint.outTransform = mAttr.create("outTransform", "outtrans", om2.MFnMatrixAttribute.kDouble)
mAttr.array = True
OUTPUT_ATTR(mAttr)
HelperJoint.addAttribute(HelperJoint.inSource)
HelperJoint.addAttribute(HelperJoint.inSourceParent)
HelperJoint.addAttribute(HelperJoint.inParInvMtx)
HelperJoint.addAttribute(HelperJoint.inSourceParSca)
HelperJoint.addAttribute(HelperJoint.inTargetList)
HelperJoint.addAttribute(HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inSource, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inSourceParent, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inParInvMtx, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inSourceParSca, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inPositionOffset, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inRotationOffset, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inRotAngle, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inRestAngle, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inRotInterp, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inPosMult, HelperJoint.outTransform)
HelperJoint.attributeAffects(HelperJoint.inNegMult, HelperJoint.outTransform)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to EulerMath class. Instances of EulerMath will use these attributes to create plugs
for use in the compute() method.
"""
eAttr = om2.MFnEnumAttribute()
uAttr = om2.MFnUnitAttribute()
nAttr = om2.MFnNumericAttribute()
EulerMath.inOperation = eAttr.create("operation", "operation", 0)
eAttr.addField("No Operation", 0)
eAttr.addField("Add", 1)
eAttr.addField("Subtract", 2)
eAttr.addField("Multiply", 3)
INPUT_ATTR(eAttr)
EulerMath.inEuler1X = uAttr.create("euler1X", "e1x",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.inEuler1Y = uAttr.create("euler1Y", "e1y",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.inEuler1Z = uAttr.create("euler1Z", "e1z",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.inEuler1 = nAttr.create("euler1", "e1", EulerMath.inEuler1X,
EulerMath.inEuler1Y,
EulerMath.inEuler1Z)
INPUT_ATTR(nAttr)
EulerMath.inEuler1RotOrder = eAttr.create("rotateOrderEuler1", "roe1",
0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
INPUT_ATTR(eAttr)
EulerMath.inEuler2X = uAttr.create("euler2X", "e2x",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.inEuler2Y = uAttr.create("euler2Y", "e2y",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.inEuler2Z = uAttr.create("euler2Z", "e2z",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.inEuler2 = nAttr.create("euler2", "e2", EulerMath.inEuler2X,
EulerMath.inEuler2Y,
EulerMath.inEuler2Z)
INPUT_ATTR(nAttr)
EulerMath.inEuler2RotOrder = eAttr.create("rotateOrderEuler2", "roe2",
0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
INPUT_ATTR(eAttr)
EulerMath.outEulerX = uAttr.create("outEulerX", "oex",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.outEulerY = uAttr.create("outEulerY", "oey",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.outEulerZ = uAttr.create("outEulerZ", "oez",
om2.MFnUnitAttribute.kAngle, 0.0)
EulerMath.outEuler = nAttr.create("outEuler", "oe",
EulerMath.outEulerX,
EulerMath.outEulerY,
EulerMath.outEulerZ)
OUTPUT_ATTR(nAttr)
EulerMath.inResRotOrder = eAttr.create("rotateOrderOutEuler", "rooe",
0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
INPUT_ATTR(eAttr)
EulerMath.addAttribute(EulerMath.inOperation)
EulerMath.addAttribute(EulerMath.inEuler1)
EulerMath.addAttribute(EulerMath.inEuler1RotOrder)
EulerMath.addAttribute(EulerMath.inEuler2)
EulerMath.addAttribute(EulerMath.inEuler2RotOrder)
EulerMath.addAttribute(EulerMath.inResRotOrder)
EulerMath.addAttribute(EulerMath.outEuler)
EulerMath.attributeAffects(EulerMath.inOperation, EulerMath.outEuler)
EulerMath.attributeAffects(EulerMath.inEuler1, EulerMath.outEuler)
EulerMath.attributeAffects(EulerMath.inEuler1RotOrder,
EulerMath.outEuler)
EulerMath.attributeAffects(EulerMath.inEuler2, EulerMath.outEuler)
EulerMath.attributeAffects(EulerMath.inEuler2RotOrder,
EulerMath.outEuler)
EulerMath.attributeAffects(EulerMath.inResRotOrder, EulerMath.outEuler)
def initialize():
"""
Defines the set of attributes for this node. The attributes declared in this function are assigned
as static members to AimConstraint class. Instances of AimConstraint will use these attributes to create plugs
for use in the compute() method.
"""
eAttr = om2.MFnEnumAttribute()
mAttr = om2.MFnMatrixAttribute()
nAttr = om2.MFnNumericAttribute()
uAttr = om2.MFnUnitAttribute()
AimConstraint.inUpVecType = eAttr.create("upVectorType", "upt", 0)
eAttr.addField("None", 0)
eAttr.addField("World Up", 1)
eAttr.addField("Object Up", 2)
eAttr.addField("Angle Up", 3)
INPUT_ATTR(eAttr)
eAttr.channelBox = True
offsetX = uAttr.create("offsetX", "offsetX",
om2.MFnUnitAttribute.kAngle, 0.0)
offsetY = uAttr.create("offsetY", "offsetY",
om2.MFnUnitAttribute.kAngle, 0.0)
offsetZ = uAttr.create("offsetZ", "offsetZ",
om2.MFnUnitAttribute.kAngle, 0.0)
AimConstraint.inOffset = nAttr.create("offset", "offset", offsetX,
offsetY, offsetZ)
INPUT_ATTR(nAttr)
AimConstraint.inWorldUpVector = nAttr.createPoint(
"worldUpVector", "wuv")
nAttr.default = (0.0, 1.0, 0.0)
INPUT_ATTR(nAttr)
AimConstraint.inWorldUpMtx = mAttr.create(
"worldUpMatrix", "wum", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
AimConstraint.inAngleUp = uAttr.create("angleUp", "angle",
om2.MFnUnitAttribute.kAngle,
0.0)
uAttr.setMin(0.0)
uAttr.setMax(2.0 * math.pi)
INPUT_ATTR(uAttr)
AimConstraint.inTargetWMtx = mAttr.create(
"targetWorldMatrix", "twmtx", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
AimConstraint.inTargetWeight = nAttr.create("targetWeight", "tw",
om2.MFnNumericData.kDouble,
1.0)
INPUT_ATTR(nAttr)
AimConstraint.inConstWMtx = mAttr.create(
"constraintWorldMatrix", "cwmtx", om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
AimConstraint.inConstParInvMtx = mAttr.create(
"constraintParentInverseMatrix", "cpim",
om2.MFnMatrixAttribute.kDouble)
INPUT_ATTR(mAttr)
jntOriX = uAttr.create("constraintJointOrientX", "cjorx",
om2.MFnUnitAttribute.kAngle, 0.0)
jntOriY = uAttr.create("constraintJointOrientY", "cjory",
om2.MFnUnitAttribute.kAngle, 0.0)
jntOriZ = uAttr.create("constraintJointOrientZ", "cjorz",
om2.MFnUnitAttribute.kAngle, 0.0)
AimConstraint.inConstJntOri = nAttr.create("constraintJointOrient",
"cjor", jntOriX, jntOriY,
jntOriZ)
INPUT_ATTR(nAttr)
AimConstraint.inConstRotOrder = eAttr.create("constraintRotateOrder",
"cro", 0)
eAttr.addField("xyz", 0)
eAttr.addField("yzx", 1)
eAttr.addField("zxy", 2)
eAttr.addField("xzy", 3)
eAttr.addField("yxz", 4)
eAttr.addField("zyx", 5)
INPUT_ATTR(eAttr)
outConstraintX = uAttr.create("constraintX", "cx",
om2.MFnUnitAttribute.kAngle, 0.0)
outConstraintY = uAttr.create("constraintY", "cy",
om2.MFnUnitAttribute.kAngle, 0.0)
outConstraintZ = uAttr.create("constraintZ", "cz",
om2.MFnUnitAttribute.kAngle, 0.0)
AimConstraint.outConstraint = nAttr.create("constraint", "const",
outConstraintX,
outConstraintY,
outConstraintZ)
OUTPUT_ATTR(nAttr)
AimConstraint.addAttribute(AimConstraint.inUpVecType)
AimConstraint.addAttribute(AimConstraint.inOffset)
AimConstraint.addAttribute(AimConstraint.inWorldUpVector)
AimConstraint.addAttribute(AimConstraint.inWorldUpMtx)
AimConstraint.addAttribute(AimConstraint.inAngleUp)
AimConstraint.addAttribute(AimConstraint.inTargetWMtx)
AimConstraint.addAttribute(AimConstraint.inTargetWeight)
AimConstraint.addAttribute(AimConstraint.inConstWMtx)
AimConstraint.addAttribute(AimConstraint.inConstParInvMtx)
AimConstraint.addAttribute(AimConstraint.inConstJntOri)
AimConstraint.addAttribute(AimConstraint.inConstRotOrder)
AimConstraint.addAttribute(AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inUpVecType,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inOffset,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inWorldUpVector,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inWorldUpMtx,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inAngleUp,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inTargetWMtx,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inTargetWeight,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inConstWMtx,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inConstParInvMtx,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inConstJntOri,
AimConstraint.outConstraint)
AimConstraint.attributeAffects(AimConstraint.inConstRotOrder,
AimConstraint.outConstraint)
