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 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 AngularTrigMath class. Instances of AngularTrigMath will use these attributes to create plugs for use in the compute() method. """ uAttr = om2.MFnUnitAttribute() eAttr = om2.MFnEnumAttribute() AngularTrigMath.inAngle1 = uAttr.create("angle1", "a1", om2.MFnUnitAttribute.kAngle, 0.0) INPUT_ATTR(uAttr) AngularTrigMath.inAngle2 = uAttr.create("angle2", "a2", om2.MFnUnitAttribute.kAngle, 0.0) INPUT_ATTR(uAttr) AngularTrigMath.inOperation = eAttr.create("operation", "operation", 0) eAttr.addField("No Operation", 0) eAttr.addField("Cosine", 1) eAttr.addField("Sine", 2) eAttr.addField("Tangent", 3) eAttr.addField("Arccos", 4) eAttr.addField("Arcsin", 5) eAttr.addField("Arctan", 6) eAttr.addField("Arctan2", 7) INPUT_ATTR(eAttr) AngularTrigMath.outAngle = uAttr.create("outAngle", "oa", om2.MFnUnitAttribute.kAngle, 0.0) OUTPUT_ATTR(uAttr) AngularTrigMath.addAttribute(AngularTrigMath.inOperation) AngularTrigMath.addAttribute(AngularTrigMath.inAngle1) AngularTrigMath.addAttribute(AngularTrigMath.inAngle2) AngularTrigMath.addAttribute(AngularTrigMath.outAngle) AngularTrigMath.attributeAffects(AngularTrigMath.inAngle1, AngularTrigMath.outAngle) AngularTrigMath.attributeAffects(AngularTrigMath.inAngle2, AngularTrigMath.outAngle) AngularTrigMath.attributeAffects(AngularTrigMath.inOperation, AngularTrigMath.outAngle)
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 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 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 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 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 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)
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 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)