def parseMatrixAttribute(self, name, shortName, attrInfo):
"""
Given a JSON subsection describing a matrix attribute create the
attribute and set all of the provided flags/members for it.
name = Attribute long name
shortName = Attribute short name
attrInfo = JSON object containing the main attribute information
"""
jsonDebug('parseMatrixAttribute(%s)' % name)
matrixType = JsonKeys.kTypeMatrixTypes[attrInfo[JsonKeys.kKeyAttrType]]
if JsonKeys.kKeyDefault in attrInfo:
jsonDebug('Setting the matrix default to "%s"' %
attrInfo[JsonKeys.kKeyDefault])
mDefault = omAPI.MFnMatrixData()
defaultValue = mDefault.create(
omAPI.MMatrix(attrInfo[JsonKeys.kKeyDefault]))
mAttr = omAPI.MFnMatrixAttribute(defaultValue)
attr = mAttr.create(name, shortName, matrixType)
else:
jsonDebug('Creating matrix attribute with no default')
mAttr = omAPI.MFnMatrixAttribute()
attr = mAttr.create(name, shortName, matrixType)
return attr
def initialize():
nAttr = om.MFnMatrixAttribute()
distanceTerrainNode.terrainMatrix = nAttr.create(
'terrainMatrix', 'terrainMtrx')
nAttr.storable = True
nAttr = om.MFnTypedAttribute()
distanceTerrainNode.terrain = nAttr.create('terrain', 'terrain',
om.MFnData.kMesh)
nAttr.storable = True
nAttr.writable = True
nAttr = om.MFnNumericAttribute()
distanceTerrainNode.jointPos = nAttr.create('jointPosition',
'jointPos',
om.MFnNumericData.k3Float,
0)
nAttr.storable = True
nAttr.writable = True
nAttr = om.MFnNumericAttribute()
distanceTerrainNode.distance = nAttr.create('distance', 'distance',
om.MFnNumericData.kFloat,
0)
distanceTerrainNode.addAttribute(distanceTerrainNode.terrainMatrix)
distanceTerrainNode.addAttribute(distanceTerrainNode.terrain)
distanceTerrainNode.addAttribute(distanceTerrainNode.jointPos)
distanceTerrainNode.addAttribute(distanceTerrainNode.distance)
distanceTerrainNode.attributeAffects(distanceTerrainNode.terrainMatrix,
distanceTerrainNode.distance)
distanceTerrainNode.attributeAffects(distanceTerrainNode.terrain,
distanceTerrainNode.distance)
distanceTerrainNode.attributeAffects(distanceTerrainNode.jointPos,
distanceTerrainNode.distance)
def initialize():
typedAttr = om.MFnTypedAttribute()
matrixAttr = om.MFnMatrixAttribute()
numericAttr = om.MFnNumericAttribute()
# OUTPUT
prCurveFrame.outputMatrix = matrixAttr.create("outputMatrix", "outputMatrix", matrixAttr.kDouble)
matrixAttr.array = True
matrixAttr.usesArrayDataBuilder = True
matrixAttr.readable = True
matrixAttr.writable = False
prCurveFrame.addAttribute(prCurveFrame.outputMatrix)
# INPUT
prCurveFrame.inputCurve = typedAttr.create('inputCurve', 'inputCurve', om.MFnNurbsCurveData.kNurbsCurve)
prCurveFrame.addAttribute(prCurveFrame.inputCurve)
prCurveFrame.attributeAffects(prCurveFrame.inputCurve, prCurveFrame.outputMatrix)
prCurveFrame.worldUpMatrix = matrixAttr.create("worldUpMatrix", "worldUpMatrix", matrixAttr.kDouble)
prCurveFrame.addAttribute(prCurveFrame.worldUpMatrix)
prCurveFrame.attributeAffects(prCurveFrame.worldUpMatrix, prCurveFrame.outputMatrix)
prCurveFrame.points = numericAttr.create("points", "points", om.MFnNumericData.kInt, 5)
numericAttr.keyable = True
prCurveFrame.addAttribute(prCurveFrame.points)
prCurveFrame.attributeAffects(prCurveFrame.points, prCurveFrame.outputMatrix)
def initialize():
mtxMFnAttr = om2.MFnMatrixAttribute()
Matrix2Vectors.mtxIn = mtxMFnAttr.create('matrixIn', 'mtxIn')
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
Matrix2Vectors.addAttribute(Matrix2Vectors.mtxIn)
Matrix2Vectors.row0 = mtxMFnAttr.create('row0Mtx', 'row0Mtx')
mtxMFnAttr.readable = True
Matrix2Vectors.addAttribute(Matrix2Vectors.row0)
Matrix2Vectors.row1 = mtxMFnAttr.create('row1Mtx', 'row1Mtx')
mtxMFnAttr.readable = True
Matrix2Vectors.addAttribute(Matrix2Vectors.row1)
Matrix2Vectors.row2 = mtxMFnAttr.create('row2Mtx', 'row2Mtx')
mtxMFnAttr.readable = True
Matrix2Vectors.addAttribute(Matrix2Vectors.row2)
Matrix2Vectors.attributeAffects(Matrix2Vectors.mtxIn,
Matrix2Vectors.row0)
Matrix2Vectors.attributeAffects(Matrix2Vectors.mtxIn,
Matrix2Vectors.row1)
Matrix2Vectors.attributeAffects(Matrix2Vectors.mtxIn,
Matrix2Vectors.row2)
def create_skeleton_compound(classtype, name):
mComp = OpenMaya.MFnCompoundAttribute()
compound = mComp.create(name, name)
setattr(classtype, name, compound)
mComp.array = True
mComp.storable = True
mComp.writable = True
mAttr = OpenMaya.MFnMatrixAttribute()
srcMatrix = mAttr.create(name + "SrcMatrix", name + "SrcMatrix")
setattr(classtype, name + "SrcMatrix", srcMatrix)
mAttr.array = False
mAttr.storable = True
mAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
boneParent = nAttr.create(name + "BoneParent", name + "BoneParent",
OpenMaya.MFnNumericData.kInt, -1)
setattr(classtype, name + "BoneParent", boneParent)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
translateScale = nAttr.create(name + "TranslateScale",
name + "TranslateScale",
OpenMaya.MFnNumericData.kFloat, 0)
setattr(classtype, name + "TranslateScale", translateScale)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
targetTranslate = nAttr.create(name + "TargetTranslate",
name + "TargetTranslate",
OpenMaya.MFnNumericData.k3Float)
setattr(classtype, name + "TargetTranslate", targetTranslate)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
nAttr.keyable = True
classtype.addAttribute(srcMatrix)
classtype.addAttribute(boneParent)
classtype.addAttribute(translateScale)
classtype.addAttribute(targetTranslate)
mComp.addChild(srcMatrix)
mComp.addChild(boneParent)
mComp.addChild(translateScale)
mComp.addChild(targetTranslate)
classtype.addAttribute(compound)
return compound
def initialize():
tAttr = om.MFnTypedAttribute()
mAttr = om.MFnMatrixAttribute()
Node.aMatrices = mAttr.create(
'matrices', 'ms', om.MFnMatrixAttribute.kDouble)
mAttr.readable = False
mAttr.array = True
Node.addAttribute(Node.aMatrices)
Node.aOutCurve = tAttr.create(
'outCurve', 'oc', om.MFnNurbsCurveData.kNurbsCurve)
tAttr.writable = False
Node.addAttribute(Node.aOutCurve)
Node.attributeAffects(Node.aMatrices, Node.aOutCurve)
def nodeInitializer():
classname = SkeletonSolverNode
#input
skel = create_skeleton_compound(classname, 'skeleton')
# output
mAttr = OpenMaya.MFnMatrixAttribute()
classname.outputs = mAttr.create("outputs", "outputs")
mAttr.array = True
mAttr.storable = True
mAttr.writable = True
classname.addAttribute(classname.outputs)
classname.attributeAffects(skel, classname.outputs)
def create_capsule_compound(classtype, name):
mComp = OpenMaya.MFnCompoundAttribute()
compound = mComp.create(name, name)
setattr(classtype, name, compound)
mComp.array = False
mComp.storable = True
mComp.writable = True
mAttr = OpenMaya.MFnMatrixAttribute()
matrix = mAttr.create(name + "Matrix", name + "Matrix")
setattr(classtype, name + "Matrix", matrix)
mAttr.array = False
mAttr.storable = True
mAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
radius = nAttr.create(name + "Radius", name + "Radius",
OpenMaya.MFnNumericData.kDouble, 0.5)
setattr(classtype, name + "Radius", radius)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
height = nAttr.create(name + "Height", name + "Height",
OpenMaya.MFnNumericData.kDouble, 1.0)
setattr(classtype, name + "Height", height)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
classtype.addAttribute(matrix)
classtype.addAttribute(radius)
classtype.addAttribute(height)
mComp.addChild(matrix)
mComp.addChild(radius)
mComp.addChild(height)
classtype.addAttribute(compound)
return compound
def initialize():
num_attr = om2.MFnNumericAttribute()
mtx_attr = om2.MFnMatrixAttribute()
SimpleNode.a_arg = mtx_attr.create('matrixIn', 'mtxIn', om2.MFnNumericData.kFloat)
mtx_attr.writable = True
mtx_attr.storable = True
om2.MPxNode.addAttribute(SimpleNode.a_arg)
SimpleNode.a_amp = num_attr.create('amp', 'amp', om2.MFnNumericData.kFloat, 1.0)
num_attr.storable = True
om2.MPxNode.addAttribute(SimpleNode.a_amp)
SimpleNode.a_val = num_attr.create('val', 'val', om2.MFnNumericData.kFloat, 0.0)
num_attr.storable = True
num_attr.writable = True
om2.MPxNode.addAttribute(SimpleNode.a_val)
om2.MPxNode.attributeAffects(SimpleNode.a_arg, SimpleNode.a_val)
om2.MPxNode.attributeAffects(SimpleNode.a_amp, SimpleNode.a_val)
def setPlugDefault(plug, default):
obj = plug.attribute()
if obj.hasFn(om2.MFn.kNumericAttribute):
attr = om2.MFnNumericAttribute(obj)
Type = attr.numericType()
attr.default = tuple(default) if Type in (
om2.MFnNumericData.k2Double, om2.MFnNumericData.k3Double,
om2.MFnNumericData.k4Double) else default
return True
elif obj.hasFn(om2.MFn.kTypedAttribute):
if not isinstance(default, om2.MObject):
raise ValueError(
"Wrong type passed to MFnTypeAttribute must be on type MObject, received : {}"
.format(type(default)))
attr = om2.MFnTypedAttribute(obj)
attr.default = default
return True
elif obj.hasFn(om2.MFn.kUnitAttribute):
if not isinstance(default, (om2.MAngle, om2.MDistance, om2.MTime)):
raise ValueError(
"Wrong type passed to MFnUnitAttribute must be on type MAngle,MDistance or MTime, received : {}"
.format(type(default)))
attr = om2.MFnUnitAttribute(obj)
attr.default = default
return True
elif obj.hasFn(om2.MFn.kMatrixAttribute):
attr = om2.MFnMatrixAttribute(obj)
attr.default = default
return True
elif obj.hasFn(om2.MFn.kEnumAttribute):
if not isinstance(default, (int, str)):
raise ValueError(
"Wrong type passed to MFnEnumAttribute must be on type int or float, received : {}"
.format(type(default)))
attr = om2.MFnEnumAttribute(obj)
if isinstance(default, int):
attr.default = default
else:
attr.setDefaultByName(default)
return True
return False
def nodeInitializer():
classname = ConstraintSolverNode
#input
skel = create_skeleton_compound(classname, 'skeleton')
primitivesS = create_primitives_compound(classname, 'primitiveSource')
primitivesD = create_primitives_compound(classname, 'primitiveDestination')
link = create_primitive_links_compound(classname, 'link')
# output
mAttr = OpenMaya.MFnMatrixAttribute()
classname.outputs = mAttr.create("outputs", "outputs")
mAttr.array = True
mAttr.storable = True
mAttr.writable = True
classname.addAttribute(classname.outputs)
classname.attributeAffects(skel, classname.outputs)
classname.attributeAffects(primitivesS, classname.outputs)
classname.attributeAffects(primitivesD, classname.outputs)
classname.attributeAffects(link, classname.outputs)
def plugDefault(plug):
obj = plug.attribute()
if obj.hasFn(om2.MFn.kNumericAttribute):
attr = om2.MFnNumericAttribute(obj)
return attr.default
elif obj.hasFn(om2.MFn.kTypedAttribute):
attr = om2.MFnTypedAttribute(obj)
default = attr.default
if default.apiType() == om2.MFn.kInvalid:
return None
elif default.apiType() == om2.MFn.kStringData:
return om2.MFnStringData(default).string()
return default
elif obj.hasFn(om2.MFn.kUnitAttribute):
attr = om2.MFnUnitAttribute(obj)
return attr.default
elif obj.hasFn(om2.MFn.kMatrixAttribute):
attr = om2.MFnMatrixAttribute(obj)
return attr.default
elif obj.hasFn(om2.MFn.kEnumAttribute):
attr = om2.MFnEnumAttribute(obj)
return attr.default
return None
def nodeInitializer():
'''
Defines the input and output attributes as static variables in our plug-in class.
'''
# The following function set will allow us to create our attributes.
numericAttributeFn = OpenMaya.MFnNumericAttribute()
angleAttributeFn = OpenMaya.MFnUnitAttribute()
matrixAttributeFn = OpenMaya.MFnMatrixAttribute()
compoundAttributeFn = OpenMaya.MFnCompoundAttribute()
#==================================#
# INPUT NODE ATTRIBUTE(S) #
#==================================#
#--------------------#
# Robot Definition #
#--------------------#
# Robot Definition Parent Attr
robotIKS.robotDef = compoundAttributeFn.create('robotDefinition', 'robotDef')
# a1 #
robotIKS.a1_attr = numericAttributeFn.create('a1', 'a1', OpenMaya.MFnNumericData.kFloat, 32.0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a1_attr)
# a2 #
robotIKS.a2_attr = numericAttributeFn.create('a2', 'a2', OpenMaya.MFnNumericData.kFloat, 20.0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a2_attr)
# b #
robotIKS.b_attr = numericAttributeFn.create('b', 'b', OpenMaya.MFnNumericData.kFloat, 0.0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.b_attr)
# c1 #
robotIKS.c1_attr = numericAttributeFn.create('c1', 'c1', OpenMaya.MFnNumericData.kFloat, 78.0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.c1_attr)
# c2 #
robotIKS.c2_attr = numericAttributeFn.create('c2', 'c2', OpenMaya.MFnNumericData.kFloat, 128.0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.c2_attr)
# c3 #
robotIKS.c3_attr = numericAttributeFn.create('c3', 'c3', OpenMaya.MFnNumericData.kFloat, 118.25)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.c3_attr)
# c4 #
robotIKS.c4_attr = numericAttributeFn.create('c4', 'c4', OpenMaya.MFnNumericData.kFloat, 20.0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.c4_attr)
robotIKS.addAttribute(robotIKS.robotDef) # Add Parent Attr
#----------------#
# Axis Offsets #
#----------------#
robotIKS.axisOffsets = compoundAttributeFn.create('axisOffsets', 'aOffsets')
# Axis 1 Offset #
robotIKS.axis1_offset_attr = numericAttributeFn.create('axis1Offset', 'a1Offset', OpenMaya.MFnNumericData.kFloat, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.axis1_offset_attr)
# Axis 2 Offset #
robotIKS.axis2_offset_attr = numericAttributeFn.create('axis2Offset', 'a2Offset', OpenMaya.MFnNumericData.kFloat, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.axis2_offset_attr)
# Axis 3 Offset #
robotIKS.axis3_offset_attr = numericAttributeFn.create('axis3Offset', 'a3Offset', OpenMaya.MFnNumericData.kFloat, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.axis3_offset_attr)
# Axis 4 Offset #
robotIKS.axis4_offset_attr = numericAttributeFn.create('axis4Offset', 'a4Offset', OpenMaya.MFnNumericData.kFloat, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.axis4_offset_attr)
# Axis 5 Offset #
robotIKS.axis5_offset_attr = numericAttributeFn.create('axis5Offset', 'a5Offset', OpenMaya.MFnNumericData.kFloat, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.axis5_offset_attr)
# Axis 6 Offset #
robotIKS.axis6_offset_attr = numericAttributeFn.create('axis6Offset', 'a6Offset', OpenMaya.MFnNumericData.kFloat, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.axis6_offset_attr)
robotIKS.addAttribute(robotIKS.axisOffsets) # Add Parent Attr
#------------------------#
# Flip Axis Directions #
#------------------------#
robotIKS.axisDirections = compoundAttributeFn.create('axisDirections', 'axisDirs')
# Flip Axis 1 Direction #
robotIKS.flip_a1_attr = numericAttributeFn.create('flipA1', 'flipA1', OpenMaya.MFnNumericData.kBoolean, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.flip_a1_attr)
# Flip Axis 2 Direction #
robotIKS.flip_a2_attr = numericAttributeFn.create('flipA2', 'flipA2', OpenMaya.MFnNumericData.kBoolean, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.flip_a2_attr)
# Flip Axis 3 Direction #
robotIKS.flip_a3_attr = numericAttributeFn.create('flipA3', 'flipA3', OpenMaya.MFnNumericData.kBoolean, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.flip_a3_attr)
# Flip Axis 4 Direction #
robotIKS.flip_a4_attr = numericAttributeFn.create('flipA4', 'flipA4', OpenMaya.MFnNumericData.kBoolean, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.flip_a4_attr)
# Flip Axis 5 Direction #
robotIKS.flip_a5_attr = numericAttributeFn.create('flipA5', 'flipA5', OpenMaya.MFnNumericData.kBoolean, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.flip_a5_attr)
# Flip Axis 6 Direction #
robotIKS.flip_a6_attr = numericAttributeFn.create('flipA6', 'flipA6', OpenMaya.MFnNumericData.kBoolean, 0)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.flip_a6_attr)
robotIKS.addAttribute(robotIKS.axisDirections) # Add Parent Attr
#----------------------#
# Joint Config Bools #
#----------------------#
# Robot Definition Parent Attr
robotIKS.jointConfig = compoundAttributeFn.create('jointConfiguration', 'config')
# soln1 #
robotIKS.sol_1_attr = numericAttributeFn.create('soln1', 'soln1', OpenMaya.MFnNumericData.kBoolean, 1)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.sol_1_attr)
# soln2 #
robotIKS.sol_2_attr = numericAttributeFn.create('soln2', 'soln2', OpenMaya.MFnNumericData.kBoolean, 1)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.sol_2_attr)
# soln3 #
robotIKS.sol_3_attr = numericAttributeFn.create('soln3', 'soln3', OpenMaya.MFnNumericData.kBoolean, 1)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.sol_3_attr)
# ik #
robotIKS.ik_attr = numericAttributeFn.create('ik', 'ik', OpenMaya.MFnNumericData.kBoolean, 1)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.ik_attr)
robotIKS.addAttribute(robotIKS.jointConfig) # Add Parent Attr
#-------------------#
# FK Controls #
#-------------------#
robotIKS.fkControls = compoundAttributeFn.create('fkControls', 'fkCtrls')
# J1 FK #
robotIKS.a1_fk_attr = angleAttributeFn.create('j1_FK', 'j1_FK', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = True
angleAttributeFn.writable = True
angleAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a1_fk_attr)
# J2 FK #
robotIKS.a2_fk_attr = angleAttributeFn.create('j2_FK', 'j2_FK', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = True
angleAttributeFn.writable = True
angleAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a2_fk_attr)
# J3 FK #
robotIKS.a3_fk_attr = angleAttributeFn.create('j3_FK', 'j3_FK', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = True
angleAttributeFn.writable = True
angleAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a3_fk_attr)
# J4 FK #
robotIKS.a4_fk_attr = angleAttributeFn.create('j4_FK', 'j4_FK', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = True
angleAttributeFn.writable = True
angleAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a4_fk_attr)
# J5 FK #
robotIKS.a5_fk_attr = angleAttributeFn.create('j5_FK', 'j5_FK', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = True
angleAttributeFn.writable = True
angleAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a5_fk_attr)
# J6 FK #
robotIKS.a6_fk_attr = angleAttributeFn.create('j6_FK', 'j6_FK', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = True
angleAttributeFn.writable = True
angleAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.a6_fk_attr)
robotIKS.addAttribute(robotIKS.fkControls)
#---------------------------------#
# TCP Translation - Local Space #
#---------------------------------#
# TCP Parent Attr
robotIKS.tcp = compoundAttributeFn.create('tcpFrame', 'tcp')
# tcpX #
robotIKS.tcp_x_attr = numericAttributeFn.create('tcpX', 'tcpX', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.tcp_x_attr)
# tcpY #
robotIKS.tcp_y_attr = numericAttributeFn.create('tcpY', 'tcpY', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.tcp_y_attr)
# tcpZ #
robotIKS.tcp_z_attr = numericAttributeFn.create('tcpZ', 'tcpZ', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.tcp_z_attr)
# TCP Matrix - Local Space ##
robotIKS.tcp_mat_attr = matrixAttributeFn.create('tcpMatrix', 'tcpMat', OpenMaya.MFnMatrixAttribute.kDouble)
matrixAttributeFn.writable = True
matrixAttributeFn.storable = True
matrixAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.tcp_mat_attr)
robotIKS.addAttribute(robotIKS.tcp) # Add parent Attr
#---------------------------------#
# LCS Translation - Local Space #
#---------------------------------#
# LCS Parent Attr
robotIKS.lcs = compoundAttributeFn.create('localFrame', 'lcs')
# lcsX #
robotIKS.lcs_x_attr = numericAttributeFn.create('lcsX', 'lcsX', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.lcs_x_attr)
# lcsY #
robotIKS.lcs_y_attr = numericAttributeFn.create('lcsY', 'lcsY', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.lcs_y_attr)
# lcsZ #
robotIKS.lcs_z_attr = numericAttributeFn.create('lcsZ', 'lcsZ', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.lcs_z_attr)
## LCS Matrix - Local Space ##
robotIKS.lcs_mat_attr = matrixAttributeFn.create('lcsMatrix', 'lcsMat', OpenMaya.MFnMatrixAttribute.kDouble)
matrixAttributeFn.writable = True
matrixAttributeFn.storable = True
matrixAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.lcs_mat_attr)
robotIKS.addAttribute(robotIKS.lcs) # Add parent Attr
#-----------------------------------------#
# Target Translation - Maya World Space #
#-----------------------------------------#
# Target Parent Attr
robotIKS.target = compoundAttributeFn.create('targetFrame', 'target')
# targetX #
robotIKS.target_x_attr = numericAttributeFn.create('targetX', 'targetX', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.target_x_attr)
# targetY #
robotIKS.target_y_attr = numericAttributeFn.create('targetY', 'targetY', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.target_y_attr)
# targetZ #
robotIKS.target_z_attr = numericAttributeFn.create('targetZ', 'targetZ', OpenMaya.MFnNumericData.kFloat)
numericAttributeFn.writable = True
numericAttributeFn.storable = True
numericAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.target_z_attr)
## Target Matrix - World Space ##
robotIKS.target_mat_attr = matrixAttributeFn.create('targetMatrix', 'targetMat', OpenMaya.MFnMatrixAttribute.kDouble)
matrixAttributeFn.writable = True
matrixAttributeFn.storable = True
matrixAttributeFn.hidden = False
compoundAttributeFn.addChild(robotIKS.target_mat_attr)
robotIKS.addAttribute(robotIKS.target) # Add parent Attr
#-----------------------------------------#
# Solver Type #
#-----------------------------------------#
robotIKS.solver_type_attr= numericAttributeFn.create('solverType', 'solverType', OpenMaya.MFnNumericData.kInt, 0)
numericAttributeFn.storable = True
numericAttributeFn.writable = True
numericAttributeFn.hidden = False
robotIKS.addAttribute(robotIKS.solver_type_attr)
#==================================#
# OUTPUT NODE ATTRIBUTE(S) #
#==================================#
# Final Joint Values Parent Attr
robotIKS.theta = compoundAttributeFn.create('JointVals', 'theta')
robotIKS.theta1_attr = angleAttributeFn.create('theta1', 'J1', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = False
angleAttributeFn.writable = False
angleAttributeFn.readable = True
angleAttributeFn.hidden = False
#robotIKS.addAttribute(robotIKS.theta1_attr)
compoundAttributeFn.addChild(robotIKS.theta1_attr)
robotIKS.theta2_attr = angleAttributeFn.create('theta2', 'J2', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = False
angleAttributeFn.writable = False
angleAttributeFn.readable = True
angleAttributeFn.hidden = False
#robotIKS.addAttribute(robotIKS.theta2_attr)
compoundAttributeFn.addChild(robotIKS.theta2_attr)
robotIKS.theta3_attr = angleAttributeFn.create('theta3', 'J3', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = False
angleAttributeFn.writable = False
angleAttributeFn.readable = True
angleAttributeFn.hidden = False
#robotIKS.addAttribute(robotIKS.theta3_attr)
compoundAttributeFn.addChild(robotIKS.theta3_attr)
robotIKS.theta4_attr = angleAttributeFn.create('theta4', 'J4', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = False
angleAttributeFn.writable = False
angleAttributeFn.readable = True
angleAttributeFn.hidden = False
#robotIKS.addAttribute(robotIKS.theta4_attr)
compoundAttributeFn.addChild(robotIKS.theta4_attr)
robotIKS.theta5_attr = angleAttributeFn.create('theta5', 'J5', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = False
angleAttributeFn.writable = False
angleAttributeFn.readable = True
angleAttributeFn.hidden = False
#robotIKS.addAttribute(robotIKS.theta5_attr)
compoundAttributeFn.addChild(robotIKS.theta5_attr)
robotIKS.theta6_attr = angleAttributeFn.create('theta6', 'J6', OpenMaya.MFnUnitAttribute.kAngle)
angleAttributeFn.storable = False
angleAttributeFn.writable = False
angleAttributeFn.readable = True
angleAttributeFn.hidden = False
#robotIKS.addAttribute(robotIKS.theta6_attr)
compoundAttributeFn.addChild(robotIKS.theta6_attr)
robotIKS.addAttribute(robotIKS.theta) # Add parent Attr
#===================================#
# NODE ATTRIBUTE DEPENDENCIES #
#===================================#
input_attrs = [robotIKS.a1_attr,
robotIKS.a2_attr,
robotIKS.b_attr,
robotIKS.c1_attr,
robotIKS.c2_attr,
robotIKS.c3_attr,
robotIKS.c4_attr,
robotIKS.axis1_offset_attr,
robotIKS.axis2_offset_attr,
robotIKS.axis3_offset_attr,
robotIKS.axis4_offset_attr,
robotIKS.axis5_offset_attr,
robotIKS.axis6_offset_attr,
robotIKS.flip_a1_attr,
robotIKS.flip_a2_attr,
robotIKS.flip_a3_attr,
robotIKS.flip_a4_attr,
robotIKS.flip_a5_attr,
robotIKS.flip_a6_attr,
robotIKS.sol_1_attr,
robotIKS.sol_2_attr,
robotIKS.sol_3_attr,
robotIKS.ik_attr,
robotIKS.a1_fk_attr,
robotIKS.a2_fk_attr,
robotIKS.a3_fk_attr,
robotIKS.a4_fk_attr,
robotIKS.a5_fk_attr,
robotIKS.a6_fk_attr,
robotIKS.tcp_x_attr,
robotIKS.tcp_y_attr,
robotIKS.tcp_z_attr,
robotIKS.tcp_mat_attr,
robotIKS.lcs_x_attr,
robotIKS.lcs_y_attr,
robotIKS.lcs_z_attr,
robotIKS.lcs_mat_attr,
robotIKS.target_x_attr,
robotIKS.target_y_attr,
robotIKS.target_z_attr,
robotIKS.target_mat_attr,
robotIKS.solver_type_attr
]
output_attrs = [robotIKS.theta1_attr,
robotIKS.theta2_attr,
robotIKS.theta3_attr,
robotIKS.theta4_attr,
robotIKS.theta5_attr,
robotIKS.theta6_attr,
robotIKS.theta]
for input_attr in input_attrs:
for output_attr in output_attrs:
robotIKS.attributeAffects(input_attr, output_attr)
def initialize():
nAttr0 = om.MFnMatrixAttribute()
MatrixCombine.inInitialMatrix = nAttr0.create('initialMatrix', 'im')
nAttr0.keyable = False
nAttrAllWeightList = om.MFnCompoundAttribute()
MatrixCombine.inAllPoseInfoList = nAttrAllWeightList.create(
'allPoseInfoList', 'pil')
nAttrAllWeightList.keyable = True
nAttrAllWeightList.array = True
nAttrAllWeightList.storable = True
nAttrAllWeightList.indexMatters = False
nAttrPoseName = om.MFnTypedAttribute()
MatrixCombine.inPoseName = nAttrPoseName.create(
'poseName', 'pl', om.MFnData.kString)
nAttrPoseName.keyable = True
nAttrMatList = om.MFnMatrixAttribute()
MatrixCombine.inPoseMatrix = nAttrMatList.create("poseMatrix", 'pm')
nAttrMatList.keyable = True
nAttrWeightInPose = om.MFnNumericAttribute()
MatrixCombine.inPoseWeights = nAttrWeightInPose.create(
'poseWeightList', 'pwl', om.MFnNumericData.kFloat, 0.0)
nAttrWeightInPose.keyable = True
nAttrWeightInPose.array = True
nAttrWeightInPose.storable = True
nAttrWeightInPose.indexMatters = False
nAttrAllWeightList.addChild(MatrixCombine.inPoseName)
nAttrAllWeightList.addChild(MatrixCombine.inPoseMatrix)
nAttrAllWeightList.addChild(MatrixCombine.inPoseWeights)
nAttrNum = om.MFnNumericAttribute()
MatrixCombine.inEditMode = nAttrNum.create("editMode", "emd",
om.MFnNumericData.kFloat,
0.0)
nAttrNum.keyable = False
nAttrEditMatrix = om.MFnMatrixAttribute()
MatrixCombine.inEditMatrix = nAttrEditMatrix.create(
"editMatrix", "emx")
nAttrEditMatrix.keyable = False
nAttrNum1 = om.MFnNumericAttribute()
MatrixCombine.inOverridingIntensity = nAttrNum1.create(
"overridingIntensity", "oi", om.MFnNumericData.kFloat, 0.0)
nAttrNum1.keyable = False
nAttrNum2 = om.MFnNumericAttribute()
MatrixCombine.inOverridingWeight = nAttrNum2.create(
"overridingWeight", "ow", om.MFnNumericData.kFloat, 1.0)
nAttrNum2.keyable = False
nAttrNum2 = om.MFnNumericAttribute()
MatrixCombine.inOverridingPoseIndex = nAttrNum2.create(
"overridingPoseIndex", "oid", om.MFnNumericData.kInt, 0)
nAttrNum2.keyable = False
nAttrOut = om.MFnNumericAttribute()
MatrixCombine.outTranslationX = nAttrOut.create(
'outTranslationX', 'otx', om.MFnNumericData.kFloat, 0.0)
nAttrOut.keyable = False
nAttrOut.storable = False
nAttrOut = om.MFnNumericAttribute()
MatrixCombine.outTranslationY = nAttrOut.create(
'outTranslationY', 'oty', om.MFnNumericData.kFloat, 0.0)
nAttrOut.keyable = False
nAttrOut.storable = False
nAttrOut = om.MFnNumericAttribute()
MatrixCombine.outTranslationZ = nAttrOut.create(
'outTranslationZ', 'otz', om.MFnNumericData.kFloat, 0.0)
nAttrOut.keyable = False
nAttrOut.storable = False
nAttrOut = om.MFnUnitAttribute()
MatrixCombine.outRotationX = nAttrOut.create(
'outRotationX', 'orx', om.MFnUnitAttribute.kAngle, 0.0)
nAttrOut.keyable = False
nAttrOut.storable = False
nAttrOut = om.MFnUnitAttribute()
MatrixCombine.outRotationY = nAttrOut.create(
'outRotationY', 'ory', om.MFnUnitAttribute.kAngle, 0.0)
nAttrOut.keyable = False
nAttrOut.storable = False
nAttrOut = om.MFnUnitAttribute()
MatrixCombine.outRotationZ = nAttrOut.create(
'outRotationZ', 'orz', om.MFnUnitAttribute.kAngle, 0.0)
nAttrOut.keyable = False
nAttrOut.storable = False
# add the attributes
om.MPxNode.addAttribute(MatrixCombine.inInitialMatrix)
om.MPxNode.addAttribute(MatrixCombine.inEditMode)
om.MPxNode.addAttribute(MatrixCombine.inEditMatrix)
om.MPxNode.addAttribute(MatrixCombine.inOverridingPoseIndex)
om.MPxNode.addAttribute(MatrixCombine.inOverridingIntensity)
om.MPxNode.addAttribute(MatrixCombine.inOverridingWeight)
om.MPxNode.addAttribute(MatrixCombine.inAllPoseInfoList)
om.MPxNode.addAttribute(MatrixCombine.outTranslationX)
om.MPxNode.addAttribute(MatrixCombine.outTranslationY)
om.MPxNode.addAttribute(MatrixCombine.outTranslationZ)
om.MPxNode.addAttribute(MatrixCombine.outRotationX)
om.MPxNode.addAttribute(MatrixCombine.outRotationY)
om.MPxNode.addAttribute(MatrixCombine.outRotationZ)
# establish effects on output
om.MPxNode.attributeAffects(MatrixCombine.inOverridingIntensity,
MatrixCombine.outTranslationX)
om.MPxNode.attributeAffects(MatrixCombine.inOverridingPoseIndex,
MatrixCombine.outTranslationX)
om.MPxNode.attributeAffects(MatrixCombine.inOverridingWeight,
MatrixCombine.outTranslationX)
om.MPxNode.attributeAffects(MatrixCombine.inInitialMatrix,
MatrixCombine.outTranslationX)
om.MPxNode.attributeAffects(MatrixCombine.inAllPoseInfoList,
MatrixCombine.outTranslationX)
om.MPxNode.attributeAffects(MatrixCombine.inEditMode,
MatrixCombine.outTranslationX)
om.MPxNode.attributeAffects(MatrixCombine.inAllPoseInfoList,
MatrixCombine.outRotationX)
om.MPxNode.attributeAffects(MatrixCombine.inAllPoseInfoList,
MatrixCombine.outRotationY)
om.MPxNode.attributeAffects(MatrixCombine.inAllPoseInfoList,
MatrixCombine.outRotationZ)
def initialize(cls):
nAttr = OpenMaya.MFnNumericAttribute()
tAttr = OpenMaya.MFnTypedAttribute()
enumAttr = OpenMaya.MFnEnumAttribute()
compAttr = OpenMaya.MFnCompoundAttribute()
matrixAttr = OpenMaya.MFnMatrixAttribute()
messageAttr = OpenMaya.MFnMessageAttribute()
cls.boundingBoxCorner1 = nAttr.create("boundingBoxCorner1", "bb1", OpenMaya.MFnNumericData.k3Double, 0)
nAttr.keyable = False
cls.addAttribute(cls.boundingBoxCorner1)
cls.boundingBoxCorner2 = nAttr.create("boundingBoxCorner2", "bb2", OpenMaya.MFnNumericData.k3Double, 0)
nAttr.keyable = False
cls.addAttribute(cls.boundingBoxCorner2)
cls.forgeID = tAttr.create("forgeID", "fid", OpenMaya.MFnData.kString, OpenMaya.MObject.kNullObj)
cls.addAttribute(cls.forgeID)
cls.handleMatrix = matrixAttr.create("handleMatrix", "hm", OpenMaya.MFnMatrixAttribute.kDouble)
cls.addAttribute(cls.handleMatrix)
cls.guideInverseScale = nAttr.create("guideInverseScale", "gis", OpenMaya.MFnNumericData.k3Double, 1.0)
cls.addAttribute(cls.guideInverseScale)
cls.guide = messageAttr.create("guide", "g")
cls.addAttribute(cls.guide)
cls.parentHandle = messageAttr.create("parentHandle", "ph")
cls.addAttribute(cls.parentHandle)
cls.parentHandleMatrix = matrixAttr.create("parentHandleMatrix", "phm", OpenMaya.MFnMatrixAttribute.kDouble)
cls.addAttribute(cls.parentHandleMatrix)
cls.childHandle = messageAttr.create("childHandle", "ch")
messageAttr.array = True
cls.addAttribute(cls.childHandle)
cls.childHandleMatrix = matrixAttr.create("childHandleMatrix", "chm", OpenMaya.MFnMatrixAttribute.kDouble)
matrixAttr.array = True
cls.addAttribute(cls.childHandleMatrix)
cls.orientTarget = messageAttr.create("orientTarget", "ot")
cls.addAttribute(cls.orientTarget)
cls.orientTargetMatrix = matrixAttr.create("orientTargetMatrix", "otm", OpenMaya.MFnMatrixAttribute.kDouble)
cls.addAttribute(cls.orientTargetMatrix)
cls.childPosition = nAttr.create("childPosition", "cpos", OpenMaya.MFnNumericData.k3Double, 0)
nAttr.array = True
nAttr.usesArrayDataBuilder = True
cls.addAttribute(cls.childPosition)
cls.jointRotateOrder = enumAttr.create("jointRotateOrder", "jro", 0)
enumAttr.addField("xyz", 0)
enumAttr.addField("yzx", 1)
enumAttr.addField("zxy", 2)
enumAttr.addField("xzy", 3)
enumAttr.addField("yxz", 4)
enumAttr.addField("zyx", 5)
enumAttr.keyable = False
cls.addAttribute(cls.jointRotateOrder)
cls.jointSide = enumAttr.create("jointSide", "js", 0)
enumAttr.addField("center", 0)
enumAttr.addField("left", 1)
enumAttr.addField("right", 2)
enumAttr.addField("none", 3)
enumAttr.keyable = True
cls.addAttribute(cls.jointSide)
cls.jointExcludeFromBind = nAttr.create("jointExcludeFromBind", "jeb", OpenMaya.MFnNumericData.kBoolean, 0)
cls.addAttribute(cls.jointExcludeFromBind)
cls.aimAxis = enumAttr.create("aimAxis", "aa", 0)
enumAttr.addField("X", 0)
enumAttr.addField("Y", 1)
enumAttr.addField("Z", 2)
enumAttr.addField("-X", 3)
enumAttr.addField("-Y", 4)
enumAttr.addField("-Z", 5)
enumAttr.keyable = False
cls.addAttribute(cls.aimAxis)
cls.upAxis = enumAttr.create("upAxis", "ua", 2)
enumAttr.addField("X", 0)
enumAttr.addField("Y", 1)
enumAttr.addField("Z", 2)
enumAttr.addField("-X", 3)
enumAttr.addField("-Y", 4)
enumAttr.addField("-Z", 5)
enumAttr.keyable = False
cls.addAttribute(cls.upAxis)
cls.aimVector = nAttr.create("aimVector", "av", OpenMaya.MFnNumericData.k3Double)
cls.addAttribute(cls.aimVector)
cls.upVector = nAttr.create("upVector", "uv", OpenMaya.MFnNumericData.k3Double)
cls.addAttribute(cls.upVector)
cls.useGuideAim = nAttr.create("useGuideAim", "uga", OpenMaya.MFnNumericData.kBoolean)
cls.addAttribute(cls.useGuideAim)
cls.jointMatrix = matrixAttr.create("jointMatrix", "jm", OpenMaya.MFnMatrixAttribute.kDouble)
cls.addAttribute(cls.jointMatrix)
cls.handleColor = nAttr.createColor("handleColor", "hc")
cls.addAttribute(cls.handleColor)
cls.handleStyle = enumAttr.create("handleStyle", "hs", 0)
enumAttr.addField("basic", 0)
enumAttr.addField("spine", 1)
enumAttr.addField("limb", 2)
enumAttr.addField("limb base", 3)
enumAttr.addField("limb hinge", 4)
enumAttr.addField("limb end", 5)
enumAttr.addField("free", 6)
enumAttr.addField("world", 7)
cls.addAttribute(cls.handleStyle)
cls.attributeAffects(cls.handleMatrix, cls.boundingBoxCorner1)
cls.attributeAffects(cls.handleMatrix, cls.boundingBoxCorner2)
cls.attributeAffects(cls.handleMatrix, cls.childPosition)
cls.attributeAffects(cls.childHandleMatrix, cls.boundingBoxCorner1)
cls.attributeAffects(cls.childHandleMatrix, cls.boundingBoxCorner2)
cls.attributeAffects(cls.childHandleMatrix, cls.childPosition)
cls.attributeAffects(cls.handleStyle, cls.boundingBoxCorner1)
cls.attributeAffects(cls.handleStyle, cls.boundingBoxCorner2)
cls.attributeAffects(cls.handleMatrix, cls.jointMatrix)
cls.attributeAffects(cls.orientTargetMatrix, cls.jointMatrix)
cls.attributeAffects(cls.parentHandleMatrix, cls.jointMatrix)
cls.attributeAffects(cls.aimAxis, cls.jointMatrix)
cls.attributeAffects(cls.upAxis, cls.jointMatrix)
cls.attributeAffects(cls.aimVector, cls.jointMatrix)
cls.attributeAffects(cls.upVector, cls.jointMatrix)
cls.attributeAffects(cls.useGuideAim, cls.jointMatrix)
def initialize():
"""
Defines the set of attributes for our node. The attributes
declared in this function are assigned as static members to our
depthShader class. Instances of ReflectionLocatorNode will use these attributes
to create plugs for use in the compute() method.
:return:
"""
eAttr = OpenMaya.MFnEnumAttribute()
nAttr = OpenMaya.MFnNumericAttribute()
mAttr = OpenMaya.MFnMatrixAttribute()
# plane shape
ReflectionLocatorNode.ui_type = eAttr.create("locatorShape", "ls", 0)
eAttr.addField("rect", 1)
eAttr.addField("locator", 2)
eAttr.addField("circle", 3)
eAttr.default = 2
ReflectionLocatorNode.addAttribute(ReflectionLocatorNode.ui_type)
# creates a vector attribute
global defaultOutputPoint
ReflectionLocatorNode.output_point = nAttr.create(
'output', 'out', OpenMaya.MFnNumericData.k3Double)
nAttr.storable = False
nAttr.hidden = False
nAttr.default = (defaultOutputPoint[0], defaultOutputPoint[1],
defaultOutputPoint[2])
ReflectionLocatorNode.addAttribute(ReflectionLocatorNode.output_point)
# creates a vector attribute
global defaultInputPoint
ReflectionLocatorNode.input_point = nAttr.create(
'input', 'in', OpenMaya.MFnNumericData.k3Double)
nAttr.storable = True
nAttr.hidden = False
nAttr.keyable = True
nAttr.default = (defaultInputPoint[0], defaultInputPoint[1],
defaultInputPoint[2])
ReflectionLocatorNode.addAttribute(ReflectionLocatorNode.input_point)
ReflectionLocatorNode.attributeAffects(
ReflectionLocatorNode.input_point,
ReflectionLocatorNode.output_point)
# create a matrix attribute
ReflectionLocatorNode.plane_matrix = mAttr.create(
"planeMatrix", "planeMatrix")
ReflectionLocatorNode.addAttribute(ReflectionLocatorNode.plane_matrix)
ReflectionLocatorNode.attributeAffects(
ReflectionLocatorNode.plane_matrix,
ReflectionLocatorNode.output_point)
# create a reflected parentInverse attribute
ReflectionLocatorNode.parent_inverse = mAttr.create(
"reflectedParentInverse", "rpi")
ReflectionLocatorNode.addAttribute(
ReflectionLocatorNode.parent_inverse)
ReflectionLocatorNode.attributeAffects(
ReflectionLocatorNode.parent_inverse,
ReflectionLocatorNode.output_point)
# create a line width attribute to change the width of a line drawing
global defaultLineWidth
ReflectionLocatorNode.line_width = nAttr.create(
"lineWidth", "lw", OpenMaya.MFnNumericData.kFloat,
defaultLineWidth)
nAttr.setMin(0.0)
nAttr.storable = False
nAttr.keyable = True
ReflectionLocatorNode.addAttribute(ReflectionLocatorNode.line_width)
# create a color attribute
global defaultPlaneColor
ReflectionLocatorNode.plane_color = nAttr.createColor(
'planeColor', 'pc')
nAttr.storable = True
nAttr.default = (defaultPlaneColor[0], defaultPlaneColor[1],
defaultPlaneColor[2])
ReflectionLocatorNode.addAttribute(ReflectionLocatorNode.plane_color)
# create a scale attribute
global defaultScaleValue
ReflectionLocatorNode.scale = nAttr.create(
"scale", "scale", OpenMaya.MFnNumericData.kDouble,
defaultScaleValue)
nAttr.keyable = True
ReflectionLocatorNode.addAttribute(ReflectionLocatorNode.scale)
ReflectionLocatorNode.attributeAffects(
ReflectionLocatorNode.scale, ReflectionLocatorNode.output_point)
def create_primitives_compound(classtype, name):
mComp = OpenMaya.MFnCompoundAttribute()
compound = mComp.create(name, name)
setattr(classtype, name, compound)
mComp.array = True
mComp.storable = True
mComp.writable = True
mCompC = OpenMaya.MFnCompoundAttribute()
capsule = mCompC.create(name + "Capsule", name + "Capsule")
setattr(classtype, name + "Capsule", capsule)
mCompC.array = True
mCompC.storable = True
mCompC.writable = True
mAttr = OpenMaya.MFnMatrixAttribute()
capsulematrix = mAttr.create(name + "CapsuleMatrix",
name + "CapsuleMatrix")
setattr(classtype, name + "CapsuleMatrix", capsulematrix)
mAttr.array = False
mAttr.storable = True
mAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
capsuleradius = nAttr.create(name + "CapsuleRadius",
name + "CapsuleRadius",
OpenMaya.MFnNumericData.kDouble, 0.5)
setattr(classtype, name + "CapsuleRadius", capsuleradius)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
capsuleheight = nAttr.create(name + "CapsuleHeight",
name + "CapsuleHeight",
OpenMaya.MFnNumericData.kDouble, 1.0)
setattr(classtype, name + "CapsuleHeight", capsuleheight)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
classtype.addAttribute(capsulematrix)
classtype.addAttribute(capsuleradius)
classtype.addAttribute(capsuleheight)
mCompC.addChild(capsulematrix)
mCompC.addChild(capsuleradius)
mCompC.addChild(capsuleheight)
classtype.addAttribute(capsule)
nAttr = OpenMaya.MFnNumericAttribute()
boneParent = nAttr.create(name + "BoneParent", name + "BoneParent",
OpenMaya.MFnNumericData.kInt, -1)
setattr(classtype, name + "BoneParent", boneParent)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
classtype.addAttribute(boneParent)
mComp.addChild(capsule)
mComp.addChild(boneParent)
classtype.addAttribute(compound)
return compound
def initialize():
e_attr = om.MFnEnumAttribute()
c_attr = om.MFnCompoundAttribute()
n_attr = om.MFnNumericAttribute()
AimConstaraintNode.aim_axis = e_attr.create("aim_axis", "axa", 0)
# e_attr.setChannelBox(True)
e_attr.keyable = False
e_attr.addField("X", 0)
e_attr.addField("Y", 1)
e_attr.addField("Z", 2)
mat_attr = om.MFnMatrixAttribute()
AimConstaraintNode.input_aim_matrix = mat_attr.create(
"input_aim_matrix", "iam")
mat_attr.writable = True
mat_attr.readable = False
mat_attr.keyable = True
AimConstaraintNode.input_target_parent_matrix = mat_attr.create(
"input_target_parent_matrix", "itm")
mat_attr.writable = True
mat_attr.readable = False
mat_attr.keyable = True
AimConstaraintNode.input_target_position = c_attr.create(
"input_target_position", "iapos")
c_attr.writable = True
c_attr.readable = False
c_attr.keyable = True
AimConstaraintNode.input_target_position_x = n_attr.create(
"input_target_pos_x", "itposx", om.MFnNumericData.kFloat, 0.0)
n_attr.writable = True
c_attr.addChild(AimConstaraintNode.input_target_position_x)
AimConstaraintNode.input_target_position_y = n_attr.create(
"input_target_pos_y", "itposy", om.MFnNumericData.kFloat, 0.0)
n_attr.writable = True
c_attr.addChild(AimConstaraintNode.input_target_position_y)
AimConstaraintNode.input_target_position_z = n_attr.create(
"input_target_pos_z", "itposz", om.MFnNumericData.kFloat, 0.0)
c_attr.addChild(AimConstaraintNode.input_target_position_z)
n_attr.writable = True
rotate_attr = om.MFnCompoundAttribute()
AimConstaraintNode.output_rotate = rotate_attr.create(
"output_rotate", "or")
rotate_attr.writable = True
rotate_unit_attr = om.MFnUnitAttribute()
AimConstaraintNode.koAngles = [0, 0, 0]
out_rotate_name = [
"output_rotateX", "output_rotateY", "output_rotateZ"
]
out_rotate_shortname = ["orx", "ory", "orz"]
for _ in range(3):
AimConstaraintNode.koAngles[_] = rotate_unit_attr.create(
out_rotate_name[_], out_rotate_shortname[_],
om.MFnUnitAttribute.kAngle, 0.0)
rotate_unit_attr.writable = True
rotate_attr.addChild(AimConstaraintNode.koAngles[_])
AimConstaraintNode.addAttribute(AimConstaraintNode.aim_axis)
AimConstaraintNode.addAttribute(AimConstaraintNode.input_aim_matrix)
AimConstaraintNode.addAttribute(
AimConstaraintNode.input_target_position)
AimConstaraintNode.addAttribute(
AimConstaraintNode.input_target_parent_matrix)
AimConstaraintNode.addAttribute(AimConstaraintNode.output_rotate)
AimConstaraintNode.attributeAffects(AimConstaraintNode.aim_axis,
AimConstaraintNode.output_rotate)
AimConstaraintNode.attributeAffects(
AimConstaraintNode.input_aim_matrix,
AimConstaraintNode.output_rotate)
AimConstaraintNode.attributeAffects(
AimConstaraintNode.input_target_parent_matrix,
AimConstaraintNode.output_rotate)
AimConstaraintNode.attributeAffects(
AimConstaraintNode.input_target_position,
AimConstaraintNode.output_rotate)
def initialize(cls):
nAttr = OpenMaya.MFnNumericAttribute()
tAttr = OpenMaya.MFnTypedAttribute()
uAttr = OpenMaya.MFnUnitAttribute()
enumAttr = OpenMaya.MFnEnumAttribute()
compAttr = OpenMaya.MFnCompoundAttribute()
matrixAttr = OpenMaya.MFnMatrixAttribute()
messageAttr = OpenMaya.MFnMessageAttribute()
cls.forgeID = tAttr.create("forgeID", "fid", OpenMaya.MFnData.kString,
OpenMaya.MObject.kNullObj)
cls.addAttribute(cls.forgeID)
cls.guideMatrix = matrixAttr.create(
"guideMatrix", "gm", OpenMaya.MFnMatrixAttribute.kDouble)
cls.addAttribute(cls.guideMatrix)
cls.handleInverseScale = nAttr.create("handleInverseScale", "his",
OpenMaya.MFnNumericData.k3Double,
1.0)
cls.addAttribute(cls.handleInverseScale)
cls.boundingBoxCorner1 = nAttr.create("boundingBoxCorner1", "bb1",
OpenMaya.MFnNumericData.k3Double,
0)
nAttr.keyable = False
cls.addAttribute(cls.boundingBoxCorner1)
cls.boundingBoxCorner2 = nAttr.create("boundingBoxCorner2", "bb2",
OpenMaya.MFnNumericData.k3Double,
0)
nAttr.keyable = False
cls.addAttribute(cls.boundingBoxCorner2)
cls.aimAxis = enumAttr.create("aimAxis", "aa", 0)
enumAttr.addField("X", 0)
enumAttr.addField("Y", 1)
enumAttr.addField("Z", 2)
enumAttr.addField("-X", 3)
enumAttr.addField("-Y", 4)
enumAttr.addField("-Z", 5)
enumAttr.keyable = False
cls.addAttribute(cls.aimAxis)
cls.upAxis = enumAttr.create("upAxis", "ua", 2)
enumAttr.addField("X", 0)
enumAttr.addField("Y", 1)
enumAttr.addField("Z", 2)
enumAttr.addField("-X", 3)
enumAttr.addField("-Y", 4)
enumAttr.addField("-Z", 5)
enumAttr.keyable = False
cls.addAttribute(cls.upAxis)
cls.aimVector = nAttr.create("aimVector", "av",
OpenMaya.MFnNumericData.k3Double)
cls.addAttribute(cls.aimVector)
cls.upVector = nAttr.create("upVector", "uv",
OpenMaya.MFnNumericData.k3Double)
cls.addAttribute(cls.upVector)
cls.provideAimVector = nAttr.create("provideAimVector", "pav",
OpenMaya.MFnNumericData.kBoolean,
0)
cls.addAttribute(cls.provideAimVector)
cls.handle = messageAttr.create("handle", "hndl")
messageAttr.array = True
cls.addAttribute(cls.handle)
cls.handleColor = nAttr.createColor("handleColor", "hc")
cls.addAttribute(cls.handleColor)
cls.parentGuide = messageAttr.create("parentGuide", "pg")
cls.addAttribute(cls.parentGuide)
cls.parentGuideHandleIndex = nAttr.create(
"parentGuideHandleIndex", "pghi", OpenMaya.MFnNumericData.kShort,
-1)
cls.addAttribute(cls.parentGuideHandleIndex)
cls.childGuide = messageAttr.create("childGuide", "cg")
cls.addAttribute(cls.childGuide)
cls.attributeAffects(cls.guideMatrix, cls.boundingBoxCorner1)
cls.attributeAffects(cls.guideMatrix, cls.boundingBoxCorner2)
cls.attributeAffects(cls.guideMatrix, cls.handleInverseScale)
cls.attributeAffects(cls.guideMatrix, cls.aimVector)
cls.attributeAffects(cls.guideMatrix, cls.upVector)
def nodeInitializer():
classname = CapsuleLinkNode
# input
inputCapsuleA = create_capsule_compound(classname, 'inputCapsuleA')
inputCapsuleB = create_capsule_compound(classname, 'inputCapsuleB')
outputCapsuleA = create_capsule_compound(classname, 'outputCapsuleA')
outputCapsuleB = create_capsule_compound(classname, 'outputCapsuleB')
mAttr = OpenMaya.MFnMatrixAttribute()
classname.outputA = mAttr.create("outputA", "outputA")
mAttr.array = False
mAttr.storable = True
mAttr.writable = True
classname.outputB = mAttr.create("outputB", "outputB")
mAttr.array = False
mAttr.storable = True
mAttr.writable = True
nAttr = OpenMaya.MFnNumericAttribute()
classname.weight = nAttr.create("weight", "weight",
OpenMaya.MFnNumericData.kDouble, 1.0)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
classname.abRatio = nAttr.create("abRatio", "abRatio",
OpenMaya.MFnNumericData.kDouble, 0.0)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
classname.aOrientationRatio = nAttr.create("aOrientationRatio",
"aOrientationRatio",
OpenMaya.MFnNumericData.kDouble,
1.0)
nAttr.array = False
nAttr.storable = True
nAttr.writable = True
classname.addAttribute(classname.outputA)
classname.addAttribute(classname.outputB)
classname.addAttribute(classname.weight)
classname.addAttribute(classname.abRatio)
classname.addAttribute(classname.aOrientationRatio)
classname.attributeAffects(inputCapsuleA, classname.outputA)
classname.attributeAffects(inputCapsuleA, classname.outputB)
classname.attributeAffects(inputCapsuleB, classname.outputA)
classname.attributeAffects(inputCapsuleB, classname.outputB)
classname.attributeAffects(outputCapsuleA, classname.outputA)
classname.attributeAffects(outputCapsuleA, classname.outputB)
classname.attributeAffects(outputCapsuleB, classname.outputA)
classname.attributeAffects(outputCapsuleB, classname.outputB)
classname.attributeAffects(classname.weight, classname.outputA)
classname.attributeAffects(classname.weight, classname.outputB)
classname.attributeAffects(classname.abRatio, classname.outputA)
classname.attributeAffects(classname.abRatio, classname.outputB)
classname.attributeAffects(classname.aOrientationRatio, classname.outputA)
classname.attributeAffects(classname.aOrientationRatio, classname.outputB)
def initialize():
numericAttr = om.MFnNumericAttribute()
compoundAttr = om.MFnCompoundAttribute()
genericAttr = om.MFnGenericAttribute()
matrixAttr = om.MFnMatrixAttribute()
# output
prKeepOut.output = numericAttr.createPoint('output', 'output')
numericAttr.array = True
numericAttr.usesArrayDataBuilder = True
numericAttr.writable = False
prKeepOut.addAttribute(prKeepOut.output)
# input
prKeepOut.enabled = numericAttr.create('enabled', 'enabled',
om.MFnNumericData.kBoolean,
True)
numericAttr.keyable = True
prKeepOut.addAttribute(prKeepOut.enabled)
prKeepOut.attributeAffects(prKeepOut.enabled, prKeepOut.output)
prKeepOut.offset = numericAttr.create('offset', 'offset',
om.MFnNumericData.kFloat, 0.0)
numericAttr.keyable = True
prKeepOut.addAttribute(prKeepOut.offset)
prKeepOut.attributeAffects(prKeepOut.offset, prKeepOut.output)
prKeepOut.offsetExtendsPosition = numericAttr.create(
'offsetExtendsPosition', 'offsetExtendsPosition',
om.MFnNumericData.kBoolean, True)
numericAttr.keyable = True
prKeepOut.addAttribute(prKeepOut.offsetExtendsPosition)
prKeepOut.attributeAffects(prKeepOut.offsetExtendsPosition,
prKeepOut.output)
prKeepOut.inputGeometry = genericAttr.create('inputGeometry',
'inputGeometry')
genericAttr.addDataType(om.MFnMeshData.kMesh)
genericAttr.addDataType(om.MFnNurbsSurfaceData.kNurbsSurface)
genericAttr.array = True
prKeepOut.addAttribute(prKeepOut.inputGeometry)
prKeepOut.attributeAffects(prKeepOut.inputGeometry, prKeepOut.output)
prKeepOut.enabledExtra = numericAttr.create('enabledExtra',
'enabledExtra',
om.MFnNumericData.kBoolean,
True)
numericAttr.keyable = True
prKeepOut.offsetExtra = numericAttr.create('offsetExtra',
'offsetExtra',
om.MFnNumericData.kFloat,
0.0)
numericAttr.keyable = True
prKeepOut.position1 = numericAttr.createPoint('position1', 'position1')
numericAttr.keyable = True
prKeepOut.position2 = numericAttr.createPoint('position2', 'position2')
numericAttr.keyable = True
prKeepOut.parentInverseMatrix = matrixAttr.create(
'parentInverseMatrix',
'parentInverseMatrix',
type=matrixAttr.kFloat)
matrixAttr.keyable = True
prKeepOut.input = compoundAttr.create('input', 'input')
compoundAttr.addChild(prKeepOut.enabledExtra)
compoundAttr.addChild(prKeepOut.offsetExtra)
compoundAttr.addChild(prKeepOut.position1)
compoundAttr.addChild(prKeepOut.position2)
compoundAttr.addChild(prKeepOut.parentInverseMatrix)
compoundAttr.array = True
prKeepOut.addAttribute(prKeepOut.input)
prKeepOut.attributeAffects(prKeepOut.enabledExtra, prKeepOut.output)
prKeepOut.attributeAffects(prKeepOut.offsetExtra, prKeepOut.output)
prKeepOut.attributeAffects(prKeepOut.position1, prKeepOut.output)
prKeepOut.attributeAffects(prKeepOut.position2, prKeepOut.output)
prKeepOut.attributeAffects(prKeepOut.parentInverseMatrix,
prKeepOut.output)
def initialize():
nAttr = om.MFnNumericAttribute()
uAttr = om.MFnUnitAttribute()
mAttr = om.MFnMatrixAttribute()
flinJiggle.aOutput = nAttr.createPoint('output', 'output')
nAttr.keyable = False
nAttr.storable = False
om.MPxNode.addAttribute(flinJiggle.aOutput)
flinJiggle.aDamping = nAttr.create('damping', 'damping',
om.MFnNumericData.kFloat, 0.0)
nAttr.keyable = True
nAttr.readable = True
nAttr.storable = True
nAttr.setMin(0)
nAttr.setMax(1)
flinJiggle.addAttribute(flinJiggle.aDamping)
flinJiggle.aStiffness = nAttr.create('stiffness', 'stiffness',
om.MFnNumericData.kFloat, 0.0)
nAttr.keyable = True
nAttr.readable = True
nAttr.storable = True
nAttr.setMin(0)
nAttr.setMax(1)
flinJiggle.addAttribute(flinJiggle.aStiffness)
flinJiggle.aJiggle = nAttr.create('jiggle', 'jiggle',
om.MFnNumericData.kFloat, 0.0)
nAttr.keyable = True
nAttr.readable = True
nAttr.storable = True
flinJiggle.addAttribute(flinJiggle.aJiggle)
flinJiggle.aTime = uAttr.create('inTime', 'inTime',
om.MFnUnitAttribute.kTime)
uAttr.keyable = True
uAttr.readable = True
uAttr.storable = True
flinJiggle.addAttribute(flinJiggle.aTime)
flinJiggle.aGoal = nAttr.createPoint('goal', 'goal')
nAttr.keyable = True
nAttr.readable = True
nAttr.storable = True
flinJiggle.addAttribute(flinJiggle.aGoal)
flinJiggle.aParentInverse = mAttr.create('parentInverse', 'parentInverse',
om.MFnData.kMatrix)
flinJiggle.addAttribute(flinJiggle.aParentInverse)
flinJiggle.aGoalInverse = mAttr.create('goalInverse', 'goalInverse',
om.MFnData.kMatrix)
flinJiggle.addAttribute(flinJiggle.aGoalInverse)
flinJiggle.attributeAffects(flinJiggle.aGoal, flinJiggle.aOutput)
flinJiggle.attributeAffects(flinJiggle.aDamping, flinJiggle.aOutput)
flinJiggle.attributeAffects(flinJiggle.aStiffness, flinJiggle.aOutput)
flinJiggle.attributeAffects(flinJiggle.aTime, flinJiggle.aOutput)
flinJiggle.attributeAffects(flinJiggle.aJiggle, flinJiggle.aOutput)
flinJiggle.attributeAffects(flinJiggle.aParentInverse, flinJiggle.aOutput)
flinJiggle.attributeAffects(flinJiggle.aGoalInverse, flinJiggle.aOutput)
def init_decode():
# (1) Setup attributes
nAttr = om.MFnNumericAttribute() # Maya's Numeric Attribute class
tAttr = om.MFnTypedAttribute()
mAttr = om.MFnMatrixAttribute()
uAttr = om.MFnUnitAttribute()
kFloat = om.MFnNumericData.kFloat # Maya's float type
k3Float = om.MFnNumericData.k3Float # Maya's float type
kAngle = om.MFnUnitAttribute.kAngle
kDoubleArray = om.MFnNumericData.kDoubleArray
kBool = om.MFnNumericData.kBoolean
# Setup attribute helper functions and classes
def add_nAttr(params):
setattr(ikrig_decode, params[0],
nAttr.create(params[0], params[1], params[2]))
nAttr.hidden = False
nAttr.keyable = True
return getattr(ikrig_decode, params[0])
def add_out_nAttr(params):
setattr(ikrig_decode, params[0],
nAttr.create(params[0], params[1], params[2]))
mAttr.writable = False
mAttr.storable = False
mAttr.readable = True
return getattr(ikrig_decode, params[0])
class out_euler_nAttr:
i = 0
def create(self, params):
rotX = uAttr.create("rotateX" + str(self.i), "rx" + str(self.i),
kAngle)
uAttr.writable = False
uAttr.storable = False
rotY = uAttr.create("rotateY" + str(self.i), "ry" + str(self.i),
kAngle)
uAttr.writable = False
uAttr.storable = False
rotZ = uAttr.create("rotateZ" + str(self.i), "rz" + str(self.i),
kAngle)
uAttr.writable = False
uAttr.storable = False
setattr(ikrig_decode, params[0],
nAttr.create(params[0], params[1], rotX, rotY, rotZ))
nAttr.writable = False
nAttr.storable = False
nAttr.readable = True
self.i += 1
return getattr(ikrig_decode, params[0])
euler_nAttr = out_euler_nAttr()
# (2) Setup the input attributes
in_attributes = []
ikrig_decode.encoded_pose = tAttr.create('encoded_pose', 'ep',
kDoubleArray,
om.MFnDoubleArrayData().create())
tAttr.connectable = True
tAttr.hidden = False
ikrig_decode.offset_mat = mAttr.create('offset_mat', 'om')
mAttr.keyable = True
mAttr.hidden = False
in_attributes.append(ikrig_decode.encoded_pose)
in_attributes.append(ikrig_decode.offset_mat)
in_attributes.append(add_nAttr(('height_hips', 'hh', kFloat)))
in_attributes.append(add_nAttr(('root_offset_neck', 'o0', k3Float)))
in_attributes.append(add_nAttr(('root_offset_leg_L', 'o1', k3Float)))
in_attributes.append(add_nAttr(('root_offset_leg_R', 'o2', k3Float)))
in_attributes.append(add_nAttr(('root_offset_arm_L', 'o3', k3Float)))
in_attributes.append(add_nAttr(('root_offset_arm_R', 'o4', k3Float)))
in_attributes.append(add_nAttr(('length_spine', 'l0', kFloat)))
in_attributes.append(add_nAttr(('length_neck', 'l1', kFloat)))
in_attributes.append(add_nAttr(('length_leg_L', 'l2', kFloat)))
in_attributes.append(add_nAttr(('length_leg_R', 'l3', kFloat)))
in_attributes.append(add_nAttr(('length_arm_L', 'l4', kFloat)))
in_attributes.append(add_nAttr(('length_arm_R', 'l5', kFloat)))
ikrig_decode.normalized_global_xfo = nAttr.create('normalized_global_xfo',
'nx', kBool, 1)
nAttr.hidden = False
nAttr.keyable = True
# (3) Setup the output attributes
out_attributes = []
ikrig_decode.global_mat = mAttr.create('global_mat', 'gm')
mAttr.writable = False
mAttr.storable = False
mAttr.connectable = True
mAttr.readable = True
out_attributes.append(ikrig_decode.global_mat)
out_attributes.append(add_out_nAttr(('ik_Spine_root', 'ikp0', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Spine_dir', 'ikd0', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Spine_eff', 'ike0', k3Float)))
out_attributes.append(euler_nAttr.create(('ik_Spine_eff_rot', 'ikr0')))
out_attributes.append(add_out_nAttr(('ik_Neck_root', 'ikp1', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Neck_dir', 'ikd1', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Neck_eff', 'ike1', k3Float)))
out_attributes.append(euler_nAttr.create(('ik_Neck_eff_rot', 'ikr1')))
out_attributes.append(add_out_nAttr(('ik_Leg_root_L', 'ikp2', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Leg_dir_L', 'ikd2', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Leg_eff_L', 'ike2', k3Float)))
out_attributes.append(euler_nAttr.create(('ik_Leg_eff_rot_L', 'ikr2')))
out_attributes.append(add_out_nAttr(('ik_Leg_root_R', 'ikp3', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Leg_dir_R', 'ikd3', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Leg_eff_R', 'ike3', k3Float)))
out_attributes.append(euler_nAttr.create(('ik_Leg_eff_rot_R', 'ikr3')))
out_attributes.append(add_out_nAttr(('ik_Arm_root_L', 'ikp4', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Arm_dir_L', 'ikd4', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Arm_eff_L', 'ike4', k3Float)))
out_attributes.append(euler_nAttr.create(('ik_Arm_eff_rot_L', 'ikr4')))
out_attributes.append(add_out_nAttr(('ik_Arm_root_R', 'ikp5', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Arm_dir_R', 'ikd5', k3Float)))
out_attributes.append(add_out_nAttr(('ik_Arm_eff_R', 'ike5', k3Float)))
out_attributes.append(euler_nAttr.create(('ik_Arm_eff_rot_R', 'ikr5')))
# (4) Add the attributes to the node
for attribute in in_attributes:
ikrig_decode.addAttribute(attribute)
for attribute in out_attributes:
ikrig_decode.addAttribute(attribute)
ikrig_decode.addAttribute(ikrig_decode.normalized_global_xfo)
# (5) Set the attribute dependencies
for out_attribute in out_attributes:
ikrig_decode.attributeAffects(ikrig_decode.normalized_global_xfo,
out_attribute)
for in_attribute in in_attributes:
ikrig_decode.attributeAffects(in_attribute, out_attribute)
def init_encode():
# (1) Setup attributes
nAttr = om.MFnNumericAttribute()
mAttr = om.MFnMatrixAttribute()
tAttr = om.MFnTypedAttribute()
kDoubleArray = om.MFnNumericData.kDoubleArray
kFloat = om.MFnNumericData.kFloat
k3Float = om.MFnNumericData.k3Float
kBool = om.MFnNumericData.kBoolean
def add_nAttr(params):
setattr(ikrig_encode, params[0],
nAttr.create(params[0], params[1], params[2]))
nAttr.hidden = False
nAttr.keyable = True
return getattr(ikrig_encode, params[0])
def add_mAttr(params):
setattr(ikrig_encode, params[0], mAttr.create(params[0], params[1]))
mAttr.writable = True
mAttr.storable = True
mAttr.connectable = True
mAttr.hidden = False
return getattr(ikrig_encode, params[0])
ikrig_encode.mirror = nAttr.create('mirror', 'mi', kBool, 0)
nAttr.hidden = False
nAttr.keyable = True
ikrig_encode.normalize_global_xfo = nAttr.create('normalize_global_xfo',
'nx', kBool, 1)
nAttr.hidden = False
nAttr.keyable = True
in_attributes = []
# Character size attr.
in_attributes.append(add_nAttr(('height_hips', 'hh', kFloat)))
in_attributes.append(add_nAttr(('root_offset_neck', 'o0', k3Float)))
in_attributes.append(add_nAttr(('root_offset_leg_L', 'o1', k3Float)))
in_attributes.append(add_nAttr(('root_offset_leg_R', 'o2', k3Float)))
in_attributes.append(add_nAttr(('root_offset_arm_L', 'o3', k3Float)))
in_attributes.append(add_nAttr(('root_offset_arm_R', 'o4', k3Float)))
in_attributes.append(add_nAttr(('length_spine', 'l0', kFloat)))
in_attributes.append(add_nAttr(('length_neck', 'l1', kFloat)))
in_attributes.append(add_nAttr(('length_leg_L', 'l2', kFloat)))
in_attributes.append(add_nAttr(('length_leg_R', 'l3', kFloat)))
in_attributes.append(add_nAttr(('length_arm_L', 'l4', kFloat)))
in_attributes.append(add_nAttr(('length_arm_R', 'l5', kFloat)))
# Character positional attr.
in_attributes.append(add_mAttr(('mat_hips_rest', 'hr')))
in_attributes.append(add_mAttr(('mat_hips', 'h')))
in_attributes.append(add_mAttr(('mat_spine', 's')))
in_attributes.append(add_mAttr(('mat_chest', 'c')))
in_attributes.append(add_mAttr(('mat_neck', 'n')))
in_attributes.append(add_mAttr(('mat_neck_mid', 'nm')))
in_attributes.append(add_mAttr(('mat_head', 'e')))
in_attributes.append(add_mAttr(('mat_leg_L', 'll')))
in_attributes.append(add_mAttr(('mat_shin_L', 'sl')))
in_attributes.append(add_mAttr(('mat_foot_L', 'fl')))
in_attributes.append(add_mAttr(('mat_leg_R', 'lr')))
in_attributes.append(add_mAttr(('mat_shin_R', 'sr')))
in_attributes.append(add_mAttr(('mat_foot_R', 'fr')))
in_attributes.append(add_mAttr(('mat_shoulder_L', 'ol')))
in_attributes.append(add_mAttr(('mat_elbow_L', 'el')))
in_attributes.append(add_mAttr(('mat_hand_L', 'al')))
in_attributes.append(add_mAttr(('mat_shoulder_R', 'or')))
in_attributes.append(add_mAttr(('mat_elbow_R', 'er')))
in_attributes.append(add_mAttr(('mat_hand_R', 'ar')))
#(2) Setup the output attributes
ikrig_encode.result = tAttr.create('result', 'r', kDoubleArray,
om.MFnDoubleArrayData().create())
tAttr.writable = False
tAttr.storable = False
tAttr.readable = True
# (3) Add the attributes to the node
for attribute in in_attributes:
ikrig_encode.addAttribute(attribute)
ikrig_encode.addAttribute(ikrig_encode.mirror)
ikrig_encode.addAttribute(ikrig_encode.normalize_global_xfo)
ikrig_encode.addAttribute(ikrig_encode.result)
# (4) Set the attribute dependencies
for attribute in in_attributes:
ikrig_encode.attributeAffects(attribute, ikrig_encode.result)
ikrig_encode.attributeAffects(ikrig_encode.mirror, ikrig_encode.result)
ikrig_encode.attributeAffects(ikrig_encode.normalize_global_xfo,
ikrig_encode.result)
def initialize(cls):
nAttr = om.MFnNumericAttribute()
enumAttr = om.MFnEnumAttribute()
matAttr = om.MFnMatrixAttribute()
uAttr = om.MFnUnitAttribute()
typedAttr = om.MFnTypedAttribute()
cls.shapeAttr = enumAttr.create('shape', 'sh', 0)
enumAttr.addField('Custom', -1)
for idx, shape in enumerate(shapes):
enumAttr.addField(shape['name'], idx)
enumAttr.channelBox = True
cls.addAttribute(cls.shapeAttr)
cls.customMeshAttr = typedAttr.create("inCustomMesh", "icm",
om.MFnMeshData.kMesh)
typedAttr.storable = False
# The kReset constant is missing from the Python 2.0 API.
typedAttr.disconnectBehavior = 1
cls.addAttribute(cls.customMeshAttr)
cls.transformAttr = matAttr.create('transform', 't',
om.MFnMatrixAttribute.kFloat)
matAttr.keyable = False
cls.addAttribute(cls.transformAttr)
localRotateX = uAttr.create('localRotateX', 'lrx',
om.MFnUnitAttribute.kAngle, 0.0)
localRotateY = uAttr.create('localRotateY', 'lry',
om.MFnUnitAttribute.kAngle, 0.0)
localRotateZ = uAttr.create('localRotateZ', 'lrz',
om.MFnUnitAttribute.kAngle, 0.0)
cls.localRotateAttr = nAttr.create('localRotate', 'lr', localRotateX,
localRotateY, localRotateZ)
nAttr.channelBox = True
nAttr.keyable = False
cls.addAttribute(cls.localRotateAttr)
cls.localTranslateAttr = nAttr.createPoint('localPosition', 'lp')
nAttr.channelBox = True
nAttr.keyable = False
cls.addAttribute(cls.localTranslateAttr)
localScaleX = nAttr.create('localScaleX', 'lsx',
om.MFnNumericData.kFloat, 1)
localScaleY = nAttr.create('localScaleY', 'lsy',
om.MFnNumericData.kFloat, 1)
localScaleZ = nAttr.create('localScaleZ', 'lsz',
om.MFnNumericData.kFloat, 1)
cls.localScaleAttr = nAttr.create('localScale', 'ls', localScaleX,
localScaleY, localScaleZ)
nAttr.channelBox = True
nAttr.keyable = False
cls.addAttribute(cls.localScaleAttr)
cls.colorAttr = nAttr.createColor('color', 'dc')
nAttr.default = (.38, 0, 0.02)
cls.addAttribute(cls.colorAttr)
cls.alphaAttr = nAttr.create('alpha', 'a', om.MFnNumericData.kFloat,
0.333)
nAttr.setSoftMin(0)
nAttr.setSoftMax(1)
nAttr.keyable = False
cls.addAttribute(cls.alphaAttr)
cls.borderColorAttr = nAttr.createColor('borderColor', 'bc')
nAttr.default = (-1, -1, -1)
cls.addAttribute(cls.borderColorAttr)
cls.borderAlphaAttr = nAttr.create('borderAlpha', 'ba',
om.MFnNumericData.kFloat, 1)
nAttr.setSoftMin(0)
nAttr.setSoftMax(1)
nAttr.keyable = False
cls.addAttribute(cls.borderAlphaAttr)
cls.xrayAttr = nAttr.create('xray', 'xr', om.MFnNumericData.kBoolean,
True)
nAttr.keyable = False
nAttr.channelBox = True
cls.addAttribute(cls.xrayAttr)
def addAttribute(node, longName, shortName, attrType=attrtypes.kMFnNumericDouble, isArray=False, apply=True):
"""This function uses the api to create attributes on the given node, currently WIP but currently works for
string,int, float, bool, message, matrix. if the attribute exists a ValueError will be raised.
:param node: MObject
:param longName: str, the long name for the attribute
:param shortName: str, the shortName for the attribute
:param attrType: attribute Type, attrtypes constants
:param apply: if False the attribute will be immediately created on the node else just return the attribute instance
:rtype: om.MObject
"""
if hasAttribute(node, longName):
raise ValueError("Node -> '%s' already has attribute -> '%s'" % (nameFromMObject(node), longName))
aobj = None
attr = None
if attrType == attrtypes.kMFnNumericDouble:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kDouble)
elif attrType == attrtypes.kMFnNumericFloat:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kFloat)
elif attrType == attrtypes.kMFnNumericBoolean:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kBoolean)
elif attrType == attrtypes.kMFnNumericInt:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kInt)
elif attrType == attrtypes.kMFnNumericShort:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kShort)
elif attrType == attrtypes.kMFnNumericLong:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kLong)
elif attrType == attrtypes.kMFnNumericByte:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kByte)
elif attrType == attrtypes.kMFnNumericChar:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kChar)
elif attrType == attrtypes.kMFnNumericAddr:
attr = om2.MFnNumericAttribute()
aobj = attr.createAddr(longName, shortName)
elif attrType == attrtypes.kMFnkEnumAttribute:
attr = om2.MFnEnumAttribute()
aobj = attr.create(longName, shortName)
elif attrType == attrtypes.kMFnCompoundAttribute:
attr = om2.MFnCompoundAttribute()
aobj = attr.create(longName, shortName)
elif attrType == attrtypes.kMFnMessageAttribute:
attr = om2.MFnMessageAttribute()
aobj = attr.create(longName, shortName)
elif attrType == attrtypes.kMFnDataString:
attr = om2.MFnTypedAttribute()
stringData = om2.MFnStringData().create("")
aobj = attr.create(longName, shortName, om2.MFnData.kString, stringData)
elif attrType == attrtypes.kMFnUnitAttributeDistance:
attr = om2.MFnUnitAttribute()
aobj = attr.create(longName, shortName, om2.MDistance())
elif attrType == attrtypes.kMFnUnitAttributeAngle:
attr = om2.MFnUnitAttribute()
aobj = attr.create(longName, shortName, om2.MAngle())
elif attrType == attrtypes.kMFnUnitAttributeTime:
attr = om2.MFnUnitAttribute()
aobj = attr.create(longName, shortName, om2.MTime())
elif attrType == attrtypes.kMFnDataMatrix:
attr = om2.MFnMatrixAttribute()
aobj = attr.create(longName, shortName)
elif attrType == attrtypes.kMFnDataFloatArray:
attr = om2.MFnFloatArray()
aobj = attr.create(longName, shortName)
elif attrType == attrtypes.kMFnDataDoubleArray:
data = om2.MFnDoubleArrayData().create(om2.MDoubleArray())
attr = om2.MFnTypedAttribute()
aobj = attr.create(longName, shortName, om2.MFnData.kDoubleArray, data)
elif attrType == attrtypes.kMFnDataIntArray:
data = om2.MFnIntArrayData().create(om2.MIntArray())
attr = om2.MFnTypedAttribute()
aobj = attr.create(longName, shortName, om2.MFnData.kIntArray, data)
elif attrType == attrtypes.kMFnDataPointArray:
data = om2.MFnPointArrayData().create(om2.MPointArray())
attr = om2.MFnTypedAttribute()
aobj = attr.create(longName, shortName, om2.MFnData.kPointArray, data)
elif attrType == attrtypes.kMFnDataVectorArray:
data = om2.MFnVectorArrayData().create(om2.MVectorArray())
attr = om2.MFnTypedAttribute()
aobj = attr.create(longName, shortName, om2.MFnData.kVectorArray, data)
elif attrType == attrtypes.kMFnDataStringArray:
data = om2.MFnStringArrayData().create(om2.MStringArray())
attr = om2.MFnTypedAttribute()
aobj = attr.create(longName, shortName, om2.MFnData.kStringArray, data)
elif attrType == attrtypes.kMFnDataMatrixArray:
data = om2.MFnMatrixArrayData().create(om2.MMatrixArray())
attr = om2.MFnTypedAttribute()
aobj = attr.create(longName, shortName, om2.MFnData.kMatrixArray, data)
elif attrType == attrtypes.kMFnNumericInt64:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kInt64)
elif attrType == attrtypes.kMFnNumericLast:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.kLast)
elif attrType == attrtypes.kMFnNumeric2Double:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k2Double)
elif attrType == attrtypes.kMFnNumeric2Float:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k2Float)
elif attrType == attrtypes.kMFnNumeric2Int:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k2Int)
elif attrType == attrtypes.kMFnNumeric2Long:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k2Long)
elif attrType == attrtypes.kMFnNumeric2Short:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k2Short)
elif attrType == attrtypes.kMFnNumeric3Double:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k3Double)
elif attrType == attrtypes.kMFnNumeric3Float:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k3Float)
elif attrType == attrtypes.kMFnNumeric3Int:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k3Int)
elif attrType == attrtypes.kMFnNumeric3Long:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k3Long)
elif attrType == attrtypes.kMFnNumeric3Short:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k3Short)
elif attrType == attrtypes.kMFnNumeric4Double:
attr = om2.MFnNumericAttribute()
aobj = attr.create(longName, shortName, om2.MFnNumericData.k4Double)
if aobj is not None and apply:
attr.array = isArray
mod = om2.MDGModifier()
mod.addAttribute(node, aobj)
mod.doIt()
return attr
def nodeInitializer():
# create attributes
# pick your pointy poison
solverAttrFn = om.MFnEnumAttribute()
generalIk.aSolver = solverAttrFn.create("solver", "sol", 0)
solverAttrFn.addField("CCD", 0)
solverAttrFn.addField("FABRIK (not yet implemented)", 1)
solverAttrFn.storable = True
solverAttrFn.keyable = True
solverAttrFn.readable = False
solverAttrFn.writable = True
om.MPxNode.addAttribute(generalIk.aSolver)
iterAttrFn = om.MFnNumericAttribute()
generalIk.aMaxIter = iterAttrFn.create("maxIterations", "mi",
om.MFnNumericData.kLong, 30)
iterAttrFn.storable = True
iterAttrFn.keyable = True
iterAttrFn.readable = False
iterAttrFn.writable = True
iterAttrFn.setMin(0)
om.MPxNode.addAttribute(generalIk.aMaxIter)
# how far will you go for perfection
toleranceAttrFn = om.MFnNumericAttribute()
generalIk.aTolerance = toleranceAttrFn.create("tolerance", "tol",
om.MFnNumericData.kDouble,
0.1)
toleranceAttrFn.storable = True
toleranceAttrFn.keyable = True
toleranceAttrFn.readable = False
toleranceAttrFn.writable = True
toleranceAttrFn.setMin(0)
om.MPxNode.addAttribute(generalIk.aTolerance)
# weight of the world
globalWeightAttrFn = om.MFnNumericAttribute()
generalIk.aGlobalWeight = globalWeightAttrFn.create(
"globalWeight", "globalWeight", om.MFnNumericData.kDouble, 0.8)
globalWeightAttrFn.writable = True
globalWeightAttrFn.keyable = True
om.MPxNode.addAttribute(generalIk.aGlobalWeight)
# let the past die?
# cacheOnAttrFn = om.MFnNumericAttribute()
# generalIk.aCacheOn = cacheOnAttrFn.create(
# "cacheOn", "cacheOn", om.MFnNumericData.kBoolean, 1)
# om.MPxNode.addAttribute(generalIk.aCacheOn)
generalIk.aCacheOn = nodeio.makeBindAttr(generalIk, name="cache")
om.MPxNode.addAttribute(generalIk.aCacheOn)
# what are your goals in life
targetMatAttrFn = om.MFnMatrixAttribute()
generalIk.aTargetMat = targetMatAttrFn.create("targetMatrix", "targetMat",
1)
targetMatAttrFn.storable = True
targetMatAttrFn.readable = False
targetMatAttrFn.keyable = False
targetMatAttrFn.writable = True
targetMatAttrFn.cached = True
om.MPxNode.addAttribute(generalIk.aTargetMat)
# compare and contrast
endMatAttrFn = om.MFnMatrixAttribute()
generalIk.aEndMat = endMatAttrFn.create("inputEndMatrix", "endMat", 1)
endMatAttrFn.storable = True
endMatAttrFn.readable = False
endMatAttrFn.keyable = False
endMatAttrFn.writable = True
endMatAttrFn.cached = True
om.MPxNode.addAttribute(generalIk.aEndMat)
# once i built a tower
jntMatAttrFn = om.MFnMatrixAttribute()
generalIk.aJntMat = jntMatAttrFn.create("worldMatrix", "worldMatrix", 1)
jntMatAttrFn.storable = False
jntMatAttrFn.writable = True
jntMatAttrFn.cached = False # prevent ghost influences from staying
# are you local
jntLocalMatAttrFn = om.MFnMatrixAttribute()
generalIk.aJntLocalMat = jntLocalMatAttrFn.create("localMatrix",
"localMatrix", 1)
# joint orients
orientRxAttrFn = om.MFnUnitAttribute()
generalIk.aOrientRx = orientRxAttrFn.create("orientX", "orientX", 1, 0.0)
orientRyAttrFn = om.MFnUnitAttribute()
generalIk.aOrientRy = orientRyAttrFn.create("orientY", "orientY", 1, 0.0)
orientRzAttrFn = om.MFnUnitAttribute()
generalIk.aOrientRz = orientRzAttrFn.create("orientZ", "orientZ", 1, 0.0)
orientRotAttrFn = om.MFnCompoundAttribute()
generalIk.aOrientRot = orientRotAttrFn.create("orient", "orient")
orientRotAttrFn.storable = False
orientRotAttrFn.writable = True
orientRotAttrFn.keyable = False
orientRotAttrFn.addChild(generalIk.aOrientRx)
orientRotAttrFn.addChild(generalIk.aOrientRy)
orientRotAttrFn.addChild(generalIk.aOrientRz)
# rotate order
rotOrderAttrFn = om.MFnNumericAttribute()
generalIk.aRotOrder = rotOrderAttrFn.create("rotateOrder", "rotateOrder",
om.MFnNumericData.kLong, 0)
# eye on the sky
jntUpMatAttrFn = om.MFnMatrixAttribute()
generalIk.aJntUpMat = jntUpMatAttrFn.create("upMatrix", "jntUpMat", 1)
jntUpMatAttrFn.storable = True
jntUpMatAttrFn.writable = True
jntUpMatAttrFn.cached = True
# om.MPxNode.addAttribute(generalIk.aJntUpMat)
# but which way is up
jntUpDirAttrFn = om.MFnNumericAttribute()
generalIk.aJntUpDir = jntUpDirAttrFn.create("upDir", "upDir",
om.MFnNumericData.k3Double)
# who is the heftiest boi
jntWeightAttrFn = om.MFnNumericAttribute()
generalIk.aJntWeight = jntWeightAttrFn.create("weight", "jntWeight",
om.MFnNumericData.kDouble, 1)
jntWeightAttrFn.storable = True
jntWeightAttrFn.keyable = True
jntWeightAttrFn.writable = True
jntWeightAttrFn.setMin(0)
# om.MPxNode.addAttribute(generalIk.aJntWeight)
limitAttrFn = om.MFnCompoundAttribute()
generalIk.aLimits = limitAttrFn.create("limits", "limits")
# like really know them
rxMaxAttrFn = om.MFnNumericAttribute()
generalIk.aRxMax = rxMaxAttrFn.create("maxRotateX", "maxRx",
om.MFnNumericData.kDouble, 0)
# how low can you go
rxMinAttrFn = om.MFnNumericAttribute()
generalIk.aRxMin = rxMinAttrFn.create("minRotateX", "minRx",
om.MFnNumericData.kDouble, 0)
limitAttrFn.addChild(generalIk.aRxMax)
limitAttrFn.addChild(generalIk.aRxMin)
## there is more to be done here
# you will never break the chain
jntArrayAttrFn = om.MFnCompoundAttribute()
generalIk.aJnts = jntArrayAttrFn.create("inputJoints", "inputJoints")
jntArrayAttrFn.array = True
jntArrayAttrFn.usesArrayDataBuilder = True
jntArrayAttrFn.addChild(generalIk.aJntMat)
jntArrayAttrFn.addChild(generalIk.aJntLocalMat)
jntArrayAttrFn.addChild(generalIk.aJntUpMat)
jntArrayAttrFn.addChild(generalIk.aJntUpDir)
jntArrayAttrFn.addChild(generalIk.aJntWeight)
jntArrayAttrFn.addChild(generalIk.aOrientRot)
jntArrayAttrFn.addChild(generalIk.aRotOrder)
jntArrayAttrFn.addChild(generalIk.aLimits)
# add limits later
om.MPxNode.addAttribute(generalIk.aJnts)
# fruits of labour
outRxAttrFn = om.MFnUnitAttribute()
generalIk.aOutRx = outRxAttrFn.create("rotateX", "outRx", 1, 0.0)
outRxAttrFn.writable = False
outRxAttrFn.keyable = False
# om.MPxNode.addAttribute(generalIk.aOutRx)
outRyAttrFn = om.MFnUnitAttribute()
generalIk.aOutRy = outRyAttrFn.create("rotateY", "outRy", 1, 0.0)
outRyAttrFn.writable = False
outRyAttrFn.keyable = False
# om.MPxNode.addAttribute(generalIk.aOutRy)
outRzAttrFn = om.MFnUnitAttribute()
generalIk.aOutRz = outRzAttrFn.create("rotateZ", "outRz", 1, 0.0)
outRzAttrFn.writable = False
outRzAttrFn.keyable = False
# om.MPxNode.addAttribute(generalIk.aOutRz)
outRotAttrFn = om.MFnCompoundAttribute()
# generalIk.aOutRot = outRotAttrFn.create("outputRotate", "outRot",
# om.MFnNumericData.k3Double)
generalIk.aOutRot = outRotAttrFn.create("rotate", "outRot")
outRotAttrFn.storable = False
outRotAttrFn.writable = False
outRotAttrFn.keyable = False
outRotAttrFn.addChild(generalIk.aOutRx)
outRotAttrFn.addChild(generalIk.aOutRy)
outRotAttrFn.addChild(generalIk.aOutRz)
om.MPxNode.addAttribute(generalIk.aOutRot)
# # add smooth jazz
outTransAttrFn = om.MFnNumericAttribute()
generalIk.aOutTrans = outTransAttrFn.create("translate", "outTrans",
om.MFnNumericData.k3Double)
outTransAttrFn.storable = False
outTransAttrFn.writable = False
outTransAttrFn.keyable = False
om.MPxNode.addAttribute(generalIk.aOutTrans)
# all that the sun touches
outArrayAttrFn = om.MFnCompoundAttribute()
generalIk.aOutArray = outArrayAttrFn.create("outputJoints", "out")
outArrayAttrFn.array = True
outArrayAttrFn.usesArrayDataBuilder = True
outArrayAttrFn.storable = False
outArrayAttrFn.writable = False
outArrayAttrFn.keyable = False
outArrayAttrFn.addChild(generalIk.aOutRot)
outArrayAttrFn.addChild(generalIk.aOutTrans)
om.MPxNode.addAttribute(generalIk.aOutArray)
# investigate rolling this into the input hierarchy
# convenience end attributes for babies
outEndTransFn = om.MFnNumericAttribute()
generalIk.aOutEndTrans = outEndTransFn.create("outputEndTranslate",
"outputEndTranslate",
om.MFnNumericData.k3Double)
outEndTransFn.writable = False
om.MPxNode.addAttribute(generalIk.aOutEndTrans)
outEndRotFn = om.MFnCompoundAttribute()
generalIk.aOutEndRot = outEndRotFn.create("outputEndRotate",
"outputEndRotate")
outEndRotFn.writable = False
outEndRxAttrFn = om.MFnUnitAttribute()
generalIk.aOutEndRx = outEndRxAttrFn.create("outputEndRotateX", "outEndRx",
1, 0.0)
outEndRotFn.addChild(generalIk.aOutEndRx)
outEndRyAttrFn = om.MFnUnitAttribute()
generalIk.aOutEndRy = outEndRyAttrFn.create("outputEndRotateY", "outEndRy",
1, 0.0)
outEndRotFn.addChild(generalIk.aOutEndRy)
outEndRzAttrFn = om.MFnUnitAttribute()
generalIk.aOutEndRz = outEndRzAttrFn.create("outputEndRotateZ", "outEndRz",
1, 0.0)
outEndRotFn.addChild(generalIk.aOutEndRz)
om.MPxNode.addAttribute(generalIk.aOutEndRot)
# debug
debugTargetFn = om.MFnMatrixAttribute()
generalIk.aDebugTarget = debugTargetFn.create("debugTarget", "debugTarget",
1)
om.MPxNode.addAttribute(generalIk.aDebugTarget)
debugOffset = om.MFnNumericAttribute()
generalIk.aDebugOffset = debugOffset.create("debugOffset", "debugOffset",
om.MFnNumericData.kDouble, 0)
om.MPxNode.addAttribute(generalIk.aDebugOffset)
# caching results to persist across graph evaluations
cacheMatricesFn = om.MFnTypedAttribute()
matrixArrayData = om.MFnMatrixArrayData().create()
generalIk.aCacheMatrices = cacheMatricesFn.create(
"cacheMatrices", "cacheMatrices", 12, matrixArrayData) # matrix array
cacheMatricesFn.writable = True
cacheMatricesFn.readable = True
cacheMatricesFn.cached = True
cacheMatricesFn.keyable = True
om.MPxNode.addAttribute(generalIk.aCacheMatrices)
# everyone's counting on you
drivers = [
generalIk.aTargetMat, generalIk.aEndMat, generalIk.aJnts,
generalIk.aMaxIter, generalIk.aGlobalWeight, generalIk.aTolerance,
generalIk.aJntWeight, generalIk.aCacheOn
]
driven = [
generalIk.aOutArray, generalIk.aOutEndTrans, generalIk.aOutEndRot,
generalIk.aDebugTarget, generalIk.aDebugOffset
]
nodeio.setAttributeAffects(drivers, driven, generalIk)
def initialize():
matrixAttr = om.MFnMatrixAttribute()
numericAttr = om.MFnNumericAttribute()
enumAttr = om.MFnEnumAttribute()
typedAttr = om.MFnTypedAttribute()
# OUTPUT
prUpCurveSpline.outputMatrix = matrixAttr.create(
'outputMatrix', 'outputMatrix')
matrixAttr.array = True
matrixAttr.usesArrayDataBuilder = True
matrixAttr.writable = False
prUpCurveSpline.addAttribute(prUpCurveSpline.outputMatrix)
# INPUTS
prUpCurveSpline.curve = typedAttr.create(
'curve', 'curve', om.MFnNurbsCurveData.kNurbsCurve)
prUpCurveSpline.addAttribute(prUpCurveSpline.curve)
prUpCurveSpline.attributeAffects(prUpCurveSpline.curve,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.upCurve = typedAttr.create(
'upCurve', 'upCurve', om.MFnNurbsCurveData.kNurbsCurve)
prUpCurveSpline.addAttribute(prUpCurveSpline.upCurve)
prUpCurveSpline.attributeAffects(prUpCurveSpline.upCurve,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.startOrientMatrix = matrixAttr.create(
'startOrientMatrix', 'startOrientMatrix')
prUpCurveSpline.addAttribute(prUpCurveSpline.startOrientMatrix)
prUpCurveSpline.attributeAffects(prUpCurveSpline.startOrientMatrix,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.endOrientMatrix = matrixAttr.create(
'endOrientMatrix', 'endOrientMatrix')
prUpCurveSpline.addAttribute(prUpCurveSpline.endOrientMatrix)
prUpCurveSpline.attributeAffects(prUpCurveSpline.endOrientMatrix,
prUpCurveSpline.outputMatrix)
# SETTINGS
prUpCurveSpline.parameterType = enumAttr.create(
'parameterType', 'parameterType', 1)
enumAttr.addField('param', 0)
enumAttr.addField('param normalized', 1)
enumAttr.addField('length', 2)
enumAttr.addField('fractionMode', 3)
enumAttr.keyable = True
prUpCurveSpline.addAttribute(prUpCurveSpline.parameterType)
prUpCurveSpline.attributeAffects(prUpCurveSpline.parameterType,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.aimAxis = enumAttr.create('aimAxis', 'aimAxis', 0)
enumAttr.addField('x', 0)
enumAttr.addField('y', 1)
enumAttr.addField('z', 2)
enumAttr.addField('-x', 3)
enumAttr.addField('-y', 4)
enumAttr.addField('-z', 5)
enumAttr.keyable = True
prUpCurveSpline.addAttribute(prUpCurveSpline.aimAxis)
prUpCurveSpline.attributeAffects(prUpCurveSpline.aimAxis,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.upAxis = enumAttr.create('upAxis', 'upAxis', 1)
enumAttr.addField('x', 0)
enumAttr.addField('y', 1)
enumAttr.addField('z', 2)
enumAttr.addField('-x', 3)
enumAttr.addField('-y', 4)
enumAttr.addField('-z', 5)
enumAttr.keyable = True
prUpCurveSpline.addAttribute(prUpCurveSpline.upAxis)
prUpCurveSpline.attributeAffects(prUpCurveSpline.upAxis,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.startOrientMatrixWeight = numericAttr.create(
'startOrientMatrixWeight', 'startOrientMatrixWeight',
om.MFnNumericData.kFloat, 0.0)
numericAttr.keyable = True
numericAttr.setMin(0.0)
numericAttr.setMax(1.0)
prUpCurveSpline.addAttribute(prUpCurveSpline.startOrientMatrixWeight)
prUpCurveSpline.attributeAffects(
prUpCurveSpline.startOrientMatrixWeight,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.endOrientMatrixWeight = numericAttr.create(
'endOrientMatrixWeight', 'endOrientMatrixWeight',
om.MFnNumericData.kFloat, 0.0)
numericAttr.keyable = True
numericAttr.setMin(0.0)
numericAttr.setMax(1.0)
prUpCurveSpline.addAttribute(prUpCurveSpline.endOrientMatrixWeight)
prUpCurveSpline.attributeAffects(prUpCurveSpline.endOrientMatrixWeight,
prUpCurveSpline.outputMatrix)
prUpCurveSpline.parameter = numericAttr.create(
'parameter', 'parameter', om.MFnNumericData.kFloat, 0.0)
numericAttr.keyable = True
numericAttr.array = True
numericAttr.usesArrayDataBuilder = True
prUpCurveSpline.addAttribute(prUpCurveSpline.parameter)
prUpCurveSpline.attributeAffects(prUpCurveSpline.parameter,
prUpCurveSpline.outputMatrix)
return tuple(mfn.get(i) for i in range(mfn.length()))
_api_type_table = {
_om2.MFn.kDoubleLinearAttribute:
lambda plug: plug.asMDistance().asUnits(_om2.MDistance.uiUnit()),
_om2.MFn.kFloatLinearAttribute:
lambda plug: plug.asMDistance().asUnits(_om2.MDistance.uiUnit()),
_om2.MFn.kDoubleAngleAttribute:
lambda plug: plug.asMAngle().asUnits(_om2.MAngle.uiUnit()),
_om2.MFn.kFloatAngleAttribute:
lambda plug: plug.asMAngle().asUnits(_om2.MAngle.uiUnit()),
_om2.MFn.kEnumAttribute:
lambda plug: plug.asInt(),
_om2.MFn.kMatrixAttribute:
lambda plug: _om2.MFnMatrixAttribute(plug.asMObject()).matrix(),
}
_typed_attr_table = {
_om2.MFnData.kString:
lambda plug: plug.asString(),
_om2.MFnData.kMatrix:
lambda plug: _om2.MFnMatrixData(plug.asMObject()).matrix(),
_om2.MFnData.kComponentList:
_get_component_list_data,
}
_numeric_attr_table = {
_om2.MFnNumericData.kBoolean: lambda plug: plug.asBool(),
_om2.MFnNumericData.kInt: lambda plug: plug.asInt(),
_om2.MFnNumericData.kByte: lambda plug: plug.asInt(),
def initialize():
mtxMFnAttr = om2.MFnMatrixAttribute()
compoundMFnAttr = om2.MFnCompoundAttribute()
numericMFnAttr = om2.MFnNumericAttribute()
numMFnAttr = om2.MFnNumericAttribute()
mFnNumericData = om2.MFnNumericData()
Vectors2Matrix.mtxOut = mtxMFnAttr.create('matrixOut', 'mtxOut')
mtxMFnAttr.readable = True
Vectors2Matrix.addAttribute(Vectors2Matrix.mtxOut)
Vectors2Matrix.row0 = compoundMFnAttr.create('row0', 'row0')
r0XChild = numMFnAttr.create("r0X", "r0X", mFnNumericData.kFloat, 1.0)
r0YChild = numMFnAttr.create("r0Y", "r0Y", mFnNumericData.kFloat, 0.0)
r0ZChild = numMFnAttr.create("r0Z", "r0Z", mFnNumericData.kFloat, 0.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
compoundMFnAttr.addChild(r0XChild)
compoundMFnAttr.addChild(r0YChild)
compoundMFnAttr.addChild(r0ZChild)
Vectors2Matrix.addAttribute(Vectors2Matrix.row0)
Vectors2Matrix.row0W = numericMFnAttr.create('row0W', 'row0W',
mFnNumericData.kFloat,
0.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
Vectors2Matrix.addAttribute(Vectors2Matrix.row0W)
Vectors2Matrix.row1 = compoundMFnAttr.create('row1', 'row1')
r1xChild = numMFnAttr.create("r1X", "r1X", mFnNumericData.kFloat, 0.0)
r1yChild = numMFnAttr.create("r1Y", "r1Y", mFnNumericData.kFloat, 1.0)
r1zChild = numMFnAttr.create("r1Z", "r1Z", mFnNumericData.kFloat, 0.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
compoundMFnAttr.addChild(r1xChild)
compoundMFnAttr.addChild(r1yChild)
compoundMFnAttr.addChild(r1zChild)
Vectors2Matrix.addAttribute(Vectors2Matrix.row1)
Vectors2Matrix.row1W = numericMFnAttr.create('row1W', 'row1W',
mFnNumericData.kFloat,
0.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
Vectors2Matrix.addAttribute(Vectors2Matrix.row1W)
Vectors2Matrix.row2 = compoundMFnAttr.create('row2', 'row2')
r2xChild = numMFnAttr.create("r2X", "r2X", mFnNumericData.kFloat, 0.0)
r2yChild = numMFnAttr.create("r2Y", "r2Y", mFnNumericData.kFloat, 0.0)
r2zChild = numMFnAttr.create("r2Z", "r2Z", mFnNumericData.kFloat, 1.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
compoundMFnAttr.addChild(r2xChild)
compoundMFnAttr.addChild(r2yChild)
compoundMFnAttr.addChild(r2zChild)
Vectors2Matrix.addAttribute(Vectors2Matrix.row2)
Vectors2Matrix.row2W = numericMFnAttr.create('row2W', 'row2W',
mFnNumericData.kFloat,
0.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
Vectors2Matrix.addAttribute(Vectors2Matrix.row2W)
Vectors2Matrix.row3 = compoundMFnAttr.create('row3', 'row3')
r3xChild = numMFnAttr.create("r3X", "r3X", mFnNumericData.kFloat, 0.0)
r3yChild = numMFnAttr.create("r3Y", "r3Y", mFnNumericData.kFloat, 0.0)
r3zChild = numMFnAttr.create("r3Z", "r3Z", mFnNumericData.kFloat, 0.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
compoundMFnAttr.addChild(r3xChild)
compoundMFnAttr.addChild(r3yChild)
compoundMFnAttr.addChild(r3zChild)
Vectors2Matrix.addAttribute(Vectors2Matrix.row3)
Vectors2Matrix.row3W = numericMFnAttr.create('row3W', 'row3W',
mFnNumericData.kFloat,
1.0)
mtxMFnAttr.readable = True
mtxMFnAttr.writable = True
mtxMFnAttr.storable = True
Vectors2Matrix.addAttribute(Vectors2Matrix.row3W)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row0,
Vectors2Matrix.mtxOut)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row0W,
Vectors2Matrix.mtxOut)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row1,
Vectors2Matrix.mtxOut)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row1W,
Vectors2Matrix.mtxOut)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row2,
Vectors2Matrix.mtxOut)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row2W,
Vectors2Matrix.mtxOut)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row3,
Vectors2Matrix.mtxOut)
Vectors2Matrix.attributeAffects(Vectors2Matrix.row3W,
Vectors2Matrix.mtxOut)
