// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus Gamma::initialize() { MFnNumericAttribute nAttr; // Input attributes aColor = nAttr.createColor( "color", "c" ); MAKE_INPUT(nAttr); aGamma = nAttr.createPoint( "gamma", "g" ); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault(1.f, 1.f, 1.f) ); // Output attributes aOutColor= nAttr.createColor( "outColor", "oc" ); MAKE_OUTPUT(nAttr); // Add attributes to the node database. CHECK_MSTATUS ( addAttribute(aColor) ); CHECK_MSTATUS ( addAttribute(aGamma) ); CHECK_MSTATUS ( addAttribute(aOutColor) ); // All input affect the output color CHECK_MSTATUS ( attributeAffects( aColor, aOutColor )); CHECK_MSTATUS ( attributeAffects( aGamma, aOutColor )); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus depthShader::initialize() { MFnNumericAttribute nAttr; // Create input attributes aColorNear = nAttr.createColor("color", "c"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setDefault(0., 1., 0.)); // Green aColorFar = nAttr.createColor("colorFar", "cf"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setDefault(0., 0., 1.)); // Blue aNear = nAttr.create("near", "n", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f)); CHECK_MSTATUS(nAttr.setSoftMax(1000.0f)); aFar = nAttr.create("far", "f", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f)); CHECK_MSTATUS(nAttr.setSoftMax(1000.0f)); CHECK_MSTATUS(nAttr.setDefault(2.0f)); aPointCamera = nAttr.createPoint("pointCamera", "p"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setHidden(true)); // Create output attributes aOutColor = nAttr.createColor("outColor", "oc"); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(addAttribute(aColorNear)); CHECK_MSTATUS(addAttribute(aColorFar)); CHECK_MSTATUS(addAttribute(aNear) ); CHECK_MSTATUS(addAttribute(aFar)); CHECK_MSTATUS(addAttribute(aPointCamera)); CHECK_MSTATUS(addAttribute(aOutColor)); CHECK_MSTATUS(attributeAffects(aColorNear, aOutColor)); CHECK_MSTATUS(attributeAffects(aColorFar, aOutColor)); CHECK_MSTATUS(attributeAffects(aNear, aOutColor)); CHECK_MSTATUS(attributeAffects(aFar, aOutColor)); CHECK_MSTATUS(attributeAffects(aPointCamera, aOutColor)); return MS::kSuccess; }
MPlug BoxParameterHandler<T>::doCreate( IECore::ConstParameterPtr parameter, const MString &plugName, MObject &node ) const { typename IECore::TypedParameter<Box<T> >::ConstPtr p = IECore::runTimeCast<const IECore::TypedParameter<Box<T > > >( parameter ); if( !p ) { return MPlug(); } MFnNumericAttribute fnNAttr; MFnCompoundAttribute fnCAttr; MObject oMin, oMax; switch( T::dimensions() ) { case 2 : { MObject oMinX = fnNAttr.create( plugName + "MinX", plugName + "MinX", NumericTraits<T>::baseDataType() ); MObject oMinY = fnNAttr.create( plugName + "MinY", plugName + "MinY", NumericTraits<T>::baseDataType() ); oMin = fnNAttr.create( plugName + "Min", plugName + "Min", oMinX, oMinY ); MObject oMaxX = fnNAttr.create( plugName + "MaxX", plugName + "MaxX", NumericTraits<T>::baseDataType() ); MObject oMaxY = fnNAttr.create( plugName + "MaxY", plugName + "MaxY", NumericTraits<T>::baseDataType() ); oMax = fnNAttr.create( plugName + "Max", plugName + "Max", oMaxX, oMaxY ); } break; case 3 : oMin = fnNAttr.createPoint( plugName + "Min", plugName + "Min" ); oMax = fnNAttr.createPoint( plugName + "Max", plugName + "Max" ); break; default : return MPlug(); } MObject attribute = fnCAttr.create( plugName, plugName ); fnCAttr.addChild( oMin ); fnCAttr.addChild( oMax ); MPlug result = finishCreating( parameter, attribute, node ); doUpdate( parameter, result ); return result; }
MStatus dynExprField::initialize() // // Descriptions: // Initialize the node, attributes. // { MStatus status; MFnNumericAttribute numAttr; // create the field basic attributes. // mDirection = numAttr.createPoint("direction","dir"); numAttr.setDefault( 0.0, 1.0, 0.0 ); numAttr.setKeyable(true); numAttr.setStorable(true); numAttr.setReadable(true); numAttr.setWritable(true); status = addAttribute( mDirection ); attributeAffects(mDirection, mOutputForce); return( MS::kSuccess ); }
MStatus slopeShaderNode::initialize() // // Description: // Initializes the attributes for this node. // { MFnNumericAttribute nAttr; MFnMatrixAttribute nMAttr; MFnTypedAttribute nTAttr; MFnGenericAttribute nGAttr; // Input Attributes // aAngle = nAttr.create( "angle", "ang", MFnNumericData::kFloat); nAttr.setDefault(30.0f); nAttr.setMin(0.0f); nAttr.setMax(100.0f); nAttr.setKeyable(true); nAttr.setStorable(true); nAttr.setReadable(true); nAttr.setWritable(true); aColor1 = nAttr.createColor( "walkableColor", "w" ); nAttr.setDefault(0.0f, 1.0f, 0.0f); nAttr.setKeyable(true); nAttr.setStorable(true); nAttr.setUsedAsColor(true); nAttr.setReadable(true); nAttr.setWritable(true); aColor2 = nAttr.createColor( "nonWalkableColor", "nw" ); nAttr.setDefault(1.0f, 0.0f, 0.0f); nAttr.setKeyable(true); nAttr.setStorable(true); nAttr.setUsedAsColor(true); nAttr.setReadable(true); nAttr.setWritable(true); // Surface Normal supplied by the render sampler // aTriangleNormalCamera = nAttr.createPoint( "triangleNormalCamera", "n" ); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(true); //View matrix from the camera into world space // aMatrixEyeToWorld = nMAttr.create( "matrixEyeToWorld", "mew", MFnMatrixAttribute::kFloat ); nAttr.setHidden(true); nMAttr.setWritable(true); // Output Attributes // aOutColor = nAttr.createColor( "outColor", "oc" ); nAttr.setStorable(false); nAttr.setHidden(false); nAttr.setReadable(true); nAttr.setWritable(false); //dummy plug for forcing evaluation // aDirtyShaderAttr = nGAttr.create( "dirtyShaderPlug", "dsp"); nGAttr.setArray(true); nGAttr.setHidden(false); nGAttr.setUsesArrayDataBuilder(true); nGAttr.setReadable(false); nGAttr.setStorable(true); nGAttr.setIndexMatters(false); nGAttr.addAccept(MFnData::kMesh); //Add attribues addAttribute(aAngle); addAttribute(aColor1); addAttribute(aColor2); addAttribute(aTriangleNormalCamera); addAttribute(aOutColor); addAttribute(aMatrixEyeToWorld); addAttribute(aDirtyShaderAttr); attributeAffects (aAngle, aOutColor); attributeAffects (aColor1, aOutColor); attributeAffects (aColor2, aOutColor); attributeAffects (aTriangleNormalCamera, aOutColor); attributeAffects (aDirtyShaderAttr, aOutColor); return MS::kSuccess; }
MStatus hingeConstraintNode::initialize() { MStatus status; MFnMessageAttribute fnMsgAttr; MFnNumericAttribute fnNumericAttr; MFnMatrixAttribute fnMatrixAttr; ia_rigidBody = fnMsgAttr.create("inRigidBody", "inrb", &status); MCHECKSTATUS(status, "creating inRigidBody attribute") status = addAttribute(ia_rigidBody); MCHECKSTATUS(status, "adding inRigidBody attribute") ia_damping = fnNumericAttr.create("damping", "dmp", MFnNumericData::kDouble, 1.0, &status); MCHECKSTATUS(status, "creating damping attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_damping); MCHECKSTATUS(status, "adding damping attribute") ia_lowerLimit = fnNumericAttr.create("lowerLimit", "llmt", MFnNumericData::kDouble, -1.57, &status); MCHECKSTATUS(status, "creating lower limit attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_lowerLimit); MCHECKSTATUS(status, "adding lower limit attribute") ia_upperLimit = fnNumericAttr.create("upperLimit", "ulmt", MFnNumericData::kDouble, 1.57, &status); MCHECKSTATUS(status, "creating upper limit attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_upperLimit); MCHECKSTATUS(status, "adding upper limit attribute") ia_limitSoftness = fnNumericAttr.create("limitSoftness", "lmSo", MFnNumericData::kDouble, 0.9, &status); MCHECKSTATUS(status, "creating limitSoftness attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_limitSoftness); MCHECKSTATUS(status, "adding limitSoftness attribute") ia_biasFactor = fnNumericAttr.create("biasFactor", "biFa", MFnNumericData::kDouble, 0.3, &status); MCHECKSTATUS(status, "creating biasFactor attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_biasFactor); MCHECKSTATUS(status, "adding biasFactor attribute") ia_relaxationFactor = fnNumericAttr.create("relaxationFactor", "reFa", MFnNumericData::kDouble, 1.0, &status); MCHECKSTATUS(status, "creating relaxationFactor attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_relaxationFactor); MCHECKSTATUS(status, "adding relaxationFactor attribute") ia_hingeAxis = fnNumericAttr.createPoint("hingeAxis", "hgAx", &status); status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 1.0); MCHECKSTATUS(status, "creating hingeAxis attribute") status = addAttribute(ia_hingeAxis); MCHECKSTATUS(status, "adding hingeAxis attribute") //------------------------------------------------------------------------------ ia_enableAngularMotor = fnNumericAttr.create("enableAngularMotor", "enAM", MFnNumericData::kBoolean, false, &status); MCHECKSTATUS(status, "creating enableAngularMotor attribute") status = addAttribute(ia_enableAngularMotor); MCHECKSTATUS(status, "adding enableAngularMotor attribute") ia_motorTargetVelocity = fnNumericAttr.create("motorTargetVelocity", "mTV", MFnNumericData::kDouble, 1, &status); MCHECKSTATUS(status, "creating motorTargetVelocity attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_motorTargetVelocity); MCHECKSTATUS(status, "adding motorTargetVelocity attribute") ia_maxMotorImpulse = fnNumericAttr.create("maxMotorImpulse", "mMI", MFnNumericData::kDouble, 1, &status); MCHECKSTATUS(status, "creating maxMotorImpulse attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_maxMotorImpulse); MCHECKSTATUS(status, "adding maxMotorImpulse attribute") //------------------------------------------------------------------------------ ca_constraint = fnNumericAttr.create("ca_constraint", "caco", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_constraint attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_constraint); MCHECKSTATUS(status, "adding ca_constraint attribute") ca_constraintParam = fnNumericAttr.create("ca_constraintParam", "cacop", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_constraintParam attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_constraintParam); MCHECKSTATUS(status, "adding ca_constraintParam attribute") status = attributeAffects(ia_rigidBody, ca_constraint); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBody, ca_constraint)") status = attributeAffects(ia_rigidBody, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBody, ca_constraintParam)") status = attributeAffects(ia_damping, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_damping, ca_constraintParam)") status = attributeAffects(ia_lowerLimit, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_lowerLimit, ca_constraintParam)") status = attributeAffects(ia_upperLimit, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_upperLimit, ca_constraintParam)") status = attributeAffects(ia_limitSoftness, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_limitSoftness, ca_constraintParam)") status = attributeAffects(ia_biasFactor, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_biasFactor, ca_constraintParam)") status = attributeAffects(ia_relaxationFactor, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_relaxationFactor, ca_constraintParam)") status = attributeAffects(ia_hingeAxis, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_hingeAxis, ca_constraintParam)") status = attributeAffects(ia_enableAngularMotor, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_enableAngularMotor, ca_constraintParam)") status = attributeAffects(ia_motorTargetVelocity, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_motorTargetVelocity, ca_constraintParam)") status = attributeAffects(ia_maxMotorImpulse, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_maxMotorImpulse, ca_constraintParam)") return MS::kSuccess; }
// initializes attribute information MStatus mySChecker::initialize() { MFnMatrixAttribute mAttr; MFnNumericAttribute nAttr; MObject x, y, z; aColor1 = nAttr.createColor("color1", "c1"); MAKE_INPUT(nAttr); nAttr.setDefault(0., .58824, .644); // Light blue aColor2 = nAttr.createColor("color2", "c2"); MAKE_INPUT(nAttr); nAttr.setDefault(1., 1., 1.); // White aBias = nAttr.create( "bias", "b", MFnNumericData::k3Float); MAKE_INPUT(nAttr); nAttr.setMin(0.0f); nAttr.setMax(1.0f); nAttr.setDefault(0.5f, 0.5f, 0.5f); aPlaceMat = mAttr.create("placementMatrix", "pm", MFnMatrixAttribute::kFloat); MAKE_INPUT(mAttr); // Internal shading attribute, implicitely connected. aPointWorld = nAttr.createPoint("pointWorld", "pw"); MAKE_INPUT(nAttr); nAttr.setHidden(true); // Create output attributes aOutColor = nAttr.createColor("outColor", "oc"); MAKE_OUTPUT(nAttr); aOutAlpha = nAttr.create( "outAlpha", "oa", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); // Add the attributes here addAttribute(aColor1); addAttribute(aColor2); addAttribute(aPointWorld); addAttribute(aPlaceMat); addAttribute(aBias); addAttribute(aOutColor); addAttribute(aOutAlpha); // all input affect the output color and alpha attributeAffects (aColor1, aOutColor); attributeAffects (aColor1, aOutAlpha); attributeAffects (aColor2, aOutColor); attributeAffects (aColor2, aOutAlpha); attributeAffects (aPointWorld, aOutColor); attributeAffects (aPointWorld, aOutAlpha); attributeAffects (aPlaceMat, aOutColor); attributeAffects (aPlaceMat, aOutAlpha); attributeAffects (aBias, aOutColor); attributeAffects (aBias, aOutAlpha); return MS::kSuccess; }
MStatus collisionShapeNode::initialize() { MStatus status; MFnMessageAttribute fnMsgAttr; MFnNumericAttribute fnNumericAttr; MFnEnumAttribute fnEnumAttr; ia_type = fnEnumAttr.create("type", "tp", 7, &status); MCHECKSTATUS(status, "creating type attribute") fnEnumAttr.addField("Convex Hull", 0); fnEnumAttr.addField("Mesh", 1); fnEnumAttr.addField("Cylinder", 2); fnEnumAttr.addField("Capsule", 3); fnEnumAttr.addField("Box", 4); fnEnumAttr.addField("Sphere", 5); fnEnumAttr.addField("Plane", 6); fnEnumAttr.addField("BvhMesh", 7); fnEnumAttr.addField("HACD", 8); fnEnumAttr.setKeyable(true); status = addAttribute(ia_type); MCHECKSTATUS(status, "adding type attribute") ia_scale = fnNumericAttr.createPoint("scale", "sc", &status); MCHECKSTATUS(status, "creating ia_scale attribute") fnNumericAttr.setDefault(1.0, 1.0, 1.0); fnNumericAttr.setKeyable(true); status = addAttribute(ia_scale); MCHECKSTATUS(status, "adding ia_scale attribute") oa_collisionShape = fnMsgAttr.create("outCollisionShape", "oucs", &status); MCHECKSTATUS(status, "creating outCollisionShape attribute") status = addAttribute(oa_collisionShape); MCHECKSTATUS(status, "adding outCollisionShape attribute") ia_shape = fnMsgAttr.create("inShape", "insh", &status); MCHECKSTATUS(status, "creating inShape attribute") status = addAttribute(ia_shape); MCHECKSTATUS(status, "adding inShape attribute") ca_collisionShape = fnNumericAttr.create("ca_collisionShape", "ccs", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_collisionShape attribute") fnNumericAttr.setWorldSpace(true); fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_collisionShape); MCHECKSTATUS(status, "adding ca_collisionShape attribute") ca_collisionShapeParam = fnNumericAttr.create("collisionShapeParam", "cspm", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_collisionShapeParam attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_collisionShapeParam); MCHECKSTATUS(status, "adding ca_collisionShapeParam attribute") // status = attributeAffects(ia_shape, oa_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, oa_collisionShape)") status = attributeAffects(ia_type, oa_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_type, oa_collisionShape)") status = attributeAffects(ia_scale, oa_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_scale, oa_collisionShape)") // status = attributeAffects(ia_shape, ca_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, ca_collisionShape)") status = attributeAffects(ia_type, ca_collisionShape); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, ca_collisionShape)") // status = attributeAffects(ia_shape, ca_collisionShapeParam); MCHECKSTATUS(status, "adding attributeAffects(ia_shape, oa_collisionShapeParam)") status = attributeAffects(ia_scale, ca_collisionShapeParam); MCHECKSTATUS(status, "adding attributeAffects(ia_scale, oa_collisionShapeParam)") status = attributeAffects(ia_type, ca_collisionShapeParam); MCHECKSTATUS(status, "adding attributeAffects(ia_type, oa_collisionShapeParam)") return MS::kSuccess; }
MStatus MG_dotProduct::initialize(){ //Input vector 1 MFnNumericAttribute numericAttrFn; vector1 = numericAttrFn.createPoint("vector1","v1"); addAttribute(vector1); numericAttrFn.setStorable(true); //Input vector 2 vector2 = numericAttrFn.createPoint("vector2","v2"); addAttribute(vector2); numericAttrFn.setStorable(true); //Projection axis attributes ,needs to be created as compound in order to set a default value // X axis projAxisXa = numericAttrFn.create("xAxisProjectionX","xPrjx",MFnNumericData::kFloat,1); addAttribute(projAxisXa); numericAttrFn.setStorable(true); projAxisXb = numericAttrFn.create("xAxisProjectionY","xPrjy",MFnNumericData::kFloat,0); addAttribute(projAxisXa); numericAttrFn.setStorable(true); projAxisXc = numericAttrFn.create("xAxisProjectionZ","xPrjz",MFnNumericData::kFloat,0); addAttribute(projAxisXa); numericAttrFn.setStorable(true); MFnCompoundAttribute compund; projAxisX= compund.create("xAxisProjection","xproj"); compund.addChild(projAxisXa); compund.addChild(projAxisXb); compund.addChild(projAxisXc); addAttribute(projAxisX); // Y axis projAxisYa = numericAttrFn.create("yAxisProjectionX","yPrjx",MFnNumericData::kFloat,0); addAttribute(projAxisYa); numericAttrFn.setStorable(true); projAxisYb = numericAttrFn.create("yAxisProjectionY","yPrjy",MFnNumericData::kFloat,1); addAttribute(projAxisYb); numericAttrFn.setStorable(true); projAxisYc = numericAttrFn.create("yAxisProjectionZ","yPrjz",MFnNumericData::kFloat,0); addAttribute(projAxisYc); numericAttrFn.setStorable(true); projAxisY= compund.create("yAxisProjection","yproj"); compund.addChild(projAxisYa); compund.addChild(projAxisYb); compund.addChild(projAxisYc); addAttribute(projAxisY); // Z axis projAxisZa = numericAttrFn.create("zAxisProjectionX","zPrjx",MFnNumericData::kFloat,0); addAttribute(projAxisZa); numericAttrFn.setStorable(true); projAxisZb = numericAttrFn.create("zAxisProjectionY","zPrjy",MFnNumericData::kFloat,0); addAttribute(projAxisZb); numericAttrFn.setStorable(true); projAxisZc = numericAttrFn.create("zAxisProjectionZ","zPrjz",MFnNumericData::kFloat,1); addAttribute(projAxisZc); numericAttrFn.setStorable(true); projAxisZ= compund.create("zAxisProjection","zproj"); compund.addChild(projAxisZa); compund.addChild(projAxisZb); compund.addChild(projAxisZc); addAttribute(projAxisZ); //normalize attribute normalize=numericAttrFn.create("normalize","n",MFnNumericData::kBoolean ); addAttribute(normalize); numericAttrFn.setStorable(true); //Output attribute that will hold the dot product value dotProductA = numericAttrFn.create("dotProduct","dp",MFnNumericData::kFloat); addAttribute(dotProductA); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //dot product max value dotProductMax = numericAttrFn.create("dotProductMaxValue","dpm",MFnNumericData::kFloat); addAttribute(dotProductMax); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //Input vector1 projection on vector 2 proj1on2 = numericAttrFn.createPoint("projectionV1onV2","pV1"); addAttribute(proj1on2); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //Input vector2 projection on vector 1 proj2on1 = numericAttrFn.createPoint("projectionV2onV1","pV2"); addAttribute(proj2on1); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //angle inbetween angleInBetweenAttr = numericAttrFn.create("angleInBetween","aib",MFnNumericData::kFloat); addAttribute(angleInBetweenAttr); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //Output attribute that will hold Xvalue of the angle inbetween angleX = numericAttrFn.create("angleX","ax",MFnNumericData::kFloat); addAttribute(angleX); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //Output attribute that will hold Xvalue of the angle inbetween angleY = numericAttrFn.create("angleY","ay",MFnNumericData::kFloat); addAttribute(angleY); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //Output attribute that will hold Xvalue of the angle inbetween angleZ = numericAttrFn.create("angleZ","az",MFnNumericData::kFloat); addAttribute(angleZ); numericAttrFn.setWritable(false); numericAttrFn.setStorable(false); //setting attribute affects attributeAffects(vector1,dotProductA); attributeAffects(vector2,dotProductA); attributeAffects(normalize,dotProductA); attributeAffects(vector1,dotProductMax); attributeAffects(vector2,dotProductMax); attributeAffects(normalize,dotProductMax); attributeAffects(vector1,proj1on2); attributeAffects(vector2,proj1on2); attributeAffects(vector1,proj2on1); attributeAffects(vector2,proj2on1); attributeAffects(vector1,angleInBetweenAttr); attributeAffects(vector2,angleInBetweenAttr); attributeAffects(vector1,angleX); attributeAffects(vector2,angleX); attributeAffects(vector1,angleY); attributeAffects(vector2,angleY); attributeAffects(vector1,angleZ); attributeAffects(vector2,angleZ); attributeAffects(projAxisXa,angleX); attributeAffects(projAxisXb,angleX); attributeAffects(projAxisXc,angleX); attributeAffects(projAxisYa,angleX); attributeAffects(projAxisYb,angleX); attributeAffects(projAxisYc,angleX); attributeAffects(projAxisZa,angleX); attributeAffects(projAxisZb,angleX); attributeAffects(projAxisZc,angleX); attributeAffects(projAxisXa,angleY); attributeAffects(projAxisXb,angleY); attributeAffects(projAxisXc,angleY); attributeAffects(projAxisYa,angleY); attributeAffects(projAxisYb,angleY); attributeAffects(projAxisYc,angleY); attributeAffects(projAxisZa,angleY); attributeAffects(projAxisZb,angleY); attributeAffects(projAxisZc,angleY); attributeAffects(projAxisXb,angleZ); attributeAffects(projAxisXc,angleZ); attributeAffects(projAxisYa,angleZ); attributeAffects(projAxisYb,angleZ); attributeAffects(projAxisYc,angleZ); attributeAffects(projAxisZa,angleZ); attributeAffects(projAxisZb,angleZ); attributeAffects(projAxisZc,angleZ); 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; }
MStatus VmIslandNode::initialize() { fprintf( stderr, "VmIslandNode::initialize()...\n" ); MStatus status; //Seed attribute { MFnNumericAttribute numericAttrFn; ia_seed = numericAttrFn.create( "seed", "sD", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 1000 ); numericAttrFn.setDefault ( 0 ); status = addAttribute( ia_seed ); CHECK_MSTATUS( status ); } //Roughness attribute { MFnNumericAttribute numericAttrFn; ia_roughness = numericAttrFn.create( "roughness", "rG", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 1 ); numericAttrFn.setDefault ( 0.75 ); status = addAttribute( ia_roughness ); CHECK_MSTATUS( status ); } //Plane Height attribute { MFnNumericAttribute numericAttrFn; ia_planeHeight = numericAttrFn.create( "planeHeight", "pH", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 2000 ); numericAttrFn.setDefault ( 5 ); status = addAttribute( ia_planeHeight ); CHECK_MSTATUS( status ); } //Plane smoothing attribute { MFnNumericAttribute numericAttrFn; ia_smooth = numericAttrFn.create( "smoothingStrength", "sS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setMax( 6 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_smooth ); CHECK_MSTATUS( status ); } //Plane resolution attribute { MFnNumericAttribute numericAttrFn; ia_resolution = numericAttrFn.create( "mayaResolution", "mR", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 10 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_resolution ); CHECK_MSTATUS( status ); } //Renderman resolution attribute { MFnNumericAttribute numericAttrFn; ia_rmanResolution = numericAttrFn.create( "rendermanResolution", "rR", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 10 ); numericAttrFn.setDefault ( 6 ); status = addAttribute( ia_rmanResolution ); CHECK_MSTATUS( status ); } //Plane size attribute { MFnNumericAttribute numericAttrFn; ia_planeSize = numericAttrFn.create( "planeSizeScale", "pS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 200 ); numericAttrFn.setDefault ( 20 ); status = addAttribute( ia_planeSize ); CHECK_MSTATUS( status ); } //Plane size attribute { MFnNumericAttribute numericAttrFn; ia_gridSize = numericAttrFn.create( "gridSize", "gS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 10 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_gridSize ); CHECK_MSTATUS( status ); } //Grass multiplier - Affects how many instances are spawned { MFnNumericAttribute numericAttrFn; ia_grassMultiplier = numericAttrFn.create( "grassInstanceMultiplier", "gM", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 1 ); numericAttrFn.setMax( 100 ); numericAttrFn.setDefault ( 1 ); status = addAttribute( ia_grassMultiplier ); CHECK_MSTATUS( status ); } //Grass multiplier - Affects how many instances are spawned { MFnNumericAttribute numericAttrFn; ia_baseWidth = numericAttrFn.create( "grassBaseWidth", "bW", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.01f ); numericAttrFn.setMax( 2.0f ); numericAttrFn.setDefault ( 0.6f ); status = addAttribute( ia_baseWidth ); CHECK_MSTATUS( status ); } //Grass segment length - Length of segment pieces { MFnNumericAttribute numericAttrFn; ia_grassSegmentLength = numericAttrFn.create( "grassSegmentLength", "gSL", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.001f ); numericAttrFn.setMax( 10.0f ); numericAttrFn.setDefault ( 1.0f ); status = addAttribute( ia_grassSegmentLength ); CHECK_MSTATUS( status ); } //Number of segments per piece of grass { MFnNumericAttribute numericAttrFn; ia_grassNumSegments = numericAttrFn.create( "numberOfGrassSegments", "nGS", MFnNumericData::kLong, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 3 ); numericAttrFn.setMax( 20 ); numericAttrFn.setDefault ( 5 ); status = addAttribute( ia_grassNumSegments ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_windDirection = numericAttrFn.createPoint( "windDirection", "wDir"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(1.0f, 0.0f, 1.0f); status = addAttribute( ia_windDirection ); CHECK_MSTATUS( status ); } //Grass bend factor { MFnNumericAttribute numericAttrFn; ia_grassBendAmount = numericAttrFn.create( "grassBendFactor", "gBF", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.0f ); numericAttrFn.setMax( 1.0f ); numericAttrFn.setDefault ( 0.0f ); status = addAttribute( ia_grassBendAmount ); CHECK_MSTATUS( status ); } //Wind strength { MFnNumericAttribute numericAttrFn; ia_windSpread = numericAttrFn.create( "windSpread", "wS", MFnNumericData::kFloat, 0, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0.01f ); numericAttrFn.setMax( 10.0f ); numericAttrFn.setDefault ( 5.0f ); status = addAttribute( ia_windSpread ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassBaseColour1 = numericAttrFn.createColor( "grassBaseColour1", "bCol1"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.0f,0.251f,0.167f); status = addAttribute( ia_grassBaseColour1 ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassTipColour1 = numericAttrFn.createColor( "grassTipColour1", "tCol1"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.395f,0.551f,0.257f); status = addAttribute( ia_grassTipColour1 ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassBaseColour2 = numericAttrFn.createColor( "grassBaseColour2", "bCol2"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.275f,0.243f,0.043f); status = addAttribute( ia_grassBaseColour2 ); CHECK_MSTATUS( status ); } //Initial grass bend direction { MFnNumericAttribute numericAttrFn; ia_grassTipColour2 = numericAttrFn.createColor( "grassTipColour2", "tCol2"); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( true ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setDefault(0.611f,0.587f,0.257f); status = addAttribute( ia_grassTipColour2 ); CHECK_MSTATUS( status ); } //Clock attribute. Passes maya frame counter into node { MFnNumericAttribute numericAttrFn; ia_clock = numericAttrFn.create( "clock", "clk", MFnNumericData::kLong, false, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( false ); numericAttrFn.setKeyable( true ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( false ); numericAttrFn.setMin( 0 ); numericAttrFn.setDefault( 0 ); status = addAttribute( ia_clock ); CHECK_MSTATUS( status ); } // "drawStyle" // // How we should draw in Maya. // // We will use this value in our Maya plug-in, but we // will NOT use it in Renderman. Note elsewhere that // this value will not be sent to Renderman, nor will // it have any effect on RIB generation. // // We think of this as an input attribute - hence the // prefix "ia_" for "input attribute". { MFnEnumAttribute enumAttrFn; ia_drawStyle = enumAttrFn.create( "drawStyle", "ds", 1, & status ); CHECK_MSTATUS( status ); enumAttrFn.setReadable( true ); enumAttrFn.setWritable( true ); enumAttrFn.setStorable( true ); enumAttrFn.setKeyable( true ); enumAttrFn.setConnectable( true ); enumAttrFn.setHidden( false ); enumAttrFn.addField( "Bounds", 0 ); enumAttrFn.addField( "Sub bounds", 1 ); enumAttrFn.addField( "Geometry", 2 ); enumAttrFn.addField( "Terrain slope normals", 3 ); enumAttrFn.addField( "Point instances", 4 ); enumAttrFn.addField( "Wind Velocity", 5 ); enumAttrFn.addField( "All", 6 ); enumAttrFn.setDefault(3); status = addAttribute( ia_drawStyle ); CHECK_MSTATUS( status ); } // "update" // // A 'dummy' attribute, and a powerful one. Although // the value of this attribute is actually meaningless, // when we ask for it we trigger an important computation // processs. // // We think of this as an input attribute - hence the // prefix "oa_" for "computation attribute". This signifies // that we don't really care about it's final value, but // that we know it's going to compute a lot of stuff. { MFnNumericAttribute numericAttrFn; oa_update = numericAttrFn.create( "update", "upd", MFnNumericData::kBoolean, false, & status ); CHECK_MSTATUS( status ); numericAttrFn.setReadable( true ); numericAttrFn.setWritable( true ); numericAttrFn.setStorable( false ); numericAttrFn.setKeyable( false ); numericAttrFn.setConnectable( true ); numericAttrFn.setHidden( true ); status = addAttribute( oa_update ); CHECK_MSTATUS( status ); } // "rib" // // A string which contains all the attributes, and that // we need to have (and indeed will see again) on the // Renderman side of things. // // We think of this as an output attribute - hence the // prefix "oa_" for "output attribute". The value // computed for this attribute (the string) is important, // an is used by whatever is asking for it. { MFnTypedAttribute typedAttrFn; oa_rib = typedAttrFn.create( "rib", "rb", MFnData::kString, MObject::kNullObj, & status ); CHECK_MSTATUS( status ); typedAttrFn.setReadable( true ); typedAttrFn.setWritable( true ); typedAttrFn.setStorable( false ); typedAttrFn.setKeyable( false ); typedAttrFn.setConnectable( true ); typedAttrFn.setHidden( true ); status = addAttribute( oa_rib ); CHECK_MSTATUS( status ); } // This section tells Maya what attribute effects // which attribute. When input attributes change, // make the attributes they effect "dirty". That // means that, when Maya asks for a dirty attribute, // it will need to be computed and "cleaned". // // Changing an effecting "input" attribute does not // trigger a computation of it's effected "output" // attribute. It just tells Maya that - if the effected // attribute is ever asked for, it will have to call // the compute method to calculate it. // // For complex relationships between attributes, // an attributeEffects() call must exist for each // relationship. If A effects B, and B effects C, // then we will need to make two attributeEffects() // calls - one for A effecting B and one for B // effecting C. Maya will not figure out that, if A // effects B, and B effets C, then A must effect C. // // Below we see that most "input" attributes effect // both our internal update and the rib generation // the same way in each case. But it's not always // exactly the same like this. // // Notice also that ia_drawStyle does not effect // any of the attributes. It's something that's just // used in the draw method. attributeAffects( ia_seed, oa_update ); attributeAffects( ia_seed, oa_rib ); attributeAffects( ia_roughness, oa_update ); attributeAffects( ia_roughness, oa_rib ); attributeAffects( ia_smooth, oa_update ); attributeAffects( ia_smooth, oa_rib ); attributeAffects( ia_planeHeight, oa_update ); attributeAffects( ia_planeHeight, oa_rib ); attributeAffects( ia_resolution, oa_update ); attributeAffects( ia_rmanResolution, oa_rib ); attributeAffects( ia_planeSize, oa_update ); attributeAffects( ia_planeSize, oa_rib ); attributeAffects( ia_gridSize, oa_update ); attributeAffects( ia_gridSize, oa_rib ); attributeAffects( ia_grassMultiplier, oa_update ); attributeAffects( ia_grassMultiplier, oa_rib ); attributeAffects( ia_baseWidth, oa_update ); attributeAffects( ia_baseWidth, oa_rib ); attributeAffects( ia_grassSegmentLength, oa_update ); attributeAffects( ia_grassSegmentLength, oa_rib ); attributeAffects( ia_grassNumSegments, oa_update ); attributeAffects( ia_grassNumSegments, oa_rib ); attributeAffects( ia_grassBendAmount, oa_update ); attributeAffects( ia_grassBendAmount, oa_rib ); attributeAffects( ia_windDirection, oa_update ); attributeAffects( ia_windDirection, oa_rib ); attributeAffects( ia_windSpread, oa_update ); attributeAffects( ia_windSpread, oa_rib ); attributeAffects( ia_clock, oa_update ); attributeAffects( ia_clock, oa_rib ); attributeAffects( ia_grassBaseColour1, oa_update); attributeAffects( ia_grassBaseColour1, oa_rib); attributeAffects( ia_grassTipColour1, oa_update); attributeAffects( ia_grassTipColour1, oa_rib); attributeAffects( ia_grassBaseColour2, oa_update); attributeAffects( ia_grassBaseColour2, oa_rib); attributeAffects( ia_grassTipColour2, oa_update); attributeAffects( ia_grassTipColour2, oa_rib); fprintf( stderr, "VmIslandNode::initialize() done\n" ); return MStatus::kSuccess; }
MStatus hwPhongShader::initialize() { // Make sure that all attributes are cached internal for // optimal performance ! TRACE_API_CALLS("initialize"); MFnNumericAttribute nAttr; // Create input attributes aColor = nAttr.createColor( "color", "c"); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(0.1f, 0.1f, 0.1f); nAttr.setCached( true ); nAttr.setInternal( true ); aDiffuseColor = nAttr.createColor( "diffuseColor", "dc" ); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(1.f, 0.5f, 0.5f); nAttr.setCached( true ); nAttr.setInternal( true ); aSpecularColor = nAttr.createColor( "specularColor", "sc" ); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(0.5f, 0.5f, 0.5f); nAttr.setCached( true ); nAttr.setInternal( true ); // This is defined as a point, so that users can easily enter // values beyond 1. aShininess = nAttr.createPoint( "shininess", "sh" ); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(100.0f, 100.0f, 100.0f); nAttr.setCached( true ); nAttr.setInternal( true ); aGeometryShape = nAttr.create( "geometryShape", "gs", MFnNumericData::kInt ); nAttr.setStorable(true); nAttr.setKeyable(true); nAttr.setDefault(0); nAttr.setCached( true ); nAttr.setInternal( true ); // create output attributes here // outColor is the only output attribute and it is inherited // so we do not need to create or add it. // // Add the attributes here addAttribute(aColor); addAttribute(aDiffuseColor); addAttribute(aSpecularColor); addAttribute(aShininess); addAttribute(aGeometryShape); attributeAffects (aColor, outColor); attributeAffects (aDiffuseColor, outColor); attributeAffects (aSpecularColor, outColor); attributeAffects (aShininess, outColor); return MS::kSuccess; }
MStatus OnbShader::initialize() { MFnNumericAttribute nAttr; MFnLightDataAttribute lAttr; // Outputs MObject outcR = nAttr.create("outColorR", "ocr", MFnNumericData::kFloat, 0.0); MObject outcG = nAttr.create("outColorG", "ocg", MFnNumericData::kFloat, 0.0); MObject outcB = nAttr.create("outColorB", "ocb", MFnNumericData::kFloat, 0.0); aOutColor = nAttr.create("outColor", "oc", outcR, outcG, outcB); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(nAttr.setUsedAsColor(true)); MObject outtR = nAttr.create("outTransparencyR", "otr", MFnNumericData::kFloat, 0.0); MObject outtG = nAttr.create("outTransparencyG", "otg", MFnNumericData::kFloat, 0.0); MObject outtB = nAttr.create("outTransparencyB", "otb", MFnNumericData::kFloat, 0.0); aOutTransparency = nAttr.create("outTransparency", "ot", outtR, outtG, outtB); MAKE_OUTPUT(nAttr); CHECK_MSTATUS(nAttr.setUsedAsColor(true)); // Inputs MObject cR = nAttr.create("colorR", "cr", MFnNumericData::kFloat, 0.5); MObject cG = nAttr.create("colorG", "cg", MFnNumericData::kFloat, 0.5); MObject cB = nAttr.create("colorB", "cb", MFnNumericData::kFloat, 0.5); aColor = nAttr.create("color", "c", cR, cG, cB); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setUsedAsColor(true)); aRoughness = nAttr.create("roughness", "r", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f)); CHECK_MSTATUS(nAttr.setMax(1.0f)); CHECK_MSTATUS(nAttr.setDefault(0.3f)); MObject tR = nAttr.create("transparencyR", "itr", MFnNumericData::kFloat, 0.0); MObject tG = nAttr.create("transparencyG", "itg", MFnNumericData::kFloat, 0.0); MObject tB = nAttr.create("transparencyB", "itb", MFnNumericData::kFloat, 0.0); aTransparency = nAttr.create("transparency", "it", tR, tG, tB); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setUsedAsColor(true)); MObject aR = nAttr.create("ambientColorR", "acr", MFnNumericData::kFloat, 0.0); MObject aG = nAttr.create("ambientColorG", "acg", MFnNumericData::kFloat, 0.0); MObject aB = nAttr.create("ambientColorB", "acb", MFnNumericData::kFloat, 0.0); aAmbientColor = nAttr.create("ambientColor", "ambc", aR, aG, aB); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setUsedAsColor(true)); MObject iR = nAttr.create("incandescenceR", "ir", MFnNumericData::kFloat, 0.0); MObject iG = nAttr.create("incandescenceG", "ig", MFnNumericData::kFloat, 0.0); MObject iB = nAttr.create("incandescenceB", "ib", MFnNumericData::kFloat, 0.0); aIncandescence = nAttr.create("incandescence", "ic", iR, iG, iB); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setUsedAsColor(true)); MObject sR = nAttr.create("specularColorR", "sr", MFnNumericData::kFloat, 1.0); MObject sG = nAttr.create("specularColorG", "sg", MFnNumericData::kFloat, 1.0); MObject sB = nAttr.create("specularColorB", "sb", MFnNumericData::kFloat, 1.0); aSpecularColor = nAttr.create("specularColor", "sc", sR, sG, sB); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setUsedAsColor(true)); aEccentricity = nAttr.create("eccentricity", "ecc", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f)); CHECK_MSTATUS(nAttr.setMax(1.0f)); CHECK_MSTATUS(nAttr.setDefault(0.1f)); aSpecularRollOff = nAttr.create("specularRollOff", "sro", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setMin(0.0f)); CHECK_MSTATUS(nAttr.setMax(1.0f)); CHECK_MSTATUS(nAttr.setDefault(0.7f)); aNormalCamera = nAttr.createPoint("normalCamera", "n"); MAKE_INPUT(nAttr); CHECK_MSTATUS(nAttr.setDefault(1.0f, 1.0f, 1.0f)); // Attributes for compute() aRayDirection = nAttr.createPoint("rayDirection", "rd"); 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)); 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)); // Add Attributes CHECK_MSTATUS(addAttribute(aOutColor)); CHECK_MSTATUS(addAttribute(aOutTransparency)); CHECK_MSTATUS(addAttribute(aColor)); CHECK_MSTATUS(addAttribute(aRoughness)); CHECK_MSTATUS(addAttribute(aTransparency)); CHECK_MSTATUS(addAttribute(aAmbientColor)); CHECK_MSTATUS(addAttribute(aIncandescence)); CHECK_MSTATUS(addAttribute(aSpecularColor)); CHECK_MSTATUS(addAttribute(aEccentricity)); CHECK_MSTATUS(addAttribute(aSpecularRollOff)); CHECK_MSTATUS(addAttribute(aNormalCamera)); CHECK_MSTATUS(addAttribute(aRayDirection)); CHECK_MSTATUS(addAttribute(aLightData)); // Attribute affects relationships CHECK_MSTATUS(attributeAffects(aColor, aOutColor)); CHECK_MSTATUS(attributeAffects(aColor, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aRoughness, aOutColor)); CHECK_MSTATUS(attributeAffects(aRoughness, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aTransparency, aOutColor)); CHECK_MSTATUS(attributeAffects(aTransparency, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aAmbientColor, aOutColor)); CHECK_MSTATUS(attributeAffects(aAmbientColor, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aIncandescence, aOutColor)); CHECK_MSTATUS(attributeAffects(aIncandescence, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aSpecularColor, aOutColor)); CHECK_MSTATUS(attributeAffects(aSpecularColor, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aEccentricity, aOutColor)); CHECK_MSTATUS(attributeAffects(aEccentricity, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aNormalCamera, aOutColor)); CHECK_MSTATUS(attributeAffects(aNormalCamera, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aRayDirection, aOutColor)); CHECK_MSTATUS(attributeAffects(aRayDirection, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aSpecularRollOff, aOutColor)); CHECK_MSTATUS(attributeAffects(aSpecularRollOff, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightDirection, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightDirection, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightIntensity, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightIntensity, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightAmbient, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightAmbient, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightDiffuse, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightDiffuse, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightSpecular, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightSpecular, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightShadowFraction, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightShadowFraction, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aPreShadowIntensity, aOutColor)); CHECK_MSTATUS(attributeAffects(aPreShadowIntensity, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightBlindData, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightBlindData, aOutTransparency)); CHECK_MSTATUS(attributeAffects(aLightData, aOutColor)); CHECK_MSTATUS(attributeAffects(aLightData, aOutTransparency)); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus InterpNode::initialize() { MFnNumericAttribute nAttr; // Inputs and Attributes // // User defined attributes require a long-name and short-name that // are required to be unique within the node. // (See the compound attribute color1 named "Sides".) // // Rendering attributes that your node wants to get from the sampler // require them to be defined given the pre-defined unique long-name. // (See the compound attribute aNormalCamera named "normalCamera".) // // User defined Attributes are generally something that you want // to store in the Maya file. The setStorable(true) method enables // an attribute to be stored into the Maya scene file. // // Rendering attributes are primarily data that is generated per sample and // not something that you want to store in a file. To disable an // attribute from being recorded to the Maya scene file use // the setStorable(false) method. // // Simple attributes that represent a range of values can enable a // slider on the Attribute Editor by using the methods setMin() and // setMax(). // (See the simple attribute InputValue named "Power".) // // Compound attributes that represent a vector of 3 floats can enable // a color swatch on the Attribute Editor that will launch a color picker // tool by using the method setUsedAsColor(true). // (See the compound attribute color1 name "Sides".) // // Both Simple and Compound attributes can be initialized with a // default value using the method setDefault(). // // Attributes by default show up in the Attribute Editor and // in the Connection Editor unless they are specified as being hidden // by using the method setHidden(true). // // Attributes by default have both read/write access in the dependency graph. // To change an attributes behaviour you can use the methods // setReadable() and setWritable(). The method setReadable(true) // indicates that the attribute can be used as the source in // a dependency graph connection. The method setWritable(true) // indicates that the attribute can be used as the destination // in a dependency graph connection. // (See the compound attribute aOutColor named "outColor" below. // It has been marked as a read-only attribute since it is // the computed result of the node, it is not stored in the Maya file since // it is always computed, and it is marked as hidden to prevent it // from being displayed in the user interface.) // // // User defined input value aInputValue = nAttr.create( "power", "pow", MFnNumericData::kFloat); CHECK_MSTATUS ( nAttr.setDefault(1.0f) ); CHECK_MSTATUS ( nAttr.setMin(0.0f) ); CHECK_MSTATUS ( nAttr.setMax(3.0f) ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(true) ); // User defined color attribute aColor1 = nAttr.createColor( "sideColor", "sc"); CHECK_MSTATUS ( nAttr.setDefault(1.0f, 1.0f, 1.0f) ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setUsedAsColor(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(true) ); aColor2 = nAttr.createColor( "facingColor", "fc"); CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.0f, 0.0f) ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setUsedAsColor(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(true) ); // Surface Normal supplied by the render sampler aNormalCamera = nAttr.createPoint( "normalCamera", "n"); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(true) ); // Point on surface in camera space, will be used to compute view vector aPointCamera = nAttr.createPoint( "pointCamera", "p"); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(true) ); // Outputs // // Always set your output attributes to be read-only // You should also mark any internal attributes that your node // computes to be read-only also, this will prevent any connections. aOutColor = nAttr.createColor( "outColor", "oc" ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( addAttribute(aInputValue) ); CHECK_MSTATUS ( addAttribute(aColor1) ); CHECK_MSTATUS ( addAttribute(aColor2) ); CHECK_MSTATUS ( addAttribute(aNormalCamera) ); CHECK_MSTATUS ( addAttribute(aPointCamera) ); CHECK_MSTATUS ( addAttribute(aOutColor) ); CHECK_MSTATUS ( attributeAffects (aInputValue, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aColor1, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aColor2, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aNormalCamera, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aPointCamera, aOutColor) ); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus ShadowMatte::initialize() { MFnNumericAttribute nAttr; MFnLightDataAttribute lAttr; // Outputs aViewColor = nAttr.create( "viewColor", "vc", MFnNumericData::kBoolean); nAttr.setKeyable(true); nAttr.setStorable(true); nAttr.setHidden(false); nAttr.setDefault(true); aOutColor = nAttr.createColor( "outColor", "oc"); nAttr.setStorable(false); nAttr.setHidden(false); nAttr.setReadable(true); nAttr.setWritable(false); aOutTransparency = nAttr.createColor( "outTransparency", "ot" ); nAttr.setStorable(false); nAttr.setHidden(false); nAttr.setReadable(true); nAttr.setWritable(false); // Inputs aLightDirection = nAttr.createPoint( "lightDirection", "ld" ); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); nAttr.setDefault(1.0f, 1.0f, 1.0f); aLightIntensity = nAttr.createColor( "lightIntensity", "li" ); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); nAttr.setDefault(1.0f, 1.0f, 1.0f); aLightAmbient = nAttr.create( "lightAmbient", "la", MFnNumericData::kBoolean); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); nAttr.setDefault(true); aLightDiffuse = nAttr.create( "lightDiffuse", "ldf", MFnNumericData::kBoolean); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); nAttr.setDefault(true); aLightSpecular = nAttr.create( "lightSpecular", "ls", MFnNumericData::kBoolean); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); nAttr.setDefault(false); aLightShadowFraction = nAttr.create("lightShadowFraction", "lsf", MFnNumericData::kFloat); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); nAttr.setDefault(0.0f); aPreShadowIntensity = nAttr.create("preShadowIntensity", "psi", MFnNumericData::kFloat); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); nAttr.setDefault(0.0f); aLightBlindData = nAttr.createAddr("lightBlindData", "lbld"); nAttr.setStorable(false); nAttr.setHidden(true); nAttr.setReadable(true); nAttr.setWritable(false); aLightData = lAttr.create( "lightDataArray", "ltd", aLightDirection, aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular, aLightShadowFraction, aPreShadowIntensity, aLightBlindData); lAttr.setArray(true); lAttr.setStorable(false); lAttr.setHidden(true); lAttr.setDefault(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, true, false, 0.0f, 1.0f, NULL); addAttribute(aLightData); addAttribute(aOutColor); addAttribute(aOutTransparency); addAttribute(aViewColor); attributeAffects (aViewColor, aOutColor); attributeAffects (aLightIntensity, aOutColor); attributeAffects (aLightData, aOutColor); attributeAffects (aLightAmbient, aOutColor); attributeAffects (aLightSpecular, aOutColor); attributeAffects (aLightDiffuse, aOutColor); attributeAffects (aLightDirection, aOutColor); attributeAffects (aLightShadowFraction, aOutColor); attributeAffects (aPreShadowIntensity, aOutColor); attributeAffects (aLightBlindData, aOutColor); attributeAffects (aViewColor, aOutTransparency); attributeAffects (aLightIntensity, aOutTransparency); attributeAffects (aLightData, aOutTransparency); attributeAffects (aLightAmbient, aOutTransparency); attributeAffects (aLightSpecular, aOutTransparency); attributeAffects (aLightDiffuse, aOutTransparency); attributeAffects (aLightDirection, aOutTransparency); attributeAffects (aLightShadowFraction, aOutTransparency); attributeAffects (aPreShadowIntensity, aOutTransparency); attributeAffects (aLightBlindData, aOutTransparency); return MS::kSuccess; }
MStatus MayaToKrayGlobals::initialize() { MayaRenderGlobalsNode::initialize(); MFnNumericAttribute nAttr; MFnTypedAttribute tAttr; MFnGenericAttribute gAttr; MFnEnumAttribute eAttr; MStatus stat = MStatus::kSuccess; // DOF (depth of field) and motion blur will not work in adaptive mode. samplingType = eAttr.create( "samplingType", "samplingType", 0, &stat); stat = eAttr.addField( "None", 0 ); stat = eAttr.addField( "Grid", 1 ); stat = eAttr.addField( "Qasi Random", 2 ); stat = eAttr.addField( "Random Full Screen AA", 3 ); CHECK_MSTATUS(addAttribute( samplingType )); rotateGrid = nAttr.create("rotateGrid", "rotateGrid", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( rotateGrid )); gridSize = nAttr.create("gridSize", "gridSize", MFnNumericData::kInt, 2); CHECK_MSTATUS(addAttribute( gridSize )); filterRadius = nAttr.create("filterRadius", "filterRadius", MFnNumericData::kFloat, 0.7); CHECK_MSTATUS(addAttribute( filterRadius )); aa_edgeAbsolute = nAttr.create("aa_edgeAbsolute", "aa_edgeAbsolute", MFnNumericData::kFloat, 0.2); CHECK_MSTATUS(addAttribute( aa_edgeAbsolute )); aa_relative = nAttr.create("aa_relative", "aa_relative", MFnNumericData::kFloat, 0.2); CHECK_MSTATUS(addAttribute( aa_relative )); aa_thickness = nAttr.create("aa_thickness", "aa_thickness", MFnNumericData::kInt, 1); CHECK_MSTATUS(addAttribute( aa_thickness )); aa_overburn = nAttr.create("aa_overburn", "aa_overburn", MFnNumericData::kFloat, 1.0); CHECK_MSTATUS(addAttribute( aa_overburn )); aa_normal = nAttr.create("aa_normal", "aa_normal", MFnNumericData::kFloat, 0.1); CHECK_MSTATUS(addAttribute( aa_normal )); aa_z = nAttr.create("aa_z", "aa_z", MFnNumericData::kFloat, 0.1); CHECK_MSTATUS(addAttribute( aa_z )); aa_undersample = nAttr.create("aa_undersample", "aa_undersample", MFnNumericData::kFloat, 0.2); CHECK_MSTATUS(addAttribute( aa_undersample )); aa_threshold = nAttr.create("aa_threshold", "aa_threshold", MFnNumericData::kFloat, 0.01); CHECK_MSTATUS(addAttribute( aa_threshold )); aa_minRays = nAttr.create("aa_minRays", "aa_minRays", MFnNumericData::kInt, 2); CHECK_MSTATUS(addAttribute( aa_minRays )); aa_maxRays = nAttr.create("aa_maxRays", "aa_maxRays", MFnNumericData::kInt, 2); CHECK_MSTATUS(addAttribute( aa_maxRays )); aa_rays = nAttr.create("aa_rays", "aa_rays", MFnNumericData::kInt, 2); CHECK_MSTATUS(addAttribute( aa_rays )); mb_subframes = nAttr.create("mb_subframes", "mb_subframes", MFnNumericData::kInt, 2); CHECK_MSTATUS(addAttribute( mb_subframes )); aa_upsample = nAttr.create("aa_upsample", "aa_upsample", MFnNumericData::kInt, 2); CHECK_MSTATUS(addAttribute( aa_upsample )); diffuseModel = eAttr.create( "diffuseModel", "diffuseModel", 2, &stat); stat = eAttr.addField( "Raytrace", 0 ); stat = eAttr.addField( "Photon Estimate", 1 ); stat = eAttr.addField( "Photon Mapping", 2 ); stat = eAttr.addField( "Path tracing", 3 ); //stat = eAttr.addField( "Cache irradiance", 3 ); //stat = eAttr.addField( "Caustics", 5 ); CHECK_MSTATUS(addAttribute( diffuseModel )); doCaustics = nAttr.create("doCaustics", "doCaustics", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( doCaustics )); diffuseModelPhoton = eAttr.create( "diffuseModelPhoton", "diffuseModelPhoton", 0, &stat); stat = eAttr.addField( "Global Filtered", 0 ); stat = eAttr.addField( "Global Unfiltered", 1 ); stat = eAttr.addField( "Precomputed Filtered", 2 ); stat = eAttr.addField( "Precomputed Unfiltered", 3 ); CHECK_MSTATUS(addAttribute( diffuseModelPhoton )); giMode = eAttr.create( "giMode", "giMode", 0, &stat); stat = eAttr.addField( "Independent", 0 ); stat = eAttr.addField( "Time interpolation", 1 ); stat = eAttr.addField( "Shared for all frames", 2 ); CHECK_MSTATUS(addAttribute( giMode )); pixelOrder = eAttr.create( "pixelOrder", "pixelOrder", 0, &stat); stat = eAttr.addField( "Scanline", 0 ); stat = eAttr.addField( "Scancolumn", 1 ); stat = eAttr.addField( "Random", 2 ); stat = eAttr.addField( "Progressive", 3 ); stat = eAttr.addField( "RenderWorm", 4 ); stat = eAttr.addField( "Frost", 5 ); CHECK_MSTATUS(addAttribute( pixelOrder )); bitdepth = eAttr.create( "bitdepth", "bitdepth", 0, &stat); stat = eAttr.addField( "8bit Integer", 0 ); stat = eAttr.addField( "16bit Integer", 1 ); //stat = eAttr.addField( "32bit Integer", 2 ); //stat = eAttr.addField( "16bit Float(Half)", 3 ); //stat = eAttr.addField( "32bit Float", 4 ); //stat = eAttr.addField( "64bit Double", 5 ); CHECK_MSTATUS(addAttribute( bitdepth )); colorSpace = eAttr.create( "colorSpace", "colorSpace", 0, &stat); stat = eAttr.addField( "linear_rgb", 0 ); stat = eAttr.addField( "srgb", 1 ); stat = eAttr.addField( "ciexyz", 2 ); CHECK_MSTATUS(addAttribute( colorSpace )); lightingEngine = eAttr.create( "lightingEngine", "lightingEngine", 0, &stat); stat = eAttr.addField( "Path tracing", 0 ); stat = eAttr.addField( "Distributed Raytracing", 1 ); CHECK_MSTATUS(addAttribute( lightingEngine )); clamping = nAttr.create("clamping", "clamping", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( clamping )); maxError = nAttr.create("maxError", "maxError", MFnNumericData::kFloat, 0.01); CHECK_MSTATUS(addAttribute( maxError )); caustics = nAttr.create("caustics", "caustics", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( caustics )); diffuseDepth = nAttr.create("diffuseDepth", "diffuseDepth", MFnNumericData::kInt, 4); CHECK_MSTATUS(addAttribute( diffuseDepth )); glossyDepth = nAttr.create("glossyDepth", "glossyDepth", MFnNumericData::kInt, 4); CHECK_MSTATUS(addAttribute( glossyDepth )); // reduced to auto because we do not need the others (I hope) remove the whole attribute in the next release assemblyExportType = eAttr.create( "assemblyExportType", "assemblyExportType", 0, &stat); stat = eAttr.addField( "Auto", 0 ); CHECK_MSTATUS(addAttribute( assemblyExportType )); assemblyPolyTheshold = nAttr.create("assemblyPolyTheshold", "assemblyPolyTheshold", MFnNumericData::kInt, 10000); CHECK_MSTATUS(addAttribute( assemblyPolyTheshold )); environmentType = eAttr.create( "environmentType", "environmentType", 0, &stat); stat = eAttr.addField( "Color Fade", 0 ); stat = eAttr.addField( "Fade", 1 ); stat = eAttr.addField( "GVolume", 2 ); stat = eAttr.addField( "Physical Sky", 3 ); stat = eAttr.addField( "VEffect", 4 ); stat = eAttr.addField( "Volume", 5 ); //environment colorFade, <rgb> color, <double> amount; // fade, <double> amount; // gVolume, <texture> t2, <int> max_recurse, <double> adaptive_threshold, <double> max_distance, <double> probe_per_length, <double> photon_per_lenght, <double> photon_radius; // phySky, <sharedObject> s2, <int> flags; // vEffect, <double> intensity, <double> start, <double> step1, <double> step2, <int> n; // volume, <texture> t2, <int> max_recurse, <double> adaptive_threshold, <double> max_distance, <double> probe_per_length, <double> photon_per_lenght, <double> photon_radius; CHECK_MSTATUS(addAttribute( environmentType )); backgroundType = eAttr.create( "backgroundType", "backgroundType", 0, &stat); stat = eAttr.addField( "Constant", 0 ); stat = eAttr.addField( "Physical Sky", 1 ); stat = eAttr.addField( "Physical Sky 2", 2 ); stat = eAttr.addField( "Sky", 3 ); stat = eAttr.addField( "Sky2", 4 ); stat = eAttr.addField( "Bitmap", 5 ); stat = eAttr.addField( "Bitmap2", 6 ); stat = eAttr.addField( "DirectionsMap", 7 ); stat = eAttr.addField( "LightMap", 8 ); stat = eAttr.addField( "SphereMap", 9 ); CHECK_MSTATUS(addAttribute( backgroundType )); environmentColor = nAttr.createColor("environmentColor", "environmentColor"); nAttr.setDefault(0.6f, 0.7f, 0.9f); nAttr.setConnectable(false); CHECK_MSTATUS(addAttribute( environmentColor )); gradientHorizon = nAttr.createColor("gradientHorizon", "gradientHorizon"); nAttr.setDefault(0.8f, 0.8f, 0.9f); nAttr.setConnectable(false); CHECK_MSTATUS(addAttribute( gradientHorizon )); gradientZenit = nAttr.createColor("gradientZenit", "gradientZenit"); nAttr.setDefault(0.2f, 0.3f, 0.6f); nAttr.setConnectable(false); CHECK_MSTATUS(addAttribute( gradientZenit )); environmentMap = nAttr.createColor("environmentMap", "environmentMap"); nAttr.setDefault(0.6f, 0.7f, 0.9f); CHECK_MSTATUS(addAttribute( environmentMap )); environmentMap2 = nAttr.createColor("environmentMap2", "environmentMap2"); nAttr.setDefault(0.6f, 0.7f, 0.9f); CHECK_MSTATUS(addAttribute( environmentMap2 )); environmentIntensity = nAttr.create("environmentIntensity", "environmentIntensity", MFnNumericData::kFloat, 1.0f); nAttr.setConnectable(false); CHECK_MSTATUS(addAttribute( environmentIntensity )); zenithDir = nAttr.createPoint("zenithDir", "zenithDir"); nAttr.setDefault(0.0f, 1.0f, 0.0f); CHECK_MSTATUS(addAttribute( zenithDir )); orientation = nAttr.createPoint("orientation", "orientation"); nAttr.setDefault(0.0f, 1.0f, 0.0f); CHECK_MSTATUS(addAttribute( orientation )); sunDir = nAttr.createPoint("sunDir", "sunDir"); nAttr.setDefault(0.0f, 1.0f, 0.0f); CHECK_MSTATUS(addAttribute( sunDir )); groundAlbedo = nAttr.createColor("groundAlbedo", "groundAlbedo"); nAttr.setDefault(1.0f, 1.0f, 1.0f); CHECK_MSTATUS(addAttribute( groundAlbedo )); nadir = nAttr.createColor("nadir", "nadir"); nAttr.setDefault(0.0f, 0.0f, 0.0f); CHECK_MSTATUS(addAttribute( nadir )); sunIntensity = nAttr.create("sunIntensity", "sunIntensity", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( sunIntensity )); sunSpotAngle = nAttr.create("sunSpotAngle", "sunSpotAngle", MFnNumericData::kFloat, 35.0f); CHECK_MSTATUS(addAttribute( sunSpotAngle )); solidAngle = nAttr.create("solidAngle", "solidAngle", MFnNumericData::kFloat, 25.0f); CHECK_MSTATUS(addAttribute( solidAngle )); exposure = nAttr.create("exposure", "exposure", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( exposure )); turbidity = nAttr.create("turbidity", "turbidity", MFnNumericData::kFloat, 10.0f); CHECK_MSTATUS(addAttribute( turbidity )); groundGamma = nAttr.create("groundGamma", "groundGamma", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( groundGamma )); skyGamma = nAttr.create("skyGamma", "skyGamma", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( skyGamma )); directLightSamples = nAttr.create("directLightSamples", "directLightSamples", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( directLightSamples )); //image_formats=@ "HDR High Dynamic Range (Radiance)", // "JPG Joint Photographic experts Group", // "PNG Portable Network Graphics", // "PNG Portable Network Graphics +alpha", // "TIF Tagged Image file Format", // "TIF Tagged Image file Format +alpha", // "TGA Truevision Graphics Adapter file", // "TGA Truevision Graphics Adapter file +alpha", // "BMP BitMaP", // "BMP BitMaP +alpha"@; //imageFormat = eAttr.create( "imageFormat", "imageFormat", 1, &stat); //CHECK_MSTATUS(addAttribute( imageFormat )); optimizedTexturePath = tAttr.create("optimizedTexturePath", "optimizedTexturePath", MFnNumericData::kString); tAttr.setUsedAsFilename(true); CHECK_MSTATUS(addAttribute( optimizedTexturePath )); latlongHoShift = nAttr.create("latlongHoShift", "latlongHoShift", MFnNumericData::kFloat, .0f); CHECK_MSTATUS(addAttribute( latlongHoShift )); latlongVeShift = nAttr.create("latlongVeShift", "latlongVeShift", MFnNumericData::kFloat, .0f); CHECK_MSTATUS(addAttribute( latlongVeShift )); // photons giResolution = nAttr.create("giResolution", "giResolution", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( giResolution )); giResolutionAuto = nAttr.create("giResolutionAuto", "giResolutionAuto", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( giResolutionAuto )); previewPhotons = nAttr.create("previewPhotons", "previewPhotons", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( previewPhotons )); photonMapType = eAttr.create( "photonMapType", "photonMapType", 0, &stat); stat = eAttr.addField( "PhotonMap", 0 ); stat = eAttr.addField( "LightMap", 1 ); CHECK_MSTATUS(addAttribute( photonMapType )); photonCount = nAttr.create("photonCount", "photonCount", MFnNumericData::kInt, 10000); CHECK_MSTATUS(addAttribute( photonCount )); photonPower = nAttr.create("photonPower", "photonPower", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( photonPower )); photonNBlur = nAttr.create("photonNBlur", "photonNBlur", MFnNumericData::kInt, 400); CHECK_MSTATUS(addAttribute( photonNBlur )); photonUseAutoPhotons = nAttr.create("photonUseAutoPhotons", "photonUseAutoPhotons", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( photonUseAutoPhotons )); photonPrecacheDist = nAttr.create("photonPrecacheDist", "photonPrecacheDist", MFnNumericData::kFloat, 50.0f); CHECK_MSTATUS(addAttribute( photonPrecacheDist )); photonPrecacheBlur = nAttr.create("photonPrecacheBlur", "photonPrecacheBlur", MFnNumericData::kFloat, 100.0f); CHECK_MSTATUS(addAttribute( photonPrecacheBlur )); photonAutoPhotonsLow = nAttr.create("photonAutoPhotonsLow", "photonAutoPhotonsLow", MFnNumericData::kFloat, 20.0); CHECK_MSTATUS(addAttribute( photonAutoPhotonsLow )); photonAutoPhotonsHigh = nAttr.create("photonAutoPhotonsHigh", "photonAutoPhotonsHigh", MFnNumericData::kFloat, 80.0f); CHECK_MSTATUS(addAttribute( photonAutoPhotonsHigh )); photonAutoPhotonsSteps = nAttr.create("photonAutoPhotonsSteps", "photonAutoPhotonsSteps", MFnNumericData::kFloat, 4.0f); CHECK_MSTATUS(addAttribute( photonAutoPhotonsSteps )); // caustics causticsAddToLightmap = nAttr.create("causticsAddToLightmap", "causticsAddToLightmap", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( causticsAddToLightmap )); causticsCount = nAttr.create("causticsCount", "causticsCount", MFnNumericData::kInt, 50000); CHECK_MSTATUS(addAttribute( causticsCount )); causticsUseAutoPhotons = nAttr.create("causticsUseAutoPhotons", "causticsUseAutoPhotons", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( causticsUseAutoPhotons )); causticsAutoPhotonsLow = nAttr.create("causticsAutoPhotonsLow", "causticsAutoPhotonsLow", MFnNumericData::kFloat, 20.0); CHECK_MSTATUS(addAttribute( causticsAutoPhotonsLow )); causticsAutoPhotonsHigh = nAttr.create("causticsAutoPhotonsHigh", "causticsAutoPhotonsHigh", MFnNumericData::kFloat, 80.0f); CHECK_MSTATUS(addAttribute( causticsAutoPhotonsHigh )); causticsAutoPhotonsSteps = nAttr.create("causticsAutoPhotonsSteps", "causticsAutoPhotonsSteps", MFnNumericData::kFloat, 4.0f); CHECK_MSTATUS(addAttribute( causticsAutoPhotonsSteps )); causticsPower = nAttr.create("causticsPower", "causticsPower", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( causticsPower )); causticsNBlur = nAttr.create("causticsNBlur", "causticsNBlur", MFnNumericData::kInt, 400); CHECK_MSTATUS(addAttribute( causticsNBlur )); // FG fgThreshold = nAttr.create("fgThreshold", "fgThreshold", MFnNumericData::kFloat, .0001f); CHECK_MSTATUS(addAttribute( fgThreshold )); fgMinRays = nAttr.create("fgMinRays", "fgMinRays", MFnNumericData::kInt, 100); CHECK_MSTATUS(addAttribute( fgMinRays )); fgMaxRays = nAttr.create("fgMaxRays", "fgMaxRays", MFnNumericData::kInt, 600); CHECK_MSTATUS(addAttribute( fgMaxRays )); fgPrerender = nAttr.create("fgPrerender", "fgPrerender", MFnNumericData::kFloat, 1.0f); CHECK_MSTATUS(addAttribute( fgPrerender )); fgPasses = nAttr.create("fgPasses", "fgPasses", MFnNumericData::kInt, 1); CHECK_MSTATUS(addAttribute( fgPasses )); fgSplotchDetect = nAttr.create("fgSplotchDetect", "fgSplotchDetect", MFnNumericData::kFloat, .05f); CHECK_MSTATUS(addAttribute( fgSplotchDetect )); fgSensitivity = nAttr.create("fgSensitivity", "fgSensitivity", MFnNumericData::kFloat, .05f); CHECK_MSTATUS(addAttribute( fgSensitivity )); fgReflections = nAttr.create("fgReflections", "fgReflections", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( fgReflections )); fgRefractions = nAttr.create("fgRefractions", "fgRefractions", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( fgRefractions )); fgSpatialTolerance = nAttr.create("fgSpatialTolerance", "fgSpatialTolerance", MFnNumericData::kFloat, .1f); CHECK_MSTATUS(addAttribute( fgSpatialTolerance )); fgAngularTolerance = nAttr.create("fgAngularTolerance", "fgAngularTolerance", MFnNumericData::kFloat, 30.0f); CHECK_MSTATUS(addAttribute( fgAngularTolerance )); fgDistMin = nAttr.create("fgDistMin", "fgDistMin", MFnNumericData::kFloat, 10.0f); CHECK_MSTATUS(addAttribute( fgDistMin )); fgDistMax = nAttr.create("fgDistMax", "fgDistMax", MFnNumericData::kFloat, 3000.00f); CHECK_MSTATUS(addAttribute( fgDistMax )); fgBrightness = nAttr.create("fgBrightness", "fgBrightness", MFnNumericData::kFloat, 0.00f); CHECK_MSTATUS(addAttribute( fgBrightness )); fgPathPasses = nAttr.create("fgPathPasses", "fgPathPasses", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( fgPathPasses )); fgCornerDist = nAttr.create("fgCornerDist", "fgCornerDist", MFnNumericData::kFloat, 50.00f); CHECK_MSTATUS(addAttribute( fgCornerDist )); fgShowSamples = nAttr.create("fgShowSamples", "fgShowSamples", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( fgShowSamples )); fullScreenAA = nAttr.create("fullScreenAA", "fullScreenAA", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( fullScreenAA )); jpgQuality = nAttr.create("jpgQuality", "jpgQuality", MFnNumericData::kInt, 75); nAttr.setMin(0); nAttr.setMax(100); CHECK_MSTATUS(addAttribute( jpgQuality )); qLuminosityModel = eAttr.create( "qLuminosityModel", "qLuminosityModel", 0, &stat); stat = eAttr.addField( "Compute as Indirect", 0 ); stat = eAttr.addField( "Compute as Direct", 1 ); stat = eAttr.addField( "Automatic", 2 ); CHECK_MSTATUS(addAttribute( qLuminosityModel )); qLevel = nAttr.create("qLevel", "qLevel", MFnNumericData::kFloat, 1.00f); CHECK_MSTATUS(addAttribute( qLevel )); qAreaLights = eAttr.create( "qAreaLights", "qAreaLights", 0, &stat); stat = eAttr.addField( "Compute Separately (AS)", 0 ); stat = eAttr.addField( "Compute With Luminosity", 1 ); CHECK_MSTATUS(addAttribute( qAreaLights )); qDoubleSided = nAttr.create("qDoubleSided", "qDoubleSided", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( qDoubleSided )); qAreaLightVisibility = eAttr.create( "qAreaLightVisibility", "qAreaLightVisibility", 0, &stat); stat = eAttr.addField( "Visible (Realistic)", 0 ); stat = eAttr.addField( "Invisible", 1 ); CHECK_MSTATUS(addAttribute( qAreaLightVisibility )); qSpotlightsToArea = nAttr.create("qSpotlightsToArea", "qSpotlightsToArea", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( qSpotlightsToArea )); qAreaLightsThreshold = nAttr.create("qAreaLightsThreshold", "qAreaLightsThreshold", MFnNumericData::kFloat, 1.00f); CHECK_MSTATUS(addAttribute( qAreaLightsThreshold )); qAMinRecursion = nAttr.create("qAMinRecursion", "qAMinRecursion", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( qAMinRecursion )); qAMaxRecursion = nAttr.create("qAMaxRecursion", "qAMaxRecursion", MFnNumericData::kInt, 1); CHECK_MSTATUS(addAttribute( qAMaxRecursion )); qLinearLightsThreshold = nAttr.create("qLinearLightsThreshold", "qLinearLightsThreshold", MFnNumericData::kFloat, 1.00f); CHECK_MSTATUS(addAttribute( qLinearLightsThreshold )); qLMinRecursion = nAttr.create("qLMinRecursion", "qLMinRecursion", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( qLMinRecursion )); qLMaxRecursion = nAttr.create("qLMaxRecursion", "qLMaxRecursion", MFnNumericData::kInt, 1); CHECK_MSTATUS(addAttribute( qLMaxRecursion )); qLuminosityThreshold = nAttr.create("qLuminosityThreshold", "qLuminosityThreshold", MFnNumericData::kFloat, 1.00f); CHECK_MSTATUS(addAttribute( qLuminosityThreshold )); qLumMinRays = nAttr.create("qLumMinRays", "qLumMinRays", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( qLumMinRays )); qLumMaxRays = nAttr.create("qLumMaxRays", "qLumMaxRays", MFnNumericData::kInt, 1); CHECK_MSTATUS(addAttribute( qLumMaxRays )); qBlurringThreshold = nAttr.create("qBlurringThreshold", "qBlurringThreshold", MFnNumericData::kFloat, 1.00f); CHECK_MSTATUS(addAttribute( qBlurringThreshold )); qBLumMinRays = nAttr.create("qBLumMinRays", "qBLumMinRays", MFnNumericData::kInt, 0); CHECK_MSTATUS(addAttribute( qBLumMinRays )); qBLumMaxRays = nAttr.create("qBLumMaxRays", "qBLumMaxRays", MFnNumericData::kInt, 1); CHECK_MSTATUS(addAttribute( qBLumMaxRays )); qBAccuracyLimit = nAttr.create("qBAccuracyLimit", "qBAccuracyLimit", MFnNumericData::kFloat, 1.00f); CHECK_MSTATUS(addAttribute( qBAccuracyLimit )); qTraceDirectLightReflections = nAttr.create("qTraceDirectLightReflections", "qTraceDirectLightReflections", MFnNumericData::kBoolean, true); CHECK_MSTATUS(addAttribute( qTraceDirectLightReflections )); qOctreeDetail = eAttr.create( "qOctreeDetail", "qOctreeDetail", 0, &stat); stat = eAttr.addField( "Very Low", 0 ); stat = eAttr.addField( "Low", 1 ); stat = eAttr.addField( "Normal", 2 ); stat = eAttr.addField( "High", 3 ); CHECK_MSTATUS(addAttribute( qOctreeDetail )); camSingleSided = nAttr.create("camSingleSided", "camSingleSided", MFnNumericData::kBoolean, false); CHECK_MSTATUS(addAttribute( camSingleSided )); return stat; }
MStatus rigidBodyNode::initialize() { MStatus status; MFnMessageAttribute fnMsgAttr; MFnNumericAttribute fnNumericAttr; MFnMatrixAttribute fnMatrixAttr; MFnTypedAttribute typedAttr; ia_collisionShape = fnMsgAttr.create("inCollisionShape", "incs", &status); MCHECKSTATUS(status, "creating inCollisionShape attribute") status = addAttribute(ia_collisionShape); MCHECKSTATUS(status, "adding inCollisionShape attribute") ia_solver = fnMsgAttr.create("solver", "solv", &status); MCHECKSTATUS(status, "creating solver attribute") status = addAttribute(ia_solver); MCHECKSTATUS(status, "adding solver attribute") ia_mass = fnNumericAttr.create("mass", "ma", MFnNumericData::kDouble, 1.0, &status); MCHECKSTATUS(status, "creating mass attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_mass); MCHECKSTATUS(status, "adding mass attribute") ia_restitution = fnNumericAttr.create("restitution", "rst", MFnNumericData::kDouble, 0.1, &status); MCHECKSTATUS(status, "creating restitution attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_restitution); MCHECKSTATUS(status, "adding restitution attribute") ia_friction = fnNumericAttr.create("friction", "fc", MFnNumericData::kDouble, 0.5, &status); MCHECKSTATUS(status, "creating friction attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_friction); MCHECKSTATUS(status, "adding friction attribute") ia_linearDamping = fnNumericAttr.create("linearDamping", "ld", MFnNumericData::kDouble, 0.3, &status); MCHECKSTATUS(status, "creating linearDamping attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_linearDamping); MCHECKSTATUS(status, "adding linearDamping attribute") ia_angularDamping = fnNumericAttr.create("angularDamping", "ad", MFnNumericData::kDouble, 0.3, &status); MCHECKSTATUS(status, "creating angularDamping attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_angularDamping); MCHECKSTATUS(status, "adding angularDamping attribute") ia_initialPosition = fnNumericAttr.createPoint("initialPosition", "inpo", &status); MCHECKSTATUS(status, "creating initialPosition attribute") status = addAttribute(ia_initialPosition); MCHECKSTATUS(status, "adding initialPosition attribute") ia_initialRotation = fnNumericAttr.createPoint("initialRotation", "inro", &status); MCHECKSTATUS(status, "creating initialRotation attribute") status = addAttribute(ia_initialRotation); MCHECKSTATUS(status, "adding initialRotation attribute") ia_initialVelocity = fnNumericAttr.createPoint("initialVelocity", "inve", &status); MCHECKSTATUS(status, "creating initialVelocity attribute") status = addAttribute(ia_initialVelocity); MCHECKSTATUS(status, "adding initialVelocity attribute") ia_initialSpin = fnNumericAttr.createPoint("initialSpin", "insp", &status); MCHECKSTATUS(status, "creating initialSpin attribute") status = addAttribute(ia_initialSpin); MCHECKSTATUS(status, "adding initialSpin attribute") ia_externalForce = fnNumericAttr.createPoint("externalForce", "exfo", &status); MCHECKSTATUS(status, "creating externalForce attribute") status = addAttribute(ia_externalForce); MCHECKSTATUS(status, "adding externalForce attribute") ia_externalTorque = fnNumericAttr.createPoint("externalTorque", "exto", &status); MCHECKSTATUS(status, "creating externalTorque attribute") status = addAttribute(ia_externalTorque); MCHECKSTATUS(status, "adding externalTorque attribute") ca_rigidBody = fnNumericAttr.create("ca_rigidBody", "carb", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_rigidBody attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_rigidBody); MCHECKSTATUS(status, "adding ca_rigidBody attribute") ca_rigidBodyParam = fnNumericAttr.create("ca_rigidBodyParam", "carbp", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_rigidBodyParam attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_rigidBodyParam); MCHECKSTATUS(status, "adding ca_rigidBodyParam attribute") ca_solver = fnNumericAttr.create("ca_solver", "caso", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_solver attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_solver); MCHECKSTATUS(status, "adding ca_solver attribute") oa_contactCount = fnNumericAttr.create("contactCount", "contactCount", MFnNumericData::kInt, 0, &status); MCHECKSTATUS(status, "creating oa_contactCount attribute") fnNumericAttr.setConnectable(true); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(oa_contactCount); MCHECKSTATUS(status, "adding oa_contactCount attribute"); MFnStringArrayData stringArrayData; oa_contactName = typedAttr.create("contactName", "contactName", MFnData::kStringArray, stringArrayData.create(), &status); MCHECKSTATUS(status, "creating oa_contactName attribute") typedAttr.setHidden(true); status = addAttribute(oa_contactName); MCHECKSTATUS(status, "adding oa_contactName attribute"); oa_contactPosition = typedAttr.create("contactPosition", "contactPosition", MFnVectorArrayData::kVectorArray, &status); MCHECKSTATUS(status, "creating oa_contactPosition attribute") typedAttr.setHidden(true); status = addAttribute(oa_contactPosition); MCHECKSTATUS(status, "adding oa_contactPosition attribute"); status = attributeAffects(ia_mass, ca_rigidBody); MCHECKSTATUS(status, "adding attributeAffects(ia_mass, ca_rigidBodyParam)") status = attributeAffects(ia_collisionShape, ca_rigidBody); MCHECKSTATUS(status, "adding attributeAffects(ia_collisionShape, ca_rigidBody)") status = attributeAffects(ia_collisionShape, ca_rigidBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_collisionShape, ca_rigidBodyParam)") status = attributeAffects(ia_mass, ca_rigidBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_mass, ca_rigidBodyParam)") status = attributeAffects(ia_restitution, ca_rigidBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_restitution, ca_rigidBodyParam)") status = attributeAffects(ia_friction, ca_rigidBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_friction, ca_rigidBodyParam)") status = attributeAffects(ia_linearDamping, ca_rigidBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_linearDamping, ca_rigidBodyParam)") status = attributeAffects(ia_angularDamping, ca_rigidBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_angularDamping, ca_rigidBodyParam)") status = attributeAffects(ia_initialPosition, ca_rigidBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_initialPosition, ca_rigidBodyParam)") status = attributeAffects(ia_solver, ca_solver); MCHECKSTATUS(status, "adding attributeAffects(ia_solver, ca_solver)") return MS::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 SoftBodyNode::initialize() { MFnMessageAttribute fnMsgAttr; MStatus status = MStatus::kSuccess; ia_solver = fnMsgAttr.create("solver", "solv", &status); MCHECKSTATUS(status, "creating solver attribute") status = addAttribute(ia_solver); MCHECKSTATUS(status, "adding solver attribute") MFnNumericAttribute fnNumericAttr; ca_solver = fnNumericAttr.create("ca_solver", "caso", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_solver attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_solver); MCHECKSTATUS(status, "adding ca_solver attribute") ca_softBody = fnNumericAttr.create("ca_softBody", "casb", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_softBody attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_softBody); MCHECKSTATUS(status, "adding ca_softBody attribute") inputMesh = fnMsgAttr.create("inMesh", "inmsh", &status); MCHECKSTATUS(status, "creating inMesh attribute") status = addAttribute(inputMesh); MCHECKSTATUS(status, "adding inMesh attribute") outputMesh = fnMsgAttr.create("outMesh", "outmsh", &status); MCHECKSTATUS(status, "creating outMesh attribute") status = addAttribute(outputMesh); MCHECKSTATUS(status, "adding outMesh attribute") /* Note that these initial* attributes are not in use for soft bodies at the moment */ ia_initialPosition = fnNumericAttr.createPoint("initialPosition", "inpo", &status); MCHECKSTATUS(status, "creating initialPosition attribute") status = addAttribute(ia_initialPosition); MCHECKSTATUS(status, "adding initialPosition attribute") ia_initialRotation = fnNumericAttr.createPoint("initialRotation", "inro", &status); MCHECKSTATUS(status, "creating initialRotation attribute") status = addAttribute(ia_initialRotation); MCHECKSTATUS(status, "adding initialRotation attribute") ia_initialVelocity = fnNumericAttr.createPoint("initialVelocity", "inve", &status); MCHECKSTATUS(status, "creating initialVelocity attribute") status = addAttribute(ia_initialVelocity); MCHECKSTATUS(status, "adding initialVelocity attribute") ia_initialSpin = fnNumericAttr.createPoint("initialSpin", "insp", &status); MCHECKSTATUS(status, "creating initialSpin attribute") status = addAttribute(ia_initialSpin); MCHECKSTATUS(status, "adding initialSpin attribute") // total soft body mass ia_mass = fnNumericAttr.create("mass", "ma", MFnNumericData::kDouble, DEFAULT_MASS, &status); MCHECKSTATUS(status, "creating mass attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_mass); MCHECKSTATUS(status, "adding mass attribute") // create dynamic friction coefficient attribute ia_dynamicFrictionCoeff = fnNumericAttr.create("dynamicfrictioncoeff", "dfc", MFnNumericData::kDouble, DEFAULT_DFC, &status); MCHECKSTATUS(status, "creating dynamicfrictioncoeff attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_dynamicFrictionCoeff); MCHECKSTATUS(status, "adding dynamicfrictioncoeff attribute") // create collision margin attribute ia_collisionMargin = fnNumericAttr.create("collisionmargin", "cmargin", MFnNumericData::kFloat, DEFAULT_CMARGIN, &status); MCHECKSTATUS(status, "creating collisionmargin attribute") fnNumericAttr.setKeyable(false); status = addAttribute(ia_collisionMargin); MCHECKSTATUS(status, "adding collision attribute") // collision clusters attribute ia_numClusters = fnNumericAttr.create("numclusters", "nclust", MFnNumericData::kInt, DEFAULT_CLUSTERS, &status); MCHECKSTATUS(status, "creating numclusters attribute") fnNumericAttr.setKeyable(false); status = addAttribute(ia_numClusters); MCHECKSTATUS(status, "adding numclusters attribute") ca_softBodyParam = fnNumericAttr.create("ca_softBodyParam", "casbp", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_softBodyParam attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_softBodyParam); MCHECKSTATUS(status, "adding ca_softBodyParam attribute") status = attributeAffects(inputMesh, ca_softBody); MCHECKSTATUS(status, "adding attributeAffects(inputMesh, ca_softBody)") status = attributeAffects(ia_solver, ca_solver); MCHECKSTATUS(status, "adding attributeAffects(ia_solver, ca_solver)") // connect soft body parameters to ca_softBodyParam connection status = attributeAffects(ia_mass, ca_softBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_mass, ca_softBodyParam)") status = attributeAffects(ia_dynamicFrictionCoeff, ca_softBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_dynamicFrictionCoeff, ca_softBodyParam)") status = attributeAffects(ia_collisionMargin, ca_softBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_collisionMargin, ca_softBodyParam)") status = attributeAffects(ia_numClusters, ca_softBodyParam); MCHECKSTATUS(status, "adding attributeAffects(ia_numClusters, ca_softBodyParam)") return status; }
MStatus mtmEnvLight::initialize() { MFnTypedAttribute tAttr; MFnNumericAttribute nAttr; MFnLightDataAttribute lAttr; MFnEnumAttribute eAttr; MFnMessageAttribute mAttr; MStatus stat; //aColor = nAttr.createColor( "color", "c" ); //CHECK_MSTATUS ( nAttr.setKeyable(true) ); //CHECK_MSTATUS ( nAttr.setStorable(true) ); //CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.58824f, 0.644f) ); aLightColor = nAttr.createColor( "lightColor", "lightColor" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); nAttr.setDefault(0.7f, 0.58824f, 0.344f); aShadowColor = nAttr.createColor( "shadowColor", "sc" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.0f, 0.0f) ); aPosition = nAttr.createPoint( "position", "pos" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); aInputDirection = nAttr.createPoint( "inputDirection", "id" ); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) ); aInputAmbient = nAttr.create( "ambientOn", "an", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aInputDiffuse = nAttr.create( "emitDiffuse", "dn", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aInputSpecular = nAttr.create( "emitSpecular", "sn", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aIntensity = nAttr.create( "intensity", "i", MFnNumericData::kFloat); CHECK_MSTATUS ( nAttr.setKeyable(true) ); CHECK_MSTATUS ( nAttr.setStorable(true) ); CHECK_MSTATUS ( nAttr.setHidden(false) ); CHECK_MSTATUS ( nAttr.setDefault(1.0f) ); samplingquality = nAttr.create( "samplingquality", "samplingquality", MFnNumericData::kFloat, 1.0); envmap = tAttr.create( "envmap", "envmap", MFnNumericData::kString); tAttr.setUsedAsFilename(true); areamap = tAttr.create( "areamap", "areamap", MFnNumericData::kString); tAttr.setUsedAsFilename(true); areafullsphere = nAttr.create( "areafullsphere", "areafullsphere", MFnNumericData::kBoolean, true); envintensity = nAttr.createColor( "envintensity", "envintensity" ); nAttr.setDefault(1.0f, 1.0f, 1.0f); raybackground = nAttr.create( "raybackground", "raybackground", MFnNumericData::kBoolean, false); castshadow = nAttr.create( "castshadow", "castshadow", MFnNumericData::kBoolean, true); envtype = eAttr.create( "envtype", "envtype", 0, &stat); stat = eAttr.addField( "Direct Lighting", 0 ); stat = eAttr.addField( "Ambient Occlusion", 1 ); stat = eAttr.addField( "Full Irradiance", 2 ); stat = eAttr.addField( "Raytrace Background", 3 ); eAttr.setDefault(0); doraysamples = nAttr.create( "doraysamples", "doraysamples", MFnNumericData::kBoolean, false); doadaptive = nAttr.create( "doadaptive", "doadaptive", MFnNumericData::kBoolean, false); domaxdist = nAttr.create( "domaxdist", "domaxdist", MFnNumericData::kBoolean, false); maxdist = nAttr.create( "maxdist", "maxdist", MFnNumericData::kFloat, 10.0); coneangle = nAttr.create( "coneangle", "coneangle", MFnNumericData::kFloat, 45.0); envtint = nAttr.createColor( "envtint", "envtint" ); nAttr.setDefault(1.0f, 1.0f, 1.0f); shadowI = nAttr.create( "shadowI", "shadowI", MFnNumericData::kFloat, 1.0); samples = nAttr.create( "samples", "samples", MFnNumericData::kInt, 32); MFnStringData fnStringData; MObject defaultObjectMask; defaultObjectMask = fnStringData.create( "*" ); objectmask = tAttr.create( "objectmask", "objectmask", MFnNumericData::kString, defaultObjectMask); usePortalGeometry = nAttr.create( "usePortalGeometry", "usePortalGeometry", MFnNumericData::kBoolean, false); portalGeometry = mAttr.create( "portalGeometry", "portalGeometry"); mAttr.setConnectable(true); mAttr.accepts(MFnData::kAny); // Outputs aLightDirection = nAttr.createPoint( "lightDirection", "ld" ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) ); aLightIntensity = nAttr.createColor( "lightIntensity", "li" ); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(1.0f, 0.5f, 0.2f) ); aLightAmbient = nAttr.create( "lightAmbient", "la", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); nAttr.setDefault(true); aLightDiffuse = nAttr.create( "lightDiffuse", "ldf", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aLightSpecular = nAttr.create( "lightSpecular", "ls", MFnNumericData::kBoolean); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(true) ); aLightShadowFraction = nAttr.create("lightShadowFraction","lsf", MFnNumericData::kFloat); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(0.0f) ); aPreShadowIntensity = nAttr.create("preShadowIntensity","psi", MFnNumericData::kFloat); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( nAttr.setDefault(0.0f) ); aLightBlindData = nAttr.createAddr("lightBlindData","lbld"); CHECK_MSTATUS ( nAttr.setStorable(false) ); CHECK_MSTATUS ( nAttr.setHidden(true) ); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); aLightData = lAttr.create( "lightData", "ltd", aLightDirection, aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular, aLightShadowFraction, aPreShadowIntensity, aLightBlindData); CHECK_MSTATUS ( nAttr.setReadable(true) ); CHECK_MSTATUS ( nAttr.setWritable(false) ); CHECK_MSTATUS ( lAttr.setStorable(false) ); CHECK_MSTATUS ( lAttr.setHidden(true) ); lAttr.setDefault(-1.0f, 0.0f, 0.0f, 1.0f, 0.5f, 0.2f, true, true, true, 0.0f, 1.0f, NULL); CHECK_MSTATUS ( addAttribute(coneangle) ); CHECK_MSTATUS ( addAttribute(samples) ); CHECK_MSTATUS ( addAttribute(objectmask) ); CHECK_MSTATUS ( addAttribute(shadowI) ); CHECK_MSTATUS ( addAttribute(envtint) ); CHECK_MSTATUS ( addAttribute(maxdist) ); CHECK_MSTATUS ( addAttribute(domaxdist) ); CHECK_MSTATUS ( addAttribute(doadaptive) ); CHECK_MSTATUS ( addAttribute(doraysamples) ); CHECK_MSTATUS ( addAttribute(envtype) ); CHECK_MSTATUS ( addAttribute(castshadow) ); CHECK_MSTATUS ( addAttribute(raybackground) ); CHECK_MSTATUS ( addAttribute(envintensity) ); CHECK_MSTATUS ( addAttribute(areafullsphere) ); CHECK_MSTATUS ( addAttribute(areamap) ); CHECK_MSTATUS ( addAttribute(envmap) ); CHECK_MSTATUS ( addAttribute(samplingquality) ); CHECK_MSTATUS ( addAttribute(usePortalGeometry) ); CHECK_MSTATUS ( addAttribute(portalGeometry) ); //CHECK_MSTATUS ( addAttribute(aColor) ); CHECK_MSTATUS ( addAttribute(aLightColor) ); CHECK_MSTATUS ( addAttribute(aShadowColor) ); CHECK_MSTATUS ( addAttribute(aPosition) ); CHECK_MSTATUS ( addAttribute(aInputDirection) ); CHECK_MSTATUS ( addAttribute(aInputAmbient) ); CHECK_MSTATUS ( addAttribute(aInputDiffuse) ); CHECK_MSTATUS ( addAttribute(aInputSpecular) ); CHECK_MSTATUS ( addAttribute(aIntensity) ); CHECK_MSTATUS ( addAttribute(aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightIntensity, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightDirection, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightAmbient, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightDiffuse, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightSpecular, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightShadowFraction, aLightData) ); CHECK_MSTATUS ( attributeAffects (aPreShadowIntensity, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightBlindData, aLightData) ); CHECK_MSTATUS ( attributeAffects (aLightData, aLightData) ); //CHECK_MSTATUS ( attributeAffects (aColor, aLightData) ); CHECK_MSTATUS ( attributeAffects (aPosition, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputDirection, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputAmbient, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputDiffuse, aLightData) ); CHECK_MSTATUS ( attributeAffects (aInputSpecular, aLightData) ); CHECK_MSTATUS ( attributeAffects (aIntensity, aLightData) ); return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus Cell3D::initialize() { MFnMatrixAttribute mAttr; MFnNumericAttribute nAttr; // Input attributes aColorGain = nAttr.createColor("colorGain", "cg"); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setDefault(1.0f,1.0f,1.0f) ); aColorOffset = nAttr.createColor("colorOffset", "co"); MAKE_INPUT(nAttr); aPlaceMat = mAttr.create("placementMatrix", "pm", MFnMatrixAttribute::kFloat); MAKE_INPUT(mAttr); // Implicit shading network attributes aPointWorld = nAttr.createPoint("pointWorld", "pw"); MAKE_INPUT(nAttr); CHECK_MSTATUS( nAttr.setHidden(true) ); // Create output attributes aOutF0 = nAttr.create( "F0", "f0", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); aOutF1 = nAttr.create( "F1", "f1", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); aOutN0 = nAttr.create( "N0", "n0", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); aOutBorderDist = nAttr.create("borderDistance", "bd", MFnNumericData::kFloat); MAKE_OUTPUT(nAttr); 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(aColorGain) ); CHECK_MSTATUS( addAttribute(aColorOffset) ); CHECK_MSTATUS( addAttribute(aPointWorld) ); CHECK_MSTATUS( addAttribute(aPlaceMat) ); CHECK_MSTATUS( addAttribute(aOutAlpha) ); CHECK_MSTATUS( addAttribute(aOutColor) ); CHECK_MSTATUS( addAttribute(aOutF0) ); CHECK_MSTATUS( addAttribute(aOutF1) ); CHECK_MSTATUS( addAttribute(aOutN0) ); CHECK_MSTATUS( addAttribute(aOutBorderDist) ); // All input affect the output color and alpha CHECK_MSTATUS( attributeAffects (aColorGain, aOutColor) ); CHECK_MSTATUS( attributeAffects (aColorOffset, aOutColor) ); CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutColor) ); CHECK_MSTATUS( attributeAffects (aPointWorld, aOutColor) ); CHECK_MSTATUS( attributeAffects (aColorGain, aOutAlpha) ); CHECK_MSTATUS( attributeAffects (aColorOffset, aOutAlpha) ); CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutAlpha) ); CHECK_MSTATUS( attributeAffects (aPointWorld, aOutAlpha) ); // Geometry attribute affect all other outputs. CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutF0) ); CHECK_MSTATUS( attributeAffects (aPointWorld, aOutF0) ); CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutF1) ); CHECK_MSTATUS( attributeAffects (aPointWorld, aOutF1) ); CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutN0) ); CHECK_MSTATUS( attributeAffects (aPointWorld, aOutN0) ); CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutBorderDist) ); CHECK_MSTATUS( attributeAffects (aPointWorld, aOutBorderDist) ); return MS::kSuccess; }
MStatus sixdofConstraintNode::initialize() { MStatus status; MFnMessageAttribute fnMsgAttr; MFnNumericAttribute fnNumericAttr; MFnMatrixAttribute fnMatrixAttr; ia_rigidBodyA = fnMsgAttr.create("inRigidBodyA", "inrbA", &status); MCHECKSTATUS(status, "creating inRigidBodyA attribute") status = addAttribute(ia_rigidBodyA); MCHECKSTATUS(status, "adding inRigidBody attribute") ia_rigidBodyB = fnMsgAttr.create("inRigidBodyB", "inrbB", &status); MCHECKSTATUS(status, "creating inRigidBodyB attribute") status = addAttribute(ia_rigidBodyB); MCHECKSTATUS(status, "adding inRigidBodyB attribute") ia_damping = fnNumericAttr.create("damping", "dmp", MFnNumericData::kDouble, 1.0, &status); MCHECKSTATUS(status, "creating damping attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_damping); MCHECKSTATUS(status, "adding damping attribute") ia_breakThreshold = fnNumericAttr.create("breakThreshold", "brkThrsh", MFnNumericData::kDouble, 100.0, &status); MCHECKSTATUS(status, "creating breakThreshold attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_breakThreshold); MCHECKSTATUS(status, "adding breakThreshold attribute") ia_disableCollide = fnNumericAttr.create("disableCollide", "dsblColl", MFnNumericData::kBoolean, true, &status); MCHECKSTATUS(status, "creating disableCollide attribute") fnNumericAttr.setHidden(true); fnNumericAttr.setKeyable(true); status = addAttribute(ia_disableCollide); MCHECKSTATUS(status, "adding disableCollide attribute") ia_lowerLinLimit = fnNumericAttr.createPoint("lowerLinLimit", "lllt", &status); MCHECKSTATUS(status, "creating lower linear limit attribute") status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); fnNumericAttr.setKeyable(true); status = addAttribute(ia_lowerLinLimit); MCHECKSTATUS(status, "adding lower linear limit attribute") ia_upperLinLimit = fnNumericAttr.createPoint("upperLinLimit", "ullt", &status); MCHECKSTATUS(status, "creating upper linear limit attribute") status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); fnNumericAttr.setKeyable(true); status = addAttribute(ia_upperLinLimit); MCHECKSTATUS(status, "adding upper linear limit attribute") ia_lowerAngLimit = fnNumericAttr.createPoint("lowerAngLimit", "lalt", &status); MCHECKSTATUS(status, "creating lower angular limit attribute") status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); fnNumericAttr.setKeyable(true); status = addAttribute(ia_lowerAngLimit); MCHECKSTATUS(status, "adding lower angular limit attribute") ia_upperAngLimit = fnNumericAttr.createPoint("upperAngLimit", "ualt", &status); MCHECKSTATUS(status, "creating upper angular limit attribute") status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); fnNumericAttr.setKeyable(true); status = addAttribute(ia_upperAngLimit); MCHECKSTATUS(status, "adding upper angular limit attribute") ca_constraint = fnNumericAttr.create("ca_constraint", "caco", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_constraint attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_constraint); MCHECKSTATUS(status, "adding ca_constraint attribute") ca_constraintParam = fnNumericAttr.create("ca_constraintParam", "cacop", MFnNumericData::kBoolean, 0, &status); MCHECKSTATUS(status, "creating ca_constraintParam attribute") fnNumericAttr.setConnectable(false); fnNumericAttr.setHidden(true); fnNumericAttr.setStorable(false); fnNumericAttr.setKeyable(false); status = addAttribute(ca_constraintParam); MCHECKSTATUS(status, "adding ca_constraintParam attribute") ia_rotationInA = fnNumericAttr.createPoint("rotationInA", "hgRotA", &status); status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); MCHECKSTATUS(status, "creating rotationInA attribute") status = addAttribute(ia_rotationInA); MCHECKSTATUS(status, "adding rotationInA attribute") ia_rotationInB = fnNumericAttr.createPoint("rotationInB", "hgRotB", &status); status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); MCHECKSTATUS(status, "creating rotationInB attribute") status = addAttribute(ia_rotationInB); MCHECKSTATUS(status, "adding rotationInB attribute") ia_pivotInA = fnNumericAttr.createPoint("pivotInA", "pivinA", &status); status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); MCHECKSTATUS(status, "creating pivotInA attribute") status = addAttribute(ia_pivotInA); MCHECKSTATUS(status, "adding pivotInA attribute") ia_pivotInB = fnNumericAttr.createPoint("pivotInB", "pivinB", &status); status = fnNumericAttr.setDefault((double) 0.0, (double) 0.0, (double) 0.0); MCHECKSTATUS(status, "creating pivotInB attribute") status = addAttribute(ia_pivotInB); MCHECKSTATUS(status, "adding pivotInB attribute") status = attributeAffects(ia_rigidBodyA, ca_constraint); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBodyA, ca_constraint)") status = attributeAffects(ia_rigidBodyA, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBodyA, ca_constraintParam)") status = attributeAffects(ia_rigidBodyB, ca_constraint); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBodyB, ca_constraint)") status = attributeAffects(ia_rigidBodyB, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_rigidBodyB, ca_constraintParam)") status = attributeAffects(ia_damping, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_damping, ca_constraintParam)") status = attributeAffects(ia_breakThreshold, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_breakThreshold, ca_constraintParam)") status = attributeAffects(ia_disableCollide, ca_constraint); MCHECKSTATUS(status, "adding attributeAffects(ia_disableCollide, ca_constraint)") status = attributeAffects(ia_lowerLinLimit, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_lowerLinLimit, ca_constraintParam)") status = attributeAffects(ia_upperLinLimit, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_upperLinLimit, ca_constraintParam)") status = attributeAffects(ia_lowerAngLimit, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_lowerAngLimit, ca_constraintParam)") status = attributeAffects(ia_upperAngLimit, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_upperAngLimit, ca_constraintParam)") status = attributeAffects(ia_rotationInA, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_rotationInA, ca_constraintParam)") status = attributeAffects(ia_rotationInB, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_rotationInB, ca_constraintParam)") status = attributeAffects(ia_pivotInA, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_pivotInA, ca_constraintParam)") status = attributeAffects(ia_pivotInB, ca_constraintParam); MCHECKSTATUS(status, "adding attributeAffects(ia_pivotInB, ca_constraintParam)") return MS::kSuccess; }
// // DESCRIPTION: /////////////////////////////////////////////////////// MStatus VolumeNode::initialize() { MFnNumericAttribute nAttr; // Inputs aColor = nAttr.createColor( "color", "c" ); CHECK_MSTATUS( nAttr.setKeyable( true ) ); CHECK_MSTATUS( nAttr.setStorable( true ) ); CHECK_MSTATUS( nAttr.setHidden(false) ); CHECK_MSTATUS( nAttr.setDefault(1.0f, 1.0f, 1.0f) ); aInputValue = nAttr.create( "distance", "d", MFnNumericData::kFloat); CHECK_MSTATUS( nAttr.setMin(0.0f) ); CHECK_MSTATUS(nAttr.setMax(100000.0f) ); CHECK_MSTATUS( nAttr.setSoftMax(1000.0f) ); CHECK_MSTATUS( nAttr.setSoftMax(1000.0f) ); CHECK_MSTATUS( nAttr.setKeyable(true) ); CHECK_MSTATUS(nAttr.setStorable(true) ); CHECK_MSTATUS( nAttr.setDefault(1.0f) ); aToggleCamera = nAttr.create( "cameraSpace", "cs", MFnNumericData::kBoolean); CHECK_MSTATUS( nAttr.setKeyable(true) ); CHECK_MSTATUS( nAttr.setStorable(true) ); CHECK_MSTATUS( nAttr.setHidden(false) ); CHECK_MSTATUS( nAttr.setDefault(false) ); aToggleObject = nAttr.create( "objectSpace", "os", MFnNumericData::kBoolean); CHECK_MSTATUS( nAttr.setKeyable(true) ); CHECK_MSTATUS( nAttr.setStorable(true) ); CHECK_MSTATUS( nAttr.setHidden(false) ); CHECK_MSTATUS( nAttr.setDefault(false) ); aToggleWorld = nAttr.create( "worldSpace", "ws", MFnNumericData::kBoolean); CHECK_MSTATUS(nAttr.setKeyable(true) ); CHECK_MSTATUS( nAttr.setStorable(true) ); CHECK_MSTATUS(nAttr.setHidden(false) ); CHECK_MSTATUS( nAttr.setDefault(true) ); aFarPointC = nAttr.createPoint("farPointCamera", "fc" ); CHECK_MSTATUS(nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(true) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(true) ); aFarPointO = nAttr.createPoint("farPointObj", "fo" ); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS(nAttr.setHidden(true) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(true) ); aFarPointW = nAttr.createPoint("farPointWorld", "fw" ); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(true) ); CHECK_MSTATUS(nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(true) ); aPointC = nAttr.createPoint("pointCamera", "p" ); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(true) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(true) ); aPointO = nAttr.createPoint("pointObj", "po" ); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(true) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(true) ); aPointW = nAttr.createPoint("pointWorld", "pw" ); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(true) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(true) ); // Outputs aOutColor = nAttr.createColor( "outColor", "oc" ); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(false) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(false) ); aOutTransparency = nAttr.createColor( "outTransparency", "ot" ); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(false) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(false) ); aOutAlpha = nAttr.create( "outAlpha", "oa", MFnNumericData::kFloat); CHECK_MSTATUS( nAttr.setStorable(false) ); CHECK_MSTATUS( nAttr.setHidden(false) ); CHECK_MSTATUS( nAttr.setReadable(true) ); CHECK_MSTATUS( nAttr.setWritable(false) ); CHECK_MSTATUS( addAttribute(aColor) ); CHECK_MSTATUS( addAttribute(aInputValue) ); CHECK_MSTATUS( addAttribute(aFarPointC) ); CHECK_MSTATUS( addAttribute(aFarPointO) ); CHECK_MSTATUS( addAttribute(aFarPointW) ); CHECK_MSTATUS( addAttribute(aPointC) ); CHECK_MSTATUS( addAttribute(aPointO) ); CHECK_MSTATUS( addAttribute(aPointW) ); CHECK_MSTATUS( addAttribute(aToggleCamera) ); CHECK_MSTATUS( addAttribute(aToggleObject) ); CHECK_MSTATUS( addAttribute(aToggleWorld) ); CHECK_MSTATUS( addAttribute(aOutColor) ); CHECK_MSTATUS( addAttribute(aOutTransparency) ); CHECK_MSTATUS( addAttribute(aOutAlpha) ); CHECK_MSTATUS( attributeAffects(aColor, aOutColor) ); CHECK_MSTATUS( attributeAffects(aColor, aOutTransparency) ); CHECK_MSTATUS( attributeAffects(aFarPointC, aOutColor) ); CHECK_MSTATUS( attributeAffects(aFarPointO, aOutColor) ); CHECK_MSTATUS( attributeAffects(aFarPointW, aOutColor) ); CHECK_MSTATUS( attributeAffects(aPointC, aOutColor) ); CHECK_MSTATUS( attributeAffects(aPointO, aOutColor) ); CHECK_MSTATUS( attributeAffects(aPointW, aOutColor) ); CHECK_MSTATUS( attributeAffects(aToggleCamera, aOutColor) ); CHECK_MSTATUS( attributeAffects(aToggleObject, aOutColor) ); CHECK_MSTATUS( attributeAffects(aToggleWorld, aOutColor) ); return MS::kSuccess; }
// initializes attribute information MStatus shiftNode::initialize() { MStatus stat; MFnNumericAttribute nAttr; // shift aShift = nAttr.create( "shift", "sh", MFnNumericData::kBoolean, false ); stat = addAttribute( aShift ); PERRORfail( stat, "addAttribute shift" ); // distance aDist = nAttr.create( "distance", "dis", MFnNumericData::kFloat, 0.0 ); stat = addAttribute( aDist ); PERRORfail( stat, "addAttribute dist" ); // inColor aColor = nAttr.createColor( "color", "c" ); nAttr.setStorable(false); stat = addAttribute( aColor ); PERRORfail( stat, "addAttribute inColor" ); // refPointCamera aRefPointCamera = nAttr.createPoint( "refPointCamera", "rpc" ); nAttr.setStorable(false); nAttr.setWritable(true); nAttr.setRenderSource(true); nAttr.setHidden(true); stat = addAttribute( aRefPointCamera ); PERRORfail( stat, "addAttribute refPointCamera" ); // uv MObject u = nAttr.create( "uCoord", "u", MFnNumericData::kFloat, 0.0 ); MObject v = nAttr.create( "vCoord", "v", MFnNumericData::kFloat, 0.0 ); aUv = nAttr.create( "uvCoord", "uv", u, v ); nAttr.setStorable(false); nAttr.setWritable(true); nAttr.setRenderSource(true); nAttr.setHidden(true); stat = addAttribute( aUv ); PERRORfail( stat, "addAttribute uv" ); // create output attributes here aOutColor = nAttr.createColor( "outColor", "oc" ); PERRORfail(stat, "initialize create outColor attribute"); nAttr.setReadable( true ); nAttr.setWritable( false ); stat = addAttribute( aOutColor ); PERRORfail(stat, "addAttribute(outColor)"); // attribute affects attributeAffects ( aShift, aOutColor ); attributeAffects ( aDist, aOutColor ); attributeAffects ( aColor, aOutColor ); attributeAffects ( aRefPointCamera, aOutColor ); attributeAffects ( aUv, aOutColor ); // we need to do the followings to cause other input attributes // to evaluate with the new values we set attributeAffects ( aUv, aUv ); attributeAffects ( aRefPointCamera, aRefPointCamera ); return MS::kSuccess; }
MStatus dSolverNode::initialize() { MStatus status; MFnEnumAttribute fnEnumAttr; MFnMessageAttribute fnMsgAttr; MFnUnitAttribute fnUnitAttr; MFnNumericAttribute fnNumericAttr; // ssSolverType = fnEnumAttr.create( "ssSolverType", "ssst", 0, &status ); MCHECKSTATUS(status, "creating ssSolverType attribute") fnEnumAttr.addField( "Bullet Physics", 0 ); fnEnumAttr.addField( "Ageia PhysX", 1 ); fnEnumAttr.addField( "Stanford PhysBAM", 2 ); status = addAttribute(ssSolverType); MCHECKSTATUS(status, "adding ssSolverType attribute") // ia_time = fnUnitAttr.create( "inTime", "it", MFnUnitAttribute::kTime, 0.0, &status ); MCHECKSTATUS(status, "creating ia_time attribute") fnUnitAttr.setHidden(true); status = addAttribute(ia_time); MCHECKSTATUS(status, "adding ia_time attribute") ia_startTime = fnUnitAttr.create( "startTime", "stm", MFnUnitAttribute::kTime, 1.0, &status ); MCHECKSTATUS(status, "creating ia_startTime attribute") status = addAttribute(ia_startTime); MCHECKSTATUS(status, "adding ia_startTime attribute") oa_rigidBodies = fnMsgAttr.create("rigidBodies", "rbds", &status); MCHECKSTATUS(status, "creating oa_rigidBodies attribute") status = addAttribute(oa_rigidBodies); MCHECKSTATUS(status, "adding oa_rigidBodies attribute") ia_gravity = fnNumericAttr.createPoint("gravity", "grvt", &status); MCHECKSTATUS(status, "creating gravity attribute") fnNumericAttr.setDefault(0.0, -9.81, 0.0); fnNumericAttr.setKeyable(true); status = addAttribute(ia_gravity); MCHECKSTATUS(status, "adding ia_gravity attribute") ia_substeps = fnNumericAttr.create("substeps", "sbs", MFnNumericData::kInt, 1, &status); MCHECKSTATUS(status, "creating substeps attribute") fnNumericAttr.setKeyable(true); status = addAttribute(ia_substeps); MCHECKSTATUS(status, "adding ia_substeps attribute") ia_enabled = fnNumericAttr.create("enabled", "enbl", MFnNumericData::kBoolean, true, &status); MCHECKSTATUS(status, "creating enabled attribute") status = addAttribute(ia_enabled); MCHECKSTATUS(status, "adding ia_enabled attribute") ia_splitImpulse = fnNumericAttr.create("splitImpulse", "spli", MFnNumericData::kBoolean, false, &status); MCHECKSTATUS(status, "creating splitImpulse attribute") status = addAttribute(ia_splitImpulse); MCHECKSTATUS(status, "adding ia_splitImpulse attribute") status = attributeAffects(ia_time, oa_rigidBodies); MCHECKSTATUS(status, "adding attributeAffects(ia_time, oa_rigidBodies)") status = attributeAffects(ia_enabled, oa_rigidBodies); MCHECKSTATUS(status, "adding attributeAffects(ia_enabled, oa_rigidBodies)") return MS::kSuccess; }
// initializes attribute information MStatus noise3::initialize() { MFnMatrixAttribute mAttr; MFnNumericAttribute nAttr; // Create 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 aScale = nAttr.create( "scale", "s", MFnNumericData::kFloat); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setDefault( 1. ) ); aBias = nAttr.create( "bias", "b", MFnNumericData::kFloat); MAKE_INPUT(nAttr); aPlaceMat = mAttr.create("placementMatrix", "pm", MFnMatrixAttribute::kFloat); MAKE_INPUT(mAttr); // Implicit shading network attributes aPointWorld = nAttr.createPoint("pointWorld", "pw"); MAKE_INPUT(nAttr); CHECK_MSTATUS ( nAttr.setHidden(true) ); // Create output attributes 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(aColor1) ); CHECK_MSTATUS ( addAttribute(aColor2) ); CHECK_MSTATUS ( addAttribute(aScale) ); CHECK_MSTATUS ( addAttribute(aBias) ); CHECK_MSTATUS ( addAttribute(aPointWorld) ); CHECK_MSTATUS ( addAttribute(aPlaceMat) ); 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 (aScale, aOutAlpha) ); CHECK_MSTATUS ( attributeAffects (aScale, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aBias, aOutAlpha) ); CHECK_MSTATUS ( attributeAffects (aBias, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aPointWorld, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aPointWorld, aOutAlpha) ); CHECK_MSTATUS ( attributeAffects (aPlaceMat, aOutColor) ); CHECK_MSTATUS ( attributeAffects (aPlaceMat, aOutAlpha) ); return MS::kSuccess; }
static MStatus initialize() { // set up uder-defined attribute MFnNumericAttribute numericAttrFn; MFnGenericAttribute genericAttrFn; // enable thie node aEnable = numericAttrFn.create( "enbale", "e", MFnNumericData::kBoolean, 0, &status ); CHECK_MSTATUS(status); numericAttrFn.setDefault(0); numericAttrFn.setKeyable(true); addAttribute(aEnable); // enable when rendering aEnableRender = numericAttrFn.create( "enbaleAsRendering", "er", MFnNumericData::kBoolean, 0, &status ); CHECK_MSTATUS(status); numericAttrFn.setDefault(0); numericAttrFn.setKeyable(true); addAttribute(aEnableRender); // Inputs // // input color aColor = numericAttrFn.createColor( "Color", "c", &status ); CHECK_MSTATUS(status); numericAttrFn.setDefault( 0.0, 0.5, 0.0); addAttribute(aColor); // enable supersampling aIsSpuersampling = numericAttrFn.create( "supersampling", "ssp", MFnNumericData::kBoolean, 0, &status ); CHECK_MSTATUS(status); numericAttrFn.setDefault(1); numericAttrFn.setKeyable(true); addAttribute(aIsSpuersampling); // filter size /* aFSize = numericAttrFn.create( "filterSize", "fs", MFnNumericData::k3Float, 0.0, &status ); CHECK_MSTATUS(status); numericAttrFn.setMin( 0.0, 0.0, 0.0 ); numericAttrFn.setMax( 10.0, 10.0, 10.0 ); numericAttrFn.setDefault( 1.0, 1.0, 1.0 ); addAttribute(aFSize); */ // filter size aFilterSize = numericAttrFn.create( "filterSizes", "fls", MFnNumericData::k2Int, 0, &status ); CHECK_MSTATUS(status); numericAttrFn.setMin( 0, 0 ); numericAttrFn.setMax( 10, 10 ); numericAttrFn.setDefault( 0, 0 ); addAttribute(aFilterSize); // sample offset aOffsetSample = numericAttrFn.create( "sampleOffset", "ao", MFnNumericData::kFloat, 0.0 , &status ); CHECK_MSTATUS(status); numericAttrFn.setSoftMin( 0.0f ); numericAttrFn.setSoftMax( 0.1f ); numericAttrFn.setDefault( 0.01f); addAttribute(aOffsetSample); // UV coordinate MObject uCoord = numericAttrFn.create( "uCoord", "u", MFnNumericData::kDouble ); MObject vCoord = numericAttrFn.create( "vCoord", "v", MFnNumericData::kDouble ); aUVCoord = numericAttrFn.create( "uvCoord", "uv", uCoord, vCoord, MObject::kNullObj, &status); CHECK_MSTATUS(status); numericAttrFn.setHidden(true); numericAttrFn.setRenderSource(true); addAttribute(aUVCoord); // UV filter size MObject sUVFilterSizeX = numericAttrFn.create( "uvFilterSizeX", "ufx", MFnNumericData::kFloat ); MObject sUVFilterSizeY = numericAttrFn.create( "uvFilterSizeY", "ufy", MFnNumericData::kFloat ); aUVFilterSize = numericAttrFn.create( "uvFilterSize", "uf", sUVFilterSizeX, sUVFilterSizeY, MObject::kNullObj, &status ); CHECK_MSTATUS(status); numericAttrFn.setHidden(true); addAttribute(aUVFilterSize); // World-space position aPointWorld = numericAttrFn.createPoint( "pointWorld", "pw", &status ); CHECK_MSTATUS(status); numericAttrFn.setHidden(true); addAttribute(aPointWorld); // input Shape as the source aShape = genericAttrFn.create( "sourceShape", "s", &status ); //genericAttrFn.addDataAccept( MFnData::kNurbsSurface ); genericAttrFn.addAccept( MFnData::kNurbsSurface ); genericAttrFn.addAccept( MFnData::kMesh ); CHECK_MSTATUS(status); addAttribute(aShape); // target shape aTargetShape = genericAttrFn.create( "targetShape", "ts", &status ); //genericAttrFn.addDataAccept( MFnData::kNurbsSurface ); genericAttrFn.addAccept( MFnData::kNurbsSurface ); genericAttrFn.addAccept( MFnData::kMesh ); CHECK_MSTATUS(status); addAttribute(aTargetShape); // output // // output color aOutColor = numericAttrFn.createColor( "outColor", "oc", &status); CHECK_MSTATUS(status); numericAttrFn.setWritable(false); addAttribute(aOutColor); // affect Attribute //attributeAffects( aFSize, aOutColor ); attributeAffects( aEnable, aOutColor ); attributeAffects( aEnableRender, aOutColor ); attributeAffects( aColor, aOutColor ); attributeAffects( aIsSpuersampling, aOutColor ); attributeAffects( aFilterSize, aOutColor ); attributeAffects( aOffsetSample, aOutColor ); attributeAffects( aUVCoord, aOutColor ); attributeAffects( aUVFilterSize, aOutColor ); attributeAffects( aPointWorld, aOutColor ); attributeAffects( aShape, aOutColor ); attributeAffects( aTargetShape, aOutColor ); attributeAffects( aUVCoord, aUVCoord ); return MS::kSuccess; }