MStatus clusterControledCurve::initialize()
{
MStatus status;
MFnNumericAttribute nAttr;
MFnMatrixAttribute mAttr;
MFnTypedAttribute tAttr;
MFnCompoundAttribute cAttr;
aInputCurve = tAttr.create( "inputCurve", "inputCurve", MFnData::kNurbsCurve );
tAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aInputCurve ) );
aInputCurveMatrix = mAttr.create( "inputCurveMatrix", "inputCurveMatrix" );
mAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aInputCurveMatrix ) );
aDumyMatrix = mAttr.create( "dumyMatrix", "dumyMatrix" );
mAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aDumyMatrix ) );
aBindPreMatrix = mAttr.create( "bindPreMatrix", "bindPreMatrix" );
mAttr.setStorable( true );
mAttr.setArray( true );
nAttr.setUsesArrayDataBuilder( true );
CHECK_MSTATUS( addAttribute( aBindPreMatrix ) );
aMatrix = mAttr.create( "matrix", "matrix" );
mAttr.setStorable( true );
mAttr.setArray( true );
CHECK_MSTATUS( addAttribute( aMatrix ) );
aWeightList = cAttr.create( "weightList", "weightList" );
aWeights = nAttr.create( "weights", "weights", MFnNumericData::kFloat, 0.0 );
nAttr.setArray( true );
nAttr.setUsesArrayDataBuilder( true );
cAttr.addChild( aWeights );
cAttr.setArray( true );
cAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aWeightList ) );
aUpdate = nAttr.create( "update", "update", MFnNumericData::kBoolean, false );
nAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aUpdate ) );
aOutputCurve = tAttr.create( "outputCurve", "outputCurve", MFnData::kNurbsCurve );
CHECK_MSTATUS( addAttribute( aOutputCurve ) );
CHECK_MSTATUS( attributeAffects( aInputCurve, aOutputCurve ) );
CHECK_MSTATUS( attributeAffects( aInputCurveMatrix, aOutputCurve ) );
CHECK_MSTATUS( attributeAffects( aDumyMatrix, aOutputCurve ) );
CHECK_MSTATUS( attributeAffects( aBindPreMatrix, aOutputCurve ) );
CHECK_MSTATUS( attributeAffects( aMatrix, aOutputCurve ) );
CHECK_MSTATUS( attributeAffects( aWeightList, aOutputCurve ) );
CHECK_MSTATUS( attributeAffects( aUpdate, aOutputCurve ) );
return MS::kSuccess;
}
MStatus sgIkSmoothStretch::initialize()
{
MStatus stat;
MFnNumericAttribute nAttr;
aInputDistance = nAttr.create( "inputDistance", "in", MFnNumericData::kDouble, 0.0 );
nAttr.setArray( true );
nAttr.setUsesArrayDataBuilder( true );
nAttr.setStorable( true );
aInPositionX = nAttr.create( "inPositionX", "ipx", MFnNumericData::kDouble, 0.0 );
nAttr.setStorable( true );
aInPositionY = nAttr.create( "inPositionY", "ipy", MFnNumericData::kDouble, 0.0 );
nAttr.setStorable( true );
aInPositionZ = nAttr.create( "inPositionZ", "ipz", MFnNumericData::kDouble, 0.0 );
nAttr.setStorable( true );
aInPosition = nAttr.create( "inPosition", "ip", aInPositionX, aInPositionY, aInPositionZ );
aOutputDistance = nAttr.create( "outputDistance", "out", MFnNumericData::kDouble, 0,0 );
nAttr.setArray( true );
nAttr.setUsesArrayDataBuilder( true );
nAttr.setStorable( false );
nAttr.setWritable( false );
aSmoothArea = nAttr.create( "smoothArea", "smoothArea", MFnNumericData::kDouble, 0.0 );
nAttr.setStorable( true );
aStretchAble = nAttr.create( "stretchAble", "sa", MFnNumericData::kFloat, 1.0 );
nAttr.setStorable( true );
nAttr.setMin( 0.0 );
nAttr.setMax( 1 );
stat = addAttribute( aInputDistance );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( aInPosition );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( aOutputDistance );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( aStretchAble );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( aSmoothArea );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = attributeAffects( aInputDistance, aOutputDistance );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( aInPosition, aOutputDistance );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( aStretchAble, aOutputDistance );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( aSmoothArea, aOutputDistance );
if (!stat) { stat.perror("attributeAffects"); return stat;}
return MS::kSuccess;
}
MStatus BCIViz::initialize()
{
MFnNumericAttribute numFn;
MFnMatrixAttribute matAttr;
MStatus stat;
ainput = matAttr.create( "input", "in", MFnMatrixAttribute::kDouble );
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setConnectable(true);
addAttribute(ainput);
atargets = matAttr.create( "target", "tgt", MFnMatrixAttribute::kDouble );
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setArray(true);
matAttr.setConnectable(true);
addAttribute(atargets);
outValue = numFn.create( "outValue", "ov", MFnNumericData::kDouble );
numFn.setStorable(false);
numFn.setWritable(false);
numFn.setReadable(true);
numFn.setArray(true);
numFn.setUsesArrayDataBuilder( true );
addAttribute(outValue);
attributeAffects(ainput, outValue);
attributeAffects(atargets, outValue);
return MS::kSuccess;
}
MStatus weightList::initialize()
{
MStatus status;
MFnNumericAttribute numAtt;
aBias = numAtt.create( "bias", "b", MFnNumericData::kFloat);
addAttribute(aBias);
aWeights = numAtt.create("weights", "w", MFnNumericData::kFloat, -1000.0, &status);
numAtt.setKeyable(true);
numAtt.setArray(true);
numAtt.setReadable(true);
numAtt.setUsesArrayDataBuilder(true);
// setIndexMatters() will only affect array attributes with setReadable set to false,
// i.e. destination attributes. We have set the default value to an unlikely value
// to guarantee an entry is created regardless of its value.
// numAtt.setIndexMatters(true);
addAttribute(aWeights);
MFnCompoundAttribute cmpAttr;
aWeightsList = cmpAttr.create("weightsList", "wl", &status);
cmpAttr.setArray(true);
cmpAttr.addChild(aWeights);
cmpAttr.setReadable(true);
cmpAttr.setUsesArrayDataBuilder(true);
// cmpAttr.setIndexMatters(true);
addAttribute(aWeightsList);
attributeAffects(aBias, aWeightsList);
return MStatus::kSuccess;
}
// init of plugin
MStatus weightControllerNode::initialize(){
MFnNumericAttribute nAttr;
aOutputs = nAttr.create("outputs", "out", MFnNumericData::kFloat, 0.0);
nAttr.setArray(true);
nAttr.setUsesArrayDataBuilder(true);
addAttribute(aOutputs);
aLocator = nAttr.create("locator", "lc", MFnNumericData::k3Float);
addAttribute(aLocator);
attributeAffects( aLocator, aOutputs );
aVertices = nAttr.create("vertices", "v", MFnNumericData::k3Float);
nAttr.setArray(true);
nAttr.setUsesArrayDataBuilder(true);
addAttribute(aVertices);
attributeAffects( aVertices, aOutputs);
return MS::kSuccess;
}
MStatus n_tentacle::initialize()
{
MFnNumericAttribute numericAttr;
MFnMatrixAttribute matrixAttr;
MFnTypedAttribute typedAttr;
MFnUnitAttribute unitAttribute;
MFnEnumAttribute enumAttr;
MStatus stat;
stretch = numericAttr.create("stretch", "st", MFnNumericData::kDouble, 0.0);
numericAttr.setMin(0.0);
numericAttr.setMax(1.0);
globalScale = numericAttr.create("globalScale", "gs", MFnNumericData::kDouble, 1.0);
numericAttr.setMin(0.00001);
numericAttr.setMax(10.0);
iniLength = numericAttr.create("iniLength", "iln", MFnNumericData::kDouble, 0.01);
parameter = numericAttr.create("parameter", "prm", MFnNumericData::kDouble, 0.0);
numericAttr.setArray(true);
blendRot = numericAttr.create("blendRot", "blr", MFnNumericData::kDouble, 0.0);
numericAttr.setArray(true);
interval = numericAttr.create("interval", "itv", MFnNumericData::kInt, 0);
numericAttr.setArray(true);
matrix = matrixAttr.create("matrix", "mtx");
matrixAttr.setArray(true);
matrixAttr.setHidden(true);
curve = typedAttr.create("curve", "crv", MFnData::kNurbsCurve);
outTranslate = numericAttr.create("outTranslate", "ot", MFnNumericData::k3Double);
numericAttr.setArray(true);
numericAttr.setHidden(true);
numericAttr.setUsesArrayDataBuilder(true);
numericAttr.setHidden(true);
outRotateX = unitAttribute.create("outRotateX", "orx", MFnUnitAttribute::kAngle);
outRotateY = unitAttribute.create("outRotateY", "ory", MFnUnitAttribute::kAngle);
outRotateZ = unitAttribute.create("outRotateZ", "orz", MFnUnitAttribute::kAngle);
outRotate = numericAttr.create("outRotate", "or",outRotateX, outRotateY, outRotateZ);
numericAttr.setArray(true);
numericAttr.setHidden(true);
numericAttr.setUsesArrayDataBuilder(true);
numericAttr.setHidden(true);
tangentAxis = enumAttr.create("tangentAxis", "tga", 1);
enumAttr.addField("X", 0);
enumAttr.addField("Y", 1);
enumAttr.addField("Z", 2);
enumAttr.addField("negativeX", 3);
enumAttr.addField("negativeY", 4);
enumAttr.addField("negativeZ", 5);
// Add the attributes we have created to the node
//
stat = addAttribute( parameter );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( blendRot );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( interval );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( stretch );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( globalScale );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( iniLength );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( matrix );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( curve );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( outTranslate );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( outRotate );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( tangentAxis );
if (!stat) { stat.perror("addAttribute"); return stat;}
attributeAffects( parameter, outTranslate );
attributeAffects( blendRot, outTranslate );
attributeAffects( interval, outTranslate );
attributeAffects( stretch, outTranslate );
attributeAffects( globalScale, outTranslate );
attributeAffects( iniLength, outTranslate );
attributeAffects( matrix, outTranslate );
attributeAffects( curve, outTranslate );
attributeAffects( tangentAxis, outTranslate );
attributeAffects( parameter, outRotate );
attributeAffects( blendRot, outRotate );
attributeAffects( interval, outRotate );
attributeAffects( stretch, outRotate );
attributeAffects( globalScale, outRotate );
attributeAffects( iniLength, outRotate );
attributeAffects( matrix, outRotate );
attributeAffects( curve, outRotate );
attributeAffects( tangentAxis, outRotate );
attributeAffects( parameter, outRotateX );
attributeAffects( blendRot, outRotateX );
attributeAffects( interval, outRotateX );
attributeAffects( stretch, outRotateX );
attributeAffects( globalScale, outRotateX );
attributeAffects( iniLength, outRotateX );
attributeAffects( matrix, outRotateX );
attributeAffects( curve, outRotateX );
attributeAffects( tangentAxis, outRotateX );
attributeAffects( parameter, outRotateY );
attributeAffects( blendRot, outRotateY );
attributeAffects( interval, outRotateY );
attributeAffects( stretch, outRotateY );
attributeAffects( globalScale, outRotateY );
attributeAffects( iniLength, outRotateY );
attributeAffects( matrix, outRotateY );
attributeAffects( curve, outRotateY );
attributeAffects( tangentAxis, outRotateY );
attributeAffects( parameter, outRotateZ );
attributeAffects( blendRot, outRotateZ );
attributeAffects( interval, outRotateZ );
attributeAffects( stretch, outRotateZ );
attributeAffects( globalScale, outRotateZ );
attributeAffects( iniLength, outRotateZ );
attributeAffects( matrix, outRotateZ );
attributeAffects( curve, outRotateZ );
attributeAffects( tangentAxis, outRotateZ );
return MS::kSuccess;
}
MStatus AlembicNode::initialize()
{
MStatus status;
MFnUnitAttribute uAttr;
MFnTypedAttribute tAttr;
MFnNumericAttribute nAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
// add the input attributes: time, file, sequence time
mTimeAttr = uAttr.create("time", "tm", MFnUnitAttribute::kTime, 0.0);
status = uAttr.setStorable(true);
status = addAttribute(mTimeAttr);
// input file name
MFnStringData fileFnStringData;
MObject fileNameDefaultObject = fileFnStringData.create("");
mAbcFileNameAttr = tAttr.create("abc_File", "fn",
MFnData::kString, fileNameDefaultObject);
status = tAttr.setStorable(true);
status = tAttr.setUsedAsFilename(true);
status = addAttribute(mAbcFileNameAttr);
// playback speed
mSpeedAttr = nAttr.create("speed", "sp",
MFnNumericData::kDouble, 1.0, &status);
status = nAttr.setWritable(true);
status = nAttr.setStorable(true);
status = nAttr.setKeyable(true);
status = addAttribute(mSpeedAttr);
// frame offset
mOffsetAttr = nAttr.create("offset", "of",
MFnNumericData::kDouble, 0, &status);
status = nAttr.setWritable(true);
status = nAttr.setStorable(true);
status = nAttr.setKeyable(true);
status = addAttribute(mOffsetAttr);
// cycle type
mCycleTypeAttr = eAttr.create("cycleType", "ct", 0, &status );
status = eAttr.addField("Hold", PLAYTYPE_HOLD);
status = eAttr.addField("Loop", PLAYTYPE_LOOP);
status = eAttr.addField("Reverse", PLAYTYPE_REVERSE);
status = eAttr.addField("Bounce", PLAYTYPE_BOUNCE);
status = eAttr.setWritable(true);
status = eAttr.setStorable(true);
status = eAttr.setKeyable(true);
status = addAttribute(mCycleTypeAttr);
// Regex Filter
// This is a hidden variable to preserve a regexIncludefilter string
// into a .ma file.
mIncludeFilterAttr = tAttr.create("regexIncludeFilter", "ift",
MFnData::kString);
status = tAttr.setStorable(true);
status = tAttr.setHidden(true);
status = addAttribute(mIncludeFilterAttr);
// Regex Filter
// This is a hidden variable to preserve a regexExcludefilter string
// into a .ma file.
mExcludeFilterAttr = tAttr.create("regexExcludeFilter", "eft",
MFnData::kString);
status = tAttr.setStorable(true);
status = tAttr.setHidden(true);
status = addAttribute(mExcludeFilterAttr);
// sequence min and max in frames
mStartFrameAttr = nAttr.create("startFrame", "sf",
MFnNumericData::kDouble, 0, &status);
status = nAttr.setWritable(false);
status = nAttr.setStorable(true);
status = addAttribute(mStartFrameAttr);
mEndFrameAttr = nAttr.create("endFrame", "ef",
MFnNumericData::kDouble, 0, &status);
status = nAttr.setWritable(false);
status = nAttr.setStorable(true);
status = addAttribute(mEndFrameAttr);
// add the output attributes
// sampled subD mesh
MFnMeshData fnMeshData;
MObject meshDefaultObject = fnMeshData.create(&status);
mOutSubDArrayAttr = tAttr.create("outSubDMesh", "osubd",
MFnData::kMesh, meshDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutSubDArrayAttr);
// sampled poly mesh
mOutPolyArrayAttr = tAttr.create("outPolyMesh", "opoly",
MFnData::kMesh, meshDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutPolyArrayAttr);
// sampled nurbs surface
MFnNurbsSurfaceData fnNSData;
MObject nsDefaultObject = fnNSData.create(&status);
mOutNurbsSurfaceArrayAttr = tAttr.create("outNSurface", "ons",
MFnData::kNurbsSurface, nsDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutNurbsSurfaceArrayAttr);
// sampled nurbs curve group
MFnNurbsCurveData fnNCData;
MObject ncDefaultObject = fnNCData.create(&status);
mOutNurbsCurveGrpArrayAttr = tAttr.create("outNCurveGrp", "onc",
MFnData::kNurbsCurve, ncDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutNurbsCurveGrpArrayAttr);
// sampled locator
mOutLocatorPosScaleArrayAttr = nAttr.create("outLoc", "olo",
MFnNumericData::kDouble, 0.0, &status);
status = nAttr.setStorable(false);
status = nAttr.setWritable(false);
status = nAttr.setArray(true);
status = nAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutLocatorPosScaleArrayAttr);
// sampled transform operations
mOutTransOpArrayAttr = nAttr.create("transOp", "to",
MFnNumericData::kDouble, 0.0, &status);
status = nAttr.setStorable(false);
status = nAttr.setWritable(false);
status = nAttr.setArray(true);
status = nAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutTransOpArrayAttr);
// sampled camera
// assume the boolean variables cannot be keyed
mOutCameraArrayAttr = nAttr.create("outCamera", "ocam",
MFnNumericData::kDouble, 0.0, &status);
status = nAttr.setStorable(false);
status = nAttr.setWritable(false);
status = nAttr.setArray(true);
status = nAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutCameraArrayAttr);
// sampled custom-attributes
mOutPropArrayAttr = gAttr.create("prop", "pr", &status);
status = gAttr.addNumericDataAccept(MFnNumericData::kBoolean);
status = gAttr.addNumericDataAccept(MFnNumericData::kByte);
status = gAttr.addNumericDataAccept(MFnNumericData::kShort);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Short);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Short);
status = gAttr.addNumericDataAccept(MFnNumericData::kInt);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Int);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Int);
status = gAttr.addNumericDataAccept(MFnNumericData::kFloat);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Float);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Float);
status = gAttr.addNumericDataAccept(MFnNumericData::kDouble);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Double);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Double);
status = gAttr.addNumericDataAccept(MFnNumericData::k4Double);
status = gAttr.addDataAccept(MFnData::kString);
status = gAttr.addDataAccept(MFnData::kIntArray);
status = gAttr.addDataAccept(MFnData::kDoubleArray);
status = gAttr.addDataAccept(MFnData::kVectorArray);
status = gAttr.addDataAccept(MFnData::kPointArray);
status = gAttr.setWritable(false);
status = gAttr.setKeyable(false);
status = gAttr.setArray(true);
status = gAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutPropArrayAttr);
// set up affection relationships
status = attributeAffects(mTimeAttr, mOutSubDArrayAttr);
status = attributeAffects(mTimeAttr, mOutPolyArrayAttr);
status = attributeAffects(mTimeAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mTimeAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mTimeAttr, mOutTransOpArrayAttr);
status = attributeAffects(mTimeAttr, mOutCameraArrayAttr);
status = attributeAffects(mTimeAttr, mOutPropArrayAttr);
status = attributeAffects(mTimeAttr, mOutLocatorPosScaleArrayAttr);
status = attributeAffects(mSpeedAttr, mOutSubDArrayAttr);
status = attributeAffects(mSpeedAttr, mOutPolyArrayAttr);
status = attributeAffects(mSpeedAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mSpeedAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mSpeedAttr, mOutTransOpArrayAttr);
status = attributeAffects(mSpeedAttr, mOutCameraArrayAttr);
status = attributeAffects(mSpeedAttr, mOutPropArrayAttr);
status = attributeAffects(mSpeedAttr, mOutLocatorPosScaleArrayAttr);
status = attributeAffects(mOffsetAttr, mOutSubDArrayAttr);
status = attributeAffects(mOffsetAttr, mOutPolyArrayAttr);
status = attributeAffects(mOffsetAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mOffsetAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mOffsetAttr, mOutTransOpArrayAttr);
status = attributeAffects(mOffsetAttr, mOutCameraArrayAttr);
status = attributeAffects(mOffsetAttr, mOutPropArrayAttr);
status = attributeAffects(mOffsetAttr, mOutLocatorPosScaleArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutSubDArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutPolyArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutTransOpArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutCameraArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutPropArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutLocatorPosScaleArrayAttr);
MGlobal::executeCommand( UITemplateMELScriptStr );
return status;
}
// plugin (un)initialiser
MStatus nwayDeformerNode::initialize()
{
MFnTypedAttribute tAttr;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnMatrixAttribute mAttr;
aBlendMesh = tAttr.create("blendMesh", "mesh", MFnData::kMesh);
tAttr.setArray(true);
tAttr.setUsesArrayDataBuilder(true);
addAttribute(aBlendMesh);
attributeAffects( aBlendMesh, outputGeom );
aWeight = nAttr.create("blendWeight", "bw", MFnNumericData::kDouble, 0.0);
nAttr.setArray(true);
nAttr.setKeyable(true);
nAttr.setStorable(true);
nAttr.setUsesArrayDataBuilder(true);
addAttribute(aWeight);
attributeAffects( aWeight, outputGeom );
aRotationConsistency = nAttr.create( "rotationConsistency", "rc", MFnNumericData::kBoolean, false );
nAttr.setStorable(true);
addAttribute( aRotationConsistency );
attributeAffects( aRotationConsistency, outputGeom );
aInitRotation = nAttr.create("initRotation", "ir", MFnNumericData::kDouble);
addAttribute(aInitRotation);
attributeAffects( aInitRotation, outputGeom );
aVisualiseEnergy = nAttr.create( "visualiseEnergy", "ve", MFnNumericData::kBoolean, false );
nAttr.setStorable(true);
addAttribute( aVisualiseEnergy );
attributeAffects( aVisualiseEnergy, outputGeom );
aVisualisationMultiplier = nAttr.create("visualisationMultiplier", "vmp", MFnNumericData::kDouble, 1.0);
nAttr.setStorable(true);
addAttribute( aVisualisationMultiplier );
attributeAffects( aVisualisationMultiplier, outputGeom );
aBlendMode = eAttr.create( "blendMode", "bm", BM_SRL );
eAttr.addField( "expSO+expSym", BM_SRL );
eAttr.addField( "logmatrix3", BM_LOG3 );
eAttr.addField( "quat+linear", BM_SQL );
eAttr.addField( "expSO+linear", BM_SlRL );
eAttr.addField( "linear", BM_AFF );
eAttr.addField( "off", BM_OFF );
addAttribute( aBlendMode );
attributeAffects( aBlendMode, outputGeom );
aTetMode = eAttr.create( "tetMode", "tm", TM_FACE );
eAttr.addField( "face", TM_FACE );
eAttr.addField( "edge", TM_EDGE );
eAttr.addField( "vertex", TM_VERTEX );
eAttr.addField( "vface", TM_VFACE );
addAttribute( aTetMode );
attributeAffects( aTetMode, outputGeom );
aIteration = nAttr.create("iteration", "it", MFnNumericData::kShort, 1);
addAttribute(aIteration);
attributeAffects(aIteration, outputGeom);
// this shouldn't affect outputGeom
aEnergy = nAttr.create("energy", "energy", MFnNumericData::kDouble, 0.0);
nAttr.setArray(true);
nAttr.setKeyable(true);
nAttr.setStorable(true);
nAttr.setUsesArrayDataBuilder(true);
addAttribute(aEnergy);
// Make the deformer weights paintable
MGlobal::executeCommand( "makePaintable -attrType multiFloat -sm deformer nwayBlender weights;" );
return MS::kSuccess;
}
// create attributes
MStatus probeDeformerARAPNode::initialize(){
MFnTypedAttribute tAttr;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnMatrixAttribute mAttr;
MRampAttribute rAttr;
// this attr will be dirtied when ARAP recomputation is needed
aARAP = nAttr.create( "arap", "arap", MFnNumericData::kBoolean, true );
nAttr.setStorable(false);
nAttr.setKeyable(false);
nAttr.setHidden(true);
addAttribute( aARAP );
// this attr will be dirtied when weight recomputation is needed
aComputeWeight = nAttr.create( "computeWeight", "computeWeight", MFnNumericData::kBoolean, true );
nAttr.setStorable(false);
nAttr.setKeyable(false);
nAttr.setHidden(true);
addAttribute( aComputeWeight );
aMatrix = mAttr.create("probeMatrix", "pm");
mAttr.setStorable(false);
mAttr.setHidden(true);
mAttr.setArray(true);
mAttr.setUsesArrayDataBuilder(true);
mAttr.setDisconnectBehavior(MFnMatrixAttribute::kDelete);
addAttribute(aMatrix);
attributeAffects( aMatrix, outputGeom );
aInitMatrix = mAttr.create("initProbeMatrix", "ipm");
mAttr.setHidden(true);
mAttr.setArray(true);
mAttr.setStorable(true);
mAttr.setUsesArrayDataBuilder(true);
addAttribute(aInitMatrix);
attributeAffects( aInitMatrix, outputGeom );
aBlendMode = eAttr.create( "blendMode", "bm", BM_SRL );
eAttr.addField( "expSO+expSym", BM_SRL );
eAttr.addField( "expSE+expSym", BM_SSE );
eAttr.addField( "logmatrix3", BM_LOG3 );
eAttr.addField( "logmatrix4", BM_LOG4 );
eAttr.addField( "quat+linear", BM_SQL );
eAttr.addField( "linear", BM_AFF );
eAttr.addField( "off", BM_OFF );
eAttr.setStorable(true);
eAttr.setKeyable(false);
addAttribute( aBlendMode );
attributeAffects( aBlendMode, outputGeom );
aRotationConsistency = nAttr.create( "rotationConsistency", "rc", MFnNumericData::kBoolean, false );
nAttr.setKeyable(false);
nAttr.setStorable(true);
addAttribute( aRotationConsistency );
attributeAffects( aRotationConsistency, outputGeom );
aFrechetSum = nAttr.create( "frechetSum", "fs", MFnNumericData::kBoolean, false );
nAttr.setKeyable(false);
nAttr.setStorable(true);
addAttribute( aFrechetSum );
attributeAffects( aFrechetSum, outputGeom );
aNormaliseWeight = eAttr.create( "normaliseWeight", "nw", NM_LINEAR );
eAttr.addField( "NONE", NM_NONE );
eAttr.addField( "Linear", NM_LINEAR );
eAttr.addField( "Softmax", NM_SOFTMAX );
eAttr.setStorable(true);
addAttribute( aNormaliseWeight );
attributeAffects( aNormaliseWeight, outputGeom );
attributeAffects( aNormaliseWeight, aComputeWeight );
aWeightMode = eAttr.create( "weightMode", "wtm", WM_HARMONIC_COTAN );
eAttr.addField( "inverse", WM_INV_DISTANCE );
eAttr.addField( "cut-off", WM_CUTOFF_DISTANCE );
eAttr.addField( "draw", WM_DRAW );
// eAttr.addField( "harmonic-arap", WM_HARMONIC_ARAP);
eAttr.addField( "harmonic-cotan", WM_HARMONIC_COTAN);
eAttr.setStorable(true);
eAttr.setKeyable(false);
addAttribute( aWeightMode );
attributeAffects( aWeightMode, outputGeom );
attributeAffects( aWeightMode, aComputeWeight );
aConstraintMode = eAttr.create( "constraintMode", "ctm", CONSTRAINT_CLOSEST );
eAttr.addField( "neighbour", CONSTRAINT_NEIGHBOUR);
eAttr.addField( "closestFace", CONSTRAINT_CLOSEST );
eAttr.setStorable(true);
eAttr.setKeyable(false);
addAttribute( aConstraintMode );
attributeAffects( aConstraintMode, outputGeom );
attributeAffects( aConstraintMode, aARAP);
aTetMode = eAttr.create( "tetMode", "tm", TM_FACE );
eAttr.addField( "face", TM_FACE );
eAttr.addField( "edge", TM_EDGE );
eAttr.addField( "vertex", TM_VERTEX );
eAttr.addField( "vface", TM_VFACE );
eAttr.setStorable(true);
eAttr.setKeyable(false);
addAttribute( aTetMode );
attributeAffects( aTetMode, outputGeom );
attributeAffects( aTetMode, aARAP );
attributeAffects( aTetMode, aComputeWeight );
aWorldMode = nAttr.create( "worldMode", "wrldmd", MFnNumericData::kBoolean, true );
nAttr.setStorable(true);
nAttr.setKeyable(false);
addAttribute( aWorldMode );
attributeAffects( aWorldMode, outputGeom );
attributeAffects( aWorldMode, aARAP );
aEffectRadius = nAttr.create("effectRadius", "er", MFnNumericData::kDouble, 8.0);
nAttr.setMin( EPSILON );
nAttr.setStorable(true);
addAttribute( aEffectRadius );
attributeAffects( aEffectRadius, outputGeom );
attributeAffects( aEffectRadius, aComputeWeight );
aTransWeight = nAttr.create("translationWeight", "tw", MFnNumericData::kDouble, 1e-20);
nAttr.setStorable(true);
addAttribute( aTransWeight );
attributeAffects( aTransWeight, outputGeom );
attributeAffects( aTransWeight, aARAP );
aAreaWeighted = nAttr.create( "areaWeighted", "aw", MFnNumericData::kBoolean, false );
nAttr.setStorable(true);
addAttribute( aAreaWeighted );
attributeAffects( aAreaWeighted, outputGeom );
attributeAffects( aAreaWeighted, aARAP );
aNeighbourWeighting = nAttr.create( "neighbourWeighting", "nghbrw", MFnNumericData::kBoolean, false );
nAttr.setStorable(true);
addAttribute( aNeighbourWeighting );
attributeAffects( aNeighbourWeighting, outputGeom );
attributeAffects( aNeighbourWeighting, aComputeWeight );
attributeAffects( aNeighbourWeighting, aARAP );
aConstraintWeight = nAttr.create("constraintWeight", "cw", MFnNumericData::kDouble, 1.0);
nAttr.setStorable(true);
addAttribute( aConstraintWeight );
attributeAffects( aConstraintWeight, outputGeom );
attributeAffects( aConstraintWeight, aARAP );
aNormExponent = nAttr.create("normExponent", "ne", MFnNumericData::kDouble, 1.0);
nAttr.setStorable(true);
addAttribute( aNormExponent );
attributeAffects( aNormExponent, outputGeom );
attributeAffects( aNormExponent, aARAP );
attributeAffects( aNormExponent, aComputeWeight );
aIteration = nAttr.create("iteration", "it", MFnNumericData::kShort, 1);
nAttr.setStorable(true);
addAttribute(aIteration);
attributeAffects(aIteration, outputGeom);
aConstraintRadius = nAttr.create("constraintRadius", "cr", MFnNumericData::kDouble, 1.0);
nAttr.setStorable(true);
addAttribute( aConstraintRadius );
attributeAffects( aConstraintRadius, outputGeom );
attributeAffects( aConstraintRadius, aARAP );
aVisualisationMode = eAttr.create( "visualisationMode", "vm", VM_OFF );
eAttr.addField( "off", VM_OFF );
eAttr.addField( "energy", VM_ENERGY );
eAttr.addField( "effect", VM_EFFECT );
eAttr.addField( "constraint", VM_CONSTRAINT );
eAttr.addField( "stiffness", VM_STIFFNESS );
eAttr.setStorable(true);
addAttribute( aVisualisationMode );
attributeAffects( aVisualisationMode, outputGeom );
aVisualisationMultiplier = nAttr.create("visualisationMultiplier", "vmp", MFnNumericData::kDouble, 1.0);
nAttr.setStorable(true);
addAttribute( aVisualisationMultiplier );
attributeAffects( aVisualisationMultiplier, outputGeom );
aStiffness = eAttr.create( "stiffnessMode", "stfm", SM_NONE );
eAttr.addField( "off", SM_NONE );
eAttr.addField( "painted weight", SM_PAINT );
eAttr.addField( "learn", SM_LEARN );
eAttr.setStorable(true);
addAttribute( aStiffness );
attributeAffects( aStiffness, outputGeom );
attributeAffects( aStiffness, aARAP );
aSupervisedMesh = tAttr.create("supervisedMesh", "svmesh", MFnData::kMesh);
tAttr.setStorable(true);
tAttr.setArray(true);
tAttr.setUsesArrayDataBuilder(true);
addAttribute(aSupervisedMesh);
attributeAffects( aSupervisedMesh, outputGeom );
attributeAffects( aSupervisedMesh, aARAP );
aProbeWeight = nAttr.create("probeWeight", "prw", MFnNumericData::kDouble, 1.0);
nAttr.setArray(true);
nAttr.setStorable(true);
nAttr.setUsesArrayDataBuilder(true);
addAttribute(aProbeWeight);
attributeAffects( aProbeWeight, outputGeom );
attributeAffects( aProbeWeight, aComputeWeight );
aProbeConstraintRadius = nAttr.create("probeConstraintRadius", "prcr", MFnNumericData::kDouble, 1.0);
nAttr.setArray(true);
nAttr.setStorable(true);
nAttr.setUsesArrayDataBuilder(true);
addAttribute(aProbeConstraintRadius);
attributeAffects( aProbeConstraintRadius, outputGeom );
attributeAffects( aProbeConstraintRadius, aARAP );
//ramp
aWeightCurveR = rAttr.createCurveRamp( "weightCurveRotation", "wcr" );
addAttribute( aWeightCurveR );
attributeAffects( aWeightCurveR, outputGeom );
attributeAffects( aWeightCurveR, aComputeWeight );
aWeightCurveS = rAttr.createCurveRamp( "weightCurveShear", "wcs" );
addAttribute( aWeightCurveS );
attributeAffects( aWeightCurveS, outputGeom );
attributeAffects( aWeightCurveS, aComputeWeight );
aWeightCurveL = rAttr.createCurveRamp( "weightCurveTranslation", "wcl" );
addAttribute( aWeightCurveL );
attributeAffects( aWeightCurveL, outputGeom );
attributeAffects( aWeightCurveL, aComputeWeight );
// Make the deformer weights paintable
MGlobal::executeCommand( "makePaintable -attrType multiFloat -sm deformer probeDeformerARAP weights;" );
return MS::kSuccess;
}
