//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")); };
void MFnCompoundAttrAddEnum( MFnCompoundAttribute &attr, const char* full, const char* brief, const char** pEnumStrings, unsigned short count, unsigned short def ) { MStatus status; MFnEnumAttribute enumAttr; MObject enumObj = enumAttr.create( full, brief, def, &status ); for(short index = 0; index < count; ++index) enumAttr.addField( pEnumStrings[index], index ); attr.addChild( enumObj ); }
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 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 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 liqCoordSysNode::initialize() { MFnEnumAttribute eAttr; MFnNumericAttribute numAttr; MStatus status; aCoordType = eAttr.create( "type", "t", 0, &status ); eAttr.addField( "Card", 0 ); eAttr.addField( "Sphere", 1 ); eAttr.addField( "Cylinder", 2 ); eAttr.addField( "Cube", 3 ); eAttr.addField( "Deep Card", 4 ); eAttr.addField( "Clipping Plane", 5 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(eAttr.setConnectable(false)); CHECK_MSTATUS( addAttribute( aCoordType ) ); aCoordColor = numAttr.createColor( "coordColor", "cc", &status ); MAKE_INPUT(numAttr); CHECK_MSTATUS( numAttr.setMin( 0.0, 0.0, 0.0 ) ); CHECK_MSTATUS( numAttr.setMax( 1.0, 1.0, 1.0 ) ); CHECK_MSTATUS( numAttr.setDefault( 0.0, 0.0, 0.5) ); CHECK_MSTATUS( addAttribute( aCoordColor ) ); aCoordOpacity = numAttr.create( "coordOpacity", "co", MFnNumericData::kFloat, 0.0, &status ); MAKE_INPUT(numAttr); CHECK_MSTATUS( numAttr.setMin( 0.0 ) ); CHECK_MSTATUS( numAttr.setMax( 1.0 ) ); CHECK_MSTATUS( addAttribute( aCoordOpacity ) ); return MS::kSuccess; }
//----------------------------------------------------------------------------- // Purpose: Initialize the node, add static attributes, etc... // Output : MStatus::kSuccess if everything was ok //----------------------------------------------------------------------------- MStatus CVstExampleLocator::Initialize() { // Add a little enum attribute to control how it's drawn MFnEnumAttribute eFn; s_iaDisplayStyle = eFn.create( "displayStyle", "ds", 0 ); eFn.setKeyable ( true ); eFn.addField( "maya", 0 ); eFn.addField( "shaded", 1 ); eFn.addField( "wireframe", 2 ); eFn.addField( "points", 3 ); addAttribute(s_iaDisplayStyle); return MS::kSuccess; }
MStatus mpBox::initialize() { MFnNumericAttribute nAttr; MFnEnumAttribute enumAttr; // add the custom attributes for mpBox // _COMMON_ATTR_INIT_; aXsize = nAttr.create( "xsize", "xsz", MFnNumericData::kFloat); nAttr.setDefault(0.5f); nAttr.setKeyable(1); nAttr.setReadable(1); nAttr.setWritable(1); nAttr.setStorable(1); aYsize = nAttr.create( "ysize", "ysz", MFnNumericData::kFloat); nAttr.setDefault(0.5f); nAttr.setKeyable(1); nAttr.setReadable(1); nAttr.setWritable(1); nAttr.setStorable(1); aZsize = nAttr.create( "zsize", "zsz", MFnNumericData::kFloat); nAttr.setDefault(0.5f); nAttr.setKeyable(1); nAttr.setReadable(1); nAttr.setWritable(1); nAttr.setStorable(1); aDrawType = enumAttr.create( "drawType" , "dt"); enumAttr.addField("wireframe", 0); enumAttr.addField("shaded", 1); enumAttr.addField("normal", 2); enumAttr.setHidden(false); enumAttr.setKeyable(true); enumAttr.setDefault(2); addAttribute(aXsize); addAttribute(aYsize); addAttribute(aZsize); addAttribute(aDrawType); return MS::kSuccess; }
//initialize //----------------------------------------------- MStatus TesselationVisualization::initialize() { //Attr functionsets MFnEnumAttribute eAttr; MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; //aVerbose aVerbose = eAttr.create("verbose", "verbose", 0); eAttr.addField("noVerbose", 0); eAttr.addField("Verbose", 1); addAttribute(aVerbose); //aTesselationType aTesselationType = eAttr.create("tesselationType", "tesselationType", 0); eAttr.addField("Structural", 0); eAttr.addField("Shear", 1); addAttribute(aTesselationType); //aInputGeo aInputGeo = tAttr.create("inputGeo", "inputGeo", MFnData::kMesh); tAttr.setReadable(false); addAttribute(aInputGeo); //aOutputGeo aOutputGeo = tAttr.create("outputGeo", "outputGeo", MFnData::kMesh); tAttr.setWritable(false); tAttr.setStorable(false); addAttribute(aOutputGeo); //aCurrentFrame aCurrentFrame = nAttr.create("currentFrame", "currentFrame", MFnNumericData::kFloat); addAttribute(aCurrentFrame); //AttributeAffects attributeAffects(aTesselationType, aOutputGeo); attributeAffects(aInputGeo, aOutputGeo); attributeAffects(aCurrentFrame, aOutputGeo); return MStatus::kSuccess; };
// // DESCRIPTION: MStatus fresnel::initialize() { MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus status; outColor = nAttr.createColor("outColor", "outColor"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( outColor )); //---------------------------- automatically created attributes start ------------------------------------ filename = tAttr.create("filename", "filename", MFnNumericData::kString); CHECK_MSTATUS(addAttribute( filename )); name = eAttr.create("name", "name", 0, &status); status = eAttr.addField( "aluminium", 0 ); status = eAttr.addField( "amorphous carbon", 1 ); status = eAttr.addField( "silver", 2 ); status = eAttr.addField( "gold", 3 ); status = eAttr.addField( "copper", 4 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( name )); luxOutFresnel = nAttr.create("luxOutFresnel", "luxOutFresnel", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( luxOutFresnel )); CHECK_MSTATUS ( attributeAffects( filename, luxOutFresnel)); CHECK_MSTATUS ( attributeAffects( filename, outColor)); //---------------------------- automatically created attributes end ------------------------------------ return MS::kSuccess; }
MStatus LSSolverNode::initialize() { MFnNumericAttribute nAttr; MFnUnitAttribute uAttr; MFnTypedAttribute tAttr; MFnEnumAttribute eAttr; MFnMatrixAttribute mAttr; tetWorldMatrix = mAttr.create("tet_world_matrix","twm",MFnMatrixAttribute::kDouble,&returnStatus); McheckErr(returnStatus, "ERROR creating LSTetgenNode worldMatrix attribute\n"); MAKE_INPUT(mAttr); mAttr.setHidden(true); restShape = tAttr.create("restShape", "rs", MFnMeshData::kMesh, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode restShape attribute\n"); MAKE_INPUT(tAttr); restElements = tAttr.create("restElements", "re", MFnData::kIntArray, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode restShape attribute\n"); MAKE_INPUT(tAttr); restVertices = tAttr.create("restVertices", "rv", MFnData::kDoubleArray, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode restShape attribute\n"); MAKE_INPUT(tAttr); selectedConstraintVerts = tAttr.create("selectedConstraintVerts", "scv", MFnData::kIntArray, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode selectedConstraintVerts attribute\n"); MAKE_INPUT(tAttr); selectedForceVerts = tAttr.create("selectedForceVerts", "sfv", MFnData::kIntArray, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode selectedForceVerts attribute\n"); MAKE_INPUT(tAttr); time = uAttr.create("time", "t", MFnUnitAttribute::kTime,0.0, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode time attribute\n"); MAKE_INPUT(uAttr); deformed = tAttr.create("deformed", "d", MFnMeshData::kMesh, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode deformed attribute\n"); MAKE_OUTPUT(tAttr); poissonRatio = nAttr.create("poissonRatio", "pr", MFnNumericData::kDouble, 0.45, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode poisson ratio\n"); MAKE_INPUT(nAttr); nAttr.setMax(0.45); nAttr.setMin(0); youngsModulus = nAttr.create("youngsModulus", "ym", MFnNumericData::kDouble, 90000000000, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode youngsModulus\n"); MAKE_INPUT(nAttr); //nAttr.setMax(50000); //nAttr.setMin(1); objectDensity = nAttr.create("density", "objd", MFnNumericData::kDouble, 1000, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode objectDensity\n"); MAKE_INPUT(nAttr); nAttr.setMax(10000); nAttr.setMin(1); friction = nAttr.create("friction", "f", MFnNumericData::kDouble, 0.98, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode friction\n"); MAKE_INPUT(nAttr); nAttr.setMax(1); nAttr.setMin(0); restitution = nAttr.create("restitution", "r", MFnNumericData::kDouble, 0.4, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode restitution\n"); MAKE_INPUT(nAttr); nAttr.setMax(1); nAttr.setMin(0); damping = nAttr.create("damping", "dmp", MFnNumericData::kDouble, 0.0, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode damping\n"); MAKE_INPUT(nAttr); nAttr.setMax(1); nAttr.setMin(0); userSuppliedDt = nAttr.create("timeStep","ts",MFnNumericData::kDouble,0.01, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode userSuppliedDt\n"); MAKE_INPUT(nAttr); nAttr.setMax(1); nAttr.setMin(0.00001); forceApplicationTime = nAttr.create("forceApplicationTime", "fat", MFnNumericData::kInt, 50, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceApplicationTime ratio\n"); MAKE_INPUT(nAttr); forceReleasedTime = nAttr.create("forceReleasedTime", "frt", MFnNumericData::kInt, 100, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceReleasedTime ratio\n"); MAKE_INPUT(nAttr); forceIncrementTime = nAttr.create("forceIncrementTime", "fit", MFnNumericData::kInt, 10, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceIncrementTime ratio\n"); MAKE_INPUT(nAttr); forceStartTime = nAttr.create("forceStartTime", "fst", MFnNumericData::kInt,100, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceStartTime\n"); MAKE_INPUT(nAttr); forceStopTime = nAttr.create("forceStopTime", "fet", MFnNumericData::kInt, 200, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceStopTime\n"); MAKE_INPUT(nAttr); forceMagnitude = nAttr.create("forceMagnitude", "fm", MFnNumericData::kDouble, 10.0, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceIdleTime ratio\n"); MAKE_INPUT(nAttr); forceDirection = nAttr.create("forceDirection", "fd", MFnNumericData::k3Double, 0.0 , &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceIdleTime ratio\n"); MAKE_INPUT(nAttr); useSuppliedConstraints = nAttr.create("useSuppliedConstraints", "usc", MFnNumericData::kBoolean,1, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode useSuppliedConstraints ratio\n"); MAKE_INPUT(nAttr); useSuppliedForce = nAttr.create("useSuppliedForce", "usf", MFnNumericData::kBoolean, 0, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode useSuppliedForces ratio\n"); MAKE_INPUT(nAttr); integrationType = eAttr.create("timeIntegrationMethod","it",0,&returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode integrationType\n"); eAttr.addField("Implicit Backward Euler",0); eAttr.addField("Implicit Newmark",1); eAttr.addField("Central Differences",2); eAttr.addField("Symplectic Euler",3); MAKE_INPUT(eAttr); forceModelType = eAttr.create("system","ft",0,&returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode forceModelType\n"); eAttr.addField("Corotational Linear FEM",0); eAttr.addField("Mass Spring System",1); MAKE_INPUT(eAttr); contactKs = nAttr.create("contactSpringForce", "cKs", MFnNumericData::kDouble, 1000.0, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode contactSpringForces\n"); MAKE_INPUT(nAttr); contactKd = nAttr.create("contactDampForce", "cKd", MFnNumericData::kDouble, 50.0, &returnStatus); McheckErr(returnStatus, "ERROR creating LSSolverNode contactDampForces\n"); MAKE_INPUT(nAttr); returnStatus = addAttribute(tetWorldMatrix); McheckErr(returnStatus, "ERROR adding LSSolverNode world matrix attribute\n"); returnStatus = addAttribute(restShape); McheckErr(returnStatus, "ERROR adding LSSolverNode step attribute\n"); returnStatus = addAttribute(restElements); McheckErr(returnStatus, "ERROR adding LSSolverNode restElements attribute\n"); returnStatus = addAttribute(restVertices); McheckErr(returnStatus, "ERROR adding LSSolverNode restVertices attribute\n"); returnStatus = addAttribute(selectedConstraintVerts); McheckErr(returnStatus, "ERROR adding LSSolverNode selectedConstraintVerts attribute\n"); returnStatus = addAttribute(selectedForceVerts); McheckErr(returnStatus, "ERROR adding LSSolverNode selectedForceVerts attribute\n"); returnStatus = addAttribute(time); McheckErr(returnStatus, "ERROR adding LSSolverNode time attribute\n"); returnStatus = addAttribute(deformed); McheckErr(returnStatus, "ERROR adding LSSolverNode deformed attribute\n"); returnStatus = addAttribute(youngsModulus); McheckErr(returnStatus, "ERROR adding LSSolverNode youngsModulus\n"); returnStatus = addAttribute(poissonRatio); McheckErr(returnStatus, "ERROR adding LSSolverNode poissonRation\n"); returnStatus = addAttribute(objectDensity); McheckErr(returnStatus, "ERROR adding LSSolverNode objectDensity\n"); returnStatus = addAttribute(friction); McheckErr(returnStatus, "ERROR adding LSSolverNode friction\n"); returnStatus = addAttribute(restitution); McheckErr(returnStatus, "ERROR adding LSSolverNode resitution\n"); returnStatus = addAttribute(damping); McheckErr(returnStatus, "ERROR adding LSSolverNode damping\n"); returnStatus = addAttribute(userSuppliedDt); McheckErr(returnStatus, "ERROR adding LSSolverNode userSuppliedDt\n"); returnStatus = addAttribute(useSuppliedConstraints); McheckErr(returnStatus, "ERROR adding LSSolverNode useSuppliedConstraints\n"); returnStatus = addAttribute(useSuppliedForce); McheckErr(returnStatus, "ERROR adding LSSolverNode useSuppliedForce\n"); returnStatus = addAttribute(forceMagnitude); McheckErr(returnStatus, "ERROR adding LSSolverNode forceMagnitude\n"); returnStatus = addAttribute(forceDirection); McheckErr(returnStatus, "ERROR adding LSSolverNode forceDirection\n"); returnStatus = addAttribute(forceApplicationTime); McheckErr(returnStatus, "ERROR adding LSSolverNode forceApplicationTime\n"); returnStatus = addAttribute(forceReleasedTime); McheckErr(returnStatus, "ERROR adding LSSolverNode forceReleasedTime\n"); returnStatus = addAttribute(forceIncrementTime); McheckErr(returnStatus, "ERROR adding LSSolverNode forceIncrementTime\n"); returnStatus = addAttribute(forceStartTime); McheckErr(returnStatus, "ERROR adding LSSolverNode forceIdleTime\n"); returnStatus = addAttribute(forceStopTime); McheckErr(returnStatus, "ERROR adding LSSolverNode forceIdleTime\n"); // returnStatus = addAttribute(inputFilePath); // McheckErr(returnStatus, "ERROR adding LSSolverNode inputFilePath\n"); returnStatus = addAttribute(integrationType); McheckErr(returnStatus, "ERROR adding LSSolverNode integrationType\n"); returnStatus = addAttribute(forceModelType); McheckErr(returnStatus, "ERROR adding LSSolverNode forceModelType\n"); returnStatus = addAttribute(contactKd); McheckErr(returnStatus, "ERROR adding LSSolverNode contactKd\n"); returnStatus = addAttribute(contactKs); McheckErr(returnStatus, "ERROR adding LSSolverNode contactKs\n"); returnStatus = attributeAffects(restShape, deformed); McheckErr(returnStatus, "ERROR in attributeAffects: restShape - deformed\n"); returnStatus = attributeAffects(time, deformed); McheckErr(returnStatus, "ERROR in attributeAffects: time - deformed\n"); return MS::kSuccess; }
// Create and Add Attributes // // 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 MayaPolySmooth::initialize() { MStatus stat; MFnCompoundAttribute cAttr; MFnEnumAttribute eAttr; MFnGenericAttribute gAttr; MFnLightDataAttribute lAttr; MFnMatrixAttribute mAttr; MFnMessageAttribute msgAttr; MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnUnitAttribute uAttr; // MAYA_NODE_BUILDER:BEG [ATTRIBUTE CREATION] ========== // a_inputPolymesh : This is a description for this attribute a_inputPolymesh = tAttr.create("inputPolymesh", "ip", MFnData::kMesh, MObject::kNullObj, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::inputPolymesh" ); stat = tAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::inputPolymesh.setReadable()" ); stat = tAttr.setWritable(true); MCHECKERR( stat, "cannot MayaPolySmooth::inputPolymesh.setWritable()" ); stat = tAttr.setHidden(true); MCHECKERR( stat, "cannot MayaPolySmooth::inputPolymesh.setHidden()" ); stat = addAttribute( a_inputPolymesh ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_inputPolymesh)" ); // a_output : This is a description for this attribute a_output = tAttr.create("output", "out", MFnData::kMesh, MObject::kNullObj, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::output" ); stat = tAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::output.setReadable()" ); stat = tAttr.setWritable(false); MCHECKERR( stat, "cannot MayaPolySmooth::output.setWritable()" ); stat = tAttr.setHidden(true); MCHECKERR( stat, "cannot MayaPolySmooth::output.setHidden()" ); stat = addAttribute( a_output ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_output)" ); // a_subdivisionLevels : The number of recursive quad subdivisions to perform on each face. a_subdivisionLevels = nAttr.create("subdivisionLevels", "sl", MFnNumericData::kInt, 0.0, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::subdivisionLevels" ); stat = nAttr.setDefault(2); MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setDefault(2)" ); stat = nAttr.setMin(0); MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setMin(0)" ); stat = nAttr.setMax(10); MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setMax(10)" ); stat = nAttr.setSoftMax(4); MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setSoftMax(4)" ); stat = nAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setReadable()" ); stat = nAttr.setWritable(true); MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setWritable()" ); stat = addAttribute( a_subdivisionLevels ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_subdivisionLevels)" ); // a_recommendedIsolation : The number of recursive quad subdivisions to perform on each face. a_recommendedIsolation = nAttr.create("recommendedIsolation", "ri", MFnNumericData::kInt, 0.0, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::recommendedIsolation" ); stat = nAttr.setDefault(2); MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setDefault(0)" ); stat = nAttr.setMin(0); MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setMin(0)" ); stat = nAttr.setMax(10); MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setSoftMax(10)" ); stat = nAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setReadable()" ); stat = nAttr.setWritable(false); MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setWritable()" ); stat = nAttr.setHidden(false); MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setHidden()" ); stat = addAttribute( a_recommendedIsolation ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_recommendedIsolation)" ); // a_vertBoundaryMethod : Controls how boundary edges and vertices are interpolated. <ul> <li>Smooth, Edges: Renderman: InterpolateBoundaryEdgeOnly</li> <li>Smooth, Edges and Corners: Renderman: InterpolateBoundaryEdgeAndCorner</li> </ul> a_vertBoundaryMethod = eAttr.create("vertBoundaryMethod", "vbm", 0, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::vertBoundaryMethod" ); stat = eAttr.addField("Interpolate Edges", k_BoundaryMethod_InterpolateBoundaryEdgeOnly); MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.addField(Interpolate Edges, k_BoundaryMethod_InterpolateBoundaryEdgeOnly)" ); stat = eAttr.addField("Interpolate Edges And Corners", k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner); MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.addField(Interpolate Edges And Corners, k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner)" ); stat = eAttr.setDefault(k_BoundaryMethod_InterpolateBoundaryEdgeOnly); MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.setDefault(k_BoundaryMethod_InterpolateBoundaryEdgeOnly)" ); stat = eAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.setReadable()" ); stat = eAttr.setWritable(true); MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.setWritable()" ); stat = addAttribute( a_vertBoundaryMethod ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_vertBoundaryMethod)" ); // a_fvarBoundaryMethod : Controls how boundaries are treated for face-varying data (UVs and Vertex Colors). <ul> <li>Bi-linear (None): Renderman: InterpolateBoundaryNone</li> <li>Smooth, (Edge Only): Renderman: InterpolateBoundaryEdgeOnly</li> <li>Smooth, (Edges and Corners: Renderman: InterpolateBoundaryEdgeAndCorner</li> <li>Smooth, (ZBrush and Maya "Smooth Internal Only"): Renderman: InterpolateBoundaryAlwaysSharp</li> </ul> a_fvarBoundaryMethod = eAttr.create("fvarBoundaryMethod", "fvbm", 0, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::fvarBoundaryMethod" ); stat = eAttr.addField("Bi-linear (None)", k_BoundaryMethod_InterpolateBoundaryNone); MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Bi-linear (None), k_BoundaryMethod_InterpolateBoundaryNone)" ); stat = eAttr.addField("Smooth (Edge Only)", k_BoundaryMethod_InterpolateBoundaryEdgeOnly); MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Smooth (Edge Only), k_BoundaryMethod_InterpolateBoundaryEdgeOnly)" ); stat = eAttr.addField("Smooth (Edge and Corner)", k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner); MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Smooth (Edge and Corner), k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner)" ); stat = eAttr.addField("Smooth (Always Sharp)", k_BoundaryMethod_InterpolateBoundaryAlwaysSharp); MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Smooth (Always Sharp), k_BoundaryMethod_InterpolateBoundaryAlwaysSharp)" ); stat = eAttr.setDefault(k_BoundaryMethod_InterpolateBoundaryNone); MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.setDefault(k_BoundaryMethod_InterpolateBoundaryNone)" ); stat = eAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.setReadable()" ); stat = eAttr.setWritable(true); MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.setWritable()" ); stat = addAttribute( a_fvarBoundaryMethod ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_fvarBoundaryMethod)" ); // a_fvarPropagateCorners : a_fvarPropagateCorners = nAttr.create("fvarPropagateCorners", "fvpc", MFnNumericData::kBoolean, 0.0, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::fvarPropagateCorners" ); stat = nAttr.setDefault(false); MCHECKERR( stat, "cannot MayaPolySmooth::fvarPropagateCorners.setDefault(false)" ); stat = nAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::fvarPropagateCorners.setReadable()" ); stat = nAttr.setWritable(true); MCHECKERR( stat, "cannot MayaPolySmooth::fvarPropagateCorners.setWritable()" ); stat = addAttribute( a_fvarPropagateCorners ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_fvarPropagateCorners)" ); // a_smoothTriangles : Apply a special subdivision rule be applied to all triangular faces that was empirically determined to make triangles subdivide more smoothly. a_smoothTriangles = nAttr.create("smoothTriangles", "stri", MFnNumericData::kBoolean, 0.0, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::smoothTriangles" ); stat = nAttr.setDefault(true); MCHECKERR( stat, "cannot MayaPolySmooth::smoothTriangles.setDefault(true)" ); stat = nAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::smoothTriangles.setReadable()" ); stat = nAttr.setWritable(true); MCHECKERR( stat, "cannot MayaPolySmooth::smoothTriangles.setWritable()" ); stat = addAttribute( a_smoothTriangles ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_smoothTriangles)" ); // a_creaseMethod : Controls how boundary edges and vertices are interpolated. <ul> <li>Normal</li> <li>Chaikin: Improves the appearance of multiedge creases with varying weight</li> </ul> a_creaseMethod = eAttr.create("creaseMethod", "crm", 0, &stat); MCHECKERR( stat, "cannot create MayaPolySmooth::creaseMethod" ); stat = eAttr.addField("Normal", k_creaseMethod_normal); MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.addField(Normal, k_creaseMethod_normal)" ); stat = eAttr.addField("Chaikin", k_creaseMethod_chaikin); MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.addField(Chaikin, k_creaseMethod_chaikin)" ); stat = eAttr.setDefault(0); MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.setDefault(0)" ); stat = eAttr.setReadable(true); MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.setReadable()" ); stat = eAttr.setWritable(true); MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.setWritable()" ); stat = addAttribute( a_creaseMethod ); MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_creaseMethod)" ); // MAYA_NODE_BUILDER:END [ATTRIBUTE CREATION] ========== // 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. // // MAYA_NODE_BUILDER:BEG [ATTRIBUTE DEPENDS] ========== stat = attributeAffects( a_creaseMethod, a_output ); MCHECKERR( stat, "cannot have attribute creaseMethod affect output" ); stat = attributeAffects( a_inputPolymesh, a_output ); MCHECKERR( stat, "cannot have attribute inputPolymesh affect output" ); stat = attributeAffects( a_subdivisionLevels, a_output ); MCHECKERR( stat, "cannot have attribute subdivisionLevels affect output" ); stat = attributeAffects( a_smoothTriangles, a_output ); MCHECKERR( stat, "cannot have attribute smoothTriangles affect output" ); stat = attributeAffects( a_fvarPropagateCorners, a_output ); MCHECKERR( stat, "cannot have attribute fvarPropagateCorners affect output" ); stat = attributeAffects( a_vertBoundaryMethod, a_output ); MCHECKERR( stat, "cannot have attribute vertBoundaryMethod affect output" ); stat = attributeAffects( a_fvarBoundaryMethod, a_output ); MCHECKERR( stat, "cannot have attribute fvarBoundaryMethod affect output" ); stat = attributeAffects( a_creaseMethod, a_recommendedIsolation ); MCHECKERR( stat, "cannot have attribute creaseMethod affect .si output" ); stat = attributeAffects( a_inputPolymesh, a_recommendedIsolation ); MCHECKERR( stat, "cannot have attribute inputPolymesh affect .si output" ); stat = attributeAffects( a_subdivisionLevels, a_recommendedIsolation ); MCHECKERR( stat, "cannot have attribute subdivisionLevels affect .si output" ); stat = attributeAffects( a_smoothTriangles, a_recommendedIsolation ); MCHECKERR( stat, "cannot have attribute smoothTriangles affect .si output" ); stat = attributeAffects( a_fvarPropagateCorners, a_recommendedIsolation ); MCHECKERR( stat, "cannot have attribute fvarPropagateCorners affect .si output" ); stat = attributeAffects( a_vertBoundaryMethod, a_recommendedIsolation ); MCHECKERR( stat, "cannot have attribute vertBoundaryMethod affect .si output" ); stat = attributeAffects( a_fvarBoundaryMethod, a_recommendedIsolation ); MCHECKERR( stat, "cannot have attribute fvarBoundaryMethod affect .si output" ); // MAYA_NODE_BUILDER:END [ATTRIBUTE DEPENDS] ========== return MS::kSuccess; }
//---------------------------------------------------------------------------------------------------------------------- // this method creates the attributes for our node and sets some default values etc //---------------------------------------------------------------------------------------------------------------------- MStatus OceanNode::initialize(){ // Attributes to check whether the amplitude or wind vector have changed m_wdx = 0.0; m_wdz = 1.0; m_ws = 100.0; m_amp = 100.0; m_res = 0; MStatus status; // an emum attribute for use with the resolution MFnEnumAttribute enumAttr; // resolution m_resolution = enumAttr.create("resolution", "res", 0, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"resolution\" attribute"); enumAttr.addField("128x128", RES128); enumAttr.addField("256x256", RES256); enumAttr.addField("512x512", RES512); enumAttr.addField("1024x1024", RES1024); enumAttr.setKeyable(true); status = addAttribute(m_resolution); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"resolution\" attribute to OceanNode"); // now we are going to add several number attributes MFnNumericAttribute numAttr; // amplitde m_amplitude = numAttr.create( "amplitude", "amp", MFnNumericData::kDouble, 100.0, &status ); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status , "Unable to create \"amplitude\" attribute" ); numAttr.setChannelBox( true ); // add attribute status = addAttribute( m_amplitude ); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status , "Unable to add \"amplitude\" attribute to OceanNode" ); // frequency m_frequency = numAttr.create("frequency", "frq", MFnNumericData::kDouble, 0.5, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"frequency\" attribute"); numAttr.setChannelBox(true); status = addAttribute(m_frequency); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"frequency\" attribute to OceanNodee"); // the wind speed inputs MFnNumericAttribute windDirectionAttr; m_windDirectionX = windDirectionAttr.create( "windDirectionX", "wdx", MFnNumericData::kDouble, 0.0, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status, "Unable to create \"wdx\" attribute"); windDirectionAttr.setChannelBox(true); windDirectionAttr.setMin(0.0); windDirectionAttr.setMax(1.0); // add attribute status = addAttribute( m_windDirectionX ); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"wdx\" attribute to OceanNode") m_windDirectionZ = windDirectionAttr.create( "windDirectionZ", "wdz", MFnNumericData::kDouble, 0.5, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status, "Unable to create \"wdy\" attribute"); windDirectionAttr.setChannelBox(true); windDirectionAttr.setMin(0.0); windDirectionAttr.setMax(1.0); // add attribute status = addAttribute( m_windDirectionZ ); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"wdz\" attribute to OceanNode"); m_windSpeed = numAttr.create( "windSpeed", "ws", MFnNumericData::kDouble, 100.0, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status, "Unable to create \"ws\" attribute"); numAttr.setChannelBox(true); // add attribute status = addAttribute( m_windSpeed ); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"ws\" attribute to OceanNode"); MFnNumericAttribute chopAttr; m_choppiness = chopAttr.create("chopiness", "chp", MFnNumericData::kDouble, 0.0, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"chopiness\" attribute"); chopAttr.setChannelBox(true); chopAttr.setMax(2.0); chopAttr.setMin(0.0); // add attribute status = addAttribute(m_choppiness); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"choppiness\" attribute to OceanNode"); // now the time inputs MFnNumericAttribute timeAttr; m_time = timeAttr.create("time", "t", MFnNumericData::kDouble, 0.0, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"t\" attribute"); // Add the attribute status = addAttribute(m_time); timeAttr.setHidden(true); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"t\" attribute to OceanNode"); // create the output attribute MFnTypedAttribute typeAttr; m_output = typeAttr.create("output", "out", MFnData::kMesh, &status); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"output\" attribute"); typeAttr.setStorable(false); typeAttr.setHidden(true); status = addAttribute(m_output); CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"output\" attribute to OceanNode"); // this links the different elements together forcing a re-compute each time the values are changed attributeAffects(m_resolution, m_output); attributeAffects(m_amplitude,m_output); attributeAffects(m_windDirectionX, m_output); attributeAffects(m_windDirectionZ, m_output); attributeAffects(m_windSpeed, m_output); attributeAffects(m_choppiness, m_output); attributeAffects(m_time, m_output); // report all was good return MStatus::kSuccess; }
static MStatus initialize() { MFnEnumAttribute enumAttrFn; MFnNumericAttribute numericAttrFn; MFnGenericAttribute genericAttrFn; MFnTypedAttribute typeAttrFn; // enable node aEnable = numericAttrFn.create( "enbale", "e", MFnNumericData::kBoolean, 0, &status ); numericAttrFn.setDefault(0); numericAttrFn.setKeyable(true); addAttribute(aEnable); aFixPanel = numericAttrFn.create( "fixPanel", "fpn", MFnNumericData::kBoolean, 0, &status); numericAttrFn.setDefault(1); numericAttrFn.setConnectable(true); addAttribute(aFixPanel); aKeepSel = numericAttrFn.create( "keepSelection", "ks", MFnNumericData::kBoolean, 0, &status); numericAttrFn.setDefault(0); addAttribute(aKeepSel); // component type aComponentType = enumAttrFn.create( "componetType", "ct", 0, &status ); CHECK_MSTATUS( status ); enumAttrFn.setDefault(0); enumAttrFn.addField( "vertex", 0 ); enumAttrFn.addField( "edge", 1 ); enumAttrFn.addField( "face", 2 ); enumAttrFn.addField( "uv", 3 ); addAttribute( aComponentType ); // source object aSourceObj = genericAttrFn.create( "sourceObject", "so", &status ); genericAttrFn.addAccept(MFnData::kMesh); genericAttrFn.setStorable(false); addAttribute( aSourceObj ); CHECK_MSTATUS( status ); // volume object aVolumeObj = genericAttrFn.create( "volumeObject", "vo", &status ); genericAttrFn.addAccept(MFnData::kMesh); genericAttrFn.setArray(true); addAttribute( aVolumeObj ); CHECK_MSTATUS( status ); aClosedObj = numericAttrFn.create( "closedVolumeObject", "cvo", MFnNumericData::kBoolean, 1, &status ); numericAttrFn.setDefault(1); addAttribute( aClosedObj ); // ouput attribute // aOutValue = numericAttrFn.create( "outValue", "ov", MFnNumericData::kInt, 0, &status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable(false); addAttribute( aOutValue ); aOutCompList = typeAttrFn.create( "outComponent", "ocp", MFnComponentListData::kComponentList, &status ); CHECK_MSTATUS( status ); addAttribute(aOutCompList); aOutMesh = typeAttrFn.create( "outMesh", "om", MFnData::kMesh, &status ); CHECK_MSTATUS( status ); addAttribute(aOutMesh); // Attribute Affects for aOutValue attributeAffects( aEnable, aOutValue ); attributeAffects( aFixPanel, aOutValue ); attributeAffects( aComponentType, aOutValue ); attributeAffects( aKeepSel, aOutValue ); attributeAffects( aClosedObj, aOutValue ); attributeAffects( aSourceObj, aOutValue ); attributeAffects( aVolumeObj, aOutValue ); //Attribute Affects for aOutCompList attributeAffects( aEnable, aOutCompList); attributeAffects( aFixPanel, aOutCompList ); attributeAffects( aComponentType, aOutCompList ); attributeAffects( aKeepSel, aOutCompList ); attributeAffects( aClosedObj, aOutCompList ); attributeAffects( aSourceObj, aOutCompList ); attributeAffects( aVolumeObj, aOutCompList ); //Attribute Affects for aOutMesh attributeAffects( aEnable, aOutMesh); attributeAffects( aFixPanel, aOutMesh ); attributeAffects( aComponentType, aOutMesh ); attributeAffects( aKeepSel, aOutMesh ); attributeAffects( aClosedObj, aOutMesh ); attributeAffects( aSourceObj, aOutMesh ); attributeAffects( aVolumeObj, aOutMesh ); return MS::kSuccess; }
MStatus OpenSubdivPtexShader::initialize() { MFnTypedAttribute typedAttr; MFnNumericAttribute numAttr; MFnEnumAttribute enumAttr; // level aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 3); numAttr.setInternal(true); numAttr.setMin(1); numAttr.setSoftMax(5); numAttr.setMax(10); // tessFactor aTessFactor = numAttr.create("tessFactor", "tessf", MFnNumericData::kLong, 2); numAttr.setInternal(true); numAttr.setMin(1); numAttr.setMax(10); // scheme aScheme = enumAttr.create("scheme", "sc", OsdPtexMeshData::kCatmark); enumAttr.addField("Catmull-Clark", OsdPtexMeshData::kCatmark); enumAttr.addField("Loop", OsdPtexMeshData::kLoop); enumAttr.addField("Bilinear", OsdPtexMeshData::kBilinear); enumAttr.setInternal(true); // kernel aKernel = enumAttr.create("kernel", "kn", OsdPtexMeshData::kCPU); enumAttr.addField("CPU", OsdPtexMeshData::kCPU); #ifdef OPENSUBDIV_HAS_OPENMP enumAttr.addField("OpenMP", OsdPtexMeshData::kOPENMP); #endif #ifdef OPENSUBDIV_HAS_OPENCL enumAttr.addField("CL", OsdPtexMeshData::kCL); #endif #ifdef OPENSUBDIV_HAS_CUDA enumAttr.addField("CUDA", OsdPtexMeshData::kCUDA); #endif enumAttr.setInternal(true); // interpolateBoundary aInterpolateBoundary = enumAttr.create("interpolateBoundary", "ib", OsdPtexMeshData::kInterpolateBoundaryNone); enumAttr.addField("None", OsdPtexMeshData::kInterpolateBoundaryNone); enumAttr.addField("Edge Only", OsdPtexMeshData::kInterpolateBoundaryEdgeOnly); enumAttr.addField("Edge and Corner", OsdPtexMeshData::kInterpolateBoundaryEdgeAndCorner); enumAttr.addField("Always Sharp", OsdPtexMeshData::kInterpolateBoundaryAlwaysSharp); enumAttr.setInternal(true); // adaptive aAdaptive = numAttr.create("adaptive", "adp", MFnNumericData::kBoolean, true); numAttr.setInternal(true); // wireframe aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean, false); // material attributes aDiffuse = numAttr.createColor("diffuse", "d"); numAttr.setDefault(0.6f, 0.6f, 0.7f); aAmbient = numAttr.createColor("ambient", "a"); numAttr.setDefault(0.1f, 0.1f, 0.1f); aSpecular = numAttr.createColor("specular", "s"); numAttr.setDefault(0.3f, 0.3f, 0.3f); // Ptex Texture Attributes // // diffuseEnvironmentMapFile; aDiffuseEnvironmentMapFile = typedAttr.create("diffuseEnvironmentMap", "difenv", MFnData::kString); typedAttr.setInternal(true); // don't let maya hold on to string when fileNode is disconnected typedAttr.setDisconnectBehavior(MFnAttribute::kReset); // specularEnvironmentMapFile; aSpecularEnvironmentMapFile = typedAttr.create("specularEnvironmentMap", "specenv", MFnData::kString); typedAttr.setInternal(true); // don't let maya hold on to string when fileNode is disconnected typedAttr.setDisconnectBehavior(MFnAttribute::kReset); // colorFile; aColorFile = typedAttr.create("colorFile", "cf", MFnData::kString); typedAttr.setInternal(true); // displacementFile; aDisplacementFile = typedAttr.create("displacementFile", "df", MFnData::kString); typedAttr.setInternal(true); // occlusionFile; aOcclusionFile = typedAttr.create("occlusionFile", "of", MFnData::kString); typedAttr.setInternal(true); // enableDisplacement; aEnableDisplacement = numAttr.create("enableDisplacement", "end", MFnNumericData::kBoolean, 1); numAttr.setInternal(true); // enableColor; aEnableColor = numAttr.create("enableColor", "enc", MFnNumericData::kBoolean, 1); numAttr.setInternal(true); // enableOcclusion; aEnableOcclusion = numAttr.create("enableOcclusion", "eno", MFnNumericData::kBoolean, 1); numAttr.setInternal(true); // enableNormal; aEnableNormal = numAttr.create("enableNormal", "enn", MFnNumericData::kBoolean, 1); numAttr.setInternal(true); // fresnelBias; aFresnelBias = numAttr.create("fresnelBias", "fb", MFnNumericData::kFloat, 0.2f); numAttr.setMin(0); numAttr.setMax(1); // fresnelScale; aFresnelScale = numAttr.create("fresnelScale", "fs", MFnNumericData::kFloat, 1.0f); numAttr.setMin(0); numAttr.setSoftMax(1); // fresnelPower; aFresnelPower = numAttr.create("fresnelPower", "fp", MFnNumericData::kFloat, 5.0f); numAttr.setMin(0); numAttr.setSoftMax(10); // shaderSource; aShaderSource = typedAttr.create("shaderSource", "ssrc", MFnData::kString); typedAttr.setInternal(true); // add attributes addAttribute(aLevel); addAttribute(aTessFactor); addAttribute(aScheme); addAttribute(aKernel); addAttribute(aInterpolateBoundary); addAttribute(aAdaptive); addAttribute(aWireframe); addAttribute(aDiffuse); addAttribute(aAmbient); addAttribute(aSpecular); addAttribute(aShaderSource); addAttribute(aDiffuseEnvironmentMapFile); addAttribute(aSpecularEnvironmentMapFile); addAttribute(aColorFile); addAttribute(aDisplacementFile); addAttribute(aOcclusionFile); addAttribute(aEnableDisplacement); addAttribute(aEnableColor); addAttribute(aEnableOcclusion); addAttribute(aEnableNormal); addAttribute(aFresnelBias); addAttribute(aFresnelScale); addAttribute(aFresnelPower); return MS::kSuccess; }
MStatus woodTexNode::initialize() { MStatus stat; MFnNumericAttribute numAttr; MFnEnumAttribute enumAttr; woodTurbulence=numAttr.create("Turbulence","tl",MFnNumericData::kFloat,5.0); MAKE_INPUT(numAttr); numAttr.setMin(0.0); numAttr.setMax(200.0); woodSize=numAttr.create("WoodSize","ws",MFnNumericData::kFloat,4.0); MAKE_INPUT(numAttr); numAttr.setMin(0.0); numAttr.setMax(32.0); woodHard=numAttr.create("Hard","hr",MFnNumericData::kBoolean,false); MAKE_INPUT(numAttr); woodType=enumAttr.create("WoodType","wt",0); enumAttr.addField("bands",0); enumAttr.addField("rings",1); MAKE_INPUT(enumAttr); woodShape=enumAttr.create("WoodShape","wosh",0); enumAttr.addField("sin",0); enumAttr.addField("saw",1); enumAttr.addField("tri",2); NoiseType=enumAttr.create("NoiseType","noty",0); enumAttr.addField("newperlin",0); enumAttr.addField("stdperlin",1); enumAttr.addField("voronoi_f1",2); enumAttr.addField("voronoi_f2",3); enumAttr.addField("voronoi_f3",4); enumAttr.addField("voronoi_f4",5); enumAttr.addField("voronoi_f2fl",6); enumAttr.addField("voronoi_crackle",7); enumAttr.addField("cellnoise",8); MAKE_INPUT(enumAttr); mappingMethod=enumAttr.create("MappingMethod","mame",0); enumAttr.addField("uv",0); enumAttr.addField("orco",1); enumAttr.addField("global",2); enumAttr.addField("window",3); MAKE_INPUT(enumAttr); texCo=enumAttr.create("TextureCoordinate","texco",0); enumAttr.addField("plain",0); enumAttr.addField("cube",1); enumAttr.addField("tube",2); enumAttr.addField("sphere",3); MAKE_INPUT(enumAttr); //*******************************layer texture attribute*********************************// layerMix=enumAttr.create("MixMethod","mm1",0); enumAttr.addField("mix",0); enumAttr.addField("add",1); enumAttr.addField("multiply",2); enumAttr.addField("subtract",3); enumAttr.addField("screen",4); enumAttr.addField("divide",5); enumAttr.addField("difference",6); enumAttr.addField("darken",7); enumAttr.addField("lighten",8); MAKE_INPUT(enumAttr); textureColor=numAttr.createColor("TextureColor","teco"); numAttr.setDefault(1.0,0.0,1.0); MAKE_INPUT(numAttr); texColorFact=numAttr.create("TextureColorWeight","tcw",MFnNumericData::kFloat,1.0); numAttr.setMin(0.0); numAttr.setMax(1.0); MAKE_INPUT(numAttr); defVal=numAttr.create("DefValue","dev",MFnNumericData::kFloat,1.0); numAttr.setMin(0.0); numAttr.setMax(1.0); MAKE_INPUT(numAttr); valFact=numAttr.create("ValueWeight","vaw",MFnNumericData::kFloat,1.0); numAttr.setMin(0.0); numAttr.setMax(1.0); MAKE_INPUT(numAttr); doColor=numAttr.create("DoColor","doco",MFnNumericData::kBoolean,true); MAKE_INPUT(numAttr); negative=numAttr.create("Negative","nega",MFnNumericData::kBoolean,false); MAKE_INPUT(numAttr); noRGB=numAttr.create("NoRGB","nr",MFnNumericData::kBoolean,false); MAKE_INPUT(numAttr); stencil=numAttr.create("Stencil","sten",MFnNumericData::kBoolean,false); MAKE_INPUT(numAttr); //*******************************layer texture attribute end*********************************// MObject u=numAttr.create("uCoord","u",MFnNumericData::kFloat); MObject v=numAttr.create("vCoord","v",MFnNumericData::kFloat); UV=numAttr.create("uvCoord","uv",u,v); MAKE_INPUT(numAttr); MObject filterX=numAttr.create("uvFilterSizeX", "fsx", MFnNumericData::kFloat); MObject filterY=numAttr.create( "uvFilterSizeY", "fsy", MFnNumericData::kFloat); UVFilterSize=numAttr.create("uvFilterSize", "fs", filterX, filterY); MAKE_INPUT(numAttr); Output=numAttr.createColor("outColor","oc"); numAttr.setHidden(true); MAKE_OUTPUT(numAttr); addAttribute(woodTurbulence); addAttribute(woodSize); addAttribute(woodHard); addAttribute(woodType); addAttribute(woodShape); addAttribute(NoiseType); addAttribute(mappingMethod); addAttribute(texCo); addAttribute(layerMix); addAttribute(textureColor); addAttribute(texColorFact); addAttribute(defVal); addAttribute(valFact); addAttribute(doColor); addAttribute(negative); addAttribute(noRGB); addAttribute(stencil); addAttribute(UV); addAttribute(UVFilterSize); addAttribute(Output); attributeAffects(woodTurbulence,Output); attributeAffects(woodSize,Output); attributeAffects(woodHard,Output); attributeAffects(woodType,Output); attributeAffects(woodShape,Output); attributeAffects(NoiseType,Output); attributeAffects(mappingMethod,Output); attributeAffects(texCo,Output); attributeAffects(layerMix,Output); attributeAffects(textureColor,Output); attributeAffects(texColorFact,Output); attributeAffects(defVal,Output); attributeAffects(valFact,Output); attributeAffects(doColor,Output); attributeAffects(negative,Output); attributeAffects(noRGB,Output); attributeAffects(stencil,Output); attributeAffects(UV,Output); attributeAffects(UVFilterSize,Output); return stat; }
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; }
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; }
//initialize //----------------------------------------------- MStatus Ocio_test::initialize() { //MFnSets MFnEnumAttribute eAttr; MFnNumericAttribute nAttr; MFnCompoundAttribute cAttr; MFnTypedAttribute tAttr; //a_verbose a_verbose = eAttr.create("verbose", "verbose", 0); eAttr.addField("no verbose", 0); eAttr.addField("verbose", 1); addAttribute(a_verbose); //a_change_list a_change_list = eAttr.create("change_list", "change_list", 0); eAttr.addField("type 1", 0); eAttr.addField("type 2", 1); addAttribute(a_change_list); //a_last_change_index a_last_change_index = nAttr.create("last_change_index", "last_change_index", MFnNumericData::kInt, 9999); nAttr.setStorable(false); addAttribute(a_last_change_index); //a_input_color a_input_color = nAttr.createColor("input_color", "input_color"); nAttr.setUsedAsColor(true); nAttr.setStorable(false); addAttribute(a_input_color); //a_width a_width = nAttr.create("width", "width", MFnNumericData::kInt); nAttr.setStorable(false); addAttribute(a_width); //a_height a_height = nAttr.create("height", "height", MFnNumericData::kInt); nAttr.setStorable(false); addAttribute(a_height); //a_config_path a_config_path = tAttr.create("config_path", "config_path", MFnData::kString); tAttr.setUsedAsFilename(true); tAttr.setStorable(true); addAttribute(a_config_path); //a_output_color a_output_color = nAttr.createColor("output_color", "output_color"); nAttr.setStorable(false); addAttribute(a_output_color); //Attribute affects attributeAffects(a_change_list, a_output_color); attributeAffects(a_input_color, a_output_color); attributeAffects(a_width, a_output_color); attributeAffects(a_height, a_output_color); return MStatus::kSuccess; }
// // DESCRIPTION: MStatus marble::initialize() { MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus status; outColor = nAttr.createColor("outColor", "outColor"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( outColor )); //---------------------------- automatically created attributes start ------------------------------------ scale = nAttr.create("scale", "scale", MFnNumericData::kFloat, 1); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( scale )); octaves = nAttr.create("octaves", "octaves", MFnNumericData::kInt, 8); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( octaves )); coordinates = eAttr.create("coordinates", "coordinates", 0, &status); status = eAttr.addField( "global", 0 ); status = eAttr.addField( "local", 1 ); status = eAttr.addField( "global normal", 2 ); status = eAttr.addField( "localnormal", 3 ); status = eAttr.addField( "uv", 4 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( coordinates )); roughness = nAttr.create("roughness", "roughness", MFnNumericData::kFloat, 0.5); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( roughness )); MObject rotateX = nAttr.create("rotateX", "rotatex", MFnNumericData::kDouble, 0.0); MObject rotateY = nAttr.create("rotateY", "rotatey", MFnNumericData::kDouble, 0.0); MObject rotateZ = nAttr.create("rotateZ", "rotatez", MFnNumericData::kDouble, 0.0); rotate = nAttr.create("rotate", "rotate", rotateX, rotateY, rotateZ); MAKE_INPUT(nAttr); nAttr.setDefault(0,0,0); CHECK_MSTATUS(addAttribute( rotate )); variation = nAttr.create("variation", "variation", MFnNumericData::kFloat, 0.2); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( variation )); MObject translateX = nAttr.create("translateX", "translatex", MFnNumericData::kDouble, 0.0); MObject translateY = nAttr.create("translateY", "translatey", MFnNumericData::kDouble, 0.0); MObject translateZ = nAttr.create("translateZ", "translatez", MFnNumericData::kDouble, 0.0); translate = nAttr.create("translate", "translate", translateX, translateY, translateZ); MAKE_INPUT(nAttr); nAttr.setDefault(0,0,0); CHECK_MSTATUS(addAttribute( translate )); luxOutColor = nAttr.createColor("luxOutColor", "luxOutColor"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( luxOutColor )); CHECK_MSTATUS ( attributeAffects( scale, luxOutColor)); CHECK_MSTATUS ( attributeAffects( scale, outColor)); //---------------------------- automatically created attributes end ------------------------------------ return MS::kSuccess; }
// // DESCRIPTION: MStatus brick::initialize() { MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus status; outColor = nAttr.createColor("outColor", "outColor"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( outColor )); //---------------------------- automatically created attributes start ------------------------------------ MObject scaleX = nAttr.create("scaleX", "scalex", MFnNumericData::kDouble, 0.0); MObject scaleY = nAttr.create("scaleY", "scaley", MFnNumericData::kDouble, 0.0); MObject scaleZ = nAttr.create("scaleZ", "scalez", MFnNumericData::kDouble, 0.0); scale = nAttr.create("scale", "scale", scaleX, scaleY, scaleZ); MAKE_INPUT(nAttr); nAttr.setDefault(1,1,1); CHECK_MSTATUS(addAttribute( scale )); brickbevel = nAttr.create("brickbevel", "brickbevel", MFnNumericData::kFloat, 0.0); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( brickbevel )); brickbond = eAttr.create("brickbond", "brickbond", 0, &status); status = eAttr.addField( "stacked", 0 ); status = eAttr.addField( "flemish", 1 ); status = eAttr.addField( "english", 2 ); status = eAttr.addField( "herringbone", 3 ); status = eAttr.addField( "basket", 4 ); status = eAttr.addField( "chain link", 5 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( brickbond )); mortarsize = nAttr.create("mortarsize", "mortarsize", MFnNumericData::kFloat, 0.01); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( mortarsize )); brickwidth = nAttr.create("brickwidth", "brickwidth", MFnNumericData::kFloat, 0.3); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( brickwidth )); bricktex = nAttr.createColor("bricktex", "bricktex"); MAKE_INPUT(nAttr); nAttr.setDefault(1.0,1.0,1.0); CHECK_MSTATUS(addAttribute( bricktex )); brickdepth = nAttr.create("brickdepth", "brickdepth", MFnNumericData::kFloat, 0.15); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( brickdepth )); coordinates = eAttr.create("coordinates", "coordinates", 0, &status); status = eAttr.addField( "global", 0 ); status = eAttr.addField( "local", 1 ); status = eAttr.addField( "global normal", 2 ); status = eAttr.addField( "localnormal", 3 ); status = eAttr.addField( "uv", 4 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( coordinates )); brickmodtex = nAttr.create("brickmodtex", "brickmodtex", MFnNumericData::kFloat, 1.0); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( brickmodtex )); MObject rotateX = nAttr.create("rotateX", "rotatex", MFnNumericData::kDouble, 0.0); MObject rotateY = nAttr.create("rotateY", "rotatey", MFnNumericData::kDouble, 0.0); MObject rotateZ = nAttr.create("rotateZ", "rotatez", MFnNumericData::kDouble, 0.0); rotate = nAttr.create("rotate", "rotate", rotateX, rotateY, rotateZ); MAKE_INPUT(nAttr); nAttr.setDefault(0,0,0); CHECK_MSTATUS(addAttribute( rotate )); motartex = nAttr.createColor("motartex", "motartex"); MAKE_INPUT(nAttr); nAttr.setDefault(0.2,0.2,0.2); CHECK_MSTATUS(addAttribute( motartex )); brickrun = nAttr.create("brickrun", "brickrun", MFnNumericData::kFloat, 0.75); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( brickrun )); MObject translateX = nAttr.create("translateX", "translatex", MFnNumericData::kDouble, 0.0); MObject translateY = nAttr.create("translateY", "translatey", MFnNumericData::kDouble, 0.0); MObject translateZ = nAttr.create("translateZ", "translatez", MFnNumericData::kDouble, 0.0); translate = nAttr.create("translate", "translate", translateX, translateY, translateZ); MAKE_INPUT(nAttr); nAttr.setDefault(0,0,0); CHECK_MSTATUS(addAttribute( translate )); brickheight = nAttr.create("brickheight", "brickheight", MFnNumericData::kFloat, 0.1); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( brickheight )); luxOutFloat = nAttr.create("luxOutFloat", "luxOutFloat", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( luxOutFloat )); luxOutColor = nAttr.createColor("luxOutColor", "luxOutColor"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( luxOutColor )); CHECK_MSTATUS ( attributeAffects( scale, luxOutFloat)); CHECK_MSTATUS ( attributeAffects( scale, luxOutColor)); CHECK_MSTATUS ( attributeAffects( scale, outColor)); //---------------------------- automatically created attributes end ------------------------------------ return MS::kSuccess; }
// // DESCRIPTION: MStatus blender_marble::initialize() { MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus status; outColor = nAttr.createColor("outColor", "outColor"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( outColor )); //---------------------------- automatically created attributes start ------------------------------------ noisesize = nAttr.create("noisesize", "noisesize", MFnNumericData::kFloat, 0.25); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( noisesize )); noisebasis2 = eAttr.create("noisebasis2", "noisebasis2", 0, &status); status = eAttr.addField( "blender_original", 0 ); status = eAttr.addField( "original_perlin", 1 ); status = eAttr.addField( "improved_perlin", 2 ); status = eAttr.addField( "voronoi_f1", 3 ); status = eAttr.addField( "voronoi_f2", 4 ); status = eAttr.addField( "voronoi_f3", 5 ); status = eAttr.addField( "voronoi_f4", 6 ); status = eAttr.addField( "voronoi_f2f1", 7 ); status = eAttr.addField( "voronoi_crackle", 8 ); status = eAttr.addField( "cell_noise", 9 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( noisebasis2 )); noisebasis = eAttr.create("noisebasis", "noisebasis", 0, &status); status = eAttr.addField( "sin", 0 ); status = eAttr.addField( "saw", 1 ); status = eAttr.addField( "tri", 2 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( noisebasis )); MObject scaleX = nAttr.create("scaleX", "scalex", MFnNumericData::kDouble, 0.0); MObject scaleY = nAttr.create("scaleY", "scaley", MFnNumericData::kDouble, 0.0); MObject scaleZ = nAttr.create("scaleZ", "scalez", MFnNumericData::kDouble, 0.0); scale = nAttr.create("scale", "scale", scaleX, scaleY, scaleZ); MAKE_INPUT(nAttr); nAttr.setDefault(1,1,1); CHECK_MSTATUS(addAttribute( scale )); noisedepth = nAttr.create("noisedepth", "noisedepth", MFnNumericData::kInt, 2); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( noisedepth )); turbulance = nAttr.create("turbulance", "turbulance", MFnNumericData::kFloat, 5.0); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( turbulance )); coordinates = eAttr.create("coordinates", "coordinates", 0, &status); status = eAttr.addField( "global", 0 ); status = eAttr.addField( "local", 1 ); status = eAttr.addField( "global normal", 2 ); status = eAttr.addField( "localnormal", 3 ); status = eAttr.addField( "uv", 4 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( coordinates )); bright = nAttr.create("bright", "bright", MFnNumericData::kFloat, 1.0); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( bright )); MObject rotateX = nAttr.create("rotateX", "rotatex", MFnNumericData::kDouble, 0.0); MObject rotateY = nAttr.create("rotateY", "rotatey", MFnNumericData::kDouble, 0.0); MObject rotateZ = nAttr.create("rotateZ", "rotatez", MFnNumericData::kDouble, 0.0); rotate = nAttr.create("rotate", "rotate", rotateX, rotateY, rotateZ); MAKE_INPUT(nAttr); nAttr.setDefault(0,0,0); CHECK_MSTATUS(addAttribute( rotate )); noisetype = eAttr.create("noisetype", "noisetype", 1, &status); status = eAttr.addField( "soft_noise", 0 ); status = eAttr.addField( "hard_noise", 1 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( noisetype )); MObject translateX = nAttr.create("translateX", "translatex", MFnNumericData::kDouble, 0.0); MObject translateY = nAttr.create("translateY", "translatey", MFnNumericData::kDouble, 0.0); MObject translateZ = nAttr.create("translateZ", "translatez", MFnNumericData::kDouble, 0.0); translate = nAttr.create("translate", "translate", translateX, translateY, translateZ); MAKE_INPUT(nAttr); nAttr.setDefault(0,0,0); CHECK_MSTATUS(addAttribute( translate )); type = eAttr.create("type", "type", 0, &status); status = eAttr.addField( "soft", 0 ); status = eAttr.addField( "sharp", 1 ); status = eAttr.addField( "sharper", 2 ); MAKE_INPUT(eAttr); CHECK_MSTATUS(addAttribute( type )); contrast = nAttr.create("contrast", "contrast", MFnNumericData::kFloat, 1.0); MAKE_INPUT(nAttr); CHECK_MSTATUS(addAttribute( contrast )); luxOutFloat = nAttr.create("luxOutFloat", "luxOutFloat", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute( luxOutFloat )); CHECK_MSTATUS ( attributeAffects( noisesize, luxOutFloat)); CHECK_MSTATUS ( attributeAffects( noisesize, outColor)); //---------------------------- automatically created attributes end ------------------------------------ return MS::kSuccess; }
MStatus n_tentacle::initialize() { MFnNumericAttribute numericAttr; MFnMatrixAttribute matrixAttr; MFnTypedAttribute typedAttr; MFnUnitAttribute unitAttribute; MFnEnumAttribute enumAttr; MStatus stat; stretch = numericAttr.create("stretch", "st", MFnNumericData::kDouble, 0.0); numericAttr.setMin(0.0); numericAttr.setMax(1.0); globalScale = numericAttr.create("globalScale", "gs", MFnNumericData::kDouble, 1.0); numericAttr.setMin(0.00001); numericAttr.setMax(10.0); iniLength = numericAttr.create("iniLength", "iln", MFnNumericData::kDouble, 0.01); parameter = numericAttr.create("parameter", "prm", MFnNumericData::kDouble, 0.0); numericAttr.setArray(true); blendRot = numericAttr.create("blendRot", "blr", MFnNumericData::kDouble, 0.0); numericAttr.setArray(true); interval = numericAttr.create("interval", "itv", MFnNumericData::kInt, 0); numericAttr.setArray(true); matrix = matrixAttr.create("matrix", "mtx"); matrixAttr.setArray(true); matrixAttr.setHidden(true); curve = typedAttr.create("curve", "crv", MFnData::kNurbsCurve); outTranslate = numericAttr.create("outTranslate", "ot", MFnNumericData::k3Double); numericAttr.setArray(true); numericAttr.setHidden(true); numericAttr.setUsesArrayDataBuilder(true); numericAttr.setHidden(true); outRotateX = unitAttribute.create("outRotateX", "orx", MFnUnitAttribute::kAngle); outRotateY = unitAttribute.create("outRotateY", "ory", MFnUnitAttribute::kAngle); outRotateZ = unitAttribute.create("outRotateZ", "orz", MFnUnitAttribute::kAngle); outRotate = numericAttr.create("outRotate", "or",outRotateX, outRotateY, outRotateZ); numericAttr.setArray(true); numericAttr.setHidden(true); numericAttr.setUsesArrayDataBuilder(true); numericAttr.setHidden(true); tangentAxis = enumAttr.create("tangentAxis", "tga", 1); enumAttr.addField("X", 0); enumAttr.addField("Y", 1); enumAttr.addField("Z", 2); enumAttr.addField("negativeX", 3); enumAttr.addField("negativeY", 4); enumAttr.addField("negativeZ", 5); // Add the attributes we have created to the node // stat = addAttribute( parameter ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( blendRot ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( interval ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( stretch ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( globalScale ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( iniLength ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( matrix ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( curve ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( outTranslate ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( outRotate ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( tangentAxis ); if (!stat) { stat.perror("addAttribute"); return stat;} attributeAffects( parameter, outTranslate ); attributeAffects( blendRot, outTranslate ); attributeAffects( interval, outTranslate ); attributeAffects( stretch, outTranslate ); attributeAffects( globalScale, outTranslate ); attributeAffects( iniLength, outTranslate ); attributeAffects( matrix, outTranslate ); attributeAffects( curve, outTranslate ); attributeAffects( tangentAxis, outTranslate ); attributeAffects( parameter, outRotate ); attributeAffects( blendRot, outRotate ); attributeAffects( interval, outRotate ); attributeAffects( stretch, outRotate ); attributeAffects( globalScale, outRotate ); attributeAffects( iniLength, outRotate ); attributeAffects( matrix, outRotate ); attributeAffects( curve, outRotate ); attributeAffects( tangentAxis, outRotate ); attributeAffects( parameter, outRotateX ); attributeAffects( blendRot, outRotateX ); attributeAffects( interval, outRotateX ); attributeAffects( stretch, outRotateX ); attributeAffects( globalScale, outRotateX ); attributeAffects( iniLength, outRotateX ); attributeAffects( matrix, outRotateX ); attributeAffects( curve, outRotateX ); attributeAffects( tangentAxis, outRotateX ); attributeAffects( parameter, outRotateY ); attributeAffects( blendRot, outRotateY ); attributeAffects( interval, outRotateY ); attributeAffects( stretch, outRotateY ); attributeAffects( globalScale, outRotateY ); attributeAffects( iniLength, outRotateY ); attributeAffects( matrix, outRotateY ); attributeAffects( curve, outRotateY ); attributeAffects( tangentAxis, outRotateY ); attributeAffects( parameter, outRotateZ ); attributeAffects( blendRot, outRotateZ ); attributeAffects( interval, outRotateZ ); attributeAffects( stretch, outRotateZ ); attributeAffects( globalScale, outRotateZ ); attributeAffects( iniLength, outRotateZ ); attributeAffects( matrix, outRotateZ ); attributeAffects( curve, outRotateZ ); attributeAffects( tangentAxis, outRotateZ ); return MS::kSuccess; }
MStatus mtmEnvLight::initialize() { MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; MFnLightDataAttribute lAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus stat; //aColor = nAttr.createColor( "color", "c" ); //CHECK_MSTATUS ( nAttr.setKeyable(true) ); //CHECK_MSTATUS ( nAttr.setStorable(true) ); //CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.58824f, 0.644f) ); aLightColor = nAttr.createColor( "lightColor", "lightColor" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); nAttr.setDefault(0.7f, 0.58824f, 0.344f); aShadowColor = nAttr.createColor( "shadowColor", "sc" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.0f, 0.0f) ); aPosition = nAttr.createPoint( "position", "pos" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); aInputDirection = nAttr.createPoint( "inputDirection", "id" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) ); aInputAmbient = nAttr.create( "ambientOn", "an", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aInputDiffuse = nAttr.create( "emitDiffuse", "dn", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aInputSpecular = nAttr.create( "emitSpecular", "sn", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aIntensity = nAttr.create( "intensity", "i", MFnNumericData::kFloat); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(1.0f) ); samplingquality = nAttr.create( "samplingquality", "samplingquality", MFnNumericData::kFloat, 1.0); envmap = tAttr.create( "envmap", "envmap", MFnNumericData::kString); tAttr.setUsedAsFilename(true); areamap = tAttr.create( "areamap", "areamap", MFnNumericData::kString); tAttr.setUsedAsFilename(true); areafullsphere = nAttr.create( "areafullsphere", "areafullsphere", MFnNumericData::kBoolean, true); envintensity = nAttr.createColor( "envintensity", "envintensity" ); nAttr.setDefault(1.0f, 1.0f, 1.0f); raybackground = nAttr.create( "raybackground", "raybackground", MFnNumericData::kBoolean, false); castshadow = nAttr.create( "castshadow", "castshadow", MFnNumericData::kBoolean, true); envtype = eAttr.create( "envtype", "envtype", 0, &stat); stat = eAttr.addField( "Direct Lighting", 0 ); stat = eAttr.addField( "Ambient Occlusion", 1 ); stat = eAttr.addField( "Full Irradiance", 2 ); stat = eAttr.addField( "Raytrace Background", 3 ); eAttr.setDefault(0); doraysamples = nAttr.create( "doraysamples", "doraysamples", MFnNumericData::kBoolean, false); doadaptive = nAttr.create( "doadaptive", "doadaptive", MFnNumericData::kBoolean, false); domaxdist = nAttr.create( "domaxdist", "domaxdist", MFnNumericData::kBoolean, false); maxdist = nAttr.create( "maxdist", "maxdist", MFnNumericData::kFloat, 10.0); coneangle = nAttr.create( "coneangle", "coneangle", MFnNumericData::kFloat, 45.0); envtint = nAttr.createColor( "envtint", "envtint" ); nAttr.setDefault(1.0f, 1.0f, 1.0f); shadowI = nAttr.create( "shadowI", "shadowI", MFnNumericData::kFloat, 1.0); samples = nAttr.create( "samples", "samples", MFnNumericData::kInt, 32); MFnStringData fnStringData; MObject defaultObjectMask; defaultObjectMask = fnStringData.create( "*" ); objectmask = tAttr.create( "objectmask", "objectmask", MFnNumericData::kString, defaultObjectMask); usePortalGeometry = nAttr.create( "usePortalGeometry", "usePortalGeometry", MFnNumericData::kBoolean, false); portalGeometry = mAttr.create( "portalGeometry", "portalGeometry"); mAttr.setConnectable(true); mAttr.accepts(MFnData::kAny); // Outputs aLightDirection = nAttr.createPoint( "lightDirection", "ld" ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) ); aLightIntensity = nAttr.createColor( "lightIntensity", "li" ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(1.0f, 0.5f, 0.2f) ); aLightAmbient = nAttr.create( "lightAmbient", "la", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); nAttr.setDefault(true); aLightDiffuse = nAttr.create( "lightDiffuse", "ldf", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aLightSpecular = nAttr.create( "lightSpecular", "ls", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aLightShadowFraction = nAttr.create("lightShadowFraction","lsf", MFnNumericData::kFloat); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(0.0f) ); aPreShadowIntensity = nAttr.create("preShadowIntensity","psi", MFnNumericData::kFloat); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(0.0f) ); aLightBlindData = nAttr.createAddr("lightBlindData","lbld"); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); aLightData = lAttr.create( "lightData", "ltd", aLightDirection, aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular, aLightShadowFraction, aPreShadowIntensity, aLightBlindData); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( lAttr.setStorable(false) ); CHECK_MSTATUS ( lAttr.setHidden(true) ); lAttr.setDefault(-1.0f, 0.0f, 0.0f, 1.0f, 0.5f, 0.2f, true, true, true, 0.0f, 1.0f, NULL); CHECK_MSTATUS ( addAttribute(coneangle) ); CHECK_MSTATUS ( addAttribute(samples) ); CHECK_MSTATUS ( addAttribute(objectmask) ); CHECK_MSTATUS ( addAttribute(shadowI) ); CHECK_MSTATUS ( addAttribute(envtint) ); CHECK_MSTATUS ( addAttribute(maxdist) ); CHECK_MSTATUS ( addAttribute(domaxdist) ); CHECK_MSTATUS ( addAttribute(doadaptive) ); CHECK_MSTATUS ( addAttribute(doraysamples) ); CHECK_MSTATUS ( addAttribute(envtype) ); CHECK_MSTATUS ( addAttribute(castshadow) ); CHECK_MSTATUS ( addAttribute(raybackground) ); CHECK_MSTATUS ( addAttribute(envintensity) ); CHECK_MSTATUS ( addAttribute(areafullsphere) ); CHECK_MSTATUS ( addAttribute(areamap) ); CHECK_MSTATUS ( addAttribute(envmap) ); CHECK_MSTATUS ( addAttribute(samplingquality) ); CHECK_MSTATUS ( addAttribute(usePortalGeometry) ); CHECK_MSTATUS ( addAttribute(portalGeometry) ); //CHECK_MSTATUS ( addAttribute(aColor) ); CHECK_MSTATUS ( addAttribute(aLightColor) ); CHECK_MSTATUS ( addAttribute(aShadowColor) ); CHECK_MSTATUS ( addAttribute(aPosition) ); CHECK_MSTATUS ( addAttribute(aInputDirection) ); CHECK_MSTATUS ( addAttribute(aInputAmbient) ); CHECK_MSTATUS ( addAttribute(aInputDiffuse) ); CHECK_MSTATUS ( addAttribute(aInputSpecular) ); CHECK_MSTATUS ( addAttribute(aIntensity) ); CHECK_MSTATUS ( addAttribute(aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightIntensity, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightDirection, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightAmbient, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightDiffuse, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightSpecular, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightShadowFraction, aLightData) ); CHECK_MSTATUS ( attributeAffects (aPreShadowIntensity, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightBlindData, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightData, aLightData) ); //CHECK_MSTATUS ( attributeAffects (aColor, aLightData) ); CHECK_MSTATUS ( attributeAffects (aPosition, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputDirection, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputAmbient, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputDiffuse, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputSpecular, aLightData) ); CHECK_MSTATUS ( attributeAffects (aIntensity, aLightData) ); return MS::kSuccess; }
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 MayaToIndigoGlobals::initialize() { MayaRenderGlobalsNode::initialize(); MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus stat = MStatus::kSuccess; // ------------- automatically created attributes start ----------- // white_point = eAttr.create("white_point", "white_point", 4, &stat); stat = eAttr.addField( "User", 0 ); stat = eAttr.addField( "A", 1 ); stat = eAttr.addField( "B", 2 ); stat = eAttr.addField( "C", 3 ); stat = eAttr.addField( "D50", 4 ); stat = eAttr.addField( "D55", 5 ); stat = eAttr.addField( "D65", 6 ); stat = eAttr.addField( "D75", 7 ); stat = eAttr.addField( "E", 8 ); stat = eAttr.addField( "F1", 9 ); stat = eAttr.addField( "F2", 10 ); stat = eAttr.addField( "F3", 11 ); stat = eAttr.addField( "F4", 12 ); stat = eAttr.addField( "F5", 13 ); stat = eAttr.addField( "F6", 14 ); stat = eAttr.addField( "F7", 15 ); stat = eAttr.addField( "F8", 16 ); stat = eAttr.addField( "F9", 17 ); stat = eAttr.addField( "F10", 18 ); stat = eAttr.addField( "F11", 19 ); stat = eAttr.addField( "F12", 20 ); CHECK_MSTATUS(addAttribute( white_point )); white_pointX = nAttr.create("white_pointX", "white_pointX", MFnNumericData::kFloat, 0.0); CHECK_MSTATUS(addAttribute( white_pointX )); white_pointY = nAttr.create("white_pointY", "white_pointY", MFnNumericData::kFloat, 0.0); CHECK_MSTATUS(addAttribute( white_pointY )); bih_tri_threshold = nAttr.create("bih_tri_threshold", "bih_tri_threshold", MFnNumericData::kInt, 1100000); CHECK_MSTATUS(addAttribute( bih_tri_threshold )); metropolis = nAttr.create("metropolis", "metropolis", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( metropolis )); large_mutation_prob = nAttr.create("large_mutation_prob", "large_mutation_prob", MFnNumericData::kFloat, 0.1); CHECK_MSTATUS(addAttribute( large_mutation_prob )); max_change = nAttr.create("max_change", "max_change", MFnNumericData::kFloat, .01); CHECK_MSTATUS(addAttribute( max_change )); max_num_consec_rejections = nAttr.create("max_num_consec_rejections", "max_num_consec_rejections", MFnNumericData::kInt, 1000); CHECK_MSTATUS(addAttribute( max_num_consec_rejections )); logging = nAttr.create("logging", "logging", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( logging )); path_tracing = eAttr.create("path_tracing", "path_tracing", 0, &stat); stat = eAttr.addField( "bidirectional", 0 ); stat = eAttr.addField( "backwards", 1 ); CHECK_MSTATUS(addAttribute( path_tracing )); tone_mapper = eAttr.create("tone_mapper", "tone_mapper", 1, &stat); stat = eAttr.addField( "linear", 0 ); stat = eAttr.addField( "reinhard", 1 ); stat = eAttr.addField( "camera", 2 ); CHECK_MSTATUS(addAttribute( tone_mapper )); tone_linearScale = nAttr.create("tone_linearScale", "tone_linearScale", MFnNumericData::kFloat, 1.0); nAttr.setMin(0.0001); nAttr.setMax(100); CHECK_MSTATUS(addAttribute( tone_linearScale )); tone_reinhardPreScale = nAttr.create("tone_reinhardPreScale", "tone_reinhardPreScale", MFnNumericData::kFloat, 1.0); CHECK_MSTATUS(addAttribute( tone_reinhardPreScale )); tone_reinhardPostScale = nAttr.create("tone_reinhardPostScale", "tone_reinhardPostScale", MFnNumericData::kFloat, 1.0); CHECK_MSTATUS(addAttribute( tone_reinhardPostScale )); tone_reinhardBurn = nAttr.create("tone_reinhardBurn", "tone_reinhardBurn", MFnNumericData::kFloat, 10.0); CHECK_MSTATUS(addAttribute( tone_reinhardBurn )); tone_cameraResponse_function_path = tAttr.create("tone_cameraResponse_function_path", "tone_cameraResponse_function_path", MFnNumericData::kString); CHECK_MSTATUS(addAttribute( tone_cameraResponse_function_path )); tone_cameraEv_adjust = nAttr.create("tone_cameraEv_adjust", "tone_cameraEv_adjust", MFnNumericData::kFloat, 0.0); CHECK_MSTATUS(addAttribute( tone_cameraEv_adjust )); tone_cameraFilm_iso = nAttr.create("tone_cameraFilm_iso", "tone_cameraFilm_iso", MFnNumericData::kFloat, 200.0); CHECK_MSTATUS(addAttribute( tone_cameraFilm_iso )); save_untonemapped_exr = nAttr.create("save_untonemapped_exr", "save_untonemapped_exr", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( save_untonemapped_exr )); save_tonemapped_exr = nAttr.create("save_tonemapped_exr", "save_tonemapped_exr", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( save_tonemapped_exr )); save_igi = nAttr.create("save_igi", "save_igi", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( save_igi )); image_save_period = nAttr.create("image_save_period", "image_save_period", MFnNumericData::kFloat, 60); CHECK_MSTATUS(addAttribute( image_save_period )); halt_time = nAttr.create("halt_time", "halt_time", MFnNumericData::kFloat, -1); CHECK_MSTATUS(addAttribute( halt_time )); halt_samples_per_pixel = nAttr.create("halt_samples_per_pixel", "halt_samples_per_pixel", MFnNumericData::kInt, -1); CHECK_MSTATUS(addAttribute( halt_samples_per_pixel )); hybrid = nAttr.create("hybrid", "hybrid", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( hybrid )); auto_choose_num_threads = nAttr.create("auto_choose_num_threads", "auto_choose_num_threads", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( auto_choose_num_threads )); num_threads = nAttr.create("num_threads", "num_threads", MFnNumericData::kBoolean, 1); CHECK_MSTATUS(addAttribute( num_threads )); super_sample_factor = nAttr.create("super_sample_factor", "super_sample_factor", MFnNumericData::kInt, 2); CHECK_MSTATUS(addAttribute( super_sample_factor )); watermark = nAttr.create("watermark", "watermark", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( watermark )); info_overlay = nAttr.create("info_overlay", "info_overlay", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( info_overlay )); cache_trees = nAttr.create("cache_trees", "cache_trees", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( cache_trees )); aperture_diffraction = nAttr.create("aperture_diffraction", "aperture_diffraction", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( aperture_diffraction )); post_process_diffraction = nAttr.create("post_process_diffraction", "post_process_diffraction", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( post_process_diffraction )); render_foreground_alpha = nAttr.create("render_foreground_alpha", "render_foreground_alpha", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( render_foreground_alpha )); splat_filter = eAttr.create("splat_filter", "splat_filter", 0, &stat); stat = eAttr.addField( "fastbox", 0 ); stat = eAttr.addField( "radial", 1 ); stat = eAttr.addField( "mn_cubic", 2 ); CHECK_MSTATUS(addAttribute( splat_filter )); splat_filter_cubic_b = nAttr.create("splat_filter_cubic_b", "splat_filter_cubic_b", MFnNumericData::kFloat, 0.6); CHECK_MSTATUS(addAttribute( splat_filter_cubic_b )); splat_filter_cubic_ring = nAttr.create("splat_filter_cubic_ring", "splat_filter_cubic_ring", MFnNumericData::kFloat, 0.2); CHECK_MSTATUS(addAttribute( splat_filter_cubic_ring )); downsize_filter = eAttr.create("downsize_filter", "downsize_filter", 0, &stat); stat = eAttr.addField( "mn_cubic", 0 ); stat = eAttr.addField( "gauss", 1 ); stat = eAttr.addField( "sharp", 2 ); CHECK_MSTATUS(addAttribute( downsize_filter )); downsize_filter_cubic_radius = nAttr.create("downsize_filter_cubic_radius", "downsize_filter_cubic_radius", MFnNumericData::kFloat, 2); CHECK_MSTATUS(addAttribute( downsize_filter_cubic_radius )); vignetting = nAttr.create("vignetting", "vignetting", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( vignetting )); gpu = nAttr.create("gpu", "gpu", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( gpu )); selected_gpu_device = eAttr.create("selected_gpu_device", "selected_gpu_device", 0, &stat); stat = eAttr.addField( "CUDA", 0 ); stat = eAttr.addField( "OPEN_CL", 1 ); CHECK_MSTATUS(addAttribute( selected_gpu_device )); glass_acceleration = nAttr.create("glass_acceleration", "glass_acceleration", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( glass_acceleration )); environmentType = eAttr.create("environmentType", "environmentType", 1, &stat); stat = eAttr.addField( "Off", 0 ); stat = eAttr.addField( "Color/Map", 1 ); stat = eAttr.addField( "Sun", 2 ); CHECK_MSTATUS(addAttribute( environmentType )); environmentColor = nAttr.createColor("environmentColor", "environmentColor"); nAttr.setDefault(0.4,0.4,1.0); CHECK_MSTATUS(addAttribute( environmentColor )); environmentSun = mAttr.create("environmentSun", "environmentSun"); CHECK_MSTATUS(addAttribute( environmentSun )); turbidity = nAttr.create("turbidity", "turbidity", MFnNumericData::kFloat, 2.0); CHECK_MSTATUS(addAttribute( turbidity )); extra_atmospheric = nAttr.create("extra_atmospheric", "extra_atmospheric", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( extra_atmospheric )); sun_layer = nAttr.create("sun_layer", "sun_layer", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( sun_layer )); sky_layer = nAttr.create("sky_layer", "sky_layer", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( sky_layer )); sky_model = eAttr.create("sky_model", "sky_model", 0, &stat); stat = eAttr.addField( "original", 0 ); stat = eAttr.addField( "captured-simulation", 1 ); CHECK_MSTATUS(addAttribute( sky_model )); environmentMapType = eAttr.create("environmentMapType", "environmentMapType", 0, &stat); stat = eAttr.addField( "Spherical", 0 ); stat = eAttr.addField( "Lat-Long", 1 ); CHECK_MSTATUS(addAttribute( environmentMapType )); environmentMapMultiplier = nAttr.create("environmentMapMultiplier", "environmentMapMultiplier", MFnNumericData::kFloat, 1.0); CHECK_MSTATUS(addAttribute( environmentMapMultiplier )); MFnStringData fnStringData; MObject defaultString; defaultString = fnStringData.create( "notepad.exe" ); preferredTextEditor = tAttr.create("preferredTextEditor", "preferredTextEditor", MFnNumericData::kString, defaultString); CHECK_MSTATUS(addAttribute( preferredTextEditor )); // ------------- automatically created attributes end ----------- // return stat; }
bool ToMayaMeshConverter::setMeshInterpolationAttribute( MObject &object, std::string interpolation ) { MStatus st; MFnMesh fnMesh(object, &st); if ( !st ) { return false; } int interpolationValue = 0; FromMayaMeshConverter fromMaya(object); const IECore::Parameter::PresetsContainer &presets = fromMaya.interpolationParameter()->presets(); IECore::Parameter::PresetsContainer::const_iterator it; if ( interpolation != "default" ) { int index = 0; for ( it = presets.begin(); it != presets.end(); it++, index++ ) { if ( interpolation == it->first || interpolation == IECore::staticPointerCast< IECore::StringData >(it->second)->readable() ) { interpolationValue = index; break; } } if ( it == presets.end() ) { return false; } } MPlug interpPlug = fnMesh.findPlug( "ieMeshInterpolation", &st ); if ( !st ) { MFnEnumAttribute fnAttrib; MObject newAttr = fnAttrib.create( "ieMeshInterpolation", "interp", 0, &st ); if ( !st ) { return false; } int index = 0; for ( it = presets.begin(); it != presets.end(); it++ ) { if ( it->first == "default" ) { continue; } fnAttrib.addField( it->first.c_str(), index ); index++; } // looks like the attribute does not exist yet.. st = fnMesh.addAttribute( newAttr ); if ( !st ) { return false; } interpPlug = fnMesh.findPlug( "ieMeshInterpolation", &st ); if ( !st ) { return false; } } st = interpPlug.setValue( interpolationValue ); if ( !st ) { return false; } return true; }
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 asMicrofacet_brdf::initialize() { MFnNumericAttribute nAttr; MFnLightDataAttribute lAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; 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. // //---------------------------- automatically created attributes start ------------------------------------ reflectance = nAttr.createColor("reflectance", "reflectance"); nAttr.setDefault(0.5,0.5,0.5); CHECK_MSTATUS(addAttribute( reflectance )); mdf = eAttr.create("mdf", "mdf", 1, &status); status = eAttr.addField( "beckmann", 0 ); status = eAttr.addField( "blinn", 1 ); status = eAttr.addField( "ggx", 2 ); status = eAttr.addField( "ward", 3 ); CHECK_MSTATUS(addAttribute( mdf )); glossiness_multiplier = nAttr.create("glossiness_multiplier", "glossiness_multiplier", MFnNumericData::kFloat, 1.0); CHECK_MSTATUS(addAttribute( glossiness_multiplier )); glossiness = nAttr.create("glossiness", "glossiness", MFnNumericData::kFloat, 0.5); CHECK_MSTATUS(addAttribute( glossiness )); fresnel_multiplier = nAttr.create("fresnel_multiplier", "fresnel_multiplier", MFnNumericData::kFloat, 1.0); CHECK_MSTATUS(addAttribute( fresnel_multiplier )); reflectance_multiplier = nAttr.create("reflectance_multiplier", "reflectance_multiplier", MFnNumericData::kFloat, 1.0); CHECK_MSTATUS(addAttribute( reflectance_multiplier )); //---------------------------- automatically created attributes end ------------------------------------ // Input Attributes // aTranslucenceCoeff = nAttr.create( "translucenceCoeff", "tc", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setKeyable( true ) ); CHECK_MSTATUS( nAttr.setStorable( true ) ); CHECK_MSTATUS( nAttr.setDefault( 0.0f ) ); aDiffuseReflectivity = nAttr.create( "diffuseReflectivity", "drfl", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setKeyable( true ) ); CHECK_MSTATUS( nAttr.setStorable( true ) ); CHECK_MSTATUS( nAttr.setDefault( 0.8f ) ); aColor = nAttr.createColor( "color", "c", &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setKeyable( true ) ); CHECK_MSTATUS( nAttr.setStorable( true ) ); CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.58824f, 0.644f ) ); aIncandescence = nAttr.createColor( "incandescence", "ic", &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setKeyable( true ) ); CHECK_MSTATUS( nAttr.setStorable( true ) ); CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.0f, 0.0f ) ); aInTransparency = nAttr.createColor( "transparency", "it", &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setKeyable( true ) ); CHECK_MSTATUS( nAttr.setStorable( true ) ); CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.0f, 0.0f ) ); // Color Output // aOutColor = nAttr.createColor( "outColor", "oc", &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setHidden( false ) ); CHECK_MSTATUS( nAttr.setReadable( true ) ); CHECK_MSTATUS( nAttr.setWritable( false ) ); aOutTransparency = nAttr.createColor( "outTransparency", "ot", &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setHidden( false ) ); CHECK_MSTATUS( nAttr.setReadable( true ) ); CHECK_MSTATUS( nAttr.setWritable( false ) ); // Camera Normals // aNormalCameraX = nAttr.create( "normalCameraX", "nx", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setStorable( false ) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aNormalCameraY = nAttr.create( "normalCameraY", "ny", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setStorable( false ) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aNormalCameraZ = nAttr.create( "normalCameraZ", "nz", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setStorable( false ) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aNormalCamera = nAttr.create( "normalCamera","n", aNormalCameraX, aNormalCameraY, aNormalCameraZ, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( nAttr.setStorable( false ) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) ); CHECK_MSTATUS( nAttr.setHidden( true ) ); // Light Direction // aLightDirectionX = nAttr.create( "lightDirectionX", "ldx", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aLightDirectionY = nAttr.create( "lightDirectionY", "ldy", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aLightDirectionZ = nAttr.create( "lightDirectionZ", "ldz", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aLightDirection = nAttr.create( "lightDirection", "ld", aLightDirectionX, aLightDirectionY, aLightDirectionZ, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) ); // Light Intensity // aLightIntensityR = nAttr.create( "lightIntensityR", "lir", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aLightIntensityG = nAttr.create( "lightIntensityG", "lig", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aLightIntensityB = nAttr.create( "lightIntensityB", "lib", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aLightIntensity = nAttr.create( "lightIntensity", "li", aLightIntensityR, aLightIntensityG, aLightIntensityB, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) ); // Light // aLightAmbient = nAttr.create( "lightAmbient", "la", MFnNumericData::kBoolean, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( true ) ); aLightDiffuse = nAttr.create( "lightDiffuse", "ldf", MFnNumericData::kBoolean, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( true ) ); aLightSpecular = nAttr.create( "lightSpecular", "ls", MFnNumericData::kBoolean, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( false ) ); aLightShadowFraction = nAttr.create( "lightShadowFraction", "lsf", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aPreShadowIntensity = nAttr.create( "preShadowIntensity", "psi", MFnNumericData::kFloat, 0, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS( nAttr.setDefault( 1.0f ) ); aLightBlindData = nAttr.createAddr( "lightBlindData", "lbld", &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); aLightData = lAttr.create( "lightDataArray", "ltd", aLightDirection, aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular, aLightShadowFraction, aPreShadowIntensity, aLightBlindData, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( lAttr.setArray( true ) ); CHECK_MSTATUS( lAttr.setStorable( false ) ); CHECK_MSTATUS( lAttr.setHidden( true ) ); CHECK_MSTATUS( lAttr.setDefault( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, true, false, 1.0f, 1.0f, NULL ) ); // Next we will add the attributes we have defined to the node // CHECK_MSTATUS( addAttribute( aTranslucenceCoeff ) ); CHECK_MSTATUS( addAttribute( aDiffuseReflectivity ) ); CHECK_MSTATUS( addAttribute( aColor ) ); CHECK_MSTATUS( addAttribute( aIncandescence ) ); CHECK_MSTATUS( addAttribute( aInTransparency ) ); CHECK_MSTATUS( addAttribute( aOutColor ) ); CHECK_MSTATUS( addAttribute( aOutTransparency ) ); CHECK_MSTATUS( addAttribute( aNormalCamera ) ); // Only add the parent of the compound CHECK_MSTATUS( addAttribute( aLightData ) ); // 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( aTranslucenceCoeff, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aDiffuseReflectivity, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aColor, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aInTransparency, aOutTransparency ) ); CHECK_MSTATUS( attributeAffects( aInTransparency, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aIncandescence, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightIntensityR, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightIntensityB, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightIntensityG, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightIntensity, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aNormalCameraX, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aNormalCameraY, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aNormalCameraZ, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aNormalCamera, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightDirectionX, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightDirectionY, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightDirectionZ, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightDirection, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightAmbient, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightSpecular, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightDiffuse, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightShadowFraction, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aPreShadowIntensity, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightBlindData, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aLightData, aOutColor ) ); return( MS::kSuccess ); }
MStatus collisionShapeNode::initialize() { MStatus status; MFnMessageAttribute fnMsgAttr; MFnNumericAttribute fnNumericAttr; MFnEnumAttribute fnEnumAttr; ia_type = fnEnumAttr.create("type", "tp", 7, &status); MCHECKSTATUS(status, "creating type attribute") fnEnumAttr.addField("Convex Hull", 0); fnEnumAttr.addField("Mesh", 1); fnEnumAttr.addField("Cylinder", 2); fnEnumAttr.addField("Capsule", 3); fnEnumAttr.addField("Box", 4); fnEnumAttr.addField("Sphere", 5); fnEnumAttr.addField("Plane", 6); fnEnumAttr.addField("BvhMesh", 7); fnEnumAttr.addField("HACD", 8); fnEnumAttr.setKeyable(true); status = addAttribute(ia_type); MCHECKSTATUS(status, "adding type attribute") ia_scale = fnNumericAttr.createPoint("scale", "sc", &status); MCHECKSTATUS(status, "creating ia_scale attribute") fnNumericAttr.setDefault(1.0, 1.0, 1.0); fnNumericAttr.setKeyable(true); status = addAttribute(ia_scale); MCHECKSTATUS(status, "adding ia_scale attribute") oa_collisionShape = fnMsgAttr.create("outCollisionShape", "oucs", &status); MCHECKSTATUS(status, "creating outCollisionShape attribute") status = addAttribute(oa_collisionShape); MCHECKSTATUS(status, "adding outCollisionShape attribute") ia_shape = fnMsgAttr.create("inShape", "insh", &status); MCHECKSTATUS(status, "creating inShape attribute") status = addAttribute(ia_shape); MCHECKSTATUS(status, "adding inShape attribute") ca_collisionShape = fnNumericAttr.create("ca_collisionShape", "ccs", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_collisionShape attribute") fnNumericAttr.setWorldSpace(true); fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_collisionShape); MCHECKSTATUS(status, "adding ca_collisionShape attribute") ca_collisionShapeParam = fnNumericAttr.create("collisionShapeParam", "cspm", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_collisionShapeParam attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_collisionShapeParam); MCHECKSTATUS(status, "adding ca_collisionShapeParam attribute") // status = attributeAffects(ia_shape, oa_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, oa_collisionShape)") status = attributeAffects(ia_type, oa_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_type, oa_collisionShape)") status = attributeAffects(ia_scale, oa_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_scale, oa_collisionShape)") // status = attributeAffects(ia_shape, ca_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, ca_collisionShape)") status = attributeAffects(ia_type, ca_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, ca_collisionShape)") // status = attributeAffects(ia_shape, ca_collisionShapeParam); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, oa_collisionShapeParam)") status = attributeAffects(ia_scale, ca_collisionShapeParam); MCHECKSTATUS(status, "adding attributeAffects(ia_scale, oa_collisionShapeParam)") status = attributeAffects(ia_type, ca_collisionShapeParam); MCHECKSTATUS(status, "adding attributeAffects(ia_type, oa_collisionShapeParam)") return MS::kSuccess; }