MStatus SwirlDeformer::initialize() { MFnMatrixAttribute mAttr; deformSpace = mAttr.create( "deformSpace", "dSp" ); mAttr.setStorable( false ); MFnUnitAttribute unitFn; startDist = unitFn.create( "startDist", "sd", MFnUnitAttribute::kDistance ); unitFn.setDefault( MDistance( 0.0, MDistance::uiUnit() ) ); unitFn.setMin( MDistance( 0.0, MDistance::uiUnit() ) ); unitFn.setKeyable( true ); endDist = unitFn.create( "endDist", "ed", MFnUnitAttribute::kDistance ); unitFn.setDefault( MDistance( 3.0, MDistance::uiUnit() ) ); unitFn.setMin( MDistance( 0.0, MDistance::uiUnit() ) ); unitFn.setKeyable( true ); addAttribute( deformSpace ); addAttribute( startDist ); addAttribute( endDist ); attributeAffects( deformSpace, outputGeom ); attributeAffects( startDist, outputGeom ); attributeAffects( endDist, outputGeom ); return MS::kSuccess; }
MStatus ArrayAngleConstructorNode::initialize() { MStatus status; MFnNumericAttribute N; MFnTypedAttribute T; MFnUnitAttribute U; aSize = N.create("size", "size", MFnNumericData::kInt, 8.0, &status); N.setKeyable(true); N.setStorable(true); N.setWritable(true); N.setDefault(8); aInput = U.create("input", "i", MFnUnitAttribute::kAngle, 0.0, &status); U.setKeyable(false); U.setStorable(true); U.setWritable(true); U.setArray(true); aOutput = T.create("output", "o", MFnData::kDoubleArray, &status); T.setKeyable(false); T.setChannelBox(false); T.setWritable(false); T.setStorable(false); addAttribute(aSize); addAttribute(aInput); addAttribute(aOutput); attributeAffects(aSize, aOutput); attributeAffects(aInput, aOutput); return MS::kSuccess; }
/*! * Initialize attributes in Maya. */ MStatus ffdPlanar::initialize() { // Local attributes. MFnNumericAttribute nAttr; latticeRow1 = nAttr.create( "row1", "r1", MFnNumericData::k3Double ); nAttr.setDefault( 0.0, 0.0, 0.0 ); nAttr.setMin( -100.0, -100.0, -100.0 ); nAttr.setMax( 100.0, 100.0, 100.0 ); nAttr.setKeyable( true ); addAttribute( latticeRow1 ); latticeRow2 = nAttr.create( "row2", "r2", MFnNumericData::k3Double ); nAttr.setDefault( 0.0, 0.0, 0.0 ); nAttr.setMin( -100.0, -100.0, -100.0 ); nAttr.setMax( 100.0, 100.0, 100.0 ); nAttr.setKeyable( true ); addAttribute( latticeRow2 ); latticeRow3 = nAttr.create( "row3", "r3", MFnNumericData::k3Double ); nAttr.setDefault( 0.0, 0.0, 0.0 ); nAttr.setMin( -100.0, -100.0, -100.0 ); nAttr.setMax( 100.0, 100.0, 100.0 ); nAttr.setKeyable( true ); addAttribute( latticeRow3 ); // Attributes affect geometry. attributeAffects( ffdPlanar::latticeRow1, ffdPlanar::outputGeom ); attributeAffects( ffdPlanar::latticeRow2, ffdPlanar::outputGeom ); attributeAffects( ffdPlanar::latticeRow3, ffdPlanar::outputGeom ); return MS::kSuccess; }
MStatus PhysicalsunNode::initialize_shader_parameters() { //CM_TRACE_FUNC("PhysicalsunNode::initialize_shader_parameters()"); MFnTypedAttribute tAttr; MFnStringData tDefault; MFnNumericAttribute nAttr; MFnEnumAttribute eAttr; MFnLightDataAttribute lAttr; MFnStringData stringData; MStatus status, sstat; CREATE_FLOAT(nAttr, ai_multiplier, "multiplier", "mul", 1.0); CREATE_COLOR(nAttr, ai_rgb_unit_conversion, "rgb_unit_conversion", "uc", 0.0, 0.0, 0.0); CREATE_FLOAT(nAttr, ai_haze, "haze", "haz", 0.0); CREATE_FLOAT(nAttr, ai_redblueshift, "redblueshift", "rbs", 0.0); CREATE_FLOAT(nAttr, ai_saturation, "saturation", "sat", 0.7); CREATE_FLOAT(nAttr, ai_horizon_height, "horizon_height", "hoh", 0.0); CREATE_FLOAT(nAttr, ai_shadow_softness, "shadow_softness","ssf", 0.0); CREATE_STRING(tAttr,ai_shadowmap, "shadowmap", "sm", "raytrace"); CREATE_INT(nAttr, ai_shadow_samples, "shadow_samples", "ssp", 3); CREATE_BOOL(nAttr, ai_y_is_up, "y_is_up", "yup", false ); IfMErrorWarn( attributeAffects( ai_multiplier, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_rgb_unit_conversion, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_haze, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_redblueshift, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_saturation, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_horizon_height, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_shadow_softness, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_shadowmap, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_shadow_samples, aOutColor ) ); IfMErrorWarn( attributeAffects( ai_y_is_up, aOutColor ) ); return MS::kSuccess; }
MStatus VolumePushCollider::initialize() { MFnNumericAttribute nAttr; MFnMatrixAttribute mAttr; // inCollider aInCollider = mAttr.create("inCollider", "col"); mAttr.setArray(true); CHECK_MSTATUS(addAttribute(aInCollider)); // inVolume aInVolume = mAttr.create("inVolume", "vol"); mAttr.setArray(true); CHECK_MSTATUS(addAttribute(aInVolume)); // output aOutput = nAttr.create("output", "out", MFnNumericData::kDouble, 0.0); nAttr.setArray(true); nAttr.setReadable(true); nAttr.setWritable(true); nAttr.setHidden(true); CHECK_MSTATUS(addAttribute(aOutput)); attributeAffects(aInCollider, aOutput); attributeAffects(aInVolume, aOutput); return MS::kSuccess; }
MStatus OccLightNode::initialize_shader_parameters() { //CM_TRACE_FUNC("OccLightNode::initialize_shader_parameters()"); MFnTypedAttribute tAttr; MFnStringData tDefault; MFnNumericAttribute nAttr; MFnEnumAttribute eAttr; MFnLightDataAttribute lAttr; MFnStringData stringData; MStatus status, sstat; CREATE_FLOAT(nAttr, akocc, "Kocc", "k", 1.0); CREATE_INT(nAttr, asamples, "samples", "sam", 64); CREATE_FLOAT(nAttr, amaxdist, "maxdist", "max", 1e36); CREATE_STRING(tAttr,adistribution, "distribution", "dis", "cosine"); CREATE_BOOL(nAttr, a__nonspecular, "__nonspecular","nsp", 1); IfMErrorWarn( attributeAffects( akocc, aOutColor ) ); IfMErrorWarn( attributeAffects( asamples, aOutColor ) ); IfMErrorWarn( attributeAffects( amaxdist, aOutColor ) ); IfMErrorWarn( attributeAffects( adistribution, aOutColor ) ); IfMErrorWarn( attributeAffects( a__nonspecular, aOutColor ) ); return MS::kSuccess; }
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; }
MStatus sgBulgeDeformer::initialize() { MStatus status; MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnMatrixAttribute mAttr; MFnCompoundAttribute cAttr; aBulgeWeight = nAttr.create(nameBulgeWeight, nameBulgeWeight, MFnNumericData::kFloat, 1.0); nAttr.setStorable(false); nAttr.setKeyable(true); addAttribute(aBulgeWeight); aBulgeRadius = nAttr.create(nameBulgeRadius, nameBulgeRadius, MFnNumericData::kDouble, 0); nAttr.setMin(0); nAttr.setStorable(false); nAttr.setKeyable(true); addAttribute(aBulgeRadius); aBulgeInputs = cAttr.create(nameBulgeInputs, nameBulgeInputs); aMatrix = mAttr.create(nameMatrix, nameMatrix); aMesh = tAttr.create(nameMesh, nameMesh, MFnData::kMesh ); cAttr.addChild(aMatrix); cAttr.addChild(aMesh); cAttr.setArray(true); addAttribute(aBulgeInputs); attributeAffects(aBulgeWeight, outputGeom); attributeAffects(aBulgeRadius, outputGeom); attributeAffects(aBulgeInputs, outputGeom); return status; }
MStatus PushDeformer::initialize() { MStatus status; MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; //add bulge attribute which affects the output geom aAmount = nAttr.create("amount", "amt", MFnNumericData::kDouble, 0.0); nAttr.setKeyable(true); addAttribute(aAmount); aStressMap = tAttr.create("aStressMap", "stMap", MFnData::kDoubleArray); tAttr.setKeyable(true); tAttr.setWritable(true); tAttr.setStorable(true); addAttribute(aStressMap); aUseStress = nAttr.create("useStress", "useStress", MFnNumericData::kBoolean, 0); nAttr.setKeyable(true); nAttr.setStorable(true); addAttribute(aUseStress); aMultiThreadingType = nAttr.create("multiThreadingType", "multiThreadingType", MFnNumericData::kInt, 0); nAttr.setKeyable(true); addAttribute(aMultiThreadingType); attributeAffects(aAmount, outputGeom); attributeAffects(aStressMap, outputGeom); attributeAffects(aUseStress, outputGeom); attributeAffects(aMultiThreadingType, outputGeom); // make paintable deformer MGlobal::executeCommand("makePaintable -attrType multiFloat -sm deformer pushDeformer weights"); return MS::kSuccess; }
MStatus simpleEvaluationNode::initialize() { MFnNumericAttribute nAttr; MFnUnitAttribute uAttr; MStatus status; input = nAttr.create( "input", "in", MFnNumericData::kFloat, 2.0 ); nAttr.setStorable(true); aTimeInput = uAttr.create( "inputTime", "itm", MFnUnitAttribute::kTime, 0.0 ); uAttr.setWritable(true); uAttr.setStorable(true); uAttr.setReadable(true); uAttr.setKeyable(true); output = nAttr.create( "output", "out", MFnNumericData::kFloat, 0.0 ); nAttr.setWritable(false); nAttr.setStorable(false); status = addAttribute( input ); if (!status) { status.perror("addAttribute"); return status;} status = addAttribute( aTimeInput ); if (!status) { status.perror("addAttribute"); return status;} status = addAttribute( output ); if (!status) { status.perror("addAttribute"); return status;} status = attributeAffects( input, output ); if (!status) { status.perror("attributeAffects"); return status;} status = attributeAffects( aTimeInput, output ); if (!status) { status.perror("attributeAffects"); return status;} return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus Gamma::initialize() { MFnNumericAttribute nAttr; // Input attributes aColor = nAttr.createColor( "color", "c" ); MAKE_INPUT(nAttr); aGamma = nAttr.createPoint( "gamma", "g" ); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault(1.f, 1.f, 1.f) ); // Output attributes aOutColor= nAttr.createColor( "outColor", "oc" ); MAKE_OUTPUT(nAttr); // Add attributes to the node database. CHECK_MSTATUS ( addAttribute(aColor) ); CHECK_MSTATUS ( addAttribute(aGamma) ); CHECK_MSTATUS ( addAttribute(aOutColor) ); // All input affect the output color CHECK_MSTATUS ( attributeAffects( aColor, aOutColor )); CHECK_MSTATUS ( attributeAffects( aGamma, aOutColor )); return MS::kSuccess; }
// // DESCRIPTION: MStatus OSLNode::initialize() { MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus status; color = nAttr.createColor("color", "color"); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( color )); script = tAttr.create("script", "script", MFnNumericData::kString); MAKE_INPUT(tAttr); CHECK_MSTATUS(addAttribute( script )); outColor = nAttr.createColor("outColor", "outColor"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( outColor )); //---------------------------- automatically created attributes start ------------------------------------ //---------------------------- automatically created attributes end ------------------------------------ attributeAffects(color, outColor); attributeAffects(script, outColor); return MS::kSuccess; }
MStatus testNpassiveNode::initialize() { MStatus stat; MFnTypedAttribute tAttr; inputGeom = tAttr.create("inputGeom", "ing", MFnData::kMesh, MObject::kNullObj, &stat ); //statCheck(stat, "failed to create inputGeom"); tAttr.setWritable(true); tAttr.setStorable(true); tAttr.setHidden(true); currentState = tAttr.create("currentState", "cus", MFnData::kNObject, MObject::kNullObj, &stat ); // statCheck(stat, "failed to create currentState"); tAttr.setWritable(true); tAttr.setStorable(false); tAttr.setHidden(true); startState = tAttr.create( "startState", "sts", MFnData::kNObject, MObject::kNullObj, &stat ); //statCheck(stat, "failed to create startState"); tAttr.setWritable(true); tAttr.setStorable(false); tAttr.setHidden(true); MFnUnitAttribute uniAttr; currentTime = uniAttr.create( "currentTime", "ctm" , MFnUnitAttribute::kTime, 0.0, &stat ); addAttribute(inputGeom); addAttribute(currentTime); addAttribute(startState); addAttribute(currentState); attributeAffects(inputGeom, startState); attributeAffects(inputGeom, currentState); attributeAffects(currentTime, currentState); attributeAffects(currentTime, startState); return MStatus::kSuccess; }
MStatus BCIViz::initialize() { MFnNumericAttribute numFn; MFnMatrixAttribute matAttr; MStatus stat; ainput = matAttr.create( "input", "in", MFnMatrixAttribute::kDouble ); matAttr.setStorable(false); matAttr.setWritable(true); matAttr.setConnectable(true); addAttribute(ainput); atargets = matAttr.create( "target", "tgt", MFnMatrixAttribute::kDouble ); matAttr.setStorable(false); matAttr.setWritable(true); matAttr.setArray(true); matAttr.setConnectable(true); addAttribute(atargets); outValue = numFn.create( "outValue", "ov", MFnNumericData::kDouble ); numFn.setStorable(false); numFn.setWritable(false); numFn.setReadable(true); numFn.setArray(true); numFn.setUsesArrayDataBuilder( true ); addAttribute(outValue); attributeAffects(ainput, outValue); attributeAffects(atargets, outValue); return MS::kSuccess; }
MStatus sgBLocator_fromGeo::initialize() { MStatus status; MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; aOutputValue = nAttr.create( "outputValue", "outputValue", MFnNumericData::kInt, 1.0 ); nAttr.setStorable( false ); CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aOutputValue ) ); CHECK_MSTATUS_AND_RETURN_IT( status ); aInputCurve = tAttr.create( "inputCurve", "inputCurve", MFnData::kNurbsCurve ); tAttr.setStorable( true ); CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputCurve ) ); aLineWidth = nAttr.create( "lineWidth", "lineWidth", MFnNumericData::kInt, 1 ); nAttr.setMin( 1 ); nAttr.setKeyable( true ); nAttr.setStorable( true ); CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aLineWidth ) ); CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputCurve, aOutputValue ) ); CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aLineWidth, aOutputValue ) ); return MS::kSuccess; }
MStatus mapBlendShape::initialize() { MStatus status; MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; aBlendMesh = tAttr.create("blendMesh", "blendMesh", MFnData::kMesh); addAttribute(aBlendMesh); aBlendMap = nAttr.createColor("blendMap", "blendMap"); addAttribute(aBlendMap); aUseBlendMap = nAttr.create("useBlendMap", "useBlendMap", MFnNumericData::kBoolean); nAttr.setDefault(true); addAttribute(aUseBlendMap); aBlendMapMultiplier = nAttr.create("blendMapMultiplier", "blendMapMultiplier", MFnNumericData::kFloat); nAttr.setDefault(1.0); nAttr.setMin(0.0); addAttribute(aBlendMapMultiplier); attributeAffects(aBlendMesh, outputGeom); attributeAffects(aBlendMap, outputGeom); attributeAffects(aUseBlendMap, outputGeom); attributeAffects(aBlendMapMultiplier, outputGeom); MGlobal::executeCommand( "makePaintable -attrType multiFloat -sm deformer blendNode weights;" ); return MS::kSuccess; }
MStatus AlembicCurvesDeformNode::initialize() { MStatus status; MFnUnitAttribute uAttr; MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; MFnGenericAttribute gAttr; MFnStringData emptyStringData; MObject emptyStringObject = emptyStringData.create(""); // input time mTimeAttr = uAttr.create("inTime", "tm", MFnUnitAttribute::kTime, 0.0); status = uAttr.setStorable(true); status = uAttr.setKeyable(true); status = addAttribute(mTimeAttr); // input file name mFileNameAttr = tAttr.create("fileName", "fn", MFnData::kString, emptyStringObject); status = tAttr.setStorable(true); status = tAttr.setUsedAsFilename(true); status = tAttr.setKeyable(false); status = addAttribute(mFileNameAttr); // input identifier mIdentifierAttr = tAttr.create("identifier", "if", MFnData::kString, emptyStringObject); status = tAttr.setStorable(true); status = tAttr.setKeyable(false); status = addAttribute(mIdentifierAttr); // output for list of ArbGeomParams mGeomParamsList = tAttr.create("ExocortexAlembic_GeomParams", "exo_gp", MFnData::kString, emptyStringObject); status = tAttr.setStorable(true); status = tAttr.setKeyable(false); status = tAttr.setHidden(false); status = tAttr.setInternal(true); status = addAttribute(mGeomParamsList); // output for list of UserAttributes mUserAttrsList = tAttr.create("ExocortexAlembic_UserAttributes", "exo_ua", MFnData::kString, emptyStringObject); status = tAttr.setStorable(true); status = tAttr.setKeyable(false); status = tAttr.setHidden(false); status = tAttr.setInternal(true); status = addAttribute(mUserAttrsList); // create a mapping status = attributeAffects(mTimeAttr, outputGeom); status = attributeAffects(mFileNameAttr, outputGeom); status = attributeAffects(mIdentifierAttr, outputGeom); return status; }
MStatus sgIkSmoothStretch::initialize() { MStatus stat; MFnNumericAttribute nAttr; aInputDistance = nAttr.create( "inputDistance", "in", MFnNumericData::kDouble, 0.0 ); nAttr.setArray( true ); nAttr.setUsesArrayDataBuilder( true ); nAttr.setStorable( true ); aInPositionX = nAttr.create( "inPositionX", "ipx", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aInPositionY = nAttr.create( "inPositionY", "ipy", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aInPositionZ = nAttr.create( "inPositionZ", "ipz", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aInPosition = nAttr.create( "inPosition", "ip", aInPositionX, aInPositionY, aInPositionZ ); aOutputDistance = nAttr.create( "outputDistance", "out", MFnNumericData::kDouble, 0,0 ); nAttr.setArray( true ); nAttr.setUsesArrayDataBuilder( true ); nAttr.setStorable( false ); nAttr.setWritable( false ); aSmoothArea = nAttr.create( "smoothArea", "smoothArea", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aStretchAble = nAttr.create( "stretchAble", "sa", MFnNumericData::kFloat, 1.0 ); nAttr.setStorable( true ); nAttr.setMin( 0.0 ); nAttr.setMax( 1 ); stat = addAttribute( aInputDistance ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aInPosition ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aOutputDistance ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aStretchAble ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aSmoothArea ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = attributeAffects( aInputDistance, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aInPosition, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aStretchAble, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aSmoothArea, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} return MS::kSuccess; }
// INIT ========================================= MStatus gear_uToPercentage::initialize() { MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; MStatus stat; // Curve curve = tAttr.create("curve", "crv", MFnData::kNurbsCurve); stat = addAttribute( curve ); if (!stat) {stat.perror("addAttribute"); return stat;} // Sliders normalizedU = nAttr.create("normalizedU", "n", MFnNumericData::kBoolean, false); nAttr.setStorable(true); nAttr.setKeyable(true); stat = addAttribute( normalizedU ); if (!stat) {stat.perror("addAttribute"); return stat;} u = nAttr.create("u", "u", MFnNumericData::kFloat, .5, 0); nAttr.setStorable(true); nAttr.setKeyable(true); stat = addAttribute( u ); if (!stat) {stat.perror("addAttribute"); return stat;} steps = nAttr.create("steps", "s", MFnNumericData::kShort, 40); nAttr.setStorable(true); nAttr.setKeyable(true); stat = addAttribute( steps ); if (!stat) {stat.perror("addAttribute"); return stat;} // Outputs percentage = nAttr.create( "percentage", "p", MFnNumericData::kFloat, 0 ); nAttr.setWritable(false); nAttr.setStorable(false); nAttr.setReadable(true); nAttr.setKeyable(false); stat = addAttribute( percentage ); if (!stat) {stat.perror("addAttribute"); return stat;} // Connections stat = attributeAffects ( curve, percentage ); if (!stat) {stat.perror("attributeAffects"); return stat;} stat = attributeAffects ( steps, percentage ); if (!stat) {stat.perror("attributeAffects"); return stat;} stat = attributeAffects ( u, percentage ); if (!stat) {stat.perror("attributeAffects"); return stat;} stat = attributeAffects ( normalizedU, percentage ); if (!stat) {stat.perror("attributeAffects"); return stat;} return MS::kSuccess; }
MStatus LSystemNode::initialize() { MFnUnitAttribute unitAttr; MFnTypedAttribute typedAttr; MFnNumericAttribute numericAttr; MStatus returnStatus; //(i)angle LSystemNode::angle = numericAttr.create("angle","ag",MFnNumericData::kDouble,90.0,&returnStatus); McheckErr(returnStatus, "ERROR creating LSystemNode angle attribute\n"); //(ii)size step = numericAttr.create("step","st",MFnNumericData::kDouble,1.0, &returnStatus); McheckErr(returnStatus, "ERROR creating LSystemNode step attribute\n");//(iv)time //(iii)grammar LSystemNode::grammar = typedAttr.create( "grammar", "grm", MFnData::kString, &returnStatus ); McheckErr(returnStatus, "ERROR creating LSystemNode grammar attribute\n"); //(iv)time LSystemNode::time = unitAttr.create( "time", "tm", MFnUnitAttribute::kTime, 0.0, &returnStatus ); McheckErr(returnStatus, "ERROR creating LSystemNode time attribute\n"); //(v)output LSystemNode::outputMesh = typedAttr.create( "outputMesh", "out", MFnData::kMesh, &returnStatus ); McheckErr(returnStatus, "ERROR creating LSystemNode output attribute\n"); typedAttr.setStorable(false); //(i)angle returnStatus = addAttribute(LSystemNode::angle); McheckErr(returnStatus, "ERROR adding angle attribute\n"); //(ii)step returnStatus = addAttribute(LSystemNode::step); McheckErr(returnStatus, "ERROR adding step attribute\n"); //(iii)grammar returnStatus = addAttribute(LSystemNode::grammar); McheckErr(returnStatus, "ERROR adding grammar attribute\n"); //(iv)time returnStatus = addAttribute(LSystemNode::time); McheckErr(returnStatus, "ERROR adding time attribute\n"); //(v)output returnStatus = addAttribute(LSystemNode::outputMesh); McheckErr(returnStatus, "ERROR adding outputMesh attribute\n"); returnStatus = attributeAffects(LSystemNode::angle,LSystemNode::outputMesh); McheckErr(returnStatus, "ERROR in attributeAffects\n"); returnStatus = attributeAffects(LSystemNode::step,LSystemNode::outputMesh); McheckErr(returnStatus, "ERROR in attributeAffects\n"); returnStatus = attributeAffects(LSystemNode::grammar,LSystemNode::outputMesh); McheckErr(returnStatus, "ERROR in attributeAffects\n"); returnStatus = attributeAffects(LSystemNode::time,LSystemNode::outputMesh); McheckErr(returnStatus, "ERROR in attributeAffects\n"); return MS::kSuccess; }
MStatus DynamicEnum::initialize() { MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnStringData sData; MStatus status; // Status will be used to hold the MStatus value // returned by each api function call. It is important // to check the status returned by a call to aid in // debugging. Failed API calls can result in subtle // errors that can be difficult to track down, you may // wish to use the CHECK_MSTATUS macro for any API // call where you do not need to provide your own // error handling. // // Attribute Initialization: aFilePath = tAttr.create( "filepath", "file", MFnData::kString, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( tAttr.setKeyable( true ) ); CHECK_MSTATUS( tAttr.setStorable( true ) ); CHECK_MSTATUS( tAttr.setDefault( sData.create("") ) ); aGridName = tAttr.create( "grid", "grd", MFnData::kString, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( tAttr.setKeyable( true ) ); CHECK_MSTATUS( tAttr.setStorable( true ) ); CHECK_MSTATUS( tAttr.setDefault( sData.create("") ) ); aOutColor = nAttr.createColor( "outColor", "oc", &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setHidden( false ) ); CHECK_MSTATUS( nAttr.setReadable( true ) ); CHECK_MSTATUS( nAttr.setWritable( false ) ); // Next we will add the attributes we have defined to the node // CHECK_MSTATUS( addAttribute( aFilePath ) ); CHECK_MSTATUS( addAttribute( aGridName ) ); CHECK_MSTATUS( addAttribute( aOutColor ) ); // The attributeAffects() method is used to indicate when the input // attribute affects the output attribute. This knowledge allows Maya // to optimize dependencies in the graph in more complex nodes where // there may be several inputs and outputs, but not all the inputs // affect all the outputs. // CHECK_MSTATUS( attributeAffects( aFilePath, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aGridName, aOutColor ) ); return( MS::kSuccess ); }
MStatus multiCurve::initialize() { MStatus stat; MFnNumericAttribute nAttr; MFnTypedAttribute typedAttr; numCurves = nAttr.create ("numCurves", "nc", MFnNumericData::kLong, 5, &stat); PERRORfail(stat, "initialize create numCurves attribute"); CHECK_MSTATUS ( nAttr.setKeyable( true ) ); stat = addAttribute( numCurves ); PERRORfail(stat, "addAttribute(numCurves)"); curveOffset = nAttr.create ("curveOffset", "co", MFnNumericData::kDouble, 1.0, &stat); PERRORfail(stat, "initialize create curveOffset attribute"); CHECK_MSTATUS ( nAttr.setKeyable( true ) ); stat = addAttribute( curveOffset ); PERRORfail(stat, "addAttribute(curveOffset)"); inputCurve = typedAttr.create( "inputCurve", "ic", MFnNurbsCurveData::kNurbsCurve, &stat ); PERRORfail(stat, "initialize create inputCurve attribute"); CHECK_MSTATUS ( typedAttr.setReadable( false ) ); CHECK_MSTATUS ( typedAttr.setWritable( true ) ); stat = addAttribute( inputCurve ); PERRORfail(stat, "addAttribute(inputCurve)"); outputCurves = typedAttr.create( "outputCurves", "oc", MFnNurbsCurveData::kNurbsCurve, &stat ); PERRORfail(stat, "initialize create outputCurves attribute"); CHECK_MSTATUS ( typedAttr.setArray( true ) ); CHECK_MSTATUS ( typedAttr.setReadable( true ) ); CHECK_MSTATUS ( typedAttr.setWritable( false ) ); CHECK_MSTATUS ( typedAttr.setUsesArrayDataBuilder( true ) ); stat = addAttribute( outputCurves ); PERRORfail(stat, "addAttribute(outputCurves)"); stat = attributeAffects( numCurves, outputCurves ); PERRORfail(stat, "attributeAffects(inputCurve, outputCurves)"); stat = attributeAffects( curveOffset, outputCurves ); PERRORfail(stat, "attributeAffects(inputCurve, outputCurves)"); stat = attributeAffects( inputCurve, outputCurves ); PERRORfail(stat, "attributeAffects(inputCurve, outputCurves)"); return stat; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus DispNode::initialize() { MFnNumericAttribute nAttr; // Inputs aColor = nAttr.createColor( "color", "c" ); CHECK_MSTATUS(nAttr.setKeyable(true)); CHECK_MSTATUS(nAttr.setStorable(true)); CHECK_MSTATUS(nAttr.setDefault(1.0f, 1.0f, 1.0f)); aInputValue = nAttr.create( "factor", "f", MFnNumericData::kFloat); CHECK_MSTATUS(nAttr.setKeyable(true)); CHECK_MSTATUS(nAttr.setStorable(true)); CHECK_MSTATUS(nAttr.setDefault(1.0f)); // Outputs aOutColor = nAttr.createColor( "outColor", "oc" ); CHECK_MSTATUS(nAttr.setStorable(false)); CHECK_MSTATUS(nAttr.setHidden(false)); CHECK_MSTATUS(nAttr.setReadable(true)); CHECK_MSTATUS(nAttr.setWritable(false)); aOutTransparency = nAttr.createColor( "outTransparency", "ot" ); CHECK_MSTATUS(nAttr.setStorable(false)); CHECK_MSTATUS(nAttr.setHidden(false)); CHECK_MSTATUS(nAttr.setReadable(true)); CHECK_MSTATUS(nAttr.setWritable(false)); aOutDisplacement = nAttr.create( "displacement", "od", MFnNumericData::kFloat); CHECK_MSTATUS(nAttr.setStorable(false)); CHECK_MSTATUS(nAttr.setHidden(false)); CHECK_MSTATUS(nAttr.setReadable(true)); CHECK_MSTATUS(nAttr.setWritable(false)); CHECK_MSTATUS(addAttribute(aColor)); CHECK_MSTATUS(addAttribute(aInputValue)); CHECK_MSTATUS(addAttribute(aOutColor)); CHECK_MSTATUS(addAttribute(aOutTransparency)); CHECK_MSTATUS(addAttribute(aOutDisplacement)); CHECK_MSTATUS(attributeAffects (aColor, aOutColor)); CHECK_MSTATUS(attributeAffects (aColor, aOutDisplacement)); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus depthShader::initialize() { MFnNumericAttribute nAttr; // Create input attributes aColorNear = nAttr.createColor("color", "c"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setDefault(0., 1., 0.)); // Green aColorFar = nAttr.createColor("colorFar", "cf"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setDefault(0., 0., 1.)); // Blue aNear = nAttr.create("near", "n", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f)); CHECK_MSTATUS(nAttr.setSoftMax(1000.0f)); aFar = nAttr.create("far", "f", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f)); CHECK_MSTATUS(nAttr.setSoftMax(1000.0f)); CHECK_MSTATUS(nAttr.setDefault(2.0f)); aPointCamera = nAttr.createPoint("pointCamera", "p"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setHidden(true)); // Create output attributes aOutColor = nAttr.createColor("outColor", "oc"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute(aColorNear)); CHECK_MSTATUS(addAttribute(aColorFar)); CHECK_MSTATUS(addAttribute(aNear) ); CHECK_MSTATUS(addAttribute(aFar)); CHECK_MSTATUS(addAttribute(aPointCamera)); CHECK_MSTATUS(addAttribute(aOutColor)); CHECK_MSTATUS(attributeAffects(aColorNear, aOutColor)); CHECK_MSTATUS(attributeAffects(aColorFar, aOutColor)); CHECK_MSTATUS(attributeAffects(aNear, aOutColor)); CHECK_MSTATUS(attributeAffects(aFar, aOutColor)); CHECK_MSTATUS(attributeAffects(aPointCamera, aOutColor)); return MS::kSuccess; }
MStatus nailConstraintNode::initialize() { MStatus status; MFnMessageAttribute fnMsgAttr; MFnNumericAttribute fnNumericAttr; MFnMatrixAttribute fnMatrixAttr; ia_rigidBody = fnMsgAttr.create("inRigidBody", "inrb", &status); MCHECKSTATUS(status, "creating inRigidBody attribute") status = addAttribute(ia_rigidBody); MCHECKSTATUS(status, "adding inRigidBody attribute") ia_damping = fnNumericAttr.create("damping", "dmp", MFnNumericData::kDouble, 1.0, &status); MCHECKSTATUS(status, "creating damping attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_damping); MCHECKSTATUS(status, "adding damping attribute") ca_constraint = fnNumericAttr.create("ca_constraint", "caco", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_constraint attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_constraint); MCHECKSTATUS(status, "adding ca_constraint attribute") ca_constraintParam = fnNumericAttr.create("ca_constraintParam", "cacop", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_constraintParam attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_constraintParam); MCHECKSTATUS(status, "adding ca_constraintParam attribute") status = attributeAffects(ia_rigidBody, ca_constraint); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBody, ca_constraint)") status = attributeAffects(ia_rigidBody, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBody, ca_constraintParam)") status = attributeAffects(ia_damping, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_damping, ca_constraintParam)") return MS::kSuccess; }
MStatus fullLoft::initialize() { MStatus stat; MFnTypedAttribute typedAttr; inputCurve=typedAttr.create( "inputCurve", "in", MFnNurbsCurveData::kNurbsCurve, &stat ); PERRORfail("initialize create input attribute"); stat = typedAttr.setArray( true ); PERRORfail("initialize set input attribute array"); outputSurface=typedAttr.create( "outputSurface", "out", MFnNurbsSurfaceData::kNurbsSurface, &stat ); PERRORfail("initialize create output attribute"); stat = typedAttr.setStorable( false ); PERRORfail("initialize set output attribute storable"); stat = addAttribute( inputCurve ); PERRORfail("addAttribute(inputCurve)"); stat = addAttribute( outputSurface ); PERRORfail("addAttribute(outputSurface)"); stat = attributeAffects( inputCurve, outputSurface ); PERRORfail("attributeAffects(inputCurve, outputSurface)"); return MS::kSuccess; }
MStatus animCube::initialize() { MFnUnitAttribute unitAttr; MFnTypedAttribute typedAttr; MStatus returnStatus; animCube::time = unitAttr.create( "time", "tm", MFnUnitAttribute::kTime, 0.0, &returnStatus ); McheckErr(returnStatus, "ERROR creating animCube time attribute\n"); animCube::outputMesh = typedAttr.create( "outputMesh", "out", MFnData::kMesh, &returnStatus ); McheckErr(returnStatus, "ERROR creating animCube output attribute\n"); typedAttr.setStorable(false); returnStatus = addAttribute(animCube::time); McheckErr(returnStatus, "ERROR adding time attribute\n"); returnStatus = addAttribute(animCube::outputMesh); McheckErr(returnStatus, "ERROR adding outputMesh attribute\n"); returnStatus = attributeAffects(animCube::time, animCube::outputMesh); McheckErr(returnStatus, "ERROR in attributeAffects\n"); return MS::kSuccess; }
MStatus connectingNode::initialize() { MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; MStatus returnStatus; connectingNode::state=0; connectingNode::tmp=nAttr.create("tmp","t",MFnNumericData::kInt,0,&returnStatus); connectingNode::tmp1=nAttr.create("tmp1","t1",MFnNumericData::kInt,0,&returnStatus); connectingNode::index1=nAttr.create("index1","in1",MFnNumericData::kInt,-1,&returnStatus); connectingNode::index2=nAttr.create("index2","in2",MFnNumericData::kInt,-1,&returnStatus); connectingNode::trigger=nAttr.create("trigger","tri",MFnNumericData::kBoolean,true,&returnStatus); connectingNode::rootNumber=nAttr.create("rootNum","rN",MFnNumericData::kInt,0,&returnStatus); addAttribute(tmp); addAttribute(tmp1); addAttribute(index1); addAttribute(index2); addAttribute(trigger); addAttribute(rootNumber); attributeAffects(tmp1,tmp); return MS::kSuccess; }
MStatus MocapMesh::initialize() { MStatus stat; MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; in_inMesh = tAttr.create("inMesh", "im",MFnData::kMesh); tAttr.setKeyable(true); tAttr.setStorable(true); tAttr.setReadable(true); tAttr.setWritable(true); stat = addAttribute(in_inMesh); if(!stat) { stat.perror("adding inMesh"); return stat; } out_message = nAttr.create("test", "test", MFnNumericData::kDouble, 0.0); nAttr.setKeyable(false); nAttr.setStorable(false); nAttr.setWritable(false); nAttr.setReadable(true); stat = addAttribute(out_message); if(!stat) { stat.perror("adding test"); return stat; } stat = attributeAffects(in_inMesh,out_message); if(!stat) { stat.perror("attributeAffects"); return stat; } return MS::kSuccess; }
MStatus blindDataMesh::initialize() { MFnTypedAttribute typedAttr; MStatus returnStatus; blindDataMesh::outputMesh = typedAttr.create( "outputMesh", "out", MFnData::kMesh, &returnStatus ); McheckErr(returnStatus, "ERROR creating blindDataMesh output attribute\n"); typedAttr.setStorable(false); returnStatus = addAttribute(blindDataMesh::outputMesh); McheckErr(returnStatus, "ERROR adding outputMesh attribute\n"); MFnNumericAttribute numAttr; blindDataMesh::seed = numAttr.create( "randomSeed", "seed", MFnNumericData::kLong, 0, &returnStatus ); McheckErr(returnStatus, "ERROR creating blindDataMesh input attribute\n"); returnStatus = addAttribute(blindDataMesh::seed); McheckErr(returnStatus, "ERROR adding input attribute\n"); returnStatus = attributeAffects(blindDataMesh::seed, blindDataMesh::outputMesh); McheckErr(returnStatus, "ERROR in attributeAffects\n"); return MS::kSuccess; }