MStatus sgLockAngleMatrix::initialize()
{
MStatus status;
MFnMatrixAttribute mAttr;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
aBaseMatrix = mAttr.create( "baseMatrix", "baseMatrix" );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aBaseMatrix ) );
aInputMatrix = mAttr.create( "inputMatrix", "inputMatrix" );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputMatrix ) );
aAngleAxis = eAttr.create( "angleAxis", "angleAxis" );
eAttr.addField( " X", 0 );eAttr.addField( " Y", 1 );eAttr.addField( " Z", 2 );
eAttr.addField( "-X", 3 );eAttr.addField( "-Y", 4 );eAttr.addField( "-Z", 5 );
eAttr.setStorable( true );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aAngleAxis ) );
aInputAngle = nAttr.create( "inputAngle", "inputAngle", MFnNumericData::kDouble, 45 );
nAttr.setStorable( true );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputAngle ) );
aOutputMatrix = mAttr.create( "outputMatrix", "outputMatrix" );
mAttr.setStorable( false );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aBaseMatrix, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputMatrix, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aAngleAxis, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputAngle, aOutputMatrix ) );
return MS::kSuccess;
}
//create_enum_attribute
void Ocio_test::create_enum_attribute(std::string attribute_name,
std::vector<std::string>& value_list,
MObject& node)
{
//eAttr
MFnEnumAttribute eAttr;
//a_attribute
MObject a_attribute = eAttr.create(attribute_name.c_str(), attribute_name.c_str(), 0);
eAttr.setStorable(true);
//iterate and add values
for(int index = 0; index < value_list.size(); index++)
eAttr.addField(value_list[index].c_str(), index);
//dg_modifier
MDGModifier dg_modifier;
dg_modifier.addAttribute(node, a_attribute);
dg_modifier.doIt();
//reload AE
MGlobal::executeCommandOnIdle(MString("openAEWindow;"));
//tmp
MGlobal::displayInfo(MString("Reopened AE"));
};
MStatus BasicLocator::initialize()
{
//standard attribute creation for the locator node
MStatus status;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
//output attribute
aIsDrawing = nAttr.create("draw", "d", MFnNumericData::kBoolean, 1);
nAttr.setWritable(true);
nAttr.setStorable(true);
addAttribute(aIsDrawing);
aIsTransparent = nAttr.create("transparent", "tpart", MFnNumericData::kFloat, 0.5);
nAttr.setMin(0.0);
nAttr.setMax(1.0);
nAttr.setWritable(true);
nAttr.setStorable(true);
addAttribute(aIsTransparent);
aShapeColor = nAttr.createColor("color", "col");
nAttr.setDefault(0.1, 0.1, 0.8);
nAttr.setStorable(true);
nAttr.setWritable(true);
addAttribute(aShapeColor);
aShapeType = eAttr.create("shapeType", "styp", 0);
eAttr.setStorable(true);
eAttr.setKeyable(true);
eAttr.addField("arrow", 0);
eAttr.addField("disc", 1);
addAttribute(aShapeType);
return MS::kSuccess;
}
MStatus sphericalBlendShapeVisualizer::initialize()
{
MStatus status;
MFnMatrixAttribute mAttr;
MFnEnumAttribute eAttr;
aSpaceMatrix = mAttr.create("spaceMatrix", "spaceMatrix", MFnMatrixAttribute::kDouble, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
aPoleAxis = eAttr.create("poleAxis", "poleAxis", 1, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(1);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
aSeamAxis = eAttr.create("seamAxis", "seamAxis", 0, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(0);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
addAttribute(aSpaceMatrix);
addAttribute(aPoleAxis);
addAttribute(aSeamAxis);
return MS::kSuccess;
}
MStatus ModifyArrayNode::initialize()
{
MStatus status;
MFnTypedAttribute T;
MFnNumericAttribute N;
MFnEnumAttribute E;
aInput = T.create("input", "i", MFnData::kDoubleArray);
T.setKeyable(false);
T.setChannelBox(false);
T.setStorable(true);
T.setWritable(true);
aOperation = E.create("operation", "operation");
E.addField("No Operation", kNO_OP);
E.addField("Sort", kSORT);
E.addField("Absolute Value", kABS);
E.addField("Reflect Left", kREFLECT_LEFT);
E.addField("Reflect Right", kREFLECT_RIGHT);
E.setDefault(kNO_OP);
E.setKeyable(true);
E.setStorable(true);
E.setWritable(true);
aReverse = N.create("reverse", "rev", MFnNumericData::kBoolean);
N.setKeyable(true);
N.setChannelBox(true);
N.setStorable(true);
N.setWritable(true);
aOutput = T.create("output", "o", MFnData::kDoubleArray);
T.setKeyable(false);
T.setChannelBox(false);
T.setWritable(false);
T.setStorable(false);
addAttribute(aOperation);
addAttribute(aInput);
addAttribute(aReverse);
addAttribute(aOutput);
attributeAffects(aOperation, aOutput);
attributeAffects(aInput, aOutput);
attributeAffects(aReverse, aOutput);
return MS::kSuccess;
}
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 );
}
MStatus ReduceArrayNode::initialize()
{
MStatus status;
MFnTypedAttribute T;
MFnNumericAttribute N;
MFnEnumAttribute E;
aInput = T.create("input", "i", MFnData::kDoubleArray);
T.setKeyable(false);
T.setChannelBox(false);
T.setStorable(true);
T.setWritable(true);
aOutput = N.create("output", "o", MFnNumericData::kDouble, 0.0);
T.setKeyable(false);
T.setChannelBox(false);
T.setWritable(true);
T.setStorable(true);
aOperation = E.create("operation", "operation");
E.addField("No Operation", kNO_OP);
E.addField("Sum", kSUM);
E.addField("Difference", kDIFFERENCE);
E.addField("Average", kAVERAGE);
E.addField("Product", kPRODUCT);
E.addField("Quotient", kQUOTIENT);
E.addField("Exponent", kEXPONENT);
E.addField("Minimum", kMIN);
E.addField("Maximum", kMAX);
E.addField("Length", kLENGTH);
E.setKeyable(true);
E.setStorable(true);
E.setWritable(true);
addAttribute(aOperation);
addAttribute(aInput);
addAttribute(aOutput);
attributeAffects(aOperation, aOutput);
attributeAffects(aInput, aOutput);
return MS::kSuccess;
}
MStatus Point::initialize() {
MFnNumericAttribute nAttr;
input_display = nAttr.create("display", "display", MFnNumericData::kInt, 1);
nAttr.setKeyable(true);
nAttr.setMin(0);
nAttr.setMax(1);
addAttribute(input_display);
input_box = nAttr.create("box", "box", MFnNumericData::kInt, 0);
nAttr.setKeyable(true);
nAttr.setMin(0);
nAttr.setMax(1);
addAttribute(input_box);
input_cross = nAttr.create("cross", "cross", MFnNumericData::kInt, 1);
nAttr.setKeyable(true);
nAttr.setMin(0);
nAttr.setMax(1);
addAttribute(input_cross);
input_tick = nAttr.create("tick", "tick", MFnNumericData::kInt, 0);
nAttr.setKeyable(true);
nAttr.setMin(0);
nAttr.setMax(1);
addAttribute(input_tick);
input_axis = nAttr.create("axis", "axis", MFnNumericData::kInt, 0);
nAttr.setKeyable(true);
nAttr.setMin(0);
nAttr.setMax(1);
addAttribute(input_axis);
MFnEnumAttribute eAttr;
input_color = eAttr.create("color", "color", MFnData::kNumeric);
eAttr.addField("Black", 0);
eAttr.addField("Grey", 1);
eAttr.addField("White", 2);
eAttr.addField("Red", 3);
eAttr.addField("Light red", 4);
eAttr.addField("Dark red", 5);
eAttr.addField("Green", 6);
eAttr.addField("Light green", 7);
eAttr.addField("Dark green", 8);
eAttr.addField("Blue", 9);
eAttr.addField("Light blue", 10);
eAttr.addField("Dark blue", 11);
eAttr.addField("Purple", 12);
eAttr.addField("Magenta", 13);
eAttr.addField("Brown", 14);
eAttr.addField("Yellow", 15);
eAttr.addField("Dark yellow", 16);
eAttr.addField("Orange", 17);
eAttr.setDefault(8);
eAttr.setKeyable(true);
eAttr.setStorable(true);
addAttribute(input_color);
colors.append(MColor(0.0f, 0.0f, 0.0f)); // black
colors.append(MColor(0.5f, 0.5f, 0.5f)); // grey
colors.append(MColor(1.0f, 1.0f, 1.0f)); // white
colors.append(MColor(1.0f, 0.0f, 0.0f)); // red
colors.append(MColor(1.0f, 0.6899999976158142f, 0.6899999976158142f)); // light_red
colors.append(MColor(0.5f, 0.0f, 0.0f)); // dark_red
colors.append(MColor(0.0f, 1.0f, 0.0f)); // green
colors.append(MColor(0.5f, 1.0f, 0.5f)); // light_green
colors.append(MColor(0.0f, 0.25f, 0.0f)); // dark_green
colors.append(MColor(0.1889999955892563f, 0.6299999952316284f, 0.6299999952316284f)); // blue
colors.append(MColor(0.3919999897480011f, 0.8629999756813049f, 1.0f)); // light_blue
colors.append(MColor(0.0f, 0.01600000075995922f, 0.37599998712539673f)); // dark_blue
colors.append(MColor(0.25f, 0.0f, 0.25f)); // purple
colors.append(MColor(1.0f, 0.0f, 1.0f)); // magenta
colors.append(MColor(0.75f, 0.2f, 0.0f)); // brown
colors.append(MColor(1.0f, 1.0f, 0.0f)); // yellow
colors.append(MColor(0.62117999792099f, 0.6299999952316284f, 0.1889999955892563f)); // dark_yellow
colors.append(MColor(1.0f, 0.5f, 0.0f)); // orange
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;
}
//initialize
MStatus Ocio_log_convert::initialize()
{
//MFnSets
MFnEnumAttribute eAttr;
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
//a_verbose
a_verbose = eAttr.create("verbose", "verbose", 1);
eAttr.addField("no verbose", 0);
eAttr.addField("verbose", 1);
addAttribute(a_verbose);
//a_input_color
a_input_color = nAttr.createColor("input_color", "input_color");
nAttr.setUsedAsColor(true);
nAttr.setStorable(true);
addAttribute(a_input_color);
//a_output_color
a_output_color = nAttr.createColor("output_color", "output_color");
nAttr.setUsedAsColor(true);
nAttr.setStorable(false);
addAttribute(a_output_color);
//a_env_or_file
a_env_or_file = eAttr.create("env_or_file", "env_or_file", 0);
eAttr.addField("OCIO Environment Variable", 0);
eAttr.addField("Custom Path", 1);
eAttr.setStorable(true);
addAttribute(a_env_or_file);
//a_last_env_or_file
a_last_env_or_file = nAttr.create("last_env_or_file", "last_env_or_file", MFnNumericData::kInt, 0);
nAttr.setHidden(true);
nAttr.setStorable(true);
addAttribute(a_last_env_or_file);
//a_config_file_path
a_config_file_path = tAttr.create("config_file_path", "config_file_path", MFnData::kString);
tAttr.setUsedAsFilename(true);
tAttr.setStorable(true);
addAttribute(a_config_file_path);
//a_last_config_file_path
a_last_config_file_path = tAttr.create("last_config_file_path", "last_config_file_path", MFnData::kString);
tAttr.setHidden(true);
tAttr.setStorable(true);
addAttribute(a_last_config_file_path);
//a_operation
a_operation = eAttr.create("operation", "operation", 0);
eAttr.addField("Log to Lin", 0);
eAttr.addField("Lin to Log", 1);
addAttribute(a_operation);
//a_last_operation
a_last_operation = nAttr.create("last_operation", "last_operation", MFnNumericData::kInt, 0);
nAttr.setHidden(true);
nAttr.setStorable(true);
addAttribute(a_last_operation);
//Attribute affects
attributeAffects(a_input_color, a_output_color);
attributeAffects(a_env_or_file, a_output_color);
attributeAffects(a_config_file_path, a_output_color);
attributeAffects(a_operation, a_output_color);
return MStatus::kSuccess;
}
MStatus worldSettingNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
backgroundTypes=enumAttr.create("BackgroundTypes","wbaty",0);
enumAttr.addField("Single Color",0);
enumAttr.addField("Gradient",1);
enumAttr.addField("Texture",2);
enumAttr.addField("Sunsky",3);
enumAttr.addField("DarkTide's Sunsky",4);
//MCHECKERROR(stat, "create background types");
enumAttr.setKeyable(true);
enumAttr.setStorable(true);
enumAttr.setHidden(true);
volumeInitTypes=enumAttr.create("VolumeTypes","wvoty",0);
enumAttr.addField("None",0);
enumAttr.addField("Single Scatter",1);
enumAttr.addField("Sky",2);
//MCHECKERROR(stat, "create volume types");
enumAttr.setKeyable(true);
enumAttr.setStorable(true);
DSSkyColorSpaces=enumAttr.create("DarkTideSunskyColorSpaces","wdasu",0);
enumAttr.addField("CIEE",0);
enumAttr.addField("CIED50",1);
enumAttr.addField("sRBGD65",2);
enumAttr.addField("sRGBD50",3);
//MCHECKERROR(stat, "create DarkTide's sunsky color spaces");
enumAttr.setKeyable(true);
enumAttr.setStorable(true);
backgroundColor=numAttr.createColor("BackgroundColor","wbaco");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(0.0,0.0,0.0);
//gradient attribute
horizonColor=numAttr.createColor("HorizonColor","whoco");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(0.1,0.8,0.5);
zenithColor=numAttr.createColor("ZenithColor","wzeco");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(0.4,0.5,0.1);
horGroundColor=numAttr.createColor("HorGroundColor","whgco");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(0.4,0.5,0.6);
zenGroundColor=numAttr.createColor("ZenGroundColor","wzgco");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(0.9,0.5,0.2);
//texture attribute
texRotation=numAttr.create("TextureRotation","wtero",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0f);
numAttr.setMax(360.0f);
//sunsky attribute
turbidity=numAttr.create("Turbidity","wtu",MFnNumericData::kFloat,1.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(1.0f);
numAttr.setMax(20.0f);
AHorBrght=numAttr.create("AHorBrght","wahb",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0f);
numAttr.setMax(10.0f);
BHorSprd=numAttr.create("BHorSprd","wbhs",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0f);
numAttr.setMax(10.0f);
CSunBrght=numAttr.create("CSunBrght","wcsb",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0f);
numAttr.setMax(10.0f);
DSunSize=numAttr.create("DSunsize","wdss",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0f);
numAttr.setMax(10.0f);
EBacklight=numAttr.create("EBacklight","webl",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0f);
numAttr.setMax(10.0f);
xDirection=numAttr.create("xDirection","wxd",MFnNumericData::kDouble,0.000);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(-1.000);
numAttr.setMax(1.000);
yDirection=numAttr.create("yDirection","wyd",MFnNumericData::kDouble,0.000);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(-1.000);
numAttr.setMax(1.000);
zDirection=numAttr.create("zDirection","wzd",MFnNumericData::kDouble,0.000);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(-1.000);
numAttr.setMax(1.000);
realSun=numAttr.create("AddRealSun","wads",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
sunPower=numAttr.create("SunPower","wsupo",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10.0);
skyLight=numAttr.create("Skylight","wsk",MFnNumericData::kBoolean,1);
numAttr.setKeyable(true);
numAttr.setStorable(true);
skySamples=numAttr.create("SkySamples","wsksa",MFnNumericData::kInt,1);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(1);
numAttr.setMax(128);
//DarkTide's sunsky attribute
DSTurbidity=numAttr.create("DarkTideTurbidity","wdatu",MFnNumericData::kFloat,2.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(2.0);
numAttr.setMax(12.0);
renderDSA=numAttr.create("BrightnessOfHorizonGradient","wbhg",MFnNumericData::kFloat,-10.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(-10.0);
numAttr.setMax(10.0);
renderDSB=numAttr.create("LuminanceOfHorizon","wloh",MFnNumericData::kFloat,-10.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(-10.0);
numAttr.setMax(10.0);
renderDSC=numAttr.create("SolarRegionIntensity","wsri",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(50.0);
renderDSD=numAttr.create("WidthOfCircumsolarRegion","wwocr",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(50.0);
renderDSE=numAttr.create("BackgroundLight","wbl",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(-30.0);
numAttr.setMax(30.0);
//sun direction shared with sunsky
DSAltitude=numAttr.create("Altitude","wal",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(-1.0);
numAttr.setMax(2.0);
DSNight=numAttr.create("Night","wni",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
DSRealSun=numAttr.create("AddDSRealSun","wadrs",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
DSSunPower=numAttr.create("DSSunPower","wdsp",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10.0);
DSSkyLight=numAttr.create("AddDSSkyLight","wadsl",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
DSSkyPower=numAttr.create("DSSkyPower","wdssp",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10000.0);
DSSkySamples=numAttr.create("DSSkySamples","wdsss",MFnNumericData::kInt,1);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(1);
numAttr.setMax(256);
DSSkyBright=numAttr.create("Brightness","wbr",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10.0);
DSExposure=numAttr.create("Exposure","wex",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10.0);
DSGammaEncoding=numAttr.create("GammaEncoding","wgaen",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
//these appear in each type of background
useIBL=numAttr.create("UseIBL","wibl",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
IBLSamples=numAttr.create("IBLSamples","wibls",MFnNumericData::kInt,1);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(1);
numAttr.setMax(512);
backgroundDiffuse=numAttr.create("DiffusePhotons","wdiph",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
backgoundCaustic=numAttr.create("CausticPhotons","wcaph",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
backgoundPower=numAttr.create("BackgroundPower","wbapo",MFnNumericData::kFloat,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10000.0);
volumeStepSize=numAttr.create("StepSize","wvstsi",MFnNumericData::kInt,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0);
numAttr.setMax(100);
volumeAdaptive=numAttr.create("Adaptive","wvad",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
volumeOptimize=numAttr.create("Optimize","wvop",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
volumeAttMapScale=numAttr.create("AttGridResolution","wvagr",MFnNumericData::kInt,1);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(1);
numAttr.setMax(50);
volumeSkyST=numAttr.create("Scale","wvsc",MFnNumericData::kDouble,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0001);
numAttr.setMax(10.000);
volumeAlpha=numAttr.create("Alpha","wval",MFnNumericData::kDouble,0.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0001);
numAttr.setMax(10.000);
//the node needs an output, even we dont need it...
worldOutput=numAttr.create("WorldSettingOutput","wwso",MFnNumericData::kBoolean);
numAttr.setDefault(true);
numAttr.setHidden(true);
setAttribute();
return stat;
}
MStatus unCreateRibbonSystem::doIt( const MArgList& args )
{
bool create = true;
MSelectionList activeList;
MStatus stat = MGlobal::getActiveSelectionList(activeList);
if (MS::kSuccess != stat)
{
MessageBox(0,"please select one joint first!",0,0);
return MS::kFailure;
}
if(activeList.length() != 1)
{
MessageBox(0,"please select ONLY one joint!",0,0);
return MS::kFailure;
}
MItSelectionList iter(activeList);
MDagPath dagPath;
for ( ; !iter.isDone(); iter.next())
{
stat = iter.getDagPath(dagPath);
break;
}
if(!stat)
{
MessageBox(0,"can't getDagPath!",0,0);
return MS::kFailure;
}
if(!dagPath.hasFn(MFn::kJoint))
{
MessageBox(0,"muse select joint node!",0,0);
return MS::kFailure;
}
MFnIkJoint joint(dagPath);
if(args.length())
create = args.asBool(0);
if(!create)
{
if(!joint.hasAttribute("unRibbonEnabled"))
{
MessageBox(0,"no ribbon system exists!",0,0);
return MS::kFailure;
}
removeRibbonAttributes(joint);
return MS::kSuccess;
}
if(joint.hasAttribute("unRibbonEnabled"))
{
MessageBox(0,"ribbon system already exists!",0,0);
return MS::kSuccess;
}
if(joint.hasAttribute("unParticleEnabled"))
{
if(MessageBox(0,"will delete particle system and attach a ribbon system to the joint,continue?",0,MB_YESNO) == IDNO)return MS::kFailure;
removeParticleAttributes(joint);
}
MFnNumericAttribute attr;
unRibbonEnabled = attr.create("unRibbonEnabled","enabled",MFnNumericData::kBoolean,true);
attr.setStorable(true);
unRibbonVisible = attr.create("unRibbonVisible","visible",MFnNumericData::kBoolean,true);
attr.setStorable(true);
attr.setKeyable(true);
unRibbonAbove = attr.create("unRibbonAbove","above",MFnNumericData::kFloat,20.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(5000.0f);
attr.setKeyable(true);
unRibbonBelow = attr.create("unRibbonBelow","below",MFnNumericData::kFloat,20.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(5000.0f);
attr.setKeyable(true);
unRibbonEdgesPerSecond = attr.create("unRibbonEdgesPerSecond","EdgePerSec",MFnNumericData::kShort,10);
attr.setStorable(true);
attr.setMin(0);
attr.setMax(100);
unRibbonEdgeLife = attr.create("unRibbonEdgeLife","EdgeLife",MFnNumericData::kFloat,2.0f);
attr.setStorable(true);
attr.setMin(0.001f);
attr.setMax(100.0f);
unRibbonGravity = attr.create("unRibbonGravity","Gravity",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(-1000.0f);
attr.setMax(1000.0f);
unRibbonTextureRows = attr.create("unRibbonTextureRows","TextureRows",MFnNumericData::kShort,1);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(16);
unRibbonTextureCols = attr.create("unRibbonTextureCols","TextureCols",MFnNumericData::kShort,1);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(16);
unRibbonTextureSlot = attr.create("unRibbonTextureSlot","TextureSlot",MFnNumericData::kShort,0);
attr.setStorable(true);
attr.setMin(0);
attr.setMax(255);
attr.setKeyable(true);
unRibbonVertexColor = attr.create("unRibbonVertexColor","VertexColor",MFnNumericData::k3Float);
attr.setStorable(true);
attr.setDefault(1.0f,0.0f,0.0f);
attr.setUsedAsColor(true);
attr.setKeyable(true);
unRibbonVertexAlpha = attr.create("unRibbonVertexAlpha","VertexAlpha",MFnNumericData::kFloat,1.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1.0f);
attr.setKeyable(true);
MFnEnumAttribute eAttr;
unRibbonBlendMode = eAttr.create("unRibbonBlendMode","BlendMode",3);
eAttr.setStorable(true);
eAttr.addField("Opaque",0);
eAttr.addField("Transparent",1);
eAttr.addField("AlphaBlend",2);
eAttr.addField("Additive",3);
eAttr.addField("AdditiveAlpha",4);
eAttr.addField("Modulate",5);
{
MFnEnumAttribute eAttr;
unRibbonWanderMode = eAttr.create("unRibbonWanderMode","WanderMode",0);
eAttr.setStorable(true);
eAttr.addField("0",0);
eAttr.addField("1",1);
}
/*unRibbonBlendModeSrc = eAttr.create("unRibbonBlendModeSrc","BlendModeSrc",3);
eAttr.setStorable(true);
eAttr.addField("SBF_ONE",0);
eAttr.addField("SBF_ZERO",1);
eAttr.addField("SBF_DEST_COLOR",2);
eAttr.addField("SBF_SOURCE_COLOR",3);
eAttr.addField("SBF_ONE_MINUS_DEST_COLOR",4);
eAttr.addField("SBF_ONE_MINUS_SOURCE_COLOR",5);
eAttr.addField("SBF_DEST_ALPHA",6);
eAttr.addField("SBF_SOURCE_ALPHA",7);
eAttr.addField("SBF_ONE_MINUS_DEST_ALPHA",8);
eAttr.addField("SBF_ONE_MINUS_SOURCE_ALPHA",9);
unRibbonBlendModeDst = eAttr.create("unRibbonBlendModeDst","BlendModeDst",0);
eAttr.setStorable(true);
eAttr.addField("SBF_ONE",0);
eAttr.addField("SBF_ZERO",1);
eAttr.addField("SBF_DEST_COLOR",2);
eAttr.addField("SBF_SOURCE_COLOR",3);
eAttr.addField("SBF_ONE_MINUS_DEST_COLOR",4);
eAttr.addField("SBF_ONE_MINUS_SOURCE_COLOR",5);
eAttr.addField("SBF_DEST_ALPHA",6);
eAttr.addField("SBF_SOURCE_ALPHA",7);
eAttr.addField("SBF_ONE_MINUS_DEST_ALPHA",8);
eAttr.addField("SBF_ONE_MINUS_SOURCE_ALPHA",9);*/
unRibbonTextureFilename = attr.createColor("unRibbonTextureFilename","TextureFilename");
attr.setStorable(true);
addRibbonAttributes(joint);
return MS::kSuccess;
}
MStatus unCreateParticleSystem::doIt( const MArgList& args )
{
bool create = true;
MSelectionList activeList;
MStatus stat = MGlobal::getActiveSelectionList(activeList);
if (MS::kSuccess != stat)
{
MessageBox(0,"please select one joint first!",0,0);
return MS::kFailure;
}
if(activeList.length() != 1)
{
MessageBox(0,"please select ONLY one joint!",0,0);
return MS::kFailure;
}
MItSelectionList iter(activeList);
MDagPath dagPath;
for ( ; !iter.isDone(); iter.next())
{
stat = iter.getDagPath(dagPath);
break;
}
if(!stat)
{
MessageBox(0,"can't getDagPath!",0,0);
return MS::kFailure;
}
if(!dagPath.hasFn(MFn::kJoint))
{
MessageBox(0,"muse select joint node!",0,0);
return MS::kFailure;
}
MFnIkJoint joint(dagPath);
if(args.length())
create = args.asBool(0);
if(!create)
{
if(!joint.hasAttribute("unParticleEnabled"))
{
MessageBox(0,"no particle system exists!",0,0);
return MS::kFailure;
}
removeParticleAttributes(joint);
return MS::kSuccess;
}
if(joint.hasAttribute("unParticleEnabled"))
{
MessageBox(0,"particle system already exists!",0,0);
return MS::kSuccess;
}
if(joint.hasAttribute("unRibbonEnabled"))
{
if(MessageBox(0,"will delete ribbon system and attach a particle system to the joint,continue?",0,MB_YESNO) == IDNO)return MS::kFailure;
removeRibbonAttributes(joint);
}
MFnNumericAttribute attr;
unParticleEnabled = attr.create("unParticleEnabled","Enabled",MFnNumericData::kBoolean,true);
attr.setStorable(true);
unParticleVisible = attr.create("unParticleVisible","Visible",MFnNumericData::kBoolean,true);
attr.setStorable(true);
attr.setKeyable(true);
unParticleSpeed = attr.create("unParticleSpeed","Speed",MFnNumericData::kFloat,40.0f);
attr.setStorable(true);
attr.setMin(-1000.0f);
attr.setMax(1000.0f);
attr.setKeyable(true);
unParticleVariation = attr.create("unParticleVariationPercent","VariationPercent",MFnNumericData::kFloat,2.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(100.0f);
attr.setKeyable(true);
unParticleConeAngle = attr.create("unParticleConeAngle","ConeAngle",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(180.0f);
attr.setKeyable(true);
unParticleGravity = attr.create("unParticleGravity","Gravity",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(-1000.0f);
attr.setMax(1000.0f);
attr.setKeyable(true);
unParticleExplosiveForce = attr.create("unParticleExplosiveForce","ExplosiveForce",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(-100.0f);
attr.setMax(100.0f);
attr.setKeyable(true);
unParticleLife = attr.create("unParticleLife","Life",MFnNumericData::kFloat,1.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1000.0f);
unParticleLifeVariation = attr.create("unParticleLifeVariation","LifeVar",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(-16.0f);
attr.setMax(16.0f);
unParticleEmissionRate = attr.create("unParticleEmissionRate","EmissionRate",MFnNumericData::kFloat,50.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1000.0f);
attr.setKeyable(true);
//版本号17加入，初始粒子数
unParticleInitialNum = attr.create("unParticleInitialNum","InitialNum",MFnNumericData ::kShort,0);
attr.setStorable(true);
attr.setMin(0);
attr.setMax(512);
//版本号11加入，最大粒子数
unParticleLimitNum = attr.create("unParticleLimitNum","LimitNum",MFnNumericData ::kShort,32);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(512);
//版本号13加入，粒子全部跟随发射点
unParticleAttachToEmitter = attr.create("unParticleAttachToEmitter","AttachToEmitter",MFnNumericData::kBoolean,false);
attr.setStorable(true);
//版本号18加入，粒子跟随发射点移动
unParticleMoveWithEmitter = attr.create("unParticleMoveWithEmitter","MoveWithEmitter",MFnNumericData::kBoolean,false);
attr.setStorable(true);
//版本号23加入，粒子指向速度方向
unParticleForTheSword = attr.create("unParticleForTheSword","ForTheSword",MFnNumericData::kBoolean,false);
attr.setStorable(true);
//版本号24加入，粒子指向速度方向，提供一个角度供初始化
unParticleForTheSwordInitialAngle = attr.create("unParticleForTheSwordInitialAngle","ForTheSwordInitialAngle",MFnNumericData::kFloat,0);
attr.setStorable(true);
attr.setMin(-180.0f);
attr.setMax(180.0f);
//版本号25，Wander
unParticleWander = attr.create("unParticleWander","Wander",MFnNumericData::kBoolean,false);
attr.setStorable(true);
//版本号25，WanderRadius
unParticleWanderRadius = attr.create("unParticleWanderRadius","WanderRadius",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1024.0f);
//版本号25，WanderSpeed
unParticleWanderSpeed = attr.create("unParticleWanderSpeed","WanderSpeed",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(16.0f);
unParticleAspectRatio = attr.create("unParticleAspectRatio","AspectRatio",MFnNumericData::kFloat,1.0f);
attr.setStorable(true);
attr.setMin(0.0625f);
attr.setMax(16.0f);
unParticleInitialAngleBegin = attr.create("unParticleInitialAngleBegin","InitialAngleBegin",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(-180.0f);
attr.setMax(180.0f);
unParticleInitialAngleEnd = attr.create("unParticleInitialAngleEnd","InitialAngleEnd",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(-180.0f);
attr.setMax(180.0f);
unParticleRotationSpeed = attr.create("unParticleRotationSpeed","RotationSpeed",MFnNumericData::kFloat,0);
attr.setStorable(true);
attr.setMin(-64.0f); //原来默认为16，鲍振伟要求改大
attr.setMax(64.0f);
unParticleRotationSpeedVar = attr.create("unParticleRotationSpeedVar","RotationSpeedVar",MFnNumericData::kFloat,0);
attr.setStorable(true);
attr.setMin(0);
attr.setMax(64);
unParticleEmitterWidth = attr.create("unParticleEmitterWidth","EmitterWidth",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1000.0f);
attr.setKeyable(true);
unParticleEmitterLength = attr.create("unParticleEmitterLength","EmitterLength",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1000.0f);
attr.setKeyable(true);
unParticleEmitterHeight = attr.create("unParticleEmitterHeight","EmitterHeight",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1000.0f);
attr.setKeyable(true);
MFnEnumAttribute eAttr;
unParticleBlendMode = eAttr.create("unParticleBlendMode","BlendMode",3);
eAttr.setStorable(true);
eAttr.addField("Opaque",0);
eAttr.addField("Transparent",1);
eAttr.addField("AlphaBlend",2);
eAttr.addField("Additive",3);
eAttr.addField("AdditiveAlpha",4);
eAttr.addField("Modulate",5);
/*unParticleBlendModeSrc = eAttr.create("unParticleBlendModeSrc","BlendModeSrc",3);
eAttr.setStorable(true);
eAttr.addField("SBF_ONE",0);
eAttr.addField("SBF_ZERO",1);
eAttr.addField("SBF_DEST_COLOR",2);
eAttr.addField("SBF_SOURCE_COLOR",3);
eAttr.addField("SBF_ONE_MINUS_DEST_COLOR",4);
eAttr.addField("SBF_ONE_MINUS_SOURCE_COLOR",5);
eAttr.addField("SBF_DEST_ALPHA",6);
eAttr.addField("SBF_SOURCE_ALPHA",7);
eAttr.addField("SBF_ONE_MINUS_DEST_ALPHA",8);
eAttr.addField("SBF_ONE_MINUS_SOURCE_ALPHA",9);
unParticleBlendModeDst = eAttr.create("unParticleBlendModeDst","BlendModeDst",0);
eAttr.setStorable(true);
eAttr.addField("SBF_ONE",0);
eAttr.addField("SBF_ZERO",1);
eAttr.addField("SBF_DEST_COLOR",2);
eAttr.addField("SBF_SOURCE_COLOR",3);
eAttr.addField("SBF_ONE_MINUS_DEST_COLOR",4);
eAttr.addField("SBF_ONE_MINUS_SOURCE_COLOR",5);
eAttr.addField("SBF_DEST_ALPHA",6);
eAttr.addField("SBF_SOURCE_ALPHA",7);
eAttr.addField("SBF_ONE_MINUS_DEST_ALPHA",8);
eAttr.addField("SBF_ONE_MINUS_SOURCE_ALPHA",9);*/
unParticleTextureFilename = attr.createColor("unParticleTextureFilename","TextureFilename");
attr.setStorable(true);
unParticleTextureRows = attr.create("unParticleTextureRows","TextureRows",MFnNumericData::kShort,1);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(16);
unParticleTextureCols = attr.create("unParticleTextureCols","TextureCols",MFnNumericData::kShort,1);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(16);
unParticleTextureChangeStyle = eAttr.create("unParticleTextureChangeStyle","TextureChangeStyle",0);
eAttr.setStorable(true);
eAttr.addField("Sequence",0);
eAttr.addField("Random",1);
unParticleTextureChangeInterval = attr.create("unParticleTextureChangeInterval","TextureChangeInterval",MFnNumericData::kShort,30);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(5000);
unParticleTailLength = attr.create("unParticleTailLength","TailLength",MFnNumericData::kFloat,1.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(10.0f);
unParticleTimeMiddle = attr.create("unParticleTimeMiddle","TimeMiddle",MFnNumericData::kFloat,0.3f);
attr.setStorable(true);
attr.setMin(0.05f);
attr.setMax(0.95f);
unParticleColorStart = attr.createColor("unParticleColorStart","ColorStart");
attr.setStorable(true);
attr.setDefault(1.0f,1.0f,1.0f);
unParticleColorMiddle = attr.createColor("unParticleColorMiddle","ColorMiddle");
attr.setStorable(true);
attr.setDefault(1.0f,1.0f,1.0f);
unParticleColorEnd = attr.createColor("unParticleColorEnd","ColorEnd");
attr.setStorable(true);
attr.setDefault(1.0f,1.0f,1.0f);
unParticleAlpha = attr.create("unParticleAlpha","Alpha",MFnNumericData::k3Float);
attr.setStorable(true);
attr.setDefault(1.0f,1.0f,0.0f);
attr.setMin(0.0f,0.0f,0.0f);
attr.setMax(1.0f,1.0f,1.0f);
unParticleScale = attr.create("unParticleScale","Scale",MFnNumericData::k3Float);
attr.setStorable(true);
attr.setDefault(10.0f,10.0f,10.0f);
attr.setMin(0.001f,0.001f,0.001f);
attr.setMax(1500.0f,1500.0f,1500.0f); //原来是500，鲍振伟要求改大
unParticleScaleVar = attr.create("unParticleScaleVar","ScaleVar",MFnNumericData::k3Float);
attr.setStorable(true);
attr.setDefault(0.0f,0.0f,0.0f);
attr.setMin(0.0f,0.0f,0.0f);
attr.setMax(500.0f,500.0f,500.0f);//原来是100，鲍振伟要求改大
unParticleFixedSize = attr.create("unParticleFixedSize","FixedSize",MFnNumericData::kBoolean,false);
attr.setStorable(true);
unParticleHeadLifeSpan = attr.create("unParticleHeadLifeSpan","HeadLifeSpan",MFnNumericData::k3Short);
attr.setStorable(true);
attr.setDefault(0,0,1);
attr.setMin(0,0,1);
attr.setMax(255,255,255);
unParticleHeadDecay = attr.create("unParticleHeadDecay","HeadDecay",MFnNumericData::k3Short);
attr.setStorable(true);
attr.setDefault(0,0,1);
attr.setMin(0,0,1);
attr.setMax(255,255,255);
unParticleTailLifeSpan = attr.create("unParticleTailLifeSpan","TailLifeSpan",MFnNumericData::k3Short);
attr.setStorable(true);
attr.setDefault(0,0,1);
attr.setMin(0,0,1);
attr.setMax(255,255,255);
unParticleTailDecay = attr.create("unParticleTailDecay","TailDecay",MFnNumericData::k3Short);
attr.setStorable(true);
attr.setDefault(0,0,1);
attr.setMin(0,0,1);
attr.setMax(255,255,255);
unParticleHead = attr.create("unParticleHead","Head",MFnNumericData::kBoolean,true);
attr.setStorable(true);
unParticleTail = attr.create("unParticleTail","Tail",MFnNumericData::kBoolean,false);
attr.setStorable(true);
unParticleUnShaded = attr.create("unParticleUnShaded","UnShaded",MFnNumericData::kBoolean,true);
attr.setStorable(true);
unParticleUnFogged = attr.create("unParticleUnFogged","UnFogged",MFnNumericData::kBoolean,true);
attr.setStorable(true);
unParticleBlockByY0 = attr.create("unParticleBlockByY0","blockByY0",MFnNumericData::kBoolean,false);
attr.setStorable(true);
addParticleAttributes(joint);
return MS::kSuccess;
}
MStatus VmIslandNode::initialize()
{
fprintf( stderr, "VmIslandNode::initialize()...\n" );
MStatus status;
//Seed attribute
{
MFnNumericAttribute numericAttrFn;
ia_seed = numericAttrFn.create( "seed", "sD", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0 );
numericAttrFn.setMax( 1000 );
numericAttrFn.setDefault ( 0 );
status = addAttribute( ia_seed );
CHECK_MSTATUS( status );
}
//Roughness attribute
{
MFnNumericAttribute numericAttrFn;
ia_roughness = numericAttrFn.create( "roughness", "rG", MFnNumericData::kFloat, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0 );
numericAttrFn.setMax( 1 );
numericAttrFn.setDefault ( 0.75 );
status = addAttribute( ia_roughness );
CHECK_MSTATUS( status );
}
//Plane Height attribute
{
MFnNumericAttribute numericAttrFn;
ia_planeHeight = numericAttrFn.create( "planeHeight", "pH", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0 );
numericAttrFn.setMax( 2000 );
numericAttrFn.setDefault ( 5 );
status = addAttribute( ia_planeHeight );
CHECK_MSTATUS( status );
}
//Plane smoothing attribute
{
MFnNumericAttribute numericAttrFn;
ia_smooth = numericAttrFn.create( "smoothingStrength", "sS", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0 );
numericAttrFn.setMax( 6 );
numericAttrFn.setDefault ( 1 );
status = addAttribute( ia_smooth );
CHECK_MSTATUS( status );
}
//Plane resolution attribute
{
MFnNumericAttribute numericAttrFn;
ia_resolution = numericAttrFn.create( "mayaResolution", "mR", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 1 );
numericAttrFn.setMax( 10 );
numericAttrFn.setDefault ( 1 );
status = addAttribute( ia_resolution );
CHECK_MSTATUS( status );
}
//Renderman resolution attribute
{
MFnNumericAttribute numericAttrFn;
ia_rmanResolution = numericAttrFn.create( "rendermanResolution", "rR", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 1 );
numericAttrFn.setMax( 10 );
numericAttrFn.setDefault ( 6 );
status = addAttribute( ia_rmanResolution );
CHECK_MSTATUS( status );
}
//Plane size attribute
{
MFnNumericAttribute numericAttrFn;
ia_planeSize = numericAttrFn.create( "planeSizeScale", "pS", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 1 );
numericAttrFn.setMax( 200 );
numericAttrFn.setDefault ( 20 );
status = addAttribute( ia_planeSize );
CHECK_MSTATUS( status );
}
//Plane size attribute
{
MFnNumericAttribute numericAttrFn;
ia_gridSize = numericAttrFn.create( "gridSize", "gS", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 1 );
numericAttrFn.setMax( 10 );
numericAttrFn.setDefault ( 1 );
status = addAttribute( ia_gridSize );
CHECK_MSTATUS( status );
}
//Grass multiplier - Affects how many instances are spawned
{
MFnNumericAttribute numericAttrFn;
ia_grassMultiplier = numericAttrFn.create( "grassInstanceMultiplier", "gM", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 1 );
numericAttrFn.setMax( 100 );
numericAttrFn.setDefault ( 1 );
status = addAttribute( ia_grassMultiplier );
CHECK_MSTATUS( status );
}
//Grass multiplier - Affects how many instances are spawned
{
MFnNumericAttribute numericAttrFn;
ia_baseWidth = numericAttrFn.create( "grassBaseWidth", "bW", MFnNumericData::kFloat, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0.01f );
numericAttrFn.setMax( 2.0f );
numericAttrFn.setDefault ( 0.6f );
status = addAttribute( ia_baseWidth );
CHECK_MSTATUS( status );
}
//Grass segment length - Length of segment pieces
{
MFnNumericAttribute numericAttrFn;
ia_grassSegmentLength = numericAttrFn.create( "grassSegmentLength", "gSL", MFnNumericData::kFloat, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0.001f );
numericAttrFn.setMax( 10.0f );
numericAttrFn.setDefault ( 1.0f );
status = addAttribute( ia_grassSegmentLength );
CHECK_MSTATUS( status );
}
//Number of segments per piece of grass
{
MFnNumericAttribute numericAttrFn;
ia_grassNumSegments = numericAttrFn.create( "numberOfGrassSegments", "nGS", MFnNumericData::kLong, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 3 );
numericAttrFn.setMax( 20 );
numericAttrFn.setDefault ( 5 );
status = addAttribute( ia_grassNumSegments );
CHECK_MSTATUS( status );
}
//Initial grass bend direction
{
MFnNumericAttribute numericAttrFn;
ia_windDirection = numericAttrFn.createPoint( "windDirection", "wDir");
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setDefault(1.0f, 0.0f, 1.0f);
status = addAttribute( ia_windDirection );
CHECK_MSTATUS( status );
}
//Grass bend factor
{
MFnNumericAttribute numericAttrFn;
ia_grassBendAmount = numericAttrFn.create( "grassBendFactor", "gBF", MFnNumericData::kFloat, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0.0f );
numericAttrFn.setMax( 1.0f );
numericAttrFn.setDefault ( 0.0f );
status = addAttribute( ia_grassBendAmount );
CHECK_MSTATUS( status );
}
//Wind strength
{
MFnNumericAttribute numericAttrFn;
ia_windSpread = numericAttrFn.create( "windSpread", "wS", MFnNumericData::kFloat, 0, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0.01f );
numericAttrFn.setMax( 10.0f );
numericAttrFn.setDefault ( 5.0f );
status = addAttribute( ia_windSpread );
CHECK_MSTATUS( status );
}
//Initial grass bend direction
{
MFnNumericAttribute numericAttrFn;
ia_grassBaseColour1 = numericAttrFn.createColor( "grassBaseColour1", "bCol1");
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setDefault(0.0f,0.251f,0.167f);
status = addAttribute( ia_grassBaseColour1 );
CHECK_MSTATUS( status );
}
//Initial grass bend direction
{
MFnNumericAttribute numericAttrFn;
ia_grassTipColour1 = numericAttrFn.createColor( "grassTipColour1", "tCol1");
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setDefault(0.395f,0.551f,0.257f);
status = addAttribute( ia_grassTipColour1 );
CHECK_MSTATUS( status );
}
//Initial grass bend direction
{
MFnNumericAttribute numericAttrFn;
ia_grassBaseColour2 = numericAttrFn.createColor( "grassBaseColour2", "bCol2");
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setDefault(0.275f,0.243f,0.043f);
status = addAttribute( ia_grassBaseColour2 );
CHECK_MSTATUS( status );
}
//Initial grass bend direction
{
MFnNumericAttribute numericAttrFn;
ia_grassTipColour2 = numericAttrFn.createColor( "grassTipColour2", "tCol2");
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( true );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setDefault(0.611f,0.587f,0.257f);
status = addAttribute( ia_grassTipColour2 );
CHECK_MSTATUS( status );
}
//Clock attribute. Passes maya frame counter into node
{
MFnNumericAttribute numericAttrFn;
ia_clock = numericAttrFn.create( "clock", "clk", MFnNumericData::kLong, false, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( false );
numericAttrFn.setKeyable( true );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( false );
numericAttrFn.setMin( 0 );
numericAttrFn.setDefault( 0 );
status = addAttribute( ia_clock );
CHECK_MSTATUS( status );
}
// "drawStyle"
//
// How we should draw in Maya.
//
// We will use this value in our Maya plug-in, but we
// will NOT use it in Renderman. Note elsewhere that
// this value will not be sent to Renderman, nor will
// it have any effect on RIB generation.
//
// We think of this as an input attribute - hence the
// prefix "ia_" for "input attribute".
{
MFnEnumAttribute enumAttrFn;
ia_drawStyle = enumAttrFn.create( "drawStyle", "ds", 1, & status );
CHECK_MSTATUS( status );
enumAttrFn.setReadable( true );
enumAttrFn.setWritable( true );
enumAttrFn.setStorable( true );
enumAttrFn.setKeyable( true );
enumAttrFn.setConnectable( true );
enumAttrFn.setHidden( false );
enumAttrFn.addField( "Bounds", 0 );
enumAttrFn.addField( "Sub bounds", 1 );
enumAttrFn.addField( "Geometry", 2 );
enumAttrFn.addField( "Terrain slope normals", 3 );
enumAttrFn.addField( "Point instances", 4 );
enumAttrFn.addField( "Wind Velocity", 5 );
enumAttrFn.addField( "All", 6 );
enumAttrFn.setDefault(3);
status = addAttribute( ia_drawStyle );
CHECK_MSTATUS( status );
}
// "update"
//
// A 'dummy' attribute, and a powerful one. Although
// the value of this attribute is actually meaningless,
// when we ask for it we trigger an important computation
// processs.
//
// We think of this as an input attribute - hence the
// prefix "oa_" for "computation attribute". This signifies
// that we don't really care about it's final value, but
// that we know it's going to compute a lot of stuff.
{
MFnNumericAttribute numericAttrFn;
oa_update = numericAttrFn.create( "update", "upd", MFnNumericData::kBoolean, false, & status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable( true );
numericAttrFn.setWritable( true );
numericAttrFn.setStorable( false );
numericAttrFn.setKeyable( false );
numericAttrFn.setConnectable( true );
numericAttrFn.setHidden( true );
status = addAttribute( oa_update );
CHECK_MSTATUS( status );
}
// "rib"
//
// A string which contains all the attributes, and that
// we need to have (and indeed will see again) on the
// Renderman side of things.
//
// We think of this as an output attribute - hence the
// prefix "oa_" for "output attribute". The value
// computed for this attribute (the string) is important,
// an is used by whatever is asking for it.
{
MFnTypedAttribute typedAttrFn;
oa_rib = typedAttrFn.create( "rib", "rb", MFnData::kString, MObject::kNullObj, & status );
CHECK_MSTATUS( status );
typedAttrFn.setReadable( true );
typedAttrFn.setWritable( true );
typedAttrFn.setStorable( false );
typedAttrFn.setKeyable( false );
typedAttrFn.setConnectable( true );
typedAttrFn.setHidden( true );
status = addAttribute( oa_rib );
CHECK_MSTATUS( status );
}
// This section tells Maya what attribute effects
// which attribute. When input attributes change,
// make the attributes they effect "dirty". That
// means that, when Maya asks for a dirty attribute,
// it will need to be computed and "cleaned".
//
// Changing an effecting "input" attribute does not
// trigger a computation of it's effected "output"
// attribute. It just tells Maya that - if the effected
// attribute is ever asked for, it will have to call
// the compute method to calculate it.
//
// For complex relationships between attributes,
// an attributeEffects() call must exist for each
// relationship. If A effects B, and B effects C,
// then we will need to make two attributeEffects()
// calls - one for A effecting B and one for B
// effecting C. Maya will not figure out that, if A
// effects B, and B effets C, then A must effect C.
//
// Below we see that most "input" attributes effect
// both our internal update and the rib generation
// the same way in each case. But it's not always
// exactly the same like this.
//
// Notice also that ia_drawStyle does not effect
// any of the attributes. It's something that's just
// used in the draw method.
attributeAffects( ia_seed, oa_update );
attributeAffects( ia_seed, oa_rib );
attributeAffects( ia_roughness, oa_update );
attributeAffects( ia_roughness, oa_rib );
attributeAffects( ia_smooth, oa_update );
attributeAffects( ia_smooth, oa_rib );
attributeAffects( ia_planeHeight, oa_update );
attributeAffects( ia_planeHeight, oa_rib );
attributeAffects( ia_resolution, oa_update );
attributeAffects( ia_rmanResolution, oa_rib );
attributeAffects( ia_planeSize, oa_update );
attributeAffects( ia_planeSize, oa_rib );
attributeAffects( ia_gridSize, oa_update );
attributeAffects( ia_gridSize, oa_rib );
attributeAffects( ia_grassMultiplier, oa_update );
attributeAffects( ia_grassMultiplier, oa_rib );
attributeAffects( ia_baseWidth, oa_update );
attributeAffects( ia_baseWidth, oa_rib );
attributeAffects( ia_grassSegmentLength, oa_update );
attributeAffects( ia_grassSegmentLength, oa_rib );
attributeAffects( ia_grassNumSegments, oa_update );
attributeAffects( ia_grassNumSegments, oa_rib );
attributeAffects( ia_grassBendAmount, oa_update );
attributeAffects( ia_grassBendAmount, oa_rib );
attributeAffects( ia_windDirection, oa_update );
attributeAffects( ia_windDirection, oa_rib );
attributeAffects( ia_windSpread, oa_update );
attributeAffects( ia_windSpread, oa_rib );
attributeAffects( ia_clock, oa_update );
attributeAffects( ia_clock, oa_rib );
attributeAffects( ia_grassBaseColour1, oa_update);
attributeAffects( ia_grassBaseColour1, oa_rib);
attributeAffects( ia_grassTipColour1, oa_update);
attributeAffects( ia_grassTipColour1, oa_rib);
attributeAffects( ia_grassBaseColour2, oa_update);
attributeAffects( ia_grassBaseColour2, oa_rib);
attributeAffects( ia_grassTipColour2, oa_update);
attributeAffects( ia_grassTipColour2, oa_rib);
fprintf( stderr, "VmIslandNode::initialize() done\n" );
return MStatus::kSuccess;
}
MStatus meshOpNode::initialize()
//
// Description:
// This method is called to create and initialize all of the attributes
// and attribute dependencies for this node type. This is only called
// once when the node type is registered with Maya.
//
// Return Values:
// MS::kSuccess
// MS::kFailure
//
{
MStatus status;
MFnTypedAttribute attrFn;
MFnEnumAttribute enumFn;
cpList = attrFn.create("inputComponents", "ics",
MFnComponentListData::kComponentList);
attrFn.setStorable(true); // To be stored during file-save
opType = enumFn.create("operationType", "oprt", 0, &status);
enumFn.addField("subd_edges", 0);
enumFn.addField("subd_faces", 1);
enumFn.setHidden(false);
enumFn.setKeyable(true);
enumFn.setStorable(true); // To be stored during file-save
inMesh = attrFn.create("inMesh", "im", MFnMeshData::kMesh);
attrFn.setStorable(true); // To be stored during file-save
// Attribute is read-only because it is an output attribute
//
outMesh = attrFn.create("outMesh", "om", MFnMeshData::kMesh);
attrFn.setStorable(false);
attrFn.setWritable(false);
// Add the attributes we have created to the node
//
status = addAttribute( cpList );
if (!status)
{
status.perror("addAttribute");
return status;
}
status = addAttribute( opType );
if (!status)
{
status.perror("addAttribute");
return status;
}
status = addAttribute( inMesh );
if (!status)
{
status.perror("addAttribute");
return status;
}
status = addAttribute( outMesh);
if (!status)
{
status.perror("addAttribute");
return status;
}
// Set up a dependency between the input and the output. This will cause
// the output to be marked dirty when the input changes. The output will
// then be recomputed the next time the value of the output is requested.
//
status = attributeAffects( inMesh, outMesh );
if (!status)
{
status.perror("attributeAffects");
return status;
}
status = attributeAffects( cpList, outMesh );
if (!status)
{
status.perror("attributeAffects");
return status;
}
status = attributeAffects( opType, outMesh );
if (!status)
{
status.perror("attributeAffects");
return status;
}
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;
}
MStatus MG_poseReader::initialize()
{
//Declaring all the needed attribute function sets
MFnEnumAttribute enumFn;
MFnMatrixAttribute matrixFn;
MFnNumericAttribute numFn;
MFnCompoundAttribute compA;
//Aim axis input attribute
aimAxis = enumFn.create("aimAxis","aa",0);
enumFn.addField("x",0);
enumFn.addField("y",1);
enumFn.addField("z",2);
enumFn.setKeyable(true);
enumFn.setStorable(true);
addAttribute(aimAxis);
//Pose matrix input attribute
poseMatrix =matrixFn.create("poseMatrix","psm");
matrixFn.setKeyable(true);
matrixFn.setStorable(true);
addAttribute(poseMatrix);
//Reader matrix input attribute
readerMatrix =matrixFn.create("readerMatrix","rm");
matrixFn.setKeyable(true);
matrixFn.setStorable(true);
addAttribute(readerMatrix);
//Aim axis input attribute
//Arrow size
size =numFn.create("size","siz",MFnNumericData::kDouble,1);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(size);
readerOnOff =numFn.create("readerOnOff","rof",MFnNumericData::kBoolean,1);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(readerOnOff);
axisOnOff =numFn.create("axisOnOff","aof",MFnNumericData::kBoolean,1);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(axisOnOff);
poseOnOff =numFn.create("poseOnOff","pof",MFnNumericData::kBoolean,1);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(poseOnOff);
xPositive = numFn.create("xPositive","xp",MFnNumericData::kDouble,0);
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(xPositive);
xNegative = numFn.create("xNegative","xn",MFnNumericData::kDouble,0);
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(xNegative);
yPositive = numFn.create("yPositive","yp",MFnNumericData::kDouble,0);
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(yPositive);
yNegative = numFn.create("yNegative","yn",MFnNumericData::kDouble,0);
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(yNegative);
zPositive = numFn.create("zPositive","zp",MFnNumericData::kDouble,0);
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(zPositive);
zNegative = numFn.create("zNegative","zn",MFnNumericData::kDouble,0);
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(zNegative);
attributeAffects (aimAxis,xPositive);
attributeAffects (poseMatrix,xPositive);
attributeAffects (readerMatrix,xPositive);
attributeAffects (size,xPositive);
attributeAffects (aimAxis,xNegative);
attributeAffects (poseMatrix,xNegative);
attributeAffects (readerMatrix,xNegative);
attributeAffects (size,xNegative);
attributeAffects (aimAxis,yPositive);
attributeAffects (poseMatrix,yPositive);
attributeAffects (readerMatrix,yPositive);
attributeAffects (size,yPositive);
attributeAffects (aimAxis,yNegative);
attributeAffects (poseMatrix,yNegative);
attributeAffects (readerMatrix,yNegative);
attributeAffects (size,yNegative);
attributeAffects (aimAxis,zPositive);
attributeAffects (poseMatrix,zPositive);
attributeAffects (readerMatrix,zPositive);
attributeAffects (size,zPositive);
attributeAffects (aimAxis,zNegative);
attributeAffects (poseMatrix,zNegative);
attributeAffects (readerMatrix,zNegative);
attributeAffects (size,zNegative);
return MS::kSuccess;
}
MStatus puttyNode::initialize()
{
MStatus status;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnTypedAttribute tAttr;
MFnMatrixAttribute mAttr;
// the script
aScript = tAttr.create( "script", "scr", MFnData::kString);
tAttr.setStorable(true);
tAttr.setKeyable(false);
SYS_ERROR_CHECK( addAttribute( aScript ), "adding aScript" );
aCmdBaseName = tAttr.create( "cmdBaseName", "cbn", MFnData::kString);
tAttr.setStorable(true);
tAttr.setKeyable(false);
tAttr.setHidden(true);
SYS_ERROR_CHECK( addAttribute( aCmdBaseName ), "adding aCmdBaseName" );
// refresh
aSource = nAttr.create( "source", "src", MFnNumericData::kBoolean, 0 );
nAttr.setHidden(true);
SYS_ERROR_CHECK( addAttribute( aSource ), "adding aSource" );
// it is important that script sourced is initialised false and not storable
// so this way the function gets sourced on maya startup
aScriptSourced = nAttr.create( "scriptSourced", "ssrc", MFnNumericData::kBoolean, 0 );
nAttr.setStorable(false);
nAttr.setHidden(true);
SYS_ERROR_CHECK( addAttribute( aScriptSourced ), "adding aScriptSourced" );
aNodeReady = nAttr.create( "nodeReady", "nr", MFnNumericData::kBoolean, 0 );
nAttr.setHidden(true);
SYS_ERROR_CHECK( addAttribute( aNodeReady ), "adding aNodeReady" );
aDynDirty = nAttr.create( "dynDirty", "dd", MFnNumericData::kBoolean, 0 );
nAttr.setHidden(true);
SYS_ERROR_CHECK( addAttribute( aDynDirty ), "adding aDynDirty" );
// space
aDefSpace = eAttr.create("deformerSpace", "dsp", MSD_SPACE_OBJECT, &status);
eAttr.addField("object (default)", MSD_SPACE_OBJECT);
eAttr.addField("world (automatic conversion)", MSD_SPACE_WORLD);
eAttr.setKeyable(false);
eAttr.setStorable(true);
SYS_ERROR_CHECK( addAttribute( aDefSpace ), "adding aDefSpace" );
// envelope
aDefEnvelope = eAttr.create("deformerEnvelope", "de", MSD_ENVELOPE_AUTO, &status);
eAttr.addField("auto", MSD_ENVELOPE_AUTO);
eAttr.addField("user", MSD_ENVELOPE_USER);
eAttr.setKeyable(false);
eAttr.setStorable(true);
SYS_ERROR_CHECK( addAttribute( aDefEnvelope ), "adding aDefEnvelope" );
// weights
aDefWeights = eAttr.create("deformerWeights", "dw", MSD_WEIGHTS_AUTO, &status);
eAttr.addField("auto", MSD_WEIGHTS_AUTO);
eAttr.addField("user", MSD_WEIGHTS_USER);
eAttr.setKeyable(false);
eAttr.setStorable(true);
SYS_ERROR_CHECK( addAttribute( aDefWeights ), "adding aDefWeights" );
/////////////////////////////////////////////////////////////////////////////
// current values
aCurrPosition = tAttr.create( "currentPosition", "cpos", MFnData::kVectorArray);
tAttr.setStorable(false);
tAttr.setKeyable(false);
tAttr.setConnectable(false);
tAttr.setWritable(false);
SYS_ERROR_CHECK( addAttribute( aCurrPosition ), "adding aCurrPos" );
aCurrWeight = tAttr.create( "currentWeight", "cwgh", MFnData::kDoubleArray);
tAttr.setStorable(false);
tAttr.setKeyable(false);
tAttr.setConnectable(false);
tAttr.setWritable(false);
SYS_ERROR_CHECK( addAttribute( aCurrWeight ), "adding aCurrWeight" );
aCurrMultiIndex = nAttr.create("currentMultiIndex","cmi",MFnNumericData::kInt);
nAttr.setStorable(false);
nAttr.setKeyable(false);
nAttr.setConnectable(false);
nAttr.setWritable(false);
SYS_ERROR_CHECK( addAttribute( aCurrMultiIndex ), "adding aCurrMultiIndex" );
aCurrWorldMatrix = mAttr.create("currentWorldMatrix","cwm");
mAttr.setStorable(false);
mAttr.setKeyable(false);
mAttr.setConnectable(false);
mAttr.setWritable(false);
SYS_ERROR_CHECK( addAttribute( aCurrWorldMatrix ), "adding aCurrObjectName" );
/*
aCurrGeometryName= tAttr.create( "currentGeometryName", "con", MFnData::kString);
tAttr.setStorable(false);
tAttr.setKeyable(false);
tAttr.setConnectable(false);
tAttr.setWritable(false);
SYS_ERROR_CHECK( addAttribute( aCurrGeometryName ), "adding aCurrObjectName" );
*/
aCurrGeometryType= tAttr.create( "currentGeometryType", "cot", MFnData::kString);
tAttr.setStorable(false);
tAttr.setKeyable(false);
tAttr.setConnectable(false);
tAttr.setWritable(false);
SYS_ERROR_CHECK( addAttribute( aCurrGeometryType ), "adding aCurrGeometryType" );
/////////////////////////////////////////////////////////////////////////////
// affects
attributeAffects( aScript ,aNodeReady);
attributeAffects( aSource, aNodeReady );
attributeAffects( aScriptSourced, aNodeReady );
attributeAffects( aScript,aScriptSourced);
attributeAffects( aSource,aScriptSourced);
attributeAffects( aScriptSourced, outputGeom );
attributeAffects( aDynDirty,outputGeom );
attributeAffects( aNodeReady,outputGeom );
attributeAffects( aScript ,outputGeom);
attributeAffects( aCmdBaseName ,outputGeom);
attributeAffects( aSource ,outputGeom );
attributeAffects( aDefSpace, outputGeom );
attributeAffects( aDefWeights,outputGeom);
attributeAffects( aDefEnvelope,outputGeom );
return MS::kSuccess;
}
MStatus sphericalBlendShape::initialize()
{
MStatus status;
MFnMatrixAttribute mAttr;
MFnEnumAttribute eAttr;
aSpaceMatrix = mAttr.create("spaceMatrix", "spaceMatrix", MFnMatrixAttribute::kDouble, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
aPoleAxis = eAttr.create("poleAxis", "poleAxis", 1, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(1);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
aSeamAxis = eAttr.create("seamAxis", "seamAxis", 0, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(0);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
aWarpMatrix = mAttr.create("warpMatrix", "warpMatrix", MFnMatrixAttribute::kDouble, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
aMethod = eAttr.create("conversionMethod", "conversionMethod", 0, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("xyzToSpherical", 0);
eAttr.addField("sphericalToXyz", 1);
eAttr.setDefault(0);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
addAttribute(aSpaceMatrix);
addAttribute(aPoleAxis);
addAttribute(aSeamAxis);
addAttribute(aWarpMatrix);
addAttribute(aMethod);
attributeAffects(aSpaceMatrix, outputGeom);
attributeAffects(aPoleAxis, outputGeom);
attributeAffects(aSeamAxis, outputGeom);
attributeAffects(aWarpMatrix, outputGeom);
attributeAffects(aMethod, outputGeom);
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 retargetLocator::initialize()
{
MFnNumericAttribute nAttr;
MFnMatrixAttribute mAttr;
MFnEnumAttribute eAttr;
MFnUnitAttribute uAttr;
MFnCompoundAttribute cAttr;
MFnTypedAttribute tAttr;
aOutput = nAttr.create( "output", "output", MFnNumericData::kDouble );
nAttr.setStorable( false );
CHECK_MSTATUS( addAttribute( aOutput ) );
aDiscMatrix = mAttr.create( "discMatrix", "discMatrix" );
mAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aDiscMatrix ) );
CHECK_MSTATUS( attributeAffects( aDiscMatrix, aOutput ) );
aDiscAxis = eAttr.create( "discAxis", "discAxis", 0 );
eAttr.addField( "X", 0 );
eAttr.addField( "Y", 1 );
eAttr.addField( "Z", 2 );
eAttr.setStorable( true );
eAttr.setChannelBox( true );
eAttr.setReadable( true );
CHECK_MSTATUS( addAttribute( aDiscAxis ) );
CHECK_MSTATUS( attributeAffects( aDiscAxis, aOutput ) );
aDiscDivision = nAttr.create( "discDivision", "discDivision", MFnNumericData::kInt, 32 );
nAttr.setMin( 1 );
nAttr.setMax( 32 );
nAttr.setStorable( true );
nAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscDivision ) );
CHECK_MSTATUS( attributeAffects( aDiscDivision, aOutput ) );
aDiscAngle = uAttr.create( "discAngle", "discAngle", MFnUnitAttribute::kAngle, 0.0 );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscAngle ) );
CHECK_MSTATUS( attributeAffects( aDiscAngle, aOutput ) );
aDiscOffsetX = nAttr.create( "discOffsetX", "discOffsetX", MFnNumericData::kDouble, 0.0 );
aDiscOffsetY = nAttr.create( "discOffsetY", "discOffsetY", MFnNumericData::kDouble, 0.0 );
aDiscOffsetZ = nAttr.create( "discOffsetZ", "discOffsetZ", MFnNumericData::kDouble, 0.0 );
aDiscOffset = nAttr.create( "discOffset", "discOffset", aDiscOffsetX, aDiscOffsetY, aDiscOffsetZ );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscOffset ) );
CHECK_MSTATUS( attributeAffects( aDiscOffset, aOutput ) );
aDiscSizeX = nAttr.create( "discSizeX", "discSizeX", MFnNumericData::kDouble, 1.0 );
aDiscSizeY = nAttr.create( "discSizeY", "discSizeY", MFnNumericData::kDouble, 1.0 );
aDiscSizeZ = nAttr.create( "discSizeZ", "discSizeZ", MFnNumericData::kDouble, 1.0 );
aDiscSize = nAttr.create( "discSize", "discSize", aDiscSizeX, aDiscSizeY, aDiscSizeZ );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscSize ) );
CHECK_MSTATUS( attributeAffects( aDiscSize, aOutput ) );
aDiscActiveColor = nAttr.createColor( "discActiveColor", "discActiveColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
CHECK_MSTATUS( addAttribute( aDiscActiveColor ) );
CHECK_MSTATUS( attributeAffects( aDiscActiveColor, aOutput ) );
aDiscLeadColor = nAttr.createColor( "discLeadColor", "discLeadColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.263f, 1.0f, .639f);
CHECK_MSTATUS( addAttribute( aDiscLeadColor ) );
CHECK_MSTATUS( attributeAffects( aDiscLeadColor, aOutput ) );
aDiscDefaultColor = nAttr.createColor( "discDefaultColor", "discDefaultColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.0f, .016f, .376f);
CHECK_MSTATUS( addAttribute( aDiscDefaultColor ) );
CHECK_MSTATUS( attributeAffects( aDiscDefaultColor, aOutput ) );
aDiscFillAlpha = nAttr.create( "discFillAlpha", "discFillAlpha", MFnNumericData::kFloat, 0.1f );
nAttr.setStorable( true );
nAttr.setMin( 0.0f );
nAttr.setMax( 1.0f );
CHECK_MSTATUS( addAttribute( aDiscFillAlpha ) );
CHECK_MSTATUS( attributeAffects( aDiscFillAlpha, aOutput ) );
aDiscLineAlpha = nAttr.create( "discLineAlpha", "discLineAlpha", MFnNumericData::kFloat, 1.0f );
nAttr.setStorable( true );
nAttr.setMin( 0.0f );
nAttr.setMax( 1.0f );
CHECK_MSTATUS( addAttribute( aDiscLineAlpha ) );
CHECK_MSTATUS( attributeAffects( aDiscLineAlpha, aOutput ) );
aArrow = cAttr.create( "arrow", "arrow" );
aInheritMatrix = nAttr.create( "inheritMatrix", "inheritMatrix", MFnNumericData::kBoolean, false );
aInputMesh = tAttr.create( "inputMesh", "inputMesh", MFnData::kMesh );
aAimMatrix = mAttr.create( "aimMatrix", "aimMatrix" );
aStartSize = nAttr.create( "startSize", "startSize", MFnNumericData::kFloat, 0.5f );
aSize = nAttr.create( "size", "size", MFnNumericData::kFloat, 1.0f );
aActiveColor = nAttr.createColor( "activeColor", "activeColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
aLeadColor = nAttr.createColor( "leadColor", "leadColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.263f, 1.0f, .639f);
aDefaultColor = nAttr.createColor( "defaultColor", "defaultColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.0f, .016f, .376f);
aFillAlpha = nAttr.create( "fillAlpha", "fillAlpha", MFnNumericData::kFloat, 0.1f );
aLineAlpha = nAttr.create( "lineAlpha", "lineAlpha", MFnNumericData::kFloat, 1.0f );
aOffsetX = nAttr.create( "offsetX", "offsetX", MFnNumericData::kDouble, 0.0 );
aOffsetY = nAttr.create( "offsetY", "offsetY", MFnNumericData::kDouble, 0.0 );
aOffsetZ = nAttr.create( "offsetZ", "offsetZ", MFnNumericData::kDouble, 0.0 );
aOffset = nAttr.create( "offset", "offset", aOffsetX, aOffsetY, aOffsetZ );
cAttr.addChild( aInheritMatrix );
cAttr.addChild( aAimMatrix );
cAttr.addChild( aInputMesh );
cAttr.addChild( aStartSize );
cAttr.addChild( aSize );
cAttr.addChild( aActiveColor );
cAttr.addChild( aLeadColor );
cAttr.addChild( aDefaultColor );
cAttr.addChild( aFillAlpha );
cAttr.addChild( aLineAlpha );
cAttr.addChild( aOffset );
cAttr.setArray( true );
cAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aArrow ) );
CHECK_MSTATUS( attributeAffects( aArrow, aOutput ) );
return MS::kSuccess;
}
MStatus buildRotation::initialize()
{
MFnNumericAttribute nAttr;
MFnMatrixAttribute mAttr;
MFnUnitAttribute uAttr;
MFnEnumAttribute eAttr;
MStatus stat;
// Set up inputs
//
upX = nAttr.create( "upX", "ux", MFnNumericData::kDouble );
nAttr.setStorable(false);
upY = nAttr.create( "upY", "uy", MFnNumericData::kDouble );
nAttr.setStorable(false);
upZ = nAttr.create( "upZ", "uz", MFnNumericData::kDouble );
nAttr.setStorable(false);
up = nAttr.create( "up", "u", upX, upY, upZ );
nAttr.setDefault( 0.0, 1.0, 0.0 );
nAttr.setStorable(false);
forwardX = nAttr.create( "forwardX", "fx", MFnNumericData::kDouble, 0.0 );
nAttr.setStorable(false);
forwardY = nAttr.create( "forwardY", "fy", MFnNumericData::kDouble, 0.0 );
nAttr.setStorable(false);
forwardZ = nAttr.create( "forwardZ", "fz", MFnNumericData::kDouble, 1.0 );
nAttr.setStorable(false);
forward = nAttr.create( "forward", "f", forwardX, forwardY, forwardZ );
nAttr.setDefault( 0.0, 0.0, 1.0 );
nAttr.setStorable(false);
rotateOrder = eAttr.create( "rotateOrder", "ro", ROTATE_ORDER_XYZ);
eAttr.addField("xyz", ROTATE_ORDER_XYZ);
eAttr.addField("yzx", ROTATE_ORDER_YZX);
eAttr.addField("zxy", ROTATE_ORDER_ZXY);
eAttr.addField("xzy", ROTATE_ORDER_XZY);
eAttr.addField("yxz", ROTATE_ORDER_YXZ);
eAttr.addField("zyx", ROTATE_ORDER_ZYX);
eAttr.setStorable(false);
// Set up outputs
//
rotateX = uAttr.create( "rotateX", "rx", MFnUnitAttribute::kAngle, 0.0 );
nAttr.setStorable(false);
rotateY = uAttr.create( "rotateY", "ry", MFnUnitAttribute::kAngle, 0.0 );
nAttr.setStorable(false);
rotateZ = uAttr.create( "rotateZ", "rz", MFnUnitAttribute::kAngle, 0.0 );
nAttr.setStorable(false);
rotate = nAttr.create( "rotate", "r", rotateX, rotateY, rotateZ );
nAttr.setStorable(false);
rotateMatrix = mAttr.create( "rotateMatrix", "rm" );
nAttr.setStorable(false);
nAttr.setConnectable(true);
stat = addAttribute( up );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( forward );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( rotate );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( rotateOrder );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( rotateMatrix );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = attributeAffects( up, rotate );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( up, rotateMatrix );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( forward, rotate );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( forward, rotateMatrix );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( rotateOrder, rotate );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( rotateOrder, rotateMatrix );
if (!stat) { stat.perror("attributeAffects"); return stat;}
return MS::kSuccess;
}
