MStatus ParameterisedHolder<B>::initialize() { MStatus s; MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; aParameterisedClassName = tAttr.create( "className", "clas", MFnData::kString ); tAttr.setReadable(true); tAttr.setWritable(true); tAttr.setStorable(true); tAttr.setConnectable(false); tAttr.setHidden(true); s = B::addAttribute( aParameterisedClassName ); assert(s); aParameterisedVersion = nAttr.create("version", "ver", MFnNumericData::kInt, 1, &s ); assert(s); nAttr.setReadable(true); nAttr.setWritable(true); nAttr.setStorable(true); nAttr.setConnectable(false); nAttr.setHidden(true); s = B::addAttribute( aParameterisedVersion ); assert(s); aParameterisedSearchPathEnvVar = tAttr.create("searchPathEnvVar", "spev", MFnData::kString ); tAttr.setReadable(true); tAttr.setWritable(true); tAttr.setStorable(true); tAttr.setConnectable(false); tAttr.setHidden(true); s = B::addAttribute( aParameterisedSearchPathEnvVar ); assert(s); MPxManipContainer::addToManipConnectTable( id ); return MS::kSuccess; }
MStatus DucttapeMergeDeformer::initialize() { MStatus stat; MFnNumericAttribute numericFn; MFnTypedAttribute typedAttrFn; ainmesh = typedAttrFn.create("inMesh", "inm", MFnData::kMesh); typedAttrFn.setStorable(false); typedAttrFn.setWritable(true); typedAttrFn.setConnectable(true); addAttribute( ainmesh ); attributeAffects(ainmesh, outputGeom); MGlobal::executeCommand( "makePaintable -attrType multiFloat -sm deformer ducttapeMergeDeformer weights" ); return MS::kSuccess; }
MStatus TestDeformer::initialize() { MFnNumericAttribute numericAttr; MFnTypedAttribute polyMeshAttr; MFnEnumAttribute enumAttr; MStatus status; // Status will be used to hold the MStatus value // vertSnapInput driver_mesh = polyMeshAttr.create( "vertSnapInput", "vsnpin", MFnData::kMesh, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( polyMeshAttr.setStorable( false ) ); CHECK_MSTATUS( polyMeshAttr.setArray(true) ); CHECK_MSTATUS( polyMeshAttr.setConnectable( true ) ); CHECK_MSTATUS( addAttribute(driver_mesh) ); CHECK_MSTATUS( attributeAffects(driver_mesh, outputGeom) ); // initialize is used to mark this node's state initialized_data = enumAttr.create( "initialize", "inl", 0/*default*/, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( enumAttr.addField( "Off", 0) ); CHECK_MSTATUS( enumAttr.addField( "Re-Set Bind", 1) ); CHECK_MSTATUS( enumAttr.addField( "Bound", 2) ); CHECK_MSTATUS( enumAttr.setKeyable(true) ); CHECK_MSTATUS( enumAttr.setStorable(true) ); CHECK_MSTATUS( enumAttr.setReadable(true) ); CHECK_MSTATUS( enumAttr.setWritable(true) ); CHECK_MSTATUS( enumAttr.setDefault(0) ); CHECK_MSTATUS( addAttribute( initialized_data ) ); CHECK_MSTATUS( attributeAffects( initialized_data, outputGeom ) ); // hold the vertex index mapping vert_map = numericAttr.create( "vtxIndexMap", "vtximp", MFnNumericData::kLong, 0/*default*/, &status ); CHECK_MSTATUS( status ); CHECK_MSTATUS( numericAttr.setKeyable(false) ); CHECK_MSTATUS( numericAttr.setArray(true) ); CHECK_MSTATUS( numericAttr.setStorable(true) ); CHECK_MSTATUS( numericAttr.setReadable(true) ); CHECK_MSTATUS( numericAttr.setWritable(true) ); CHECK_MSTATUS( addAttribute( vert_map ) ); CHECK_MSTATUS( attributeAffects( vert_map, outputGeom ) ); CHECK_MSTATUS( MGlobal::executePythonCommand("import maya.cmds; maya.cmds.makePaintable('"+TestDeformer::cTypeName()+"', 'weights', attrType='multiFloat')") ); return( MS::kSuccess ); }
//---------------------------------------------------------------------------- MStatus BPT_InsertVtx::initialize() //---------------------------------------------------------------------------- { MFnEnumAttribute FnEnumAttr; MFnTypedAttribute FnTypedAttr; MFnNumericAttribute FnFloatAttr; MStatus status; IVinMesh = FnTypedAttr.create("inMesh","in",MFnData::kMesh); FnTypedAttr.setStorable(true); //FnTypedAttr.setCached(false); FnTypedAttr.setInternal(true); IVoutMesh = FnTypedAttr.create("outMesh","out",MFnData::kMesh); FnTypedAttr.setStorable(true); FnTypedAttr.setWritable(false); IVcount = FnFloatAttr.create("count","c",MFnNumericData::kLong); FnFloatAttr.setStorable(true); FnFloatAttr.setInternal(true); FnFloatAttr.setKeyable(true); FnFloatAttr.setMin(1); FnFloatAttr.setSoftMax(15); IVselEdgeIDs = FnTypedAttr.create("edgeIDs","eID",MFnData::kIntArray); FnTypedAttr.setStorable(true); FnTypedAttr.setHidden(true); FnTypedAttr.setConnectable(false); IVselVertIDs = FnTypedAttr.create("vertIDs","vID",MFnData::kIntArray); FnTypedAttr.setStorable(true); FnTypedAttr.setHidden(true); FnTypedAttr.setConnectable(false); IVoptions = FnTypedAttr.create("options","op",MFnData::kIntArray); FnTypedAttr.setStorable(true); FnTypedAttr.setHidden(true); FnTypedAttr.setConnectable(false); IVslide = FnFloatAttr.create("slide","sl",MFnNumericData::kDouble); FnFloatAttr.setStorable(true); FnFloatAttr.setInternal(true); // FnFloatAttr.setMin(0.0); // FnFloatAttr.setMax(1.0); FnFloatAttr.setKeyable(true); IVnormal = FnFloatAttr.create("alongNormal","an",MFnNumericData::kDouble); FnFloatAttr.setStorable(true); FnFloatAttr.setDefault(0.0); FnFloatAttr.setKeyable(true); IVslideRelative = FnFloatAttr.create("slideRelative","sr",MFnNumericData::kLong); FnFloatAttr.setStorable(true); FnFloatAttr.setMin(0.0); FnFloatAttr.setMax(1.0); FnFloatAttr.setKeyable(true); IVnormalRelative = FnFloatAttr.create("normalRelative","nr",MFnNumericData::kLong); FnFloatAttr.setStorable(true); FnFloatAttr.setMin(0.0); FnFloatAttr.setMax(1.0); FnFloatAttr.setKeyable(true); IVwhichSide = FnFloatAttr.create("side","si",MFnNumericData::kLong); FnFloatAttr.setStorable(true); FnFloatAttr.setMin(0.0); FnFloatAttr.setMax(1.0); FnFloatAttr.setKeyable(true); IVSlideLimited = FnFloatAttr.create("slideLimited","sll",MFnNumericData::kLong); FnFloatAttr.setStorable(true); FnFloatAttr.setMin(0.0); FnFloatAttr.setMax(1.0); FnFloatAttr.setKeyable(false); IVspin = FnFloatAttr.create("spin","sp",MFnNumericData::kLong); FnFloatAttr.setStorable(true); FnFloatAttr.setMin(0.0); FnFloatAttr.setKeyable(true); FnFloatAttr.setInternal(true); // Add attributes status = addAttribute(IVslideRelative); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVnormalRelative); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVwhichSide); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVnormal); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVslide); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVSlideLimited); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVoptions); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVspin); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVcount); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVselEdgeIDs); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVselVertIDs); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVoutMesh); MCheckStatus(status, "AddAttrIVNode"); status = addAttribute(IVinMesh); MCheckStatus(status, "AddAttrIVNode"); // Add attribute affects status = attributeAffects( IVspin, IVoutMesh ); MCheckStatus(status, "AddAttrAffectsIVNode"); status = attributeAffects( IVcount, IVoutMesh ); MCheckStatus(status, "AddAttrAffectsIVNode"); status = attributeAffects( IVinMesh, IVoutMesh ); MCheckStatus(status, "AddAttrAffectsIVNode"); status = attributeAffects( IVslide, IVoutMesh); MCheckStatus(status, "AddAttrAffectsIVNode"); status = attributeAffects( IVslideRelative, IVoutMesh); MCheckStatus(status, "AddAttrAffectsIVNode"); status = attributeAffects( IVnormalRelative, IVoutMesh); MCheckStatus(status, "AddAttrAffectsIVNode"); status = attributeAffects( IVwhichSide, IVoutMesh); MCheckStatus(status, "AddAttrAffectsIVNode"); status = attributeAffects( IVnormal, IVoutMesh); MCheckStatus(status, "AddAttrAffectsIVNode"); // Zuletzt die SoftTransformationAttribute hinzufuegen // Per Macro - dirty, aber funktioniert - wie machen die ALIAS Typen das ??? Die leiten auch stuendig von einer BaseNode ab, und da gehen dann keine Attribute flueten // Oder werden unbrauchbar so wie bei mir, so dass im Endeffekt suemtliche Attribute ein eindeutiges statisches Attribut haben muessen STE_ADD_ATTRIBUTES(IV) return status; }
MStatus ProxyViz::initialize() { MFnNumericAttribute numFn; MStatus stat; alodgatehigh = numFn.create( "lodGateMax", "ldmx", MFnNumericData::kFloat, 1.f); numFn.setKeyable(true); numFn.setStorable(true); numFn.setMin(0.001f); numFn.setMax(2.f); addAttribute(alodgatehigh); alodgatelow = numFn.create( "lodGateMin", "ldmin", MFnNumericData::kFloat, 0.f); numFn.setKeyable(true); numFn.setStorable(true); numFn.setMin(0.f); numFn.setMax(0.999f); addAttribute(alodgatelow); abboxminx = numFn.create( "bBoxMinX", "bbmnx", MFnNumericData::kFloat, -1.f ); numFn.setKeyable(true); numFn.setStorable(true); addAttribute(abboxminx); abboxminy = numFn.create( "bBoxMinY", "bbmny", MFnNumericData::kFloat, -1.f ); numFn.setKeyable(true); numFn.setStorable(true); addAttribute(abboxminy); abboxminz = numFn.create( "bBoxMinZ", "bbmnz", MFnNumericData::kFloat, -1.f ); numFn.setKeyable(true); numFn.setStorable(true); addAttribute(abboxminz); abboxmaxx = numFn.create( "bBoxMaxX", "bbmxx", MFnNumericData::kFloat, 1.f ); numFn.setKeyable(true); numFn.setStorable(true); addAttribute(abboxmaxx); abboxmaxy = numFn.create( "bBoxMaxY", "bbmxy", MFnNumericData::kFloat, 1.f); numFn.setKeyable(true); numFn.setStorable(true); addAttribute(abboxmaxy); abboxmaxz = numFn.create( "bBoxMaxZ", "bbmxz", MFnNumericData::kFloat, 1.f); numFn.setKeyable(true); numFn.setStorable(true); addAttribute(abboxmaxz); aradiusMult = numFn.create( "radiusMultiplier", "rml", MFnNumericData::kFloat); numFn.setStorable(true); numFn.setKeyable(true); numFn.setDefault(1.f); numFn.setMin(.05f); addAttribute(aradiusMult); axmultiplier = numFn.create( "visualMultiplierX", "vmx", MFnNumericData::kFloat, 1.f); numFn.setKeyable(true); numFn.setStorable(true); numFn.setMin(0.001f); addAttribute(axmultiplier); aymultiplier = numFn.create( "visualMultiplierY", "vmy", MFnNumericData::kFloat, 1.f); numFn.setKeyable(true); numFn.setStorable(true); numFn.setMin(0.001f); addAttribute(aymultiplier); azmultiplier = numFn.create( "visualMultiplierZ", "vmz", MFnNumericData::kFloat, 1.f); numFn.setKeyable(true); numFn.setStorable(true); numFn.setMin(0.001f); addAttribute(azmultiplier); agroupcount = numFn.create( "numberInstances", "nis", MFnNumericData::kInt, 1); numFn.setKeyable(false); numFn.setStorable(true); numFn.setMin(1); addAttribute(agroupcount); ainstanceId = numFn.create( "instanceId", "iis", MFnNumericData::kInt, 0); numFn.setKeyable(false); numFn.setStorable(true); numFn.setMin(0); addAttribute(ainstanceId); MFnTypedAttribute typedAttrFn; MVectorArray defaultVectArray; MFnVectorArrayData vectArrayDataFn; vectArrayDataFn.create( defaultVectArray ); outPositionPP = typedAttrFn.create( "outPosition", "opos", MFnData::kVectorArray, vectArrayDataFn.object(), &stat ); if(!stat) MGlobal::displayWarning("failed create pospp"); typedAttrFn.setStorable(false); if(addAttribute( outPositionPP ) != MS::kSuccess) MGlobal::displayWarning("failed add pospp"); outScalePP = typedAttrFn.create( "outScale", "oscl", MFnData::kVectorArray, vectArrayDataFn.object(), &stat ); if(!stat) MGlobal::displayWarning("failed create sclpp"); typedAttrFn.setStorable(false); if(addAttribute(outScalePP) != MS::kSuccess) MGlobal::displayWarning("failed add sclpp"); outRotationPP = typedAttrFn.create( "outRotation", "orot", MFnData::kVectorArray, vectArrayDataFn.object(), &stat ); if(!stat) MGlobal::displayWarning("failed create rotpp"); typedAttrFn.setStorable(false); if(addAttribute(outRotationPP) != MS::kSuccess) MGlobal::displayWarning("failed add rotpp"); MDoubleArray defaultDArray; MFnDoubleArrayData dArrayDataFn; dArrayDataFn.create( defaultDArray ); outReplacePP = typedAttrFn.create( "outReplace", "orpl", MFnData::kDoubleArray, dArrayDataFn.object(), &stat ); if(stat != MS::kSuccess) { MGlobal::displayWarning("failed create outReplace"); } typedAttrFn.setStorable(false); stat = addAttribute(outReplacePP); if(stat != MS::kSuccess) { MGlobal::displayWarning("failed add outReplace"); } outValue = numFn.create( "outValue", "ov", MFnNumericData::kFloat ); numFn.setStorable(false); numFn.setWritable(false); addAttribute(outValue); outValue1 = numFn.create( "outValue1", "ov1", MFnNumericData::kFloat ); numFn.setStorable(false); numFn.setWritable(false); addAttribute(outValue1); MFnTypedAttribute stringAttr; acachename = stringAttr.create( "cachePath", "cp", MFnData::kString ); stringAttr.setStorable(true); addAttribute( acachename ); astandinNames = stringAttr.create( "standinNames", "sdn", MFnData::kString ); stringAttr.setStorable(true); stringAttr.setArray(true); addAttribute(astandinNames); MFnMatrixAttribute matAttr; acameraspace = matAttr.create( "cameraSpace", "cspc", MFnMatrixAttribute::kDouble ); matAttr.setStorable(false); matAttr.setWritable(true); matAttr.setConnectable(true); addAttribute(acameraspace); ahapeture = numFn.create( "horizontalFilmAperture", "hfa", MFnNumericData::kDouble, 1.0 ); numFn.setStorable(false); numFn.setConnectable(true); addAttribute( ahapeture ); avapeture = numFn.create( "verticalFilmAperture", "vfa", MFnNumericData::kDouble, 1.0 ); numFn.setStorable(false); numFn.setConnectable(true); addAttribute( avapeture ); afocallength = numFn.create( "focalLength", "fl", MFnNumericData::kDouble ); numFn.setStorable(false); numFn.setConnectable(true); addAttribute( afocallength ); aconvertPercentage = numFn.create( "convertPercentage", "cvp", MFnNumericData::kDouble ); numFn.setStorable(false); numFn.setConnectable(true); numFn.setDefault(1.0); numFn.setMax(1.0); numFn.setMin(0.01); addAttribute(aconvertPercentage); agroundMesh = typedAttrFn.create("groundMesh", "grdm", MFnMeshData::kMesh); typedAttrFn.setStorable(false); typedAttrFn.setWritable(true); typedAttrFn.setConnectable(true); typedAttrFn.setArray(true); typedAttrFn.setDisconnectBehavior(MFnAttribute::kDelete); addAttribute( agroundMesh ); attributeAffects(agroundMesh, outValue); agroundSpace = matAttr.create("groundSpace", "grdsp", MFnMatrixAttribute::kDouble); matAttr.setStorable(false); matAttr.setWritable(true); matAttr.setConnectable(true); matAttr.setArray(true); matAttr.setDisconnectBehavior(MFnAttribute::kDelete); addAttribute( agroundSpace ); attributeAffects(agroundSpace, outValue); MPointArray defaultPntArray; MFnPointArrayData pntArrayDataFn; pntArrayDataFn.create( defaultPntArray ); aplantTransformCache = typedAttrFn.create( "transformCachePlant", "tmcpl", MFnData::kPointArray, pntArrayDataFn.object(), &stat ); typedAttrFn.setStorable(true); addAttribute(aplantTransformCache); MIntArray defaultIntArray; MFnIntArrayData intArrayDataFn; intArrayDataFn.create( defaultIntArray ); aplantIdCache = typedAttrFn.create( "idCachePlant", "idcpl", MFnData::kIntArray, intArrayDataFn.object(), &stat ); typedAttrFn.setStorable(true); addAttribute(aplantIdCache); aplantTriangleIdCache = typedAttrFn.create( "triCachePlant", "trcpl", MFnData::kIntArray, intArrayDataFn.object(), &stat ); typedAttrFn.setStorable(true); addAttribute(aplantTriangleIdCache); aplantTriangleCoordCache = typedAttrFn.create( "coordCachePlant", "crcpl", MFnData::kVectorArray, vectArrayDataFn.object(), &stat ); typedAttrFn.setStorable(true); addAttribute(aplantTriangleCoordCache); aplantOffsetCache = typedAttrFn.create( "offsetCachePlant", "otcpl", MFnData::kVectorArray, vectArrayDataFn.object(), &stat ); typedAttrFn.setStorable(true); addAttribute(aplantOffsetCache); ainexamp = typedAttrFn.create("inExample", "ixmp", MFnData::kPlugin); typedAttrFn.setStorable(false); typedAttrFn.setConnectable(true); typedAttrFn.setArray(true); addAttribute(ainexamp); adisplayVox = numFn.create( "showVoxelThreshold", "svt", MFnNumericData::kFloat ); numFn.setDefault(1.0); numFn.setMin(.7); numFn.setMax(1.0); numFn.setStorable(true); numFn.setKeyable(true); addAttribute(adisplayVox); acheckDepth = numFn.create( "checkDepth", "cdp", MFnNumericData::kBoolean ); numFn.setDefault(0); numFn.setStorable(false); addAttribute(acheckDepth); ainoverscan = numFn.create( "cameraOverscan", "cos", MFnNumericData::kDouble ); numFn.setDefault(1.33); numFn.setStorable(false); addAttribute(ainoverscan); aactivated = numFn.create( "activated", "act", MFnNumericData::kBoolean ); numFn.setDefault(0); numFn.setStorable(false); addAttribute(aactivated); attributeAffects(ainexamp, outValue1); attributeAffects(aradiusMult, outValue1); attributeAffects(abboxminx, outValue); attributeAffects(abboxmaxx, outValue); attributeAffects(abboxminy, outValue); attributeAffects(abboxmaxy, outValue); attributeAffects(abboxminz, outValue); attributeAffects(abboxmaxz, outValue); attributeAffects(outPositionPP, outValue); return MS::kSuccess; }
// DESCRIPTION: // MStatus PtexColorNode::initialize() { MStatus status; MFnNumericAttribute numericAttribute; // Input attributes MFnTypedAttribute fileNameAttribute; aPtexFileName = fileNameAttribute.create( "ptexFileName", "f", MFnData::kString ); MAKE_INPUT( fileNameAttribute ); fileNameAttribute.setConnectable(false); MFnEnumAttribute enumAttribute; aPtexFilterType = enumAttribute.create( "ptexFilterType", "t", 0, &status ); MCHECKERROR( status, "create filterType attribute" ); enumAttribute.addField( "Point", 0 ); enumAttribute.addField( "Bilinear", 1 ); enumAttribute.addField( "Box", 2 ); enumAttribute.addField( "Gaussian", 3 ); enumAttribute.addField( "Bicubic", 4 ); enumAttribute.addField( "BSpline", 5 ); enumAttribute.addField( "CatmullRom", 6 ); enumAttribute.addField( "Mitchell", 7 ); enumAttribute.setHidden( false ); MAKE_INPUT( enumAttribute ); enumAttribute.setConnectable(false); MCHECKERROR( status, "Error adding shapeType attribute." ); MFnNumericAttribute filterSizeAttribute; aPtexFilterSize = filterSizeAttribute.create( "ptexFilterSize", "s", MFnNumericData::kFloat, 1.0 ); MAKE_INPUT( filterSizeAttribute ); filterSizeAttribute.setConnectable(false); // Implicit shading network attributes MObject child1 = numericAttribute.create( "uCoord", "u", MFnNumericData::kFloat); MObject child2 = numericAttribute.create( "vCoord", "v", MFnNumericData::kFloat); aUVPos = numericAttribute.create( "uvCoord", "uv", child1, child2); MAKE_INPUT( numericAttribute ); CHECK_MSTATUS( numericAttribute.setHidden(true) ); child1 = numericAttribute.create( "uvFilterSizeX", "fsx", MFnNumericData::kFloat); child2 = numericAttribute.create( "uvFilterSizeY", "fsy", MFnNumericData::kFloat); aUVSize = numericAttribute.create( "uvFilterSize", "fs", child1, child2 ); MAKE_INPUT( numericAttribute ); CHECK_MSTATUS( numericAttribute.setHidden(true) ); // Output attributes aOutColor = numericAttribute.createColor("outColor", "oc"); MAKE_OUTPUT(numericAttribute); // Add attributes to the node database. CHECK_MSTATUS( addAttribute(aPtexFileName) ); CHECK_MSTATUS( addAttribute(aPtexFilterType) ); CHECK_MSTATUS( addAttribute(aPtexFilterSize) ); CHECK_MSTATUS( addAttribute(aUVPos) ); CHECK_MSTATUS( addAttribute(aUVSize) ); CHECK_MSTATUS( addAttribute(aOutColor) ); // All input affect the output color CHECK_MSTATUS( attributeAffects( aPtexFileName, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aPtexFilterSize, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aPtexFilterType, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aUVPos, aOutColor ) ); CHECK_MSTATUS( attributeAffects( aUVSize, aOutColor ) ); return MS::kSuccess; }
MStatus puttyNode::initialize() { MStatus status; MFnNumericAttribute nAttr; MFnEnumAttribute eAttr; MFnTypedAttribute tAttr; MFnMatrixAttribute mAttr; // the script aScript = tAttr.create( "script", "scr", MFnData::kString); tAttr.setStorable(true); tAttr.setKeyable(false); SYS_ERROR_CHECK( addAttribute( aScript ), "adding aScript" ); aCmdBaseName = tAttr.create( "cmdBaseName", "cbn", MFnData::kString); tAttr.setStorable(true); tAttr.setKeyable(false); tAttr.setHidden(true); SYS_ERROR_CHECK( addAttribute( aCmdBaseName ), "adding aCmdBaseName" ); // refresh aSource = nAttr.create( "source", "src", MFnNumericData::kBoolean, 0 ); nAttr.setHidden(true); SYS_ERROR_CHECK( addAttribute( aSource ), "adding aSource" ); // it is important that script sourced is initialised false and not storable // so this way the function gets sourced on maya startup aScriptSourced = nAttr.create( "scriptSourced", "ssrc", MFnNumericData::kBoolean, 0 ); nAttr.setStorable(false); nAttr.setHidden(true); SYS_ERROR_CHECK( addAttribute( aScriptSourced ), "adding aScriptSourced" ); aNodeReady = nAttr.create( "nodeReady", "nr", MFnNumericData::kBoolean, 0 ); nAttr.setHidden(true); SYS_ERROR_CHECK( addAttribute( aNodeReady ), "adding aNodeReady" ); aDynDirty = nAttr.create( "dynDirty", "dd", MFnNumericData::kBoolean, 0 ); nAttr.setHidden(true); SYS_ERROR_CHECK( addAttribute( aDynDirty ), "adding aDynDirty" ); // space aDefSpace = eAttr.create("deformerSpace", "dsp", MSD_SPACE_OBJECT, &status); eAttr.addField("object (default)", MSD_SPACE_OBJECT); eAttr.addField("world (automatic conversion)", MSD_SPACE_WORLD); eAttr.setKeyable(false); eAttr.setStorable(true); SYS_ERROR_CHECK( addAttribute( aDefSpace ), "adding aDefSpace" ); // envelope aDefEnvelope = eAttr.create("deformerEnvelope", "de", MSD_ENVELOPE_AUTO, &status); eAttr.addField("auto", MSD_ENVELOPE_AUTO); eAttr.addField("user", MSD_ENVELOPE_USER); eAttr.setKeyable(false); eAttr.setStorable(true); SYS_ERROR_CHECK( addAttribute( aDefEnvelope ), "adding aDefEnvelope" ); // weights aDefWeights = eAttr.create("deformerWeights", "dw", MSD_WEIGHTS_AUTO, &status); eAttr.addField("auto", MSD_WEIGHTS_AUTO); eAttr.addField("user", MSD_WEIGHTS_USER); eAttr.setKeyable(false); eAttr.setStorable(true); SYS_ERROR_CHECK( addAttribute( aDefWeights ), "adding aDefWeights" ); ///////////////////////////////////////////////////////////////////////////// // current values aCurrPosition = tAttr.create( "currentPosition", "cpos", MFnData::kVectorArray); tAttr.setStorable(false); tAttr.setKeyable(false); tAttr.setConnectable(false); tAttr.setWritable(false); SYS_ERROR_CHECK( addAttribute( aCurrPosition ), "adding aCurrPos" ); aCurrWeight = tAttr.create( "currentWeight", "cwgh", MFnData::kDoubleArray); tAttr.setStorable(false); tAttr.setKeyable(false); tAttr.setConnectable(false); tAttr.setWritable(false); SYS_ERROR_CHECK( addAttribute( aCurrWeight ), "adding aCurrWeight" ); aCurrMultiIndex = nAttr.create("currentMultiIndex","cmi",MFnNumericData::kInt); nAttr.setStorable(false); nAttr.setKeyable(false); nAttr.setConnectable(false); nAttr.setWritable(false); SYS_ERROR_CHECK( addAttribute( aCurrMultiIndex ), "adding aCurrMultiIndex" ); aCurrWorldMatrix = mAttr.create("currentWorldMatrix","cwm"); mAttr.setStorable(false); mAttr.setKeyable(false); mAttr.setConnectable(false); mAttr.setWritable(false); SYS_ERROR_CHECK( addAttribute( aCurrWorldMatrix ), "adding aCurrObjectName" ); /* aCurrGeometryName= tAttr.create( "currentGeometryName", "con", MFnData::kString); tAttr.setStorable(false); tAttr.setKeyable(false); tAttr.setConnectable(false); tAttr.setWritable(false); SYS_ERROR_CHECK( addAttribute( aCurrGeometryName ), "adding aCurrObjectName" ); */ aCurrGeometryType= tAttr.create( "currentGeometryType", "cot", MFnData::kString); tAttr.setStorable(false); tAttr.setKeyable(false); tAttr.setConnectable(false); tAttr.setWritable(false); SYS_ERROR_CHECK( addAttribute( aCurrGeometryType ), "adding aCurrGeometryType" ); ///////////////////////////////////////////////////////////////////////////// // affects attributeAffects( aScript ,aNodeReady); attributeAffects( aSource, aNodeReady ); attributeAffects( aScriptSourced, aNodeReady ); attributeAffects( aScript,aScriptSourced); attributeAffects( aSource,aScriptSourced); attributeAffects( aScriptSourced, outputGeom ); attributeAffects( aDynDirty,outputGeom ); attributeAffects( aNodeReady,outputGeom ); attributeAffects( aScript ,outputGeom); attributeAffects( aCmdBaseName ,outputGeom); attributeAffects( aSource ,outputGeom ); attributeAffects( aDefSpace, outputGeom ); attributeAffects( aDefWeights,outputGeom); attributeAffects( aDefEnvelope,outputGeom ); return MS::kSuccess; }
MStatus VmIslandNode::initialize() { fprintf( stderr, "VmIslandNode::initialize()...\n" ); MStatus status; //Seed attribute { MFnNumericAttribute numericAttrFn; ia_seed = numericAttrFn.create( "seed", "sD", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 1000 ); numericAttrFn.setDefault ( 0 ); status = addAttribute( ia_seed ); CHECK_MSTATUS( status ); } //Roughness attribute { MFnNumericAttribute numericAttrFn; ia_roughness = numericAttrFn.create( "roughness", "rG", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 1 ); numericAttrFn.setDefault ( 0.75 ); status = addAttribute( ia_roughness ); CHECK_MSTATUS( status ); } //Plane Height attribute { MFnNumericAttribute numericAttrFn; ia_planeHeight = numericAttrFn.create( "planeHeight", "pH", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 2000 ); numericAttrFn.setDefault ( 5 ); status = addAttribute( ia_planeHeight ); CHECK_MSTATUS( status ); } //Plane smoothing attribute { MFnNumericAttribute numericAttrFn; ia_smooth = numericAttrFn.create( "smoothingStrength", "sS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 6 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_smooth ); CHECK_MSTATUS( status ); } //Plane resolution attribute { MFnNumericAttribute numericAttrFn; ia_resolution = numericAttrFn.create( "mayaResolution", "mR", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 10 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_resolution ); CHECK_MSTATUS( status ); } //Renderman resolution attribute { MFnNumericAttribute numericAttrFn; ia_rmanResolution = numericAttrFn.create( "rendermanResolution", "rR", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 10 ); numericAttrFn.setDefault ( 6 ); status = addAttribute( ia_rmanResolution ); CHECK_MSTATUS( status ); } //Plane size attribute { MFnNumericAttribute numericAttrFn; ia_planeSize = numericAttrFn.create( "planeSizeScale", "pS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 200 ); numericAttrFn.setDefault ( 20 ); status = addAttribute( ia_planeSize ); CHECK_MSTATUS( status ); } //Plane size attribute { MFnNumericAttribute numericAttrFn; ia_gridSize = numericAttrFn.create( "gridSize", "gS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 10 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_gridSize ); CHECK_MSTATUS( status ); } //Grass multiplier - Affects how many instances are spawned { MFnNumericAttribute numericAttrFn; ia_grassMultiplier = numericAttrFn.create( "grassInstanceMultiplier", "gM", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 100 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_grassMultiplier ); CHECK_MSTATUS( status ); } //Grass multiplier - Affects how many instances are spawned { MFnNumericAttribute numericAttrFn; ia_baseWidth = numericAttrFn.create( "grassBaseWidth", "bW", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.01f ); numericAttrFn.setMax( 2.0f ); numericAttrFn.setDefault ( 0.6f ); status = addAttribute( ia_baseWidth ); CHECK_MSTATUS( status ); } //Grass segment length - Length of segment pieces { MFnNumericAttribute numericAttrFn; ia_grassSegmentLength = numericAttrFn.create( "grassSegmentLength", "gSL", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.001f ); numericAttrFn.setMax( 10.0f ); numericAttrFn.setDefault ( 1.0f ); status = addAttribute( ia_grassSegmentLength ); CHECK_MSTATUS( status ); } //Number of segments per piece of grass { MFnNumericAttribute numericAttrFn; ia_grassNumSegments = numericAttrFn.create( "numberOfGrassSegments", "nGS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 3 ); numericAttrFn.setMax( 20 ); numericAttrFn.setDefault ( 5 ); status = addAttribute( ia_grassNumSegments ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_windDirection = numericAttrFn.createPoint( "windDirection", "wDir"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(1.0f, 0.0f, 1.0f); status = addAttribute( ia_windDirection ); CHECK_MSTATUS( status ); } //Grass bend factor { MFnNumericAttribute numericAttrFn; ia_grassBendAmount = numericAttrFn.create( "grassBendFactor", "gBF", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.0f ); numericAttrFn.setMax( 1.0f ); numericAttrFn.setDefault ( 0.0f ); status = addAttribute( ia_grassBendAmount ); CHECK_MSTATUS( status ); } //Wind strength { MFnNumericAttribute numericAttrFn; ia_windSpread = numericAttrFn.create( "windSpread", "wS", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.01f ); numericAttrFn.setMax( 10.0f ); numericAttrFn.setDefault ( 5.0f ); status = addAttribute( ia_windSpread ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassBaseColour1 = numericAttrFn.createColor( "grassBaseColour1", "bCol1"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.0f,0.251f,0.167f); status = addAttribute( ia_grassBaseColour1 ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassTipColour1 = numericAttrFn.createColor( "grassTipColour1", "tCol1"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.395f,0.551f,0.257f); status = addAttribute( ia_grassTipColour1 ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassBaseColour2 = numericAttrFn.createColor( "grassBaseColour2", "bCol2"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.275f,0.243f,0.043f); status = addAttribute( ia_grassBaseColour2 ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassTipColour2 = numericAttrFn.createColor( "grassTipColour2", "tCol2"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.611f,0.587f,0.257f); status = addAttribute( ia_grassTipColour2 ); CHECK_MSTATUS( status ); } //Clock attribute. Passes maya frame counter into node { MFnNumericAttribute numericAttrFn; ia_clock = numericAttrFn.create( "clock", "clk", MFnNumericData::kLong, false, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( false ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setDefault( 0 ); status = addAttribute( ia_clock ); CHECK_MSTATUS( status ); } // "drawStyle" // // How we should draw in Maya. // // We will use this value in our Maya plug-in, but we // will NOT use it in Renderman. Note elsewhere that // this value will not be sent to Renderman, nor will // it have any effect on RIB generation. // // We think of this as an input attribute - hence the // prefix "ia_" for "input attribute". { MFnEnumAttribute enumAttrFn; ia_drawStyle = enumAttrFn.create( "drawStyle", "ds", 1, & status ); CHECK_MSTATUS( status ); enumAttrFn.setReadable( true ); enumAttrFn.setWritable( true ); enumAttrFn.setStorable( true ); enumAttrFn.setKeyable( true ); enumAttrFn.setConnectable( true ); enumAttrFn.setHidden( false ); enumAttrFn.addField( "Bounds", 0 ); enumAttrFn.addField( "Sub bounds", 1 ); enumAttrFn.addField( "Geometry", 2 ); enumAttrFn.addField( "Terrain slope normals", 3 ); enumAttrFn.addField( "Point instances", 4 ); enumAttrFn.addField( "Wind Velocity", 5 ); enumAttrFn.addField( "All", 6 ); enumAttrFn.setDefault(3); status = addAttribute( ia_drawStyle ); CHECK_MSTATUS( status ); } // "update" // // A 'dummy' attribute, and a powerful one. Although // the value of this attribute is actually meaningless, // when we ask for it we trigger an important computation // processs. // // We think of this as an input attribute - hence the // prefix "oa_" for "computation attribute". This signifies // that we don't really care about it's final value, but // that we know it's going to compute a lot of stuff. { MFnNumericAttribute numericAttrFn; oa_update = numericAttrFn.create( "update", "upd", MFnNumericData::kBoolean, false, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( false ); numericAttrFn.setKeyable( false ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( true ); status = addAttribute( oa_update ); CHECK_MSTATUS( status ); } // "rib" // // A string which contains all the attributes, and that // we need to have (and indeed will see again) on the // Renderman side of things. // // We think of this as an output attribute - hence the // prefix "oa_" for "output attribute". The value // computed for this attribute (the string) is important, // an is used by whatever is asking for it. { MFnTypedAttribute typedAttrFn; oa_rib = typedAttrFn.create( "rib", "rb", MFnData::kString, MObject::kNullObj, & status ); CHECK_MSTATUS( status ); typedAttrFn.setReadable( true ); typedAttrFn.setWritable( true ); typedAttrFn.setStorable( false ); typedAttrFn.setKeyable( false ); typedAttrFn.setConnectable( true ); typedAttrFn.setHidden( true ); status = addAttribute( oa_rib ); CHECK_MSTATUS( status ); } // This section tells Maya what attribute effects // which attribute. When input attributes change, // make the attributes they effect "dirty". That // means that, when Maya asks for a dirty attribute, // it will need to be computed and "cleaned". // // Changing an effecting "input" attribute does not // trigger a computation of it's effected "output" // attribute. It just tells Maya that - if the effected // attribute is ever asked for, it will have to call // the compute method to calculate it. // // For complex relationships between attributes, // an attributeEffects() call must exist for each // relationship. If A effects B, and B effects C, // then we will need to make two attributeEffects() // calls - one for A effecting B and one for B // effecting C. Maya will not figure out that, if A // effects B, and B effets C, then A must effect C. // // Below we see that most "input" attributes effect // both our internal update and the rib generation // the same way in each case. But it's not always // exactly the same like this. // // Notice also that ia_drawStyle does not effect // any of the attributes. It's something that's just // used in the draw method. attributeAffects( ia_seed, oa_update ); attributeAffects( ia_seed, oa_rib ); attributeAffects( ia_roughness, oa_update ); attributeAffects( ia_roughness, oa_rib ); attributeAffects( ia_smooth, oa_update ); attributeAffects( ia_smooth, oa_rib ); attributeAffects( ia_planeHeight, oa_update ); attributeAffects( ia_planeHeight, oa_rib ); attributeAffects( ia_resolution, oa_update ); attributeAffects( ia_rmanResolution, oa_rib ); attributeAffects( ia_planeSize, oa_update ); attributeAffects( ia_planeSize, oa_rib ); attributeAffects( ia_gridSize, oa_update ); attributeAffects( ia_gridSize, oa_rib ); attributeAffects( ia_grassMultiplier, oa_update ); attributeAffects( ia_grassMultiplier, oa_rib ); attributeAffects( ia_baseWidth, oa_update ); attributeAffects( ia_baseWidth, oa_rib ); attributeAffects( ia_grassSegmentLength, oa_update ); attributeAffects( ia_grassSegmentLength, oa_rib ); attributeAffects( ia_grassNumSegments, oa_update ); attributeAffects( ia_grassNumSegments, oa_rib ); attributeAffects( ia_grassBendAmount, oa_update ); attributeAffects( ia_grassBendAmount, oa_rib ); attributeAffects( ia_windDirection, oa_update ); attributeAffects( ia_windDirection, oa_rib ); attributeAffects( ia_windSpread, oa_update ); attributeAffects( ia_windSpread, oa_rib ); attributeAffects( ia_clock, oa_update ); attributeAffects( ia_clock, oa_rib ); attributeAffects( ia_grassBaseColour1, oa_update); attributeAffects( ia_grassBaseColour1, oa_rib); attributeAffects( ia_grassTipColour1, oa_update); attributeAffects( ia_grassTipColour1, oa_rib); attributeAffects( ia_grassBaseColour2, oa_update); attributeAffects( ia_grassBaseColour2, oa_rib); attributeAffects( ia_grassTipColour2, oa_update); attributeAffects( ia_grassTipColour2, oa_rib); fprintf( stderr, "VmIslandNode::initialize() done\n" ); return MStatus::kSuccess; }
MStatus TCC::initialize() { MFnNumericAttribute numAttr; MFnTypedAttribute attrFn; MFnIntArrayData defaultIArrayDataFn; MFnDoubleArrayData defaultDArrayDataFn; MStatus stat; aRes = numAttr.create( "SubdivisionResolution", "res", MFnNumericData::kInt, 3 ); aRefRes = numAttr.create( "SubdivisionRefinementResolution", "refres", MFnNumericData::kInt, 0 ); aLineThickness = numAttr.create( "UVLineThickness", "th", MFnNumericData::kFloat, 0 ); aInputMesh = attrFn.create("inputMesh", "inMesh", MFnMeshData::kMesh); defaultIArrayDataFn.create( ); anFVc = attrFn.create("nFVcached", "nFVc", MFnData::kIntArray, defaultIArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); defaultIArrayDataFn.create( ); aFc = attrFn.create("Fcached", "Fc", MFnData::kIntArray, defaultIArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); defaultIArrayDataFn.create( ); aPole = attrFn.create("pole", "pole", MFnData::kIntArray, defaultIArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); defaultIArrayDataFn.create( ); aCorner = attrFn.create("corner", "corner", MFnData::kIntArray, defaultIArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); defaultIArrayDataFn.create( ); aT = attrFn.create("T", "T", MFnData::kIntArray, defaultIArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); defaultIArrayDataFn.create( ); aEqc = attrFn.create("eqc", "eqc", MFnData::kIntArray, defaultIArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); defaultDArrayDataFn.create( ); aItv = attrFn.create("itv", "itv", MFnData::kDoubleArray, defaultDArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); defaultIArrayDataFn.create( ); aErr = attrFn.create("err", "err", MFnData::kIntArray, defaultIArrayDataFn.object()); attrFn.setConnectable(false); attrFn.setStorable(true); aOutputMesh = attrFn.create( "outputMesh", "out", MFnData::kMesh); attrFn.setStorable(false); attrFn.setWritable(false); stat = addAttribute(aRes); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aRefRes); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aLineThickness); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aInputMesh); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(anFVc); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aFc); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aPole); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aCorner); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aT); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aEqc); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aItv); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aErr); McheckErr(stat, "ERROR adding attribute\n"); stat = addAttribute(aOutputMesh); McheckErr(stat, "ERROR adding attribute\n"); stat = attributeAffects(aRes, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aRefRes, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aLineThickness, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aInputMesh, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(anFVc, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aFc, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aPole, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aCorner, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aT, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aEqc, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aItv, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); stat = attributeAffects(aErr, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n"); return MS::kSuccess; }