MStatus HesMeshNode::initialize()
{
MFnNumericAttribute numAttr;
MStatus stat;
MFnTypedAttribute stringAttr;
input = stringAttr.create( "hesPath", "hsp", MFnData::kString );
stringAttr.setStorable(true);
addAttribute( input );
ameshname = stringAttr.create( "meshName", "mn", MFnData::kString );
stringAttr.setStorable(true);
stringAttr.setArray(true);
stringAttr.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( ameshname );
MFnTypedAttribute meshAttr;
outMesh = meshAttr.create( "outMesh", "o", MFnData::kMesh );
meshAttr.setStorable(false);
meshAttr.setWritable(false);
meshAttr.setArray(true);
meshAttr.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( outMesh );
attributeAffects( input, outMesh );
return MS::kSuccess;
}
MStatus fullLoft::initialize()
{
MStatus stat;
MFnTypedAttribute typedAttr;
inputCurve=typedAttr.create( "inputCurve", "in",
MFnNurbsCurveData::kNurbsCurve,
&stat );
PERRORfail("initialize create input attribute");
stat = typedAttr.setArray( true );
PERRORfail("initialize set input attribute array");
outputSurface=typedAttr.create( "outputSurface", "out",
MFnNurbsSurfaceData::kNurbsSurface,
&stat );
PERRORfail("initialize create output attribute");
stat = typedAttr.setStorable( false );
PERRORfail("initialize set output attribute storable");
stat = addAttribute( inputCurve );
PERRORfail("addAttribute(inputCurve)");
stat = addAttribute( outputSurface );
PERRORfail("addAttribute(outputSurface)");
stat = attributeAffects( inputCurve, outputSurface );
PERRORfail("attributeAffects(inputCurve, outputSurface)");
return MS::kSuccess;
}
MStatus testNucleusNode::initialize()
{
MStatus stat;
MFnTypedAttribute tAttr;
startState = tAttr.create("startState", "sst", MFnData::kNObject, MObject::kNullObj, &stat );
statCheck(stat, "failed to create startState");
tAttr.setWritable(true);
tAttr.setStorable(true);
tAttr.setHidden(true);
tAttr.setArray(true);
currentState = tAttr.create("currentState", "cst", MFnData::kNObject, MObject::kNullObj, &stat );
statCheck(stat, "failed to create currentState");
tAttr.setWritable(true);
tAttr.setStorable(true);
tAttr.setHidden(true);
tAttr.setArray(true);
nextState = tAttr.create("nextState", "nst", MFnData::kNObject, MObject::kNullObj, &stat );
statCheck(stat, "failed to create nextState");
tAttr.setWritable(true);
tAttr.setStorable(true);
tAttr.setHidden(true);
tAttr.setArray(true);
MFnUnitAttribute uniAttr;
currentTime = uniAttr.create( "currentTime", "ctm" , MFnUnitAttribute::kTime, 0.0, &stat );
addAttribute(startState);
addAttribute(currentState);
addAttribute(nextState);
addAttribute(currentTime);
attributeAffects(startState, nextState);
attributeAffects(currentState, nextState);
attributeAffects(currentTime, nextState);
return MStatus::kSuccess;
}
MStatus multiCurve::initialize()
{
MStatus stat;
MFnNumericAttribute nAttr;
MFnTypedAttribute typedAttr;
numCurves = nAttr.create ("numCurves", "nc",
MFnNumericData::kLong, 5, &stat);
PERRORfail(stat, "initialize create numCurves attribute");
CHECK_MSTATUS ( nAttr.setKeyable( true ) );
stat = addAttribute( numCurves );
PERRORfail(stat, "addAttribute(numCurves)");
curveOffset = nAttr.create ("curveOffset", "co",
MFnNumericData::kDouble, 1.0, &stat);
PERRORfail(stat, "initialize create curveOffset attribute");
CHECK_MSTATUS ( nAttr.setKeyable( true ) );
stat = addAttribute( curveOffset );
PERRORfail(stat, "addAttribute(curveOffset)");
inputCurve = typedAttr.create( "inputCurve", "ic",
MFnNurbsCurveData::kNurbsCurve, &stat );
PERRORfail(stat, "initialize create inputCurve attribute");
CHECK_MSTATUS ( typedAttr.setReadable( false ) );
CHECK_MSTATUS ( typedAttr.setWritable( true ) );
stat = addAttribute( inputCurve );
PERRORfail(stat, "addAttribute(inputCurve)");
outputCurves = typedAttr.create( "outputCurves", "oc",
MFnNurbsCurveData::kNurbsCurve, &stat );
PERRORfail(stat, "initialize create outputCurves attribute");
CHECK_MSTATUS ( typedAttr.setArray( true ) );
CHECK_MSTATUS ( typedAttr.setReadable( true ) );
CHECK_MSTATUS ( typedAttr.setWritable( false ) );
CHECK_MSTATUS ( typedAttr.setUsesArrayDataBuilder( true ) );
stat = addAttribute( outputCurves );
PERRORfail(stat, "addAttribute(outputCurves)");
stat = attributeAffects( numCurves, outputCurves );
PERRORfail(stat, "attributeAffects(inputCurve, outputCurves)");
stat = attributeAffects( curveOffset, outputCurves );
PERRORfail(stat, "attributeAffects(inputCurve, outputCurves)");
stat = attributeAffects( inputCurve, outputCurves );
PERRORfail(stat, "attributeAffects(inputCurve, outputCurves)");
return stat;
}
MStatus TestDeformer::initialize()
{
MFnNumericAttribute numericAttr;
MFnTypedAttribute polyMeshAttr;
MFnEnumAttribute enumAttr;
MStatus status; // Status will be used to hold the MStatus value
// vertSnapInput
driver_mesh = polyMeshAttr.create( "vertSnapInput", "vsnpin", MFnData::kMesh, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( polyMeshAttr.setStorable( false ) );
CHECK_MSTATUS( polyMeshAttr.setArray(true) );
CHECK_MSTATUS( polyMeshAttr.setConnectable( true ) );
CHECK_MSTATUS( addAttribute(driver_mesh) );
CHECK_MSTATUS( attributeAffects(driver_mesh, outputGeom) );
// initialize is used to mark this node's state
initialized_data = enumAttr.create( "initialize", "inl", 0/*default*/, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( enumAttr.addField( "Off", 0) );
CHECK_MSTATUS( enumAttr.addField( "Re-Set Bind", 1) );
CHECK_MSTATUS( enumAttr.addField( "Bound", 2) );
CHECK_MSTATUS( enumAttr.setKeyable(true) );
CHECK_MSTATUS( enumAttr.setStorable(true) );
CHECK_MSTATUS( enumAttr.setReadable(true) );
CHECK_MSTATUS( enumAttr.setWritable(true) );
CHECK_MSTATUS( enumAttr.setDefault(0) );
CHECK_MSTATUS( addAttribute( initialized_data ) );
CHECK_MSTATUS( attributeAffects( initialized_data, outputGeom ) );
// hold the vertex index mapping
vert_map = numericAttr.create( "vtxIndexMap", "vtximp", MFnNumericData::kLong, 0/*default*/, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( numericAttr.setKeyable(false) );
CHECK_MSTATUS( numericAttr.setArray(true) );
CHECK_MSTATUS( numericAttr.setStorable(true) );
CHECK_MSTATUS( numericAttr.setReadable(true) );
CHECK_MSTATUS( numericAttr.setWritable(true) );
CHECK_MSTATUS( addAttribute( vert_map ) );
CHECK_MSTATUS( attributeAffects( vert_map, outputGeom ) );
CHECK_MSTATUS( MGlobal::executePythonCommand("import maya.cmds; maya.cmds.makePaintable('"+TestDeformer::cTypeName()+"', 'weights', attrType='multiFloat')") );
return( MS::kSuccess );
}
//
// Initialize the node
//
MStatus jhMeshBlur::initialize()
{
// attribute types
MFnUnitAttribute unitAttr;
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
aOldMeshData = tAttr.create("oldMesh","om",MFnData::kPointArray);
tAttr.setArray(true);
tAttr.setHidden(true);
tAttr.setIndexMatters(true);
// create the attributes
aStrength = nAttr.create( "Strength", "str", MFnNumericData::kFloat,1.0);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setMax(1.0);
nAttr.setMin(0.0);
aTreshhold = nAttr.create( "Treshold", "tres", MFnNumericData::kFloat,0.0);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setMin(0.0);
aShapeFactor = nAttr.create( "ShapeFactor", "shapef", MFnNumericData::kFloat,0.5);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setMax(1.0);
nAttr.setMin(0.0);
aTweakBlur = nAttr.create( "TweakBlur", "tweak", MFnNumericData::kBoolean,false);
nAttr.setKeyable(false);
nAttr.setChannelBox(true);
aQuadInterp = nAttr.create( "QuadInterpolation", "qi", MFnNumericData::kBoolean,true);
nAttr.setKeyable(false);
nAttr.setChannelBox(true);
aInterpPower = nAttr.create( "InterpolationPower", "interp", MFnNumericData::kDouble, 0.75);
nAttr.setKeyable(true);
nAttr.setMax(1.0);
nAttr.setMin(0.0);
aTime = unitAttr.create( "time", "tm", MFnUnitAttribute::kTime, 1.0 );
unitAttr.setStorable(true);
unitAttr.setCached(true);
unitAttr.setReadable(true);
unitAttr.setWritable(true);
unitAttr.setAffectsAppearance(true);
unitAttr.setAffectsWorldSpace(true);
// Make the attributes visible to the user
addAttribute( aStrength);
addAttribute( aTreshhold);
addAttribute( aTime);
addAttribute( aTweakBlur);
addAttribute( aQuadInterp);
addAttribute( aInterpPower);
addAttribute( aOldMeshData);
// Make sure when an attribute changes, the node updates
attributeAffects( aTime, outputGeom );
attributeAffects( aStrength, outputGeom );
attributeAffects( aTreshhold, outputGeom );
attributeAffects( aQuadInterp, outputGeom );
attributeAffects( aInterpPower, outputGeom );
// Not implented yet, but make the weights paintable :)
MGlobal::executeCommand("makePaintable -attrType multiFloat -sm deformer jhMeshBlur weights;");
return MStatus::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;
}
MStatus NBuddyEMPSaverNode::initialize()
{
MStatus status;
MFnTypedAttribute typedAttr; //Typed attributes
MFnUnitAttribute unitAttr;
MFnStringData stringData; //String Attributes
MFnNumericAttribute numFn; //Numerics
MFnPluginData dataFn;
//Create the body input array attribute
_inBodies = typedAttr.create("inBodies","inb" , naiadBodyData::id , MObject::kNullObj , &status);
NM_CheckMStatus(status, "ERROR creating inBodies attribute.\n");
typedAttr.setStorable( false );
typedAttr.setKeyable( false );
typedAttr.setWritable(true);
typedAttr.setReadable(false);
typedAttr.setArray( true );
status = addAttribute( _inBodies );
NM_CheckMStatus(status, "ERROR adding inBodies attribute.\n");
//Attribute for the folder in which to put the emp files
_empOutputPath = typedAttr.create( "empOutputPath", "ef", MFnData::kString ,stringData.create(MString("/home/jimmi/dev/naiad/emopen/maya/naiadForMaya/test.#.emp")), &status);
NM_CheckMStatus( status, "Failed to create empOutputPath attribute");
typedAttr.setStorable( true );
status = addAttribute( _empOutputPath );
NM_CheckMStatus( status, "Failed to add empOutputPath plug");
//Time input
_time = unitAttr.create( "time", "tm", MFnUnitAttribute::kTime, 0.0, &status );
NM_CheckMStatus( status, "Failed to create time attribute");
unitAttr.setStorable(true);
unitAttr.setWritable(true);
status = addAttribute( _time );
NM_CheckMStatus( status, "Failed to add time plug");
_framePadding = numFn.create( "framePadding", "fp", MFnNumericData::kInt, 4 , &status );
NM_CheckMStatus( status, "Failed to create framePadding attribute");
numFn.setStorable(true);
numFn.setWritable(true);
status = addAttribute( _framePadding );
NM_CheckMStatus( status, "Failed to add framePadding plug");
_timeStep = numFn.create( "timeStep", "ts", MFnNumericData::kInt, 0 , &status );
NM_CheckMStatus( status, "Failed to create timeStep attribute");
numFn.setStorable(true);
numFn.setWritable(true);
status = addAttribute( _timeStep );
NM_CheckMStatus( status, "Failed to add timeStep plug");
// an dummy output trigger to force evaluation of the node
_outTrigger = numFn.create("outTrigger", "ot", MFnNumericData::kBoolean);
NM_CheckMStatus( status, "Failed to create outTrigger attribute");
numFn.setStorable(false);
numFn.setWritable(false);
status = addAttribute( _outTrigger );
NM_CheckMStatus( status, "Failed to add outTrigger plug");
//Attribute Affects
attributeAffects( _inBodies, _outTrigger );
attributeAffects( _time, _outTrigger );
attributeAffects( _framePadding, _outTrigger );
attributeAffects( _timeStep, _outTrigger );
attributeAffects( _empOutputPath, _outTrigger );
return MS::kSuccess;
}
MStatus ProxyViz::initialize()
{
MFnNumericAttribute numFn;
MStatus stat;
alodgatehigh = numFn.create( "lodGateMax", "ldmx", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
numFn.setMax(2.f);
addAttribute(alodgatehigh);
alodgatelow = numFn.create( "lodGateMin", "ldmin", MFnNumericData::kFloat, 0.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.f);
numFn.setMax(0.999f);
addAttribute(alodgatelow);
abboxminx = numFn.create( "bBoxMinX", "bbmnx", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminx);
abboxminy = numFn.create( "bBoxMinY", "bbmny", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminy);
abboxminz = numFn.create( "bBoxMinZ", "bbmnz", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminz);
abboxmaxx = numFn.create( "bBoxMaxX", "bbmxx", MFnNumericData::kFloat, 1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxx);
abboxmaxy = numFn.create( "bBoxMaxY", "bbmxy", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxy);
abboxmaxz = numFn.create( "bBoxMaxZ", "bbmxz", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxz);
aradiusMult = numFn.create( "radiusMultiplier", "rml", MFnNumericData::kFloat);
numFn.setStorable(true);
numFn.setKeyable(true);
numFn.setDefault(1.f);
numFn.setMin(.05f);
addAttribute(aradiusMult);
axmultiplier = numFn.create( "visualMultiplierX", "vmx", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(axmultiplier);
aymultiplier = numFn.create( "visualMultiplierY", "vmy", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(aymultiplier);
azmultiplier = numFn.create( "visualMultiplierZ", "vmz", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(azmultiplier);
agroupcount = numFn.create( "numberInstances", "nis", MFnNumericData::kInt, 1);
numFn.setKeyable(false);
numFn.setStorable(true);
numFn.setMin(1);
addAttribute(agroupcount);
ainstanceId = numFn.create( "instanceId", "iis", MFnNumericData::kInt, 0);
numFn.setKeyable(false);
numFn.setStorable(true);
numFn.setMin(0);
addAttribute(ainstanceId);
MFnTypedAttribute typedAttrFn;
MVectorArray defaultVectArray;
MFnVectorArrayData vectArrayDataFn;
vectArrayDataFn.create( defaultVectArray );
outPositionPP = typedAttrFn.create( "outPosition",
"opos",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create pospp");
typedAttrFn.setStorable(false);
if(addAttribute( outPositionPP ) != MS::kSuccess) MGlobal::displayWarning("failed add pospp");
outScalePP = typedAttrFn.create( "outScale",
"oscl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create sclpp");
typedAttrFn.setStorable(false);
if(addAttribute(outScalePP) != MS::kSuccess) MGlobal::displayWarning("failed add sclpp");
outRotationPP = typedAttrFn.create( "outRotation",
"orot",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create rotpp");
typedAttrFn.setStorable(false);
if(addAttribute(outRotationPP) != MS::kSuccess) MGlobal::displayWarning("failed add rotpp");
MDoubleArray defaultDArray;
MFnDoubleArrayData dArrayDataFn;
dArrayDataFn.create( defaultDArray );
outReplacePP = typedAttrFn.create( "outReplace", "orpl",
MFnData::kDoubleArray, dArrayDataFn.object(),
&stat );
if(stat != MS::kSuccess) {
MGlobal::displayWarning("failed create outReplace");
}
typedAttrFn.setStorable(false);
stat = addAttribute(outReplacePP);
if(stat != MS::kSuccess) {
MGlobal::displayWarning("failed add outReplace");
}
outValue = numFn.create( "outValue", "ov", MFnNumericData::kFloat );
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(outValue);
outValue1 = numFn.create( "outValue1", "ov1", MFnNumericData::kFloat );
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(outValue1);
MFnTypedAttribute stringAttr;
acachename = stringAttr.create( "cachePath", "cp", MFnData::kString );
stringAttr.setStorable(true);
addAttribute( acachename );
astandinNames = stringAttr.create( "standinNames", "sdn", MFnData::kString );
stringAttr.setStorable(true);
stringAttr.setArray(true);
addAttribute(astandinNames);
MFnMatrixAttribute matAttr;
acameraspace = matAttr.create( "cameraSpace", "cspc", MFnMatrixAttribute::kDouble );
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setConnectable(true);
addAttribute(acameraspace);
ahapeture = numFn.create( "horizontalFilmAperture", "hfa", MFnNumericData::kDouble, 1.0 );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( ahapeture );
avapeture = numFn.create( "verticalFilmAperture", "vfa", MFnNumericData::kDouble, 1.0 );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( avapeture );
afocallength = numFn.create( "focalLength", "fl", MFnNumericData::kDouble );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( afocallength );
aconvertPercentage = numFn.create( "convertPercentage", "cvp", MFnNumericData::kDouble );
numFn.setStorable(false);
numFn.setConnectable(true);
numFn.setDefault(1.0);
numFn.setMax(1.0);
numFn.setMin(0.01);
addAttribute(aconvertPercentage);
agroundMesh = typedAttrFn.create("groundMesh", "grdm", MFnMeshData::kMesh);
typedAttrFn.setStorable(false);
typedAttrFn.setWritable(true);
typedAttrFn.setConnectable(true);
typedAttrFn.setArray(true);
typedAttrFn.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( agroundMesh );
attributeAffects(agroundMesh, outValue);
agroundSpace = matAttr.create("groundSpace", "grdsp", MFnMatrixAttribute::kDouble);
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setConnectable(true);
matAttr.setArray(true);
matAttr.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( agroundSpace );
attributeAffects(agroundSpace, outValue);
MPointArray defaultPntArray;
MFnPointArrayData pntArrayDataFn;
pntArrayDataFn.create( defaultPntArray );
aplantTransformCache = typedAttrFn.create( "transformCachePlant",
"tmcpl",
MFnData::kPointArray,
pntArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTransformCache);
MIntArray defaultIntArray;
MFnIntArrayData intArrayDataFn;
intArrayDataFn.create( defaultIntArray );
aplantIdCache = typedAttrFn.create( "idCachePlant",
"idcpl",
MFnData::kIntArray,
intArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantIdCache);
aplantTriangleIdCache = typedAttrFn.create( "triCachePlant",
"trcpl",
MFnData::kIntArray,
intArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTriangleIdCache);
aplantTriangleCoordCache = typedAttrFn.create( "coordCachePlant",
"crcpl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTriangleCoordCache);
aplantOffsetCache = typedAttrFn.create( "offsetCachePlant",
"otcpl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantOffsetCache);
ainexamp = typedAttrFn.create("inExample", "ixmp", MFnData::kPlugin);
typedAttrFn.setStorable(false);
typedAttrFn.setConnectable(true);
typedAttrFn.setArray(true);
addAttribute(ainexamp);
adisplayVox = numFn.create( "showVoxelThreshold", "svt", MFnNumericData::kFloat );
numFn.setDefault(1.0);
numFn.setMin(.7);
numFn.setMax(1.0);
numFn.setStorable(true);
numFn.setKeyable(true);
addAttribute(adisplayVox);
acheckDepth = numFn.create( "checkDepth", "cdp", MFnNumericData::kBoolean );
numFn.setDefault(0);
numFn.setStorable(false);
addAttribute(acheckDepth);
ainoverscan = numFn.create( "cameraOverscan", "cos", MFnNumericData::kDouble );
numFn.setDefault(1.33);
numFn.setStorable(false);
addAttribute(ainoverscan);
aactivated = numFn.create( "activated", "act", MFnNumericData::kBoolean );
numFn.setDefault(0);
numFn.setStorable(false);
addAttribute(aactivated);
attributeAffects(ainexamp, outValue1);
attributeAffects(aradiusMult, outValue1);
attributeAffects(abboxminx, outValue);
attributeAffects(abboxmaxx, outValue);
attributeAffects(abboxminy, outValue);
attributeAffects(abboxmaxy, outValue);
attributeAffects(abboxminz, outValue);
attributeAffects(abboxmaxz, outValue);
attributeAffects(outPositionPP, outValue);
return MS::kSuccess;
}
MStatus snapDeformer::initialize() {
MStatus stat;
MFnNumericAttribute FnNumeric;
MFnNumericAttribute FnNumericA;
MFnTypedAttribute FnTyped;
MFnEnumAttribute FnEnum;
//weight
weight = FnNumeric.create("weight", "we", MFnNumericData::kFloat);
FnNumeric.setKeyable(true);
FnNumeric.setStorable(true);
FnNumeric.setReadable(true);
FnNumeric.setWritable(true);
FnNumeric.setDefault( 1.0 );
addAttribute( weight );
///space target
space = FnEnum.create("space", "sp", 0);
FnEnum.addField("world",0);
FnEnum.addField("object",1);
FnEnum.setStorable(true);
FnEnum.setKeyable(true);
addAttribute(space);
///space source
spaceSource = FnEnum.create("spaceSource", "sps", 0);
FnEnum.addField("world",0);
FnEnum.addField("object",1);
FnEnum.setStorable(true);
FnEnum.setKeyable(true);
addAttribute(spaceSource);
//pointlist
pointList = FnNumericA.create("pointList", "pl", MFnNumericData::kInt);
FnNumericA.setArray( true );
FnNumericA.setKeyable(false);
FnNumericA.setStorable(true);
FnNumericA.setReadable(true);
FnNumericA.setWritable(true);
FnNumericA.setIndexMatters(true);
addAttribute( pointList );
//snapMesh
snapMesh = FnTyped.create("snapMesh", "sm", MFnData::kMesh);
FnTyped.setArray( false );
FnTyped.setReadable(true);
FnTyped.setWritable(true);
addAttribute( snapMesh );
attributeAffects(snapMesh, outputGeom);
attributeAffects(pointList, outputGeom);
attributeAffects(space, outputGeom);
attributeAffects(spaceSource, outputGeom);
attributeAffects(weight, outputGeom);
return stat;
}
MStatus AlembicCurvesNode::initialize()
{
MStatus status;
MFnUnitAttribute uAttr;
MFnTypedAttribute tAttr;
MFnNumericAttribute nAttr;
MFnGenericAttribute gAttr;
MFnStringData emptyStringData;
MObject emptyStringObject = emptyStringData.create("");
// input time
mTimeAttr = uAttr.create("inTime", "tm", MFnUnitAttribute::kTime, 0.0);
status = uAttr.setStorable(true);
status = uAttr.setKeyable(true);
status = addAttribute(mTimeAttr);
// input file name
mFileNameAttr =
tAttr.create("fileName", "fn", MFnData::kString, emptyStringObject);
status = tAttr.setStorable(true);
status = tAttr.setUsedAsFilename(true);
status = tAttr.setKeyable(false);
status = addAttribute(mFileNameAttr);
// input identifier
mIdentifierAttr =
tAttr.create("identifier", "if", MFnData::kString, emptyStringObject);
status = tAttr.setStorable(true);
status = tAttr.setKeyable(false);
status = addAttribute(mIdentifierAttr);
// output curve
mOutGeometryAttr = tAttr.create("outCurve", "os", MFnData::kNurbsCurve);
status = tAttr.setArray(true);
status = tAttr.setReadable(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setHidden(false);
status = addAttribute(mOutGeometryAttr);
// output for list of ArbGeomParams
mGeomParamsList = tAttr.create("ExocortexAlembic_GeomParams", "exo_gp",
MFnData::kString, emptyStringObject);
status = tAttr.setStorable(true);
status = tAttr.setKeyable(false);
status = tAttr.setHidden(false);
status = tAttr.setInternal(true);
status = addAttribute(mGeomParamsList);
// output for list of UserAttributes
mUserAttrsList = tAttr.create("ExocortexAlembic_UserAttributes", "exo_ua",
MFnData::kString, emptyStringObject);
status = tAttr.setStorable(true);
status = tAttr.setKeyable(false);
status = tAttr.setHidden(false);
status = tAttr.setInternal(true);
status = addAttribute(mUserAttrsList);
// create a mapping
status = attributeAffects(mTimeAttr, mOutGeometryAttr);
status = attributeAffects(mFileNameAttr, mOutGeometryAttr);
status = attributeAffects(mIdentifierAttr, mOutGeometryAttr);
return status;
}
// initialize
// ------------
//! Initialises the Attributes on the node, and set the evaluation dependencies
MStatus NBuddySurfaceToBodyNode::initialize()
{
MStatus status;
//Function sets needed
MFnStringData stringData;
MFnPluginData dataFn;
MFnMatrixData matrixFn;
MFnGenericAttribute genFn;
MFnTypedAttribute typedAttr;
MFnNumericAttribute numAttr;
MFnMatrixAttribute mAttr;
//Attribute that specifies if the object should be converted to worldspace or localspace
_useTransform = numAttr.create( "useTransform", "ut", MFnNumericData::kBoolean, true, &status );
NM_CheckMStatus(status, "ERROR creating useWorldSpace attribute.\n");
status = addAttribute( _useTransform );
//The input transform for the object
_inTransform = mAttr.create("inTransform","it", MFnMatrixAttribute::kDouble, &status);
mAttr.setStorable( true );
mAttr.setConnectable(true);
NM_CheckMStatus(status, "ERROR creating inTransform attribute.\n");
status = addAttribute( _inTransform );
NM_CheckMStatus(status, "ERROR adding inTransform attribute.\n");
//Create the inSurface plug
_inSurface = genFn.create( "inSurface", "surf", &status);
NM_CheckMStatus( status, "Failed to create inSurface GenericAttribute");
genFn.addAccept(MFnData::kNurbsSurface);
genFn.addAccept(MFnData::kMesh);
genFn.addAccept(MFnData::kSubdSurface);
genFn.setStorable(false);
genFn.setCached(false);
status = addAttribute( _inSurface );
NM_CheckMStatus(status, "ERROR adding inSurface attribute.\n");
// Create the attribute for the body output
_outBody = typedAttr.create("outBody","ob" , naiadBodyData::id , MObject::kNullObj , &status);
NM_CheckMStatus(status, "ERROR creating outBody attribute.\n");
typedAttr.setKeyable( false );
typedAttr.setWritable( false );
typedAttr.setReadable( true );
typedAttr.setStorable( false );
status = addAttribute( _outBody );
NM_CheckMStatus(status, "ERROR adding outBody attribute.\n");
// Create the attribute for the body name
_bodyName = typedAttr.create( "bodyName", "bn", MFnData::kString ,stringData.create( MString("mesh-body") ), &status);
NM_CheckMStatus( status, "Failed to create bodyName attribute");
typedAttr.setStorable( true );
typedAttr.setArray( false );
status = addAttribute( _bodyName );
NM_CheckMStatus( status, "Failed to add bodyName plug");
//Tesselation settings
_subDivide = numAttr.create( "subDivide", "td", MFnNumericData::kInt , 0, &status);
NM_CheckMStatus( status, "Failed to create subDivide attribute");
numAttr.setStorable( true );
numAttr.setArray( false );
status = addAttribute( _subDivide );
NM_CheckMStatus( status, "Failed to add bodyName plug");
// Attribute affects
attributeAffects( _bodyName, _outBody );
attributeAffects( _subDivide, _outBody );
attributeAffects( _inSurface, _outBody );
attributeAffects( _useTransform, _outBody );
attributeAffects( _inTransform, _outBody );
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;
}
// add some additional inputs
MStatus HRBFSkinCluster::initialize()
{
std::cout << "called initialize" << std::endl;
MFnNumericAttribute numAttr;
MFnTypedAttribute typedAttr;
//MFnCompoundAttribute cmpdAttr;
MStatus returnStatus;
HRBFSkinCluster::rebuildHRBF = numAttr.create("RebuildHRBF", "rbld", MFnNumericData::kInt,
0, &returnStatus);
McheckErr(returnStatus, "ERROR creating rbld attribute\n");
returnStatus = addAttribute(HRBFSkinCluster::rebuildHRBF);
McheckErr(returnStatus, "ERROR adding rbld attribute\n");
HRBFSkinCluster::exportComposition = numAttr.create("ExportComp", "exprtC", MFnNumericData::kInt,
0, &returnStatus);
McheckErr(returnStatus, "ERROR creating exprtC attribute\n");
returnStatus = addAttribute(HRBFSkinCluster::exportComposition);
McheckErr(returnStatus, "ERROR adding exprtC attribute\n");
HRBFSkinCluster::exportHRBFSamples = typedAttr.create("ExportHRBFs", "exprtS", MFnNumericData::kString,
&returnStatus);
McheckErr(returnStatus, "ERROR creating exprtS attribute\n");
returnStatus = addAttribute(HRBFSkinCluster::exportHRBFSamples);
McheckErr(returnStatus, "ERROR adding exprtS attribute\n");
HRBFSkinCluster::exportHRBFValues = typedAttr.create("ExportHRBFv", "exprtV", MFnNumericData::kString,
&returnStatus);
McheckErr(returnStatus, "ERROR creating exprtV attribute\n");
returnStatus = addAttribute(HRBFSkinCluster::exportHRBFValues);
McheckErr(returnStatus, "ERROR adding exprtV attribute\n");
HRBFSkinCluster::useDQ = numAttr.create("UseDualQuaternions", "useDQ", MFnNumericData::kInt,
0, &returnStatus);
McheckErr(returnStatus, "ERROR creating useDQ attribute\n");
returnStatus = addAttribute(HRBFSkinCluster::useDQ);
McheckErr(returnStatus, "ERROR adding useDQ attribute\n");
HRBFSkinCluster::useHRBF = numAttr.create("UseHRBFCorrection", "useHRBF", MFnNumericData::kInt,
0, &returnStatus);
McheckErr(returnStatus, "ERROR creating useHRBF attribute\n");
returnStatus = addAttribute(HRBFSkinCluster::useHRBF);
McheckErr(returnStatus, "ERROR adding useHRBF attribute\n");
HRBFSkinCluster::checkHRBFAt = numAttr.create("checkHRBFAt", "chkHRBF", MFnNumericData::k3Double,
0, &returnStatus);
McheckErr(returnStatus, "ERROR creating checkHRBFAt attribute\n");
returnStatus = addAttribute(HRBFSkinCluster::checkHRBFAt);
McheckErr(returnStatus, "ERROR adding checkHRBFAt attribute\n");
// hierarchy information
// http://download.autodesk.com/us/maya/2011help/API/weight_list_node_8cpp-example.html#a15
HRBFSkinCluster::jointParentIdcs = numAttr.create("parentJointIDCS", "pJIDCS", MFnNumericData::kInt,
0, &returnStatus);
McheckErr(returnStatus, "ERROR creating pIDCS attribute\n");
numAttr.setArray(true);
returnStatus = addAttribute(HRBFSkinCluster::jointParentIdcs);
McheckErr(returnStatus, "ERROR adding pIDCS attribute\n");
// joint names
HRBFSkinCluster::jointNames = typedAttr.create("jointNames", "jNms", MFnData::kString,
&returnStatus);
McheckErr(returnStatus, "ERROR creating pIDCS attribute\n");
typedAttr.setArray(true);
returnStatus = addAttribute(HRBFSkinCluster::jointNames);
McheckErr(returnStatus, "ERROR adding jNms attribute\n");
// set up affects
returnStatus = attributeAffects(HRBFSkinCluster::rebuildHRBF,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with rebuildHRBF\n");
returnStatus = attributeAffects(HRBFSkinCluster::exportComposition,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with exportComposition\n");
returnStatus = attributeAffects(HRBFSkinCluster::exportHRBFSamples,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with exportHRBFSamples\n");
returnStatus = attributeAffects(HRBFSkinCluster::exportHRBFValues,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with exportHRBFValues\n");
returnStatus = attributeAffects(HRBFSkinCluster::useDQ,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with useDQ\n");
returnStatus = attributeAffects(HRBFSkinCluster::useHRBF,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with useHRBF\n");
returnStatus = attributeAffects(HRBFSkinCluster::jointParentIdcs,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with jointParentIdcs\n");
returnStatus = attributeAffects(HRBFSkinCluster::checkHRBFAt,
HRBFSkinCluster::outputGeom);
McheckErr(returnStatus, "ERROR in attributeAffects with checkHRBFAt\n");
return returnStatus;
}
