/*! * Initialize attributes in Maya. */ MStatus ffdPlanar::initialize() { // Local attributes. MFnNumericAttribute nAttr; latticeRow1 = nAttr.create( "row1", "r1", MFnNumericData::k3Double ); nAttr.setDefault( 0.0, 0.0, 0.0 ); nAttr.setMin( -100.0, -100.0, -100.0 ); nAttr.setMax( 100.0, 100.0, 100.0 ); nAttr.setKeyable( true ); addAttribute( latticeRow1 ); latticeRow2 = nAttr.create( "row2", "r2", MFnNumericData::k3Double ); nAttr.setDefault( 0.0, 0.0, 0.0 ); nAttr.setMin( -100.0, -100.0, -100.0 ); nAttr.setMax( 100.0, 100.0, 100.0 ); nAttr.setKeyable( true ); addAttribute( latticeRow2 ); latticeRow3 = nAttr.create( "row3", "r3", MFnNumericData::k3Double ); nAttr.setDefault( 0.0, 0.0, 0.0 ); nAttr.setMin( -100.0, -100.0, -100.0 ); nAttr.setMax( 100.0, 100.0, 100.0 ); nAttr.setKeyable( true ); addAttribute( latticeRow3 ); // Attributes affect geometry. attributeAffects( ffdPlanar::latticeRow1, ffdPlanar::outputGeom ); attributeAffects( ffdPlanar::latticeRow2, ffdPlanar::outputGeom ); attributeAffects( ffdPlanar::latticeRow3, ffdPlanar::outputGeom ); return MS::kSuccess; }
MStatus blendCurve::initialize() { MStatus status; MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnCompoundAttribute cAttr; aInputs = cAttr.create( "inputs", "inputs" ); aInputCurve = tAttr.create( "inputCurve", "inputCurve", MFnData::kNurbsCurve ); tAttr.setStorable( false ); aWeight = nAttr.create( "weight", "weight", MFnNumericData::kFloat, 1.0 ); nAttr.setMin( 0.0 ); nAttr.setMax( 1.0 ); nAttr.setKeyable( true ); aBlendPosition = nAttr.create( "blendPosition", "blendPosition", MFnNumericData::kFloat, 1.0 ); nAttr.setMin( 0.0 ); nAttr.setMax( 1.0 ); nAttr.setKeyable( true ); aBlendArea = nAttr.create( "blendArea", "blendArea", MFnNumericData::kFloat, 0.5 ); nAttr.setMin( 0.0 ); nAttr.setMax( 1.0 ); nAttr.setKeyable( true ); cAttr.addChild( aInputCurve ); cAttr.addChild( aWeight ); cAttr.addChild( aBlendPosition ); cAttr.addChild( aBlendArea ); cAttr.setArray( true ); CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputs ) ); CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputs, outputGeom ) ); return MS::kSuccess; }
MStatus areaLightNode::initialize() { MStatus stat; MFnNumericAttribute numAttr; areaLightColor=numAttr.createColor("LightColor","lico"); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setDefault(0.5,0.5,0.5); areaPower=numAttr.create("Power","ap",MFnNumericData::kFloat,1.0); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setMin(0.0); numAttr.setMax(10000.0); areaSamples=numAttr.create("Samples","as",MFnNumericData::kInt,1); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setMin(0); numAttr.setMax(512); areaMakeGeo=numAttr.create("MakeGeometry","mg",MFnNumericData::kBoolean,0); numAttr.setKeyable(true); numAttr.setStorable(true); addAttribute(areaLightColor); addAttribute(areaPower); addAttribute(areaSamples); addAttribute(areaMakeGeo); return stat; }
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; }
// Initialize the plug-in. Called once when the plug-in is loaded. // This mostly involve creating attributes. MStatus hwRefractReflectShader_NV20::initialize() { MFnNumericAttribute nAttr; MStatus status; MFnTypedAttribute sAttr; // For string attributes // Create input attributes colorR = nAttr.create( "colorR", "cr",MFnNumericData::kFloat); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(1.0f); colorG = nAttr.create( "colorG", "cg",MFnNumericData::kFloat); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(0.5f); colorB = nAttr.create( "colorB", "cb",MFnNumericData::kFloat); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(0.5f); color = nAttr.create( "color", "c", colorR, colorG, colorB); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(1.0f, 0.5f, 0.5f); nAttr.setUsedAsColor(true); refractionIndex = nAttr.create( "refractionIndex", "ri", MFnNumericData::kFloat); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setMin(1.0f); nAttr.setMax(2.0f); nAttr.setDefault(1.1f); reflectivity = nAttr.create( "reflectivity", "rfl", MFnNumericData::kFloat); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setMin(0.0f); nAttr.setMax(1.0f); nAttr.setDefault(0.5f); // Add the attributes here addAttribute(color); addAttribute(refractionIndex); addAttribute(reflectivity); attributeAffects (colorR, outColor); attributeAffects (colorG, outColor); attributeAffects (colorB, outColor); attributeAffects (color, outColor); attributeAffects (refractionIndex, outColor); attributeAffects (reflectivity, outColor); 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 sgIkSmoothStretch::initialize() { MStatus stat; MFnNumericAttribute nAttr; aInputDistance = nAttr.create( "inputDistance", "in", MFnNumericData::kDouble, 0.0 ); nAttr.setArray( true ); nAttr.setUsesArrayDataBuilder( true ); nAttr.setStorable( true ); aInPositionX = nAttr.create( "inPositionX", "ipx", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aInPositionY = nAttr.create( "inPositionY", "ipy", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aInPositionZ = nAttr.create( "inPositionZ", "ipz", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aInPosition = nAttr.create( "inPosition", "ip", aInPositionX, aInPositionY, aInPositionZ ); aOutputDistance = nAttr.create( "outputDistance", "out", MFnNumericData::kDouble, 0,0 ); nAttr.setArray( true ); nAttr.setUsesArrayDataBuilder( true ); nAttr.setStorable( false ); nAttr.setWritable( false ); aSmoothArea = nAttr.create( "smoothArea", "smoothArea", MFnNumericData::kDouble, 0.0 ); nAttr.setStorable( true ); aStretchAble = nAttr.create( "stretchAble", "sa", MFnNumericData::kFloat, 1.0 ); nAttr.setStorable( true ); nAttr.setMin( 0.0 ); nAttr.setMax( 1 ); stat = addAttribute( aInputDistance ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aInPosition ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aOutputDistance ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aStretchAble ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aSmoothArea ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = attributeAffects( aInputDistance, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aInPosition, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aStretchAble, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aSmoothArea, aOutputDistance ); if (!stat) { stat.perror("attributeAffects"); return stat;} return MS::kSuccess; }
MStatus sphereLightNode::initialize() { MStatus stat; MFnNumericAttribute numAttr; sphereColor=numAttr.createColor("LightColor","lico"); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setDefault(1.0,1.0,1.0); spherePower=numAttr.create("Power","pw",MFnNumericData::kFloat,1.0); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setMin(0.0); numAttr.setMax(10000.0); sphereRadius=numAttr.create("Radius","ra",MFnNumericData::kFloat,1.0); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setMin(0.0); numAttr.setMax(100.0); sphereSamples=numAttr.create("Samples","sam",MFnNumericData::kInt,16); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setMin(0); numAttr.setMax(512); sphereMakeGeometry=numAttr.create("MakeGeometry","mg",MFnNumericData::kBoolean,0); numAttr.setKeyable(true); numAttr.setStorable(true); addAttribute(sphereColor); addAttribute(spherePower); addAttribute(sphereRadius); addAttribute(sphereSamples); addAttribute(sphereMakeGeometry); return stat; }
// initializes attribute information MStatus myComp::initialize() { MFnNumericAttribute nAttr; // Create input attributes aForegroundColor = nAttr.createColor("foreground", "fg"); MAKE_INPUT(nAttr); aBackgroundColor = nAttr.createColor("background", "bg"); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setDefault(1., 1., 1.)); aBackColor = nAttr.createColor("backColor", "bk"); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setDefault(1., 1., 1.)); aMask = nAttr.create( "mask", "ms", MFnNumericData::kFloat); CHECK_MSTATUS( nAttr.setMin(0.f)); CHECK_MSTATUS( nAttr.setMax(1.f)); MAKE_INPUT(nAttr); // Create output attributes here aOutColor = nAttr.createColor("outColor", "oc"); MAKE_OUTPUT(nAttr); aOutAlpha = nAttr.create( "outAlpha", "oa", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); // Add the attributes here CHECK_MSTATUS( addAttribute(aForegroundColor) ); CHECK_MSTATUS( addAttribute(aBackgroundColor) ); CHECK_MSTATUS( addAttribute(aBackColor) ); CHECK_MSTATUS( addAttribute(aMask) ); CHECK_MSTATUS( addAttribute(aOutColor) ); CHECK_MSTATUS( addAttribute(aOutAlpha) ); // all input affect the output color and alpha CHECK_MSTATUS( attributeAffects(aForegroundColor, aOutColor) ); CHECK_MSTATUS( attributeAffects(aForegroundColor, aOutAlpha) ); CHECK_MSTATUS( attributeAffects(aBackgroundColor, aOutColor) ); CHECK_MSTATUS( attributeAffects(aBackgroundColor, aOutAlpha) ); CHECK_MSTATUS( attributeAffects(aBackColor, aOutColor) ); CHECK_MSTATUS( attributeAffects(aBackColor, aOutAlpha) ); CHECK_MSTATUS( attributeAffects(aMask, aOutColor) ); CHECK_MSTATUS( attributeAffects(aMask, aOutAlpha) ); return MS::kSuccess; }
MStatus OpenSubdivShader::initialize() { MStatus stat; MFnTypedAttribute typedAttr; MFnNumericAttribute numAttr; MFnEnumAttribute enumAttr; aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 1); numAttr.setInternal(true); numAttr.setMin(1); numAttr.setSoftMax(5); aScheme = enumAttr.create("scheme", "sc"); enumAttr.addField("Catmull-Clark", kCatmark); enumAttr.addField("Loop", kLoop); enumAttr.addField("Bilinear", kBilinear); enumAttr.setInternal(true); aKernel = enumAttr.create("kernel", "kn"); enumAttr.addField("CPU", OpenSubdiv::OsdKernelDispatcher::kCPU); if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kOPENMP)) enumAttr.addField("OpenMP", OpenSubdiv::OsdKernelDispatcher::kOPENMP); if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kCL)) enumAttr.addField("CL", OpenSubdiv::OsdKernelDispatcher::kCL); if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kCUDA)) enumAttr.addField("CUDA", OpenSubdiv::OsdKernelDispatcher::kCUDA); enumAttr.setInternal(true); aDiffuse = numAttr.createColor("diffuse", "d"); numAttr.setDefault(1.0f, 1.0f, 1.0f); aSpecular = numAttr.createColor("specular", "s"); numAttr.setDefault(1.0f, 1.0f, 1.0f); aAmbient = numAttr.createColor("ambient", "a"); numAttr.setDefault(1.0f, 1.0f, 1.0f); aShininess = numAttr.create("shininess", "shin", MFnNumericData::kFloat, 16.0f); numAttr.setMin(0); numAttr.setMax(128.0f); aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean); addAttribute(aLevel); addAttribute(aScheme); addAttribute(aKernel); addAttribute(aDiffuse); addAttribute(aSpecular); addAttribute(aAmbient); addAttribute(aShininess); addAttribute(aWireframe); return MS::kSuccess; }
MStatus BasicLocator::initialize() { MFnUnitAttribute unitFn; MFnNumericAttribute numFn; MStatus stat; xWidth = unitFn.create( "xWidth", "xw", MFnUnitAttribute::kDistance ); unitFn.setDefault( MDistance(1.0, MDistance::uiUnit()) ); unitFn.setMin( MDistance(0.0, MDistance::uiUnit()) ); unitFn.setKeyable( true ); stat = addAttribute( xWidth ); if (!stat) { stat.perror( "Unable to add \"xWidth\" attribute" ); return stat; } zWidth = unitFn.create( "zWidth", "zw", MFnUnitAttribute::kDistance ); unitFn.setDefault( MDistance(1.0, MDistance::uiUnit()) ); unitFn.setMin( MDistance(0.0, MDistance::uiUnit()) ); unitFn.setKeyable( true ); stat = addAttribute( zWidth ); if (!stat) { stat.perror( "Unable to add \"zWidth\" attribute" ); return stat; } dispType = numFn.create( "dispType", "att", MFnNumericData::kShort ); numFn.setDefault( 0); numFn.setMin( 0 ); numFn.setMax( 2 ); numFn.setKeyable( true ); stat = addAttribute( dispType ); if (!stat) { stat.perror( "Unable to add \"dispType\" attribute" ); return stat; } // Notify Maya that there is an associated manipulator for this particular type of node MPxManipContainer::addToManipConnectTable( const_cast<MTypeId &>( typeId ) ); return MS::kSuccess; }
MStatus PRTAttrs::addFloatParameter(MFnDependencyNode & node, MObject & attr, const MString & name, double value, double min, double max) { MStatus stat; MFnNumericAttribute nAttr; attr = nAttr.create(longName(name), briefName(name), MFnNumericData::kDouble, value, &stat ); if ( stat != MS::kSuccess ) throw stat; if(!isnan(min)) { MCHECK(nAttr.setMin(min)); } if(!isnan(max)) { MCHECK(nAttr.setMax( max )); } MCHECK(addParameter(node, attr, nAttr)); MPlug plug(node.object(), attr); MCHECK(plug.setValue(value)); return MS::kSuccess; }
MStatus pointLightNode::initialize() { MStatus stat; MFnNumericAttribute numAttr; pointLightColor=numAttr.createColor("LightColor","plico"); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setDefault(1.0,1.0,1.0); pointPower=numAttr.create("Power","pp",MFnNumericData::kFloat,1.0); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setMin(0.0); numAttr.setMax(10000.0); addAttribute(pointLightColor); addAttribute(pointPower); return stat=MStatus::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 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 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; }
//---------------------------------------------------------------------------------------------------------------------- // 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; }
MStatus MG_softIk::initialize() { //This is the nurbs input attribute MFnTypedAttribute typedFn; MFnCompoundAttribute compund; MFnNumericAttribute numFn; MFnMatrixAttribute matrixFn; startMatrix =matrixFn.create("startMatrix","stm"); addAttribute(startMatrix); endMatrix =matrixFn.create("endMatrix","enm"); addAttribute(endMatrix); upInitLength = numFn.create("upInitLength","uil",MFnNumericData::kDouble,0); numFn.setStorable(true); numFn.setKeyable(true); addAttribute(upInitLength); downInitLength = numFn.create("downInitLength","dil",MFnNumericData::kDouble,0); numFn.setStorable(true); numFn.setKeyable(true); addAttribute(downInitLength); globalScale = numFn.create("globalScale","gb",MFnNumericData::kDouble,0); numFn.setStorable(true); numFn.setKeyable(true); numFn.setMin(0.001); addAttribute(globalScale); softDistance = numFn.create("softDistance","sd",MFnNumericData::kDouble,0); numFn.setMin(0.001); numFn.setStorable(true); numFn.setKeyable(true); addAttribute(softDistance); stretch = numFn.create("stretch","str",MFnNumericData::kDouble,0); numFn.setMin(0.0); numFn.setMax(1.0); numFn.setStorable(true); numFn.setKeyable(true); addAttribute(stretch); slide = numFn.create("slide","sld",MFnNumericData::kDouble,0.5); numFn.setMin(0.0); numFn.setMax(1.0); numFn.setStorable(true); numFn.setKeyable(true); addAttribute(slide); upScale = numFn.create("upScale","ups",MFnNumericData::kDouble,1); numFn.setStorable(false); numFn.setKeyable(false); numFn.setWritable(false); addAttribute(upScale); downScale = numFn.create("downScale","dws",MFnNumericData::kDouble,1); numFn.setStorable(false); numFn.setKeyable(false); numFn.setWritable(false); addAttribute(downScale); outputTranslateX = numFn.create("outputTranslateX","otx",MFnNumericData::kDouble,0); numFn.setStorable(false); numFn.setKeyable(false); numFn.setWritable(false); addAttribute(outputTranslateX); outputTranslateY = numFn.create("outputTranslateY","oty",MFnNumericData::kDouble,0); numFn.setStorable(false); numFn.setWritable(false); numFn.setKeyable(false); addAttribute(outputTranslateY); outputTranslateZ = numFn.create("outputTranslateZ","otz",MFnNumericData::kDouble,0); numFn.setStorable(false); numFn.setKeyable(false); numFn.setWritable(false); addAttribute(outputTranslateZ); outputTranslate= compund.create("outputTranslate","ot"); compund.addChild(outputTranslateX); compund.addChild(outputTranslateY); compund.addChild(outputTranslateZ); compund.setStorable(false); compund.setKeyable(false); compund.setWritable(false); addAttribute(outputTranslate); attributeAffects( startMatrix ,outputTranslate) ; attributeAffects( endMatrix ,outputTranslate) ; attributeAffects( softDistance ,outputTranslate) ; attributeAffects( stretch ,outputTranslate) ; attributeAffects( slide ,outputTranslate) ; attributeAffects( globalScale ,outputTranslate) ; attributeAffects( startMatrix ,upScale) ; attributeAffects( endMatrix ,upScale) ; attributeAffects( stretch ,upScale) ; attributeAffects( softDistance ,upScale) ; attributeAffects( slide ,upScale) ; attributeAffects( globalScale ,upScale) ; attributeAffects( startMatrix ,downScale) ; attributeAffects( endMatrix ,downScale) ; attributeAffects( softDistance ,downScale) ; attributeAffects( stretch ,downScale) ; attributeAffects( slide ,downScale) ; attributeAffects( globalScale ,downScale) ; 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; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus PhongNode::initialize() { MFnNumericAttribute nAttr; MFnLightDataAttribute lAttr; aTranslucenceCoeff = nAttr.create("translucenceCoeff", "tc", MFnNumericData::kFloat); MAKE_INPUT(nAttr); aDiffuseReflectivity = nAttr.create("diffuseReflectivity", "drfl", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault(0.8f) ); aColor = nAttr.createColor( "color", "c" ); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.58824f, 0.644f) ); aIncandescence = nAttr.createColor( "incandescence", "ic" ); MAKE_INPUT(nAttr); aOutColor = nAttr.createColor( "outColor", "oc" ); MAKE_OUTPUT(nAttr); aPointCamera = nAttr.createPoint( "pointCamera", "pc" ); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault(1.0f, 1.0f, 1.0f) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); aPower = nAttr.create( "power", "pow", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setMin(0.0f) ); CHECK_MSTATUS ( nAttr.setMax(200.0f) ); CHECK_MSTATUS ( nAttr.setDefault(10.0f) ); aSpecularity = nAttr.create( "specularity", "spc", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setMin(0.0f) ); CHECK_MSTATUS ( nAttr.setMax(1.0f) ) ; CHECK_MSTATUS ( nAttr.setDefault(0.5f) ); aReflectGain = nAttr.create( "reflectionGain", "rg", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setMin(0.0f) ); CHECK_MSTATUS ( nAttr.setMax(1.0f) ); CHECK_MSTATUS ( nAttr.setDefault(0.5f) ); aNormalCamera = nAttr.createPoint( "normalCamera", "n" ); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault(1.0f, 1.0f, 1.0f) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); aTriangleNormalCamera = nAttr.createPoint( "triangleNormalCamera", "tn" ); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault(1.0f, 1.0f, 1.0f)); CHECK_MSTATUS ( nAttr.setHidden(true)); 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, 1.0f, 1.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, 1.0f, 1.0f) ); 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) ); CHECK_MSTATUS ( nAttr.setHidden(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) ); 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) ); 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) ); 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) ); 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( "lightDataArray", "ltd", aLightDirection, aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular, aLightShadowFraction, aPreShadowIntensity, aLightBlindData); 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, 0.0f, 1.0f, NULL) ); // rayOrigin MObject RayX = nAttr.create( "rayOx", "rxo", MFnNumericData::kFloat, 0.0 ); MObject RayY = nAttr.create( "rayOy", "ryo", MFnNumericData::kFloat, 0.0 ); MObject RayZ = nAttr.create( "rayOz", "rzo", MFnNumericData::kFloat, 0.0 ); aRayOrigin = nAttr.create( "rayOrigin", "rog", RayX, RayY, RayZ ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(false) ); // rayDirection RayX = nAttr.create( "rayDirectionX", "rdx", MFnNumericData::kFloat, 1.0 ); RayY = nAttr.create( "rayDirectionY", "rdy", MFnNumericData::kFloat, 0.0 ); RayZ = nAttr.create( "rayDirectionZ", "rdz", MFnNumericData::kFloat, 0.0 ); aRayDirection = nAttr.create( "rayDirection", "rad", RayX, RayY, RayZ ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(false) ); // objectId aObjectId = nAttr.createAddr( "objectId", "oi" ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(false) ); // raySampler aRaySampler = nAttr.createAddr("raySampler", "rtr"); CHECK_MSTATUS ( nAttr.setStorable(false)); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(false) ); // rayDepth aRayDepth = nAttr.create( "rayDepth", "rd", MFnNumericData::kShort, 0.0 ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS (nAttr.setHidden(true) ) ; CHECK_MSTATUS ( nAttr.setReadable(false) ); CHECK_MSTATUS ( addAttribute(aTranslucenceCoeff) ); CHECK_MSTATUS ( addAttribute(aDiffuseReflectivity) ); CHECK_MSTATUS ( addAttribute(aColor) ); CHECK_MSTATUS ( addAttribute(aIncandescence) ); CHECK_MSTATUS ( addAttribute(aPointCamera) ); CHECK_MSTATUS ( addAttribute(aNormalCamera) ); CHECK_MSTATUS ( addAttribute(aTriangleNormalCamera) ); CHECK_MSTATUS ( addAttribute(aLightData) ); CHECK_MSTATUS ( addAttribute(aPower) ); CHECK_MSTATUS ( addAttribute(aSpecularity) ); CHECK_MSTATUS ( addAttribute(aOutColor) ); CHECK_MSTATUS ( addAttribute(aRayOrigin) ); CHECK_MSTATUS ( addAttribute(aRayDirection) ); CHECK_MSTATUS ( addAttribute(aObjectId) ); CHECK_MSTATUS ( addAttribute(aRaySampler) ); CHECK_MSTATUS ( addAttribute(aRayDepth) ); CHECK_MSTATUS ( addAttribute(aReflectGain) ); CHECK_MSTATUS ( attributeAffects (aTranslucenceCoeff, aOutColor)); CHECK_MSTATUS ( attributeAffects (aDiffuseReflectivity, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightIntensity, aOutColor)); CHECK_MSTATUS ( attributeAffects (aIncandescence, aOutColor)); CHECK_MSTATUS ( attributeAffects (aPointCamera, aOutColor)); CHECK_MSTATUS ( attributeAffects (aNormalCamera, aOutColor)); CHECK_MSTATUS ( attributeAffects (aTriangleNormalCamera, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightData, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightAmbient, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightSpecular, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightDiffuse, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightDirection, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightShadowFraction, aOutColor)); CHECK_MSTATUS ( attributeAffects (aPreShadowIntensity, aOutColor)); CHECK_MSTATUS ( attributeAffects (aLightBlindData, aOutColor)); CHECK_MSTATUS ( attributeAffects (aPower, aOutColor)); CHECK_MSTATUS ( attributeAffects (aSpecularity, aOutColor)); CHECK_MSTATUS ( attributeAffects (aColor, aOutColor)); CHECK_MSTATUS ( attributeAffects (aRayOrigin,aOutColor)); CHECK_MSTATUS ( attributeAffects (aRayDirection,aOutColor)); CHECK_MSTATUS ( attributeAffects (aObjectId,aOutColor)); CHECK_MSTATUS ( attributeAffects (aRaySampler,aOutColor)); CHECK_MSTATUS ( attributeAffects (aRayDepth,aOutColor)); CHECK_MSTATUS ( attributeAffects (aReflectGain,aOutColor) ); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus CheckerNode::initialize() { MFnNumericAttribute nAttr; // Input attributes aColor1 = nAttr.createColor("color1", "c1"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setDefault(0., .58824, .644) ); // Light blue aColor2 = nAttr.createColor("color2", "c2"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setDefault(1., 1., 1.) ); // White aBias = nAttr.create( "bias", "b", MFnNumericData::k2Float); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f, 0.0f) ); CHECK_MSTATUS(nAttr.setMax(1.0f, 1.0f) ); CHECK_MSTATUS(nAttr.setDefault(0.5f, 0.5f) ); // Implicit shading network attributes MObject child1 = nAttr.create( "uCoord", "u", MFnNumericData::kFloat); MObject child2 = nAttr.create( "vCoord", "v", MFnNumericData::kFloat); aUVCoord = nAttr.create( "uvCoord","uv", child1, child2); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setHidden(true) ); // Output attributes aOutColor = nAttr.createColor("outColor", "oc"); MAKE_OUTPUT(nAttr); aOutAlpha = nAttr.create( "outAlpha", "oa", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); // Add attributes to the node database. CHECK_MSTATUS(addAttribute(aColor1)); CHECK_MSTATUS(addAttribute(aColor2)); CHECK_MSTATUS(addAttribute(aBias)); CHECK_MSTATUS(addAttribute(aUVCoord)); CHECK_MSTATUS(addAttribute(aOutColor)); CHECK_MSTATUS(addAttribute(aOutAlpha)); // All input affect the output color and alpha CHECK_MSTATUS(attributeAffects (aColor1, aOutColor)); CHECK_MSTATUS(attributeAffects(aColor1, aOutAlpha)); CHECK_MSTATUS(attributeAffects (aColor2, aOutColor)); CHECK_MSTATUS(attributeAffects(aColor2, aOutAlpha)); CHECK_MSTATUS(attributeAffects(aBias, aOutColor)); CHECK_MSTATUS(attributeAffects(aBias, aOutAlpha)); CHECK_MSTATUS(attributeAffects (aUVCoord, aOutColor)); CHECK_MSTATUS(attributeAffects(aUVCoord, aOutAlpha)); return MS::kSuccess; }
MStatus uiDrawManager::initialize() { MStatus status; MFnNumericAttribute nAttr; MFnEnumAttribute eAttr; MFnTypedAttribute typedAttr; // Add ui type attribute aUIType = eAttr.create("uiType", "ut", uiDrawManager::kText); eAttr.addField("text", uiDrawManager::kText); eAttr.addField("line", uiDrawManager::kLine); eAttr.addField("point", uiDrawManager::kPoint); eAttr.addField("rect", uiDrawManager::kRect); eAttr.addField("quad", uiDrawManager::kQuad); eAttr.addField("sphere", uiDrawManager::kSphere); eAttr.addField("circle", uiDrawManager::kCircle); eAttr.addField("arc", uiDrawManager::kArc); eAttr.addField("line list", uiDrawManager::kLineList); eAttr.addField("line strip", uiDrawManager::kLineStrip); eAttr.addField("point list", uiDrawManager::kPointList); eAttr.addField("icon", uiDrawManager::kIcon); eAttr.addField("cone", uiDrawManager::kCone); eAttr.addField("box", uiDrawManager::kBox); MPxNode::addAttribute(aUIType); // Add color attribute aPrimitiveColor = nAttr.create("primitiveColor", "pc", MFnNumericData::k3Float); nAttr.setDefault(1.0f, 0.0f, 0.0f); nAttr.setUsedAsColor(true); MPxNode::addAttribute(aPrimitiveColor); // Add transparency attribute aPrimitiveTransparency = nAttr.create("primitiveTransparency", "pt", MFnNumericData::kFloat, 0.0); nAttr.setSoftMin(0.0); nAttr.setSoftMax(1.0); MPxNode::addAttribute(aPrimitiveTransparency); // add line width and line style attributes aLineWidth = nAttr.create("lineWidth", "lw", MFnNumericData::kFloat, 2.0); MPxNode::addAttribute(aLineWidth); aLineStyle = eAttr.create("lineStyle", "ls", MUIDrawManager::kSolid); eAttr.addField("solid", MUIDrawManager::kSolid); eAttr.addField("shortdotted", MUIDrawManager::kShortDotted); eAttr.addField("shortdashed", MUIDrawManager::kShortDashed); eAttr.addField("dashed", MUIDrawManager::kDashed); eAttr.addField("dotted", MUIDrawManager::kDotted); MPxNode::addAttribute(aLineStyle); // Add filled attribute aIsFilled = nAttr.create("isFilled", "if", MFnNumericData::kBoolean, 0); MPxNode::addAttribute(aIsFilled); // Add shaded attribute aShaded = nAttr.create("shaded", "sd", MFnNumericData::kBoolean, 0); MPxNode::addAttribute(aShaded); // Add radius attribute aRadius = nAttr.create("radius", "ra", MFnNumericData::kDouble, 1.0); MPxNode::addAttribute(aRadius); // add 2D attributes aDraw2D = nAttr.create("draw2D", "d2", MFnNumericData::kBoolean, 0); MPxNode::addAttribute(aDraw2D); aPosition = nAttr.create("position", "pos", MFnNumericData::k3Double); nAttr.setDefault(0.0, 0.0, 0.001); MPxNode::addAttribute(aPosition); // Add text attributes. MFnStringData stringFn; MObject defaultText = stringFn.create("uiDrawManager-Text"); aText = typedAttr.create("text", "t", MFnData::kString, defaultText); MPxNode::addAttribute(aText); aTextFontSize = nAttr.create("textFontSize", "tfs", MFnNumericData::kInt, MUIDrawManager::kDefaultFontSize); nAttr.setMin(-1); nAttr.setMax(99); MPxNode::addAttribute(aTextFontSize); unsigned int nFont = MUIDrawManager::getFontList(uiDrawManagerData::fFontList); if (nFont == 0) { perror("No font available!"); } aFontFaceName = eAttr.create("fontFaceName", "ffn", 0); for (unsigned int i = 0; i < nFont; i++) { MString str = uiDrawManagerData::fFontList[i]; eAttr.addField(str, (short)i); } MPxNode::addAttribute(aFontFaceName); aTextAlignment = eAttr.create("textAlignment", "ta", MUIDrawManager::kLeft); eAttr.addField("left", MUIDrawManager::kLeft); eAttr.addField("center", MUIDrawManager::kCenter); eAttr.addField("right", MUIDrawManager::kRight); MPxNode::addAttribute(aTextAlignment); eTextIncline = eAttr.create("textIncline", "tic", MUIDrawManager::kInclineNormal); eAttr.addField("normal", MUIDrawManager::kInclineNormal); eAttr.addField("italic", MUIDrawManager::kInclineItalic); MPxNode::addAttribute(eTextIncline); aTextWeight = eAttr.create("textWeight", "tw", MUIDrawManager::kWeightBold); eAttr.addField("light", MUIDrawManager::kWeightLight); eAttr.addField("normal", MUIDrawManager::kWeightNormal); eAttr.addField("demiBold", MUIDrawManager::kWeightDemiBold); eAttr.addField("bold", MUIDrawManager::kWeightBold); eAttr.addField("black", MUIDrawManager::kWeightBlack); MPxNode::addAttribute(aTextWeight); aTextStretch = nAttr.create("textStretch", "ts", MFnNumericData::kInt, MUIDrawManager::kStretchUnstretched); nAttr.setMin(50); nAttr.setMax(200); MPxNode::addAttribute(aTextStretch); aTextLine = eAttr.create("textLine", "tl", 0); eAttr.addField("none", 0); eAttr.addField("overline", MUIDrawManager::kLineOverline); eAttr.addField("underline", MUIDrawManager::kLineUnderline); eAttr.addField("strikeout", MUIDrawManager::kLineStrikeoutLine); MPxNode::addAttribute(aTextLine); aTextBoxSize = nAttr.create("textBoxSize", "tbs", MFnNumericData::k2Int); nAttr.setDefault(0, 0); MPxNode::addAttribute(aTextBoxSize); aTextBoxColor = nAttr.create("textBoxColor", "tbc", MFnNumericData::k3Float); nAttr.setDefault(0.0f, 1.0f, 1.0f); nAttr.setUsedAsColor(true); MPxNode::addAttribute(aTextBoxColor); aTextBoxTransparency = nAttr.create("textBoxTransparency", "tbt", MFnNumericData::kFloat, 0.0); nAttr.setSoftMin(0.0); nAttr.setSoftMax(1.0); MPxNode::addAttribute(aTextBoxTransparency); // add point attributes aPointSize = nAttr.create("pointSize", "ps", MFnNumericData::kFloat, 2.0); MPxNode::addAttribute(aPointSize); // add line attributes aLineStartPoint = nAttr.create("lineStartPoint", "lsp", MFnNumericData::k3Double); nAttr.setDefault(0.0, 0.0, 0.0); MPxNode::addAttribute(aLineStartPoint); aLineEndPoint = nAttr.create("lineEndPoint", "lep", MFnNumericData::k3Double); nAttr.setDefault(1.0, 1.0, 1.0); MPxNode::addAttribute(aLineEndPoint); // add rect attributes aRectUp = nAttr.create("rectUp", "ru", MFnNumericData::k3Double); nAttr.setDefault(0.0, 1.0, 0.0); MPxNode::addAttribute(aRectUp); aRectNormal = nAttr.create("rectNormal", "rn", MFnNumericData::k3Double); nAttr.setDefault(0.0, 0.0, 1.0); MPxNode::addAttribute(aRectNormal); aRectScale = nAttr.create("rectScale", "rs", MFnNumericData::k2Double); nAttr.setDefault(1.0, 1.0); MPxNode::addAttribute(aRectScale); // add quad attributes double defaultPosition[4][3] = { {0.0, 0.0, 0.0}, {1.0, 0.0, 0.0}, {1.0, 1.0, 0.0}, {0.0, 1.0, 0.0} }; for (int i = 0; i < 4; ++i) { MString fullName = "quadVertex"; MString shortName = "qv"; aQuadVertex[i] = nAttr.create(fullName + i, shortName + i, MFnNumericData::k3Double); nAttr.setDefault(defaultPosition[i][0], defaultPosition[i][1], defaultPosition[i][2]); MPxNode::addAttribute(aQuadVertex[i]); } // add circle attributes aCircleNormal = nAttr.create("circleNormal", "cn", MFnNumericData::k3Double); nAttr.setDefault(0.0, 0.0, 1.0); MPxNode::addAttribute(aCircleNormal); // add arc attributes aArcStart = nAttr.create("arcStartVector", "asv", MFnNumericData::k3Double); nAttr.setDefault(1.0, 0.0, 0.0); MPxNode::addAttribute(aArcStart); aArcEnd = nAttr.create("arcEndVector", "aev", MFnNumericData::k3Double); nAttr.setDefault(0.0, 1.0, 0.0); MPxNode::addAttribute(aArcEnd); aArcNormal = nAttr.create("arcNormal", "an", MFnNumericData::k3Double); nAttr.setDefault(0.0, 0.0, 1.0); MPxNode::addAttribute(aArcNormal); // icon attributes aIconName = eAttr.create("icon", "i", 0 ); unsigned int iconCount = MUIDrawManager::getIconNames(uiDrawManagerData::fIconList); for (unsigned int i=0; i<iconCount; i++) { MString str = uiDrawManagerData::fIconList[i]; eAttr.addField(str, (short)i); } MPxNode::addAttribute(aIconName); aIconScale = nAttr.create("iconScale", "cs", MFnNumericData::kFloat, 1.0); MPxNode::addAttribute(aIconScale); // cone attributes aConeDirection = nAttr.create("coneDirection", "cd", MFnNumericData::k3Double); nAttr.setDefault(0.0, 0.0, 1.0); MPxNode::addAttribute(aConeDirection); aConeHeight = nAttr.create("coneHeight", "ch", MFnNumericData::kDouble); nAttr.setDefault(1.0); MPxNode::addAttribute(aConeHeight); // box attributes aBoxUp = nAttr.create("boxUp", "bu", MFnNumericData::k3Double); nAttr.setDefault(0.0, 0.0, 1.0); MPxNode::addAttribute(aBoxUp); aBoxRight = nAttr.create("boxRight", "br", MFnNumericData::k3Double); nAttr.setDefault(0.0, 1.0, 0.0); MPxNode::addAttribute(aBoxRight); aBoxScale = nAttr.create("boxScale", "bs", MFnNumericData::k3Double); nAttr.setDefault(1.0, 1.0, 1.0); MPxNode::addAttribute(aBoxScale); return MS::kSuccess; }
MStatus roughGlassNode::initialize() { MFnNumericAttribute numAttr; mirrorTexLayer=numAttr.createColor("MirrorTextureLayer","mtl"); MAKE_INPUT(numAttr); filterTexLayer=numAttr.createColor("FilterTextureLayer","ftl"); MAKE_INPUT(numAttr); bumpTexLayer=numAttr.createColor("BumpTextureLayer","btl"); MAKE_INPUT(numAttr); absorbColor=numAttr.createColor("AbsorbColor","gabco"); MAKE_INPUT(numAttr); absorbDistance=numAttr.create("AbsorbDistance","gabdi",MFnNumericData::kFloat,1.0); MAKE_INPUT(numAttr); numAttr.setMin(0.0f); numAttr.setMax(100.0f); filterColor=numAttr.createColor("FilterColor","rgfico"); MAKE_INPUT(numAttr); mirrorColor=numAttr.createColor("MirrorColor","rgco"); MAKE_INPUT(numAttr); IOR=numAttr.create("IOR","rgior",MFnNumericData::kFloat,1.0); MAKE_INPUT(numAttr); numAttr.setMin(0.0f); numAttr.setMax(30.0f); transmitFilter=numAttr.create("TransmitFilter","rgtrfi",MFnNumericData::kDouble,1.0); MAKE_INPUT(numAttr); numAttr.setMin(0.0); numAttr.setMax(1.0); dispersionPower=numAttr.create("DispersionPower","rgpo",MFnNumericData::kFloat,0.0); MAKE_INPUT(numAttr); numAttr.setMin(0.0f); numAttr.setMax(10000.0f); fakeShadows=numAttr.create("FakeShadows","rgfash",MFnNumericData::kBoolean,true); MAKE_INPUT(numAttr); exponent=numAttr.create("Exponent","rgex",MFnNumericData::kFloat,500.0); MAKE_INPUT(numAttr); numAttr.setMin(1.0f); numAttr.setMax(10000.0f); alpha=numAttr.create("Roughness","rgr",MFnNumericData::kFloat,0.0); MAKE_INPUT(numAttr); numAttr.setMin(0.0f); numAttr.setMax(1.0f); outRoughGlass=numAttr.createColor("outColor","oc"); numAttr.setHidden(true); MAKE_OUTPUT(numAttr); addAttribute(alpha); addAttribute(absorbColor); addAttribute(absorbDistance); addAttribute( filterColor ); addAttribute(filterTexLayer); addAttribute(mirrorColor); addAttribute(mirrorTexLayer); addAttribute(bumpTexLayer); addAttribute(IOR); addAttribute(transmitFilter); addAttribute(dispersionPower); addAttribute(fakeShadows); addAttribute(exponent); addAttribute(outRoughGlass); attributeAffects(mirrorTexLayer,outRoughGlass); attributeAffects(filterTexLayer,outRoughGlass); attributeAffects(bumpTexLayer,outRoughGlass); attributeAffects(alpha,outRoughGlass); attributeAffects(absorbColor,outRoughGlass); attributeAffects(absorbDistance,outRoughGlass); attributeAffects(filterColor,outRoughGlass); attributeAffects(mirrorColor,outRoughGlass); attributeAffects(IOR,outRoughGlass); attributeAffects(transmitFilter,outRoughGlass); attributeAffects(dispersionPower,outRoughGlass); attributeAffects(fakeShadows,outRoughGlass); attributeAffects(exponent,outRoughGlass); return MStatus::kSuccess; }
// initializes attribute information // call by MAYA when this plug-in was loded. // MStatus anisotropicShaderNode::initialize() { MFnNumericAttribute nAttr; MFnLightDataAttribute lAttr; MFnMatrixAttribute mAttr; aMatrixOToW = mAttr.create( "matrixObjectToWorld", "mow", MFnMatrixAttribute::kFloat ); CHECK_MSTATUS( mAttr.setStorable( false ) ); CHECK_MSTATUS( mAttr.setHidden( true ) ); aMatrixWToC = mAttr.create( "matrixWorldToEye", "mwc", MFnMatrixAttribute::kFloat ); CHECK_MSTATUS( mAttr.setStorable( false ) ); CHECK_MSTATUS( mAttr.setHidden( true ) ); aDiffuseReflectivity = nAttr.create( "diffuseReflectivity", "drfl", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setDefault(0.8f) ); CHECK_MSTATUS( nAttr.setMin(0.0f) ); CHECK_MSTATUS( nAttr.setMax(1.0f) ); aColor = nAttr.createColor( "color", "c" ); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setDefault(0.0f, 0.58824f, 0.644f) ); aNormalCamera = nAttr.createPoint( "normalCamera", "n" ); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setHidden(true) ); 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) ); 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) ); 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) ); 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) ); 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) ); 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) ); 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) ); 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( "lightDataArray", "ltd", aLightDirection, aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular, aLightShadowFraction, aPreShadowIntensity, aLightBlindData); 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, 0.0f, 1.0f, NULL) ); aSpecularCoeff = nAttr.create( "specularCoeff", "scf", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setMin(0.0f) ); CHECK_MSTATUS( nAttr.setMax(1.0f) ); CHECK_MSTATUS( nAttr.setDefault(0.8f) ); aPointCamera = nAttr.createPoint( "pointCamera", "pc" ); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setHidden(true) ); // input transparency aInTransparency = nAttr.createColor( "transparency", "it" ); MAKE_INPUT(nAttr); // ray direction aRayDirection = nAttr.createPoint( "rayDirection", "rd" ); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setHidden(true) ); // specular color aSpecColor = nAttr.createColor( "specularColor","sc" ); CHECK_MSTATUS( nAttr.setDefault( .5, .5, .5 ) ); MAKE_INPUT(nAttr); // anisotropic parameters // aRoughness1 = nAttr.create( "roughness1", "rn1", MFnNumericData::kFloat); CHECK_MSTATUS( nAttr.setMin(0.0f) ); CHECK_MSTATUS( nAttr.setMax(1.0f) ); CHECK_MSTATUS( nAttr.setDefault(0.2f) ); aRoughness2 = nAttr.create( "roughness2", "rn2", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setMin(0.0f) ); CHECK_MSTATUS( nAttr.setMax(1.0f) ); CHECK_MSTATUS( nAttr.setDefault(0.4f) ); aAxesVector = nAttr.createPoint( "axesVector", "av" ); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setDefault( 0.0f, 1.0f, 0.0f ) ); // output color aOutColor = nAttr.createColor( "outColor", "oc" ); MAKE_OUTPUT(nAttr); // output transparency aOutTransparency = nAttr.createColor( "outTransparency", "ot" ); MAKE_OUTPUT(nAttr); setAttribute(); return MS::kSuccess; }
MStatus blendTwoMatrixDecompose::initialize() { MStatus stat; MFnMatrixAttribute mAttr; MFnNumericAttribute nAttr; MFnUnitAttribute uAttr; aMatrix1 = mAttr.create( "inMatrix1", "i1" ); mAttr.setStorable( true ); aMatrix2 = mAttr.create( "inMatrix2", "i2" ); mAttr.setStorable( true ); aBlender = nAttr.create( "attributeBlender", "ab", MFnNumericData::kFloat, 0.5 ); nAttr.setMin(0); nAttr.setMax(1); nAttr.setStorable( true ); aOutputTranslateX = nAttr.create( "outputTranslateX", "otx", MFnNumericData::kDouble, 0.0 ); aOutputTranslateY = nAttr.create( "outputTranslateY", "oty", MFnNumericData::kDouble, 0.0 ); aOutputTranslateZ = nAttr.create( "outputTranslateZ", "otz", MFnNumericData::kDouble, 0.0 ); aOutputTranslate = nAttr.create( "outputTranslate", "ot", aOutputTranslateX, aOutputTranslateY, aOutputTranslateZ ); nAttr.setStorable( false ); nAttr.setWritable( false ); aOutputRotateX = uAttr.create( "outputRotateX", "orx", MFnUnitAttribute::kAngle, 0.0 ); aOutputRotateY = uAttr.create( "outputRotateY", "ory", MFnUnitAttribute::kAngle, 0.0 ); aOutputRotateZ = uAttr.create( "outputRotateZ", "orz", MFnUnitAttribute::kAngle, 0.0 ); aOutputRotate = nAttr.create( "outputRotate", "or", aOutputRotateX, aOutputRotateY, aOutputRotateZ ); nAttr.setStorable( false ); nAttr.setWritable( false ); aOutputScaleX = nAttr.create( "outputScaleX", "osx", MFnNumericData::kDouble, 0.0 ); aOutputScaleY = nAttr.create( "outputScaleY", "osy", MFnNumericData::kDouble, 0.0 ); aOutputScaleZ = nAttr.create( "outputScaleZ", "osz", MFnNumericData::kDouble, 0.0 ); aOutputScale = nAttr.create( "outputScale", "os", aOutputScaleX, aOutputScaleY, aOutputScaleZ ); nAttr.setStorable( false ); nAttr.setWritable( false ); aOutputShearX = nAttr.create( "outputShearX", "oshx", MFnNumericData::kDouble, 0.0 ); aOutputShearY = nAttr.create( "outputShearY", "oshy", MFnNumericData::kDouble, 0.0 ); aOutputShearZ = nAttr.create( "outputShearZ", "oshz", MFnNumericData::kDouble, 0.0 ); aOutputShear = nAttr.create( "outputShear", "osh", aOutputShearX, aOutputShearY, aOutputShearZ ); nAttr.setStorable( false ); nAttr.setWritable( false ); stat = addAttribute( aMatrix1 ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aMatrix2 ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aBlender ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aOutputTranslate ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aOutputRotate ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aOutputScale ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = addAttribute( aOutputShear ); if (!stat) { stat.perror("addAttribute"); return stat;} stat = attributeAffects( aMatrix1, aOutputTranslate ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aMatrix1, aOutputRotate ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aMatrix1, aOutputScale ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aMatrix1, aOutputShear ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aMatrix2, aOutputTranslate ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aMatrix2, aOutputRotate ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aMatrix2, aOutputScale ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aMatrix2, aOutputShear ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aBlender, aOutputTranslate ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aBlender, aOutputRotate ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aBlender, aOutputScale ); if (!stat) { stat.perror("attributeAffects"); return stat;} stat = attributeAffects( aBlender, aOutputShear ); if (!stat) { stat.perror("attributeAffects"); return stat;} 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; }
// // Initialize the node // MStatus jhMeshBlur::initialize() { // attribute types MFnUnitAttribute unitAttr; MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; aOldMeshData = tAttr.create("oldMesh","om",MFnData::kPointArray); tAttr.setArray(true); tAttr.setHidden(true); tAttr.setIndexMatters(true); // create the attributes aStrength = nAttr.create( "Strength", "str", MFnNumericData::kFloat,1.0); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setMax(1.0); nAttr.setMin(0.0); aTreshhold = nAttr.create( "Treshold", "tres", MFnNumericData::kFloat,0.0); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setMin(0.0); aShapeFactor = nAttr.create( "ShapeFactor", "shapef", MFnNumericData::kFloat,0.5); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setMax(1.0); nAttr.setMin(0.0); aTweakBlur = nAttr.create( "TweakBlur", "tweak", MFnNumericData::kBoolean,false); nAttr.setKeyable(false); nAttr.setChannelBox(true); aQuadInterp = nAttr.create( "QuadInterpolation", "qi", MFnNumericData::kBoolean,true); nAttr.setKeyable(false); nAttr.setChannelBox(true); aInterpPower = nAttr.create( "InterpolationPower", "interp", MFnNumericData::kDouble, 0.75); nAttr.setKeyable(true); nAttr.setMax(1.0); nAttr.setMin(0.0); aTime = unitAttr.create( "time", "tm", MFnUnitAttribute::kTime, 1.0 ); unitAttr.setStorable(true); unitAttr.setCached(true); unitAttr.setReadable(true); unitAttr.setWritable(true); unitAttr.setAffectsAppearance(true); unitAttr.setAffectsWorldSpace(true); // Make the attributes visible to the user addAttribute( aStrength); addAttribute( aTreshhold); addAttribute( aTime); addAttribute( aTweakBlur); addAttribute( aQuadInterp); addAttribute( aInterpPower); addAttribute( aOldMeshData); // Make sure when an attribute changes, the node updates attributeAffects( aTime, outputGeom ); attributeAffects( aStrength, outputGeom ); attributeAffects( aTreshhold, outputGeom ); attributeAffects( aQuadInterp, outputGeom ); attributeAffects( aInterpPower, outputGeom ); // Not implented yet, but make the weights paintable :) MGlobal::executeCommand("makePaintable -attrType multiFloat -sm deformer jhMeshBlur weights;"); return MStatus::kSuccess; }
MStatus 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; }
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; }