//create_enum_attribute
void Ocio_test::create_enum_attribute(std::string attribute_name,
std::vector<std::string>& value_list,
MObject& node)
{
//eAttr
MFnEnumAttribute eAttr;
//a_attribute
MObject a_attribute = eAttr.create(attribute_name.c_str(), attribute_name.c_str(), 0);
eAttr.setStorable(true);
//iterate and add values
for(int index = 0; index < value_list.size(); index++)
eAttr.addField(value_list[index].c_str(), index);
//dg_modifier
MDGModifier dg_modifier;
dg_modifier.addAttribute(node, a_attribute);
dg_modifier.doIt();
//reload AE
MGlobal::executeCommandOnIdle(MString("openAEWindow;"));
//tmp
MGlobal::displayInfo(MString("Reopened AE"));
};
void MFnCompoundAttrAddEnum( MFnCompoundAttribute &attr, const char* full, const char* brief, const char** pEnumStrings, unsigned short count, unsigned short def )
{
MStatus status;
MFnEnumAttribute enumAttr;
MObject enumObj = enumAttr.create( full, brief, def, &status );
for(short index = 0; index < count; ++index)
enumAttr.addField( pEnumStrings[index], index );
attr.addChild( enumObj );
}
MStatus TestDeformer::initialize()
{
MFnNumericAttribute numericAttr;
MFnTypedAttribute polyMeshAttr;
MFnEnumAttribute enumAttr;
MStatus status; // Status will be used to hold the MStatus value
// vertSnapInput
driver_mesh = polyMeshAttr.create( "vertSnapInput", "vsnpin", MFnData::kMesh, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( polyMeshAttr.setStorable( false ) );
CHECK_MSTATUS( polyMeshAttr.setArray(true) );
CHECK_MSTATUS( polyMeshAttr.setConnectable( true ) );
CHECK_MSTATUS( addAttribute(driver_mesh) );
CHECK_MSTATUS( attributeAffects(driver_mesh, outputGeom) );
// initialize is used to mark this node's state
initialized_data = enumAttr.create( "initialize", "inl", 0/*default*/, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( enumAttr.addField( "Off", 0) );
CHECK_MSTATUS( enumAttr.addField( "Re-Set Bind", 1) );
CHECK_MSTATUS( enumAttr.addField( "Bound", 2) );
CHECK_MSTATUS( enumAttr.setKeyable(true) );
CHECK_MSTATUS( enumAttr.setStorable(true) );
CHECK_MSTATUS( enumAttr.setReadable(true) );
CHECK_MSTATUS( enumAttr.setWritable(true) );
CHECK_MSTATUS( enumAttr.setDefault(0) );
CHECK_MSTATUS( addAttribute( initialized_data ) );
CHECK_MSTATUS( attributeAffects( initialized_data, outputGeom ) );
// hold the vertex index mapping
vert_map = numericAttr.create( "vtxIndexMap", "vtximp", MFnNumericData::kLong, 0/*default*/, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( numericAttr.setKeyable(false) );
CHECK_MSTATUS( numericAttr.setArray(true) );
CHECK_MSTATUS( numericAttr.setStorable(true) );
CHECK_MSTATUS( numericAttr.setReadable(true) );
CHECK_MSTATUS( numericAttr.setWritable(true) );
CHECK_MSTATUS( addAttribute( vert_map ) );
CHECK_MSTATUS( attributeAffects( vert_map, outputGeom ) );
CHECK_MSTATUS( MGlobal::executePythonCommand("import maya.cmds; maya.cmds.makePaintable('"+TestDeformer::cTypeName()+"', 'weights', attrType='multiFloat')") );
return( MS::kSuccess );
}
MStatus sgLockAngleMatrix::initialize()
{
MStatus status;
MFnMatrixAttribute mAttr;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
aBaseMatrix = mAttr.create( "baseMatrix", "baseMatrix" );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aBaseMatrix ) );
aInputMatrix = mAttr.create( "inputMatrix", "inputMatrix" );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputMatrix ) );
aAngleAxis = eAttr.create( "angleAxis", "angleAxis" );
eAttr.addField( " X", 0 );eAttr.addField( " Y", 1 );eAttr.addField( " Z", 2 );
eAttr.addField( "-X", 3 );eAttr.addField( "-Y", 4 );eAttr.addField( "-Z", 5 );
eAttr.setStorable( true );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aAngleAxis ) );
aInputAngle = nAttr.create( "inputAngle", "inputAngle", MFnNumericData::kDouble, 45 );
nAttr.setStorable( true );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputAngle ) );
aOutputMatrix = mAttr.create( "outputMatrix", "outputMatrix" );
mAttr.setStorable( false );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aBaseMatrix, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputMatrix, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aAngleAxis, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputAngle, aOutputMatrix ) );
return MS::kSuccess;
}
MStatus BasicLocator::initialize()
{
//standard attribute creation for the locator node
MStatus status;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
//output attribute
aIsDrawing = nAttr.create("draw", "d", MFnNumericData::kBoolean, 1);
nAttr.setWritable(true);
nAttr.setStorable(true);
addAttribute(aIsDrawing);
aIsTransparent = nAttr.create("transparent", "tpart", MFnNumericData::kFloat, 0.5);
nAttr.setMin(0.0);
nAttr.setMax(1.0);
nAttr.setWritable(true);
nAttr.setStorable(true);
addAttribute(aIsTransparent);
aShapeColor = nAttr.createColor("color", "col");
nAttr.setDefault(0.1, 0.1, 0.8);
nAttr.setStorable(true);
nAttr.setWritable(true);
addAttribute(aShapeColor);
aShapeType = eAttr.create("shapeType", "styp", 0);
eAttr.setStorable(true);
eAttr.setKeyable(true);
eAttr.addField("arrow", 0);
eAttr.addField("disc", 1);
addAttribute(aShapeType);
return MS::kSuccess;
}
MStatus liqCoordSysNode::initialize()
{
MFnEnumAttribute eAttr;
MFnNumericAttribute numAttr;
MStatus status;
aCoordType = eAttr.create( "type", "t", 0, &status );
eAttr.addField( "Card", 0 );
eAttr.addField( "Sphere", 1 );
eAttr.addField( "Cylinder", 2 );
eAttr.addField( "Cube", 3 );
eAttr.addField( "Deep Card", 4 );
eAttr.addField( "Clipping Plane", 5 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(eAttr.setConnectable(false));
CHECK_MSTATUS( addAttribute( aCoordType ) );
aCoordColor = numAttr.createColor( "coordColor", "cc", &status );
MAKE_INPUT(numAttr);
CHECK_MSTATUS( numAttr.setMin( 0.0, 0.0, 0.0 ) );
CHECK_MSTATUS( numAttr.setMax( 1.0, 1.0, 1.0 ) );
CHECK_MSTATUS( numAttr.setDefault( 0.0, 0.0, 0.5) );
CHECK_MSTATUS( addAttribute( aCoordColor ) );
aCoordOpacity = numAttr.create( "coordOpacity", "co", MFnNumericData::kFloat, 0.0, &status );
MAKE_INPUT(numAttr);
CHECK_MSTATUS( numAttr.setMin( 0.0 ) );
CHECK_MSTATUS( numAttr.setMax( 1.0 ) );
CHECK_MSTATUS( addAttribute( aCoordOpacity ) );
return MS::kSuccess;
}
//-----------------------------------------------------------------------------
// Purpose: Initialize the node, add static attributes, etc...
// Output : MStatus::kSuccess if everything was ok
//-----------------------------------------------------------------------------
MStatus CVstExampleLocator::Initialize()
{
// Add a little enum attribute to control how it's drawn
MFnEnumAttribute eFn;
s_iaDisplayStyle = eFn.create( "displayStyle", "ds", 0 );
eFn.setKeyable ( true );
eFn.addField( "maya", 0 );
eFn.addField( "shaded", 1 );
eFn.addField( "wireframe", 2 );
eFn.addField( "points", 3 );
addAttribute(s_iaDisplayStyle);
return MS::kSuccess;
}
MStatus mpBox::initialize()
{
MFnNumericAttribute nAttr;
MFnEnumAttribute enumAttr;
// add the custom attributes for mpBox //
_COMMON_ATTR_INIT_;
aXsize = nAttr.create( "xsize", "xsz", MFnNumericData::kFloat);
nAttr.setDefault(0.5f);
nAttr.setKeyable(1);
nAttr.setReadable(1);
nAttr.setWritable(1);
nAttr.setStorable(1);
aYsize = nAttr.create( "ysize", "ysz", MFnNumericData::kFloat);
nAttr.setDefault(0.5f);
nAttr.setKeyable(1);
nAttr.setReadable(1);
nAttr.setWritable(1);
nAttr.setStorable(1);
aZsize = nAttr.create( "zsize", "zsz", MFnNumericData::kFloat);
nAttr.setDefault(0.5f);
nAttr.setKeyable(1);
nAttr.setReadable(1);
nAttr.setWritable(1);
nAttr.setStorable(1);
aDrawType = enumAttr.create( "drawType" , "dt");
enumAttr.addField("wireframe", 0);
enumAttr.addField("shaded", 1);
enumAttr.addField("normal", 2);
enumAttr.setHidden(false);
enumAttr.setKeyable(true);
enumAttr.setDefault(2);
addAttribute(aXsize);
addAttribute(aYsize);
addAttribute(aZsize);
addAttribute(aDrawType);
return MS::kSuccess;
}
//initialize
//-----------------------------------------------
MStatus TesselationVisualization::initialize()
{
//Attr functionsets
MFnEnumAttribute eAttr;
MFnTypedAttribute tAttr;
MFnNumericAttribute nAttr;
//aVerbose
aVerbose = eAttr.create("verbose", "verbose", 0);
eAttr.addField("noVerbose", 0);
eAttr.addField("Verbose", 1);
addAttribute(aVerbose);
//aTesselationType
aTesselationType = eAttr.create("tesselationType", "tesselationType", 0);
eAttr.addField("Structural", 0);
eAttr.addField("Shear", 1);
addAttribute(aTesselationType);
//aInputGeo
aInputGeo = tAttr.create("inputGeo", "inputGeo", MFnData::kMesh);
tAttr.setReadable(false);
addAttribute(aInputGeo);
//aOutputGeo
aOutputGeo = tAttr.create("outputGeo", "outputGeo", MFnData::kMesh);
tAttr.setWritable(false);
tAttr.setStorable(false);
addAttribute(aOutputGeo);
//aCurrentFrame
aCurrentFrame = nAttr.create("currentFrame", "currentFrame", MFnNumericData::kFloat);
addAttribute(aCurrentFrame);
//AttributeAffects
attributeAffects(aTesselationType, aOutputGeo);
attributeAffects(aInputGeo, aOutputGeo);
attributeAffects(aCurrentFrame, aOutputGeo);
return MStatus::kSuccess;
};
//
// DESCRIPTION:
MStatus fresnel::initialize()
{
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus status;
outColor = nAttr.createColor("outColor", "outColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( outColor ));
//---------------------------- automatically created attributes start ------------------------------------
filename = tAttr.create("filename", "filename", MFnNumericData::kString);
CHECK_MSTATUS(addAttribute( filename ));
name = eAttr.create("name", "name", 0, &status);
status = eAttr.addField( "aluminium", 0 );
status = eAttr.addField( "amorphous carbon", 1 );
status = eAttr.addField( "silver", 2 );
status = eAttr.addField( "gold", 3 );
status = eAttr.addField( "copper", 4 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( name ));
luxOutFresnel = nAttr.create("luxOutFresnel", "luxOutFresnel", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( luxOutFresnel ));
CHECK_MSTATUS ( attributeAffects( filename, luxOutFresnel));
CHECK_MSTATUS ( attributeAffects( filename, outColor));
//---------------------------- automatically created attributes end ------------------------------------
return MS::kSuccess;
}
MStatus LSSolverNode::initialize()
{
MFnNumericAttribute nAttr;
MFnUnitAttribute uAttr;
MFnTypedAttribute tAttr;
MFnEnumAttribute eAttr;
MFnMatrixAttribute mAttr;
tetWorldMatrix = mAttr.create("tet_world_matrix","twm",MFnMatrixAttribute::kDouble,&returnStatus);
McheckErr(returnStatus, "ERROR creating LSTetgenNode worldMatrix attribute\n");
MAKE_INPUT(mAttr);
mAttr.setHidden(true);
restShape = tAttr.create("restShape", "rs", MFnMeshData::kMesh, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode restShape attribute\n");
MAKE_INPUT(tAttr);
restElements = tAttr.create("restElements", "re", MFnData::kIntArray, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode restShape attribute\n");
MAKE_INPUT(tAttr);
restVertices = tAttr.create("restVertices", "rv", MFnData::kDoubleArray, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode restShape attribute\n");
MAKE_INPUT(tAttr);
selectedConstraintVerts = tAttr.create("selectedConstraintVerts", "scv", MFnData::kIntArray, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode selectedConstraintVerts attribute\n");
MAKE_INPUT(tAttr);
selectedForceVerts = tAttr.create("selectedForceVerts", "sfv", MFnData::kIntArray, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode selectedForceVerts attribute\n");
MAKE_INPUT(tAttr);
time = uAttr.create("time", "t", MFnUnitAttribute::kTime,0.0, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode time attribute\n");
MAKE_INPUT(uAttr);
deformed = tAttr.create("deformed", "d", MFnMeshData::kMesh, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode deformed attribute\n");
MAKE_OUTPUT(tAttr);
poissonRatio = nAttr.create("poissonRatio", "pr", MFnNumericData::kDouble, 0.45, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode poisson ratio\n");
MAKE_INPUT(nAttr);
nAttr.setMax(0.45);
nAttr.setMin(0);
youngsModulus = nAttr.create("youngsModulus", "ym", MFnNumericData::kDouble, 90000000000, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode youngsModulus\n");
MAKE_INPUT(nAttr);
//nAttr.setMax(50000);
//nAttr.setMin(1);
objectDensity = nAttr.create("density", "objd", MFnNumericData::kDouble, 1000, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode objectDensity\n");
MAKE_INPUT(nAttr);
nAttr.setMax(10000);
nAttr.setMin(1);
friction = nAttr.create("friction", "f", MFnNumericData::kDouble, 0.98, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode friction\n");
MAKE_INPUT(nAttr);
nAttr.setMax(1);
nAttr.setMin(0);
restitution = nAttr.create("restitution", "r", MFnNumericData::kDouble, 0.4, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode restitution\n");
MAKE_INPUT(nAttr);
nAttr.setMax(1);
nAttr.setMin(0);
damping = nAttr.create("damping", "dmp", MFnNumericData::kDouble, 0.0, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode damping\n");
MAKE_INPUT(nAttr);
nAttr.setMax(1);
nAttr.setMin(0);
userSuppliedDt = nAttr.create("timeStep","ts",MFnNumericData::kDouble,0.01, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode userSuppliedDt\n");
MAKE_INPUT(nAttr);
nAttr.setMax(1);
nAttr.setMin(0.00001);
forceApplicationTime = nAttr.create("forceApplicationTime", "fat", MFnNumericData::kInt, 50, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceApplicationTime ratio\n");
MAKE_INPUT(nAttr);
forceReleasedTime = nAttr.create("forceReleasedTime", "frt", MFnNumericData::kInt, 100, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceReleasedTime ratio\n");
MAKE_INPUT(nAttr);
forceIncrementTime = nAttr.create("forceIncrementTime", "fit", MFnNumericData::kInt, 10, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceIncrementTime ratio\n");
MAKE_INPUT(nAttr);
forceStartTime = nAttr.create("forceStartTime", "fst", MFnNumericData::kInt,100, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceStartTime\n");
MAKE_INPUT(nAttr);
forceStopTime = nAttr.create("forceStopTime", "fet", MFnNumericData::kInt, 200, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceStopTime\n");
MAKE_INPUT(nAttr);
forceMagnitude = nAttr.create("forceMagnitude", "fm", MFnNumericData::kDouble, 10.0, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceIdleTime ratio\n");
MAKE_INPUT(nAttr);
forceDirection = nAttr.create("forceDirection", "fd", MFnNumericData::k3Double, 0.0 , &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceIdleTime ratio\n");
MAKE_INPUT(nAttr);
useSuppliedConstraints = nAttr.create("useSuppliedConstraints", "usc", MFnNumericData::kBoolean,1, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode useSuppliedConstraints ratio\n");
MAKE_INPUT(nAttr);
useSuppliedForce = nAttr.create("useSuppliedForce", "usf", MFnNumericData::kBoolean, 0, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode useSuppliedForces ratio\n");
MAKE_INPUT(nAttr);
integrationType = eAttr.create("timeIntegrationMethod","it",0,&returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode integrationType\n");
eAttr.addField("Implicit Backward Euler",0);
eAttr.addField("Implicit Newmark",1);
eAttr.addField("Central Differences",2);
eAttr.addField("Symplectic Euler",3);
MAKE_INPUT(eAttr);
forceModelType = eAttr.create("system","ft",0,&returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode forceModelType\n");
eAttr.addField("Corotational Linear FEM",0);
eAttr.addField("Mass Spring System",1);
MAKE_INPUT(eAttr);
contactKs = nAttr.create("contactSpringForce", "cKs", MFnNumericData::kDouble, 1000.0, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode contactSpringForces\n");
MAKE_INPUT(nAttr);
contactKd = nAttr.create("contactDampForce", "cKd", MFnNumericData::kDouble, 50.0, &returnStatus);
McheckErr(returnStatus, "ERROR creating LSSolverNode contactDampForces\n");
MAKE_INPUT(nAttr);
returnStatus = addAttribute(tetWorldMatrix);
McheckErr(returnStatus, "ERROR adding LSSolverNode world matrix attribute\n");
returnStatus = addAttribute(restShape);
McheckErr(returnStatus, "ERROR adding LSSolverNode step attribute\n");
returnStatus = addAttribute(restElements);
McheckErr(returnStatus, "ERROR adding LSSolverNode restElements attribute\n");
returnStatus = addAttribute(restVertices);
McheckErr(returnStatus, "ERROR adding LSSolverNode restVertices attribute\n");
returnStatus = addAttribute(selectedConstraintVerts);
McheckErr(returnStatus, "ERROR adding LSSolverNode selectedConstraintVerts attribute\n");
returnStatus = addAttribute(selectedForceVerts);
McheckErr(returnStatus, "ERROR adding LSSolverNode selectedForceVerts attribute\n");
returnStatus = addAttribute(time);
McheckErr(returnStatus, "ERROR adding LSSolverNode time attribute\n");
returnStatus = addAttribute(deformed);
McheckErr(returnStatus, "ERROR adding LSSolverNode deformed attribute\n");
returnStatus = addAttribute(youngsModulus);
McheckErr(returnStatus, "ERROR adding LSSolverNode youngsModulus\n");
returnStatus = addAttribute(poissonRatio);
McheckErr(returnStatus, "ERROR adding LSSolverNode poissonRation\n");
returnStatus = addAttribute(objectDensity);
McheckErr(returnStatus, "ERROR adding LSSolverNode objectDensity\n");
returnStatus = addAttribute(friction);
McheckErr(returnStatus, "ERROR adding LSSolverNode friction\n");
returnStatus = addAttribute(restitution);
McheckErr(returnStatus, "ERROR adding LSSolverNode resitution\n");
returnStatus = addAttribute(damping);
McheckErr(returnStatus, "ERROR adding LSSolverNode damping\n");
returnStatus = addAttribute(userSuppliedDt);
McheckErr(returnStatus, "ERROR adding LSSolverNode userSuppliedDt\n");
returnStatus = addAttribute(useSuppliedConstraints);
McheckErr(returnStatus, "ERROR adding LSSolverNode useSuppliedConstraints\n");
returnStatus = addAttribute(useSuppliedForce);
McheckErr(returnStatus, "ERROR adding LSSolverNode useSuppliedForce\n");
returnStatus = addAttribute(forceMagnitude);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceMagnitude\n");
returnStatus = addAttribute(forceDirection);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceDirection\n");
returnStatus = addAttribute(forceApplicationTime);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceApplicationTime\n");
returnStatus = addAttribute(forceReleasedTime);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceReleasedTime\n");
returnStatus = addAttribute(forceIncrementTime);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceIncrementTime\n");
returnStatus = addAttribute(forceStartTime);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceIdleTime\n");
returnStatus = addAttribute(forceStopTime);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceIdleTime\n");
// returnStatus = addAttribute(inputFilePath);
// McheckErr(returnStatus, "ERROR adding LSSolverNode inputFilePath\n");
returnStatus = addAttribute(integrationType);
McheckErr(returnStatus, "ERROR adding LSSolverNode integrationType\n");
returnStatus = addAttribute(forceModelType);
McheckErr(returnStatus, "ERROR adding LSSolverNode forceModelType\n");
returnStatus = addAttribute(contactKd);
McheckErr(returnStatus, "ERROR adding LSSolverNode contactKd\n");
returnStatus = addAttribute(contactKs);
McheckErr(returnStatus, "ERROR adding LSSolverNode contactKs\n");
returnStatus = attributeAffects(restShape, deformed);
McheckErr(returnStatus, "ERROR in attributeAffects: restShape - deformed\n");
returnStatus = attributeAffects(time, deformed);
McheckErr(returnStatus, "ERROR in attributeAffects: time - deformed\n");
return MS::kSuccess;
}
// Create and Add Attributes
//
// Description:
// This method is called to create and initialize all of the attributes
// and attribute dependencies for this node type. This is only called
// once when the node type is registered with Maya.
//
// Return Values:
// MS::kSuccess
// MS::kFailure
//
MStatus
MayaPolySmooth::initialize() {
MStatus stat;
MFnCompoundAttribute cAttr;
MFnEnumAttribute eAttr;
MFnGenericAttribute gAttr;
MFnLightDataAttribute lAttr;
MFnMatrixAttribute mAttr;
MFnMessageAttribute msgAttr;
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnUnitAttribute uAttr;
// MAYA_NODE_BUILDER:BEG [ATTRIBUTE CREATION] ==========
// a_inputPolymesh : This is a description for this attribute
a_inputPolymesh = tAttr.create("inputPolymesh", "ip", MFnData::kMesh, MObject::kNullObj, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::inputPolymesh" );
stat = tAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::inputPolymesh.setReadable()" );
stat = tAttr.setWritable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::inputPolymesh.setWritable()" );
stat = tAttr.setHidden(true);
MCHECKERR( stat, "cannot MayaPolySmooth::inputPolymesh.setHidden()" );
stat = addAttribute( a_inputPolymesh );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_inputPolymesh)" );
// a_output : This is a description for this attribute
a_output = tAttr.create("output", "out", MFnData::kMesh, MObject::kNullObj, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::output" );
stat = tAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::output.setReadable()" );
stat = tAttr.setWritable(false);
MCHECKERR( stat, "cannot MayaPolySmooth::output.setWritable()" );
stat = tAttr.setHidden(true);
MCHECKERR( stat, "cannot MayaPolySmooth::output.setHidden()" );
stat = addAttribute( a_output );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_output)" );
// a_subdivisionLevels : The number of recursive quad subdivisions to perform on each face.
a_subdivisionLevels = nAttr.create("subdivisionLevels", "sl", MFnNumericData::kInt, 0.0, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::subdivisionLevels" );
stat = nAttr.setDefault(2);
MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setDefault(2)" );
stat = nAttr.setMin(0);
MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setMin(0)" );
stat = nAttr.setMax(10);
MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setMax(10)" );
stat = nAttr.setSoftMax(4);
MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setSoftMax(4)" );
stat = nAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setReadable()" );
stat = nAttr.setWritable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::subdivisionLevels.setWritable()" );
stat = addAttribute( a_subdivisionLevels );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_subdivisionLevels)" );
// a_recommendedIsolation : The number of recursive quad subdivisions to perform on each face.
a_recommendedIsolation = nAttr.create("recommendedIsolation", "ri", MFnNumericData::kInt, 0.0, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::recommendedIsolation" );
stat = nAttr.setDefault(2);
MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setDefault(0)" );
stat = nAttr.setMin(0);
MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setMin(0)" );
stat = nAttr.setMax(10);
MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setSoftMax(10)" );
stat = nAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setReadable()" );
stat = nAttr.setWritable(false);
MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setWritable()" );
stat = nAttr.setHidden(false);
MCHECKERR( stat, "cannot MayaPolySmooth::recommendedIsolation.setHidden()" );
stat = addAttribute( a_recommendedIsolation );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_recommendedIsolation)" );
// a_vertBoundaryMethod : Controls how boundary edges and vertices are interpolated. <ul> <li>Smooth, Edges: Renderman: InterpolateBoundaryEdgeOnly</li> <li>Smooth, Edges and Corners: Renderman: InterpolateBoundaryEdgeAndCorner</li> </ul>
a_vertBoundaryMethod = eAttr.create("vertBoundaryMethod", "vbm", 0, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::vertBoundaryMethod" );
stat = eAttr.addField("Interpolate Edges", k_BoundaryMethod_InterpolateBoundaryEdgeOnly);
MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.addField(Interpolate Edges, k_BoundaryMethod_InterpolateBoundaryEdgeOnly)" );
stat = eAttr.addField("Interpolate Edges And Corners", k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner);
MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.addField(Interpolate Edges And Corners, k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner)" );
stat = eAttr.setDefault(k_BoundaryMethod_InterpolateBoundaryEdgeOnly);
MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.setDefault(k_BoundaryMethod_InterpolateBoundaryEdgeOnly)" );
stat = eAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.setReadable()" );
stat = eAttr.setWritable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::vertBoundaryMethod.setWritable()" );
stat = addAttribute( a_vertBoundaryMethod );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_vertBoundaryMethod)" );
// a_fvarBoundaryMethod : Controls how boundaries are treated for face-varying data (UVs and Vertex Colors). <ul> <li>Bi-linear (None): Renderman: InterpolateBoundaryNone</li> <li>Smooth, (Edge Only): Renderman: InterpolateBoundaryEdgeOnly</li> <li>Smooth, (Edges and Corners: Renderman: InterpolateBoundaryEdgeAndCorner</li> <li>Smooth, (ZBrush and Maya "Smooth Internal Only"): Renderman: InterpolateBoundaryAlwaysSharp</li> </ul>
a_fvarBoundaryMethod = eAttr.create("fvarBoundaryMethod", "fvbm", 0, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::fvarBoundaryMethod" );
stat = eAttr.addField("Bi-linear (None)", k_BoundaryMethod_InterpolateBoundaryNone);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Bi-linear (None), k_BoundaryMethod_InterpolateBoundaryNone)" );
stat = eAttr.addField("Smooth (Edge Only)", k_BoundaryMethod_InterpolateBoundaryEdgeOnly);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Smooth (Edge Only), k_BoundaryMethod_InterpolateBoundaryEdgeOnly)" );
stat = eAttr.addField("Smooth (Edge and Corner)", k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Smooth (Edge and Corner), k_BoundaryMethod_InterpolateBoundaryEdgeAndCorner)" );
stat = eAttr.addField("Smooth (Always Sharp)", k_BoundaryMethod_InterpolateBoundaryAlwaysSharp);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.addField(Smooth (Always Sharp), k_BoundaryMethod_InterpolateBoundaryAlwaysSharp)" );
stat = eAttr.setDefault(k_BoundaryMethod_InterpolateBoundaryNone);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.setDefault(k_BoundaryMethod_InterpolateBoundaryNone)" );
stat = eAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.setReadable()" );
stat = eAttr.setWritable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarBoundaryMethod.setWritable()" );
stat = addAttribute( a_fvarBoundaryMethod );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_fvarBoundaryMethod)" );
// a_fvarPropagateCorners :
a_fvarPropagateCorners = nAttr.create("fvarPropagateCorners", "fvpc", MFnNumericData::kBoolean, 0.0, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::fvarPropagateCorners" );
stat = nAttr.setDefault(false);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarPropagateCorners.setDefault(false)" );
stat = nAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarPropagateCorners.setReadable()" );
stat = nAttr.setWritable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::fvarPropagateCorners.setWritable()" );
stat = addAttribute( a_fvarPropagateCorners );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_fvarPropagateCorners)" );
// a_smoothTriangles : Apply a special subdivision rule be applied to all triangular faces that was empirically determined to make triangles subdivide more smoothly.
a_smoothTriangles = nAttr.create("smoothTriangles", "stri", MFnNumericData::kBoolean, 0.0, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::smoothTriangles" );
stat = nAttr.setDefault(true);
MCHECKERR( stat, "cannot MayaPolySmooth::smoothTriangles.setDefault(true)" );
stat = nAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::smoothTriangles.setReadable()" );
stat = nAttr.setWritable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::smoothTriangles.setWritable()" );
stat = addAttribute( a_smoothTriangles );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_smoothTriangles)" );
// a_creaseMethod : Controls how boundary edges and vertices are interpolated. <ul> <li>Normal</li> <li>Chaikin: Improves the appearance of multiedge creases with varying weight</li> </ul>
a_creaseMethod = eAttr.create("creaseMethod", "crm", 0, &stat);
MCHECKERR( stat, "cannot create MayaPolySmooth::creaseMethod" );
stat = eAttr.addField("Normal", k_creaseMethod_normal);
MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.addField(Normal, k_creaseMethod_normal)" );
stat = eAttr.addField("Chaikin", k_creaseMethod_chaikin);
MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.addField(Chaikin, k_creaseMethod_chaikin)" );
stat = eAttr.setDefault(0);
MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.setDefault(0)" );
stat = eAttr.setReadable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.setReadable()" );
stat = eAttr.setWritable(true);
MCHECKERR( stat, "cannot MayaPolySmooth::creaseMethod.setWritable()" );
stat = addAttribute( a_creaseMethod );
MCHECKERR( stat, "cannot MayaPolySmooth::addAttribute(a_creaseMethod)" );
// MAYA_NODE_BUILDER:END [ATTRIBUTE CREATION] ==========
// Set up a dependency between the input and the output. This will cause
// the output to be marked dirty when the input changes. The output will
// then be recomputed the next time the value of the output is requested.
//
// MAYA_NODE_BUILDER:BEG [ATTRIBUTE DEPENDS] ==========
stat = attributeAffects( a_creaseMethod, a_output );
MCHECKERR( stat, "cannot have attribute creaseMethod affect output" );
stat = attributeAffects( a_inputPolymesh, a_output );
MCHECKERR( stat, "cannot have attribute inputPolymesh affect output" );
stat = attributeAffects( a_subdivisionLevels, a_output );
MCHECKERR( stat, "cannot have attribute subdivisionLevels affect output" );
stat = attributeAffects( a_smoothTriangles, a_output );
MCHECKERR( stat, "cannot have attribute smoothTriangles affect output" );
stat = attributeAffects( a_fvarPropagateCorners, a_output );
MCHECKERR( stat, "cannot have attribute fvarPropagateCorners affect output" );
stat = attributeAffects( a_vertBoundaryMethod, a_output );
MCHECKERR( stat, "cannot have attribute vertBoundaryMethod affect output" );
stat = attributeAffects( a_fvarBoundaryMethod, a_output );
MCHECKERR( stat, "cannot have attribute fvarBoundaryMethod affect output" );
stat = attributeAffects( a_creaseMethod, a_recommendedIsolation );
MCHECKERR( stat, "cannot have attribute creaseMethod affect .si output" );
stat = attributeAffects( a_inputPolymesh, a_recommendedIsolation );
MCHECKERR( stat, "cannot have attribute inputPolymesh affect .si output" );
stat = attributeAffects( a_subdivisionLevels, a_recommendedIsolation );
MCHECKERR( stat, "cannot have attribute subdivisionLevels affect .si output" );
stat = attributeAffects( a_smoothTriangles, a_recommendedIsolation );
MCHECKERR( stat, "cannot have attribute smoothTriangles affect .si output" );
stat = attributeAffects( a_fvarPropagateCorners, a_recommendedIsolation );
MCHECKERR( stat, "cannot have attribute fvarPropagateCorners affect .si output" );
stat = attributeAffects( a_vertBoundaryMethod, a_recommendedIsolation );
MCHECKERR( stat, "cannot have attribute vertBoundaryMethod affect .si output" );
stat = attributeAffects( a_fvarBoundaryMethod, a_recommendedIsolation );
MCHECKERR( stat, "cannot have attribute fvarBoundaryMethod affect .si output" );
// MAYA_NODE_BUILDER:END [ATTRIBUTE DEPENDS] ==========
return MS::kSuccess;
}
//----------------------------------------------------------------------------------------------------------------------
// this method creates the attributes for our node and sets some default values etc
//----------------------------------------------------------------------------------------------------------------------
MStatus OceanNode::initialize(){
// Attributes to check whether the amplitude or wind vector have changed
m_wdx = 0.0;
m_wdz = 1.0;
m_ws = 100.0;
m_amp = 100.0;
m_res = 0;
MStatus status;
// an emum attribute for use with the resolution
MFnEnumAttribute enumAttr;
// resolution
m_resolution = enumAttr.create("resolution", "res", 0, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"resolution\" attribute");
enumAttr.addField("128x128", RES128);
enumAttr.addField("256x256", RES256);
enumAttr.addField("512x512", RES512);
enumAttr.addField("1024x1024", RES1024);
enumAttr.setKeyable(true);
status = addAttribute(m_resolution);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"resolution\" attribute to OceanNode");
// now we are going to add several number attributes
MFnNumericAttribute numAttr;
// amplitde
m_amplitude = numAttr.create( "amplitude", "amp", MFnNumericData::kDouble, 100.0, &status );
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status , "Unable to create \"amplitude\" attribute" );
numAttr.setChannelBox( true );
// add attribute
status = addAttribute( m_amplitude );
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status , "Unable to add \"amplitude\" attribute to OceanNode" );
// frequency
m_frequency = numAttr.create("frequency", "frq", MFnNumericData::kDouble, 0.5, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"frequency\" attribute");
numAttr.setChannelBox(true);
status = addAttribute(m_frequency);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"frequency\" attribute to OceanNodee");
// the wind speed inputs
MFnNumericAttribute windDirectionAttr;
m_windDirectionX = windDirectionAttr.create( "windDirectionX", "wdx", MFnNumericData::kDouble, 0.0, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status, "Unable to create \"wdx\" attribute");
windDirectionAttr.setChannelBox(true);
windDirectionAttr.setMin(0.0);
windDirectionAttr.setMax(1.0);
// add attribute
status = addAttribute( m_windDirectionX );
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"wdx\" attribute to OceanNode")
m_windDirectionZ = windDirectionAttr.create( "windDirectionZ", "wdz", MFnNumericData::kDouble, 0.5, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status, "Unable to create \"wdy\" attribute");
windDirectionAttr.setChannelBox(true);
windDirectionAttr.setMin(0.0);
windDirectionAttr.setMax(1.0);
// add attribute
status = addAttribute( m_windDirectionZ );
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"wdz\" attribute to OceanNode");
m_windSpeed = numAttr.create( "windSpeed", "ws", MFnNumericData::kDouble, 100.0, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL( status, "Unable to create \"ws\" attribute");
numAttr.setChannelBox(true);
// add attribute
status = addAttribute( m_windSpeed );
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"ws\" attribute to OceanNode");
MFnNumericAttribute chopAttr;
m_choppiness = chopAttr.create("chopiness", "chp", MFnNumericData::kDouble, 0.0, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"chopiness\" attribute");
chopAttr.setChannelBox(true);
chopAttr.setMax(2.0);
chopAttr.setMin(0.0);
// add attribute
status = addAttribute(m_choppiness);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"choppiness\" attribute to OceanNode");
// now the time inputs
MFnNumericAttribute timeAttr;
m_time = timeAttr.create("time", "t", MFnNumericData::kDouble, 0.0, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"t\" attribute");
// Add the attribute
status = addAttribute(m_time);
timeAttr.setHidden(true);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"t\" attribute to OceanNode");
// create the output attribute
MFnTypedAttribute typeAttr;
m_output = typeAttr.create("output", "out", MFnData::kMesh, &status);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to create \"output\" attribute");
typeAttr.setStorable(false);
typeAttr.setHidden(true);
status = addAttribute(m_output);
CHECK_STATUS_AND_RETURN_MSTATUS_IF_FAIL(status, "Unable to add \"output\" attribute to OceanNode");
// this links the different elements together forcing a re-compute each time the values are changed
attributeAffects(m_resolution, m_output);
attributeAffects(m_amplitude,m_output);
attributeAffects(m_windDirectionX, m_output);
attributeAffects(m_windDirectionZ, m_output);
attributeAffects(m_windSpeed, m_output);
attributeAffects(m_choppiness, m_output);
attributeAffects(m_time, m_output);
// report all was good
return MStatus::kSuccess;
}
static MStatus initialize()
{
MFnEnumAttribute enumAttrFn;
MFnNumericAttribute numericAttrFn;
MFnGenericAttribute genericAttrFn;
MFnTypedAttribute typeAttrFn;
// enable node
aEnable = numericAttrFn.create( "enbale", "e", MFnNumericData::kBoolean, 0, &status );
numericAttrFn.setDefault(0);
numericAttrFn.setKeyable(true);
addAttribute(aEnable);
aFixPanel = numericAttrFn.create( "fixPanel", "fpn", MFnNumericData::kBoolean, 0, &status);
numericAttrFn.setDefault(1);
numericAttrFn.setConnectable(true);
addAttribute(aFixPanel);
aKeepSel = numericAttrFn.create( "keepSelection", "ks", MFnNumericData::kBoolean, 0, &status);
numericAttrFn.setDefault(0);
addAttribute(aKeepSel);
// component type
aComponentType = enumAttrFn.create( "componetType", "ct", 0, &status );
CHECK_MSTATUS( status );
enumAttrFn.setDefault(0);
enumAttrFn.addField( "vertex", 0 );
enumAttrFn.addField( "edge", 1 );
enumAttrFn.addField( "face", 2 );
enumAttrFn.addField( "uv", 3 );
addAttribute( aComponentType );
// source object
aSourceObj = genericAttrFn.create( "sourceObject", "so", &status );
genericAttrFn.addAccept(MFnData::kMesh);
genericAttrFn.setStorable(false);
addAttribute( aSourceObj );
CHECK_MSTATUS( status );
// volume object
aVolumeObj = genericAttrFn.create( "volumeObject", "vo", &status );
genericAttrFn.addAccept(MFnData::kMesh);
genericAttrFn.setArray(true);
addAttribute( aVolumeObj );
CHECK_MSTATUS( status );
aClosedObj = numericAttrFn.create( "closedVolumeObject", "cvo", MFnNumericData::kBoolean, 1, &status );
numericAttrFn.setDefault(1);
addAttribute( aClosedObj );
// ouput attribute
//
aOutValue = numericAttrFn.create( "outValue", "ov", MFnNumericData::kInt, 0, &status );
CHECK_MSTATUS( status );
numericAttrFn.setReadable(false);
addAttribute( aOutValue );
aOutCompList = typeAttrFn.create( "outComponent", "ocp", MFnComponentListData::kComponentList, &status );
CHECK_MSTATUS( status );
addAttribute(aOutCompList);
aOutMesh = typeAttrFn.create( "outMesh", "om", MFnData::kMesh, &status );
CHECK_MSTATUS( status );
addAttribute(aOutMesh);
// Attribute Affects for aOutValue
attributeAffects( aEnable, aOutValue );
attributeAffects( aFixPanel, aOutValue );
attributeAffects( aComponentType, aOutValue );
attributeAffects( aKeepSel, aOutValue );
attributeAffects( aClosedObj, aOutValue );
attributeAffects( aSourceObj, aOutValue );
attributeAffects( aVolumeObj, aOutValue );
//Attribute Affects for aOutCompList
attributeAffects( aEnable, aOutCompList);
attributeAffects( aFixPanel, aOutCompList );
attributeAffects( aComponentType, aOutCompList );
attributeAffects( aKeepSel, aOutCompList );
attributeAffects( aClosedObj, aOutCompList );
attributeAffects( aSourceObj, aOutCompList );
attributeAffects( aVolumeObj, aOutCompList );
//Attribute Affects for aOutMesh
attributeAffects( aEnable, aOutMesh);
attributeAffects( aFixPanel, aOutMesh );
attributeAffects( aComponentType, aOutMesh );
attributeAffects( aKeepSel, aOutMesh );
attributeAffects( aClosedObj, aOutMesh );
attributeAffects( aSourceObj, aOutMesh );
attributeAffects( aVolumeObj, aOutMesh );
return MS::kSuccess;
}
MStatus
OpenSubdivPtexShader::initialize()
{
MFnTypedAttribute typedAttr;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
// level
aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 3);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setSoftMax(5);
numAttr.setMax(10);
// tessFactor
aTessFactor = numAttr.create("tessFactor", "tessf", MFnNumericData::kLong, 2);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setMax(10);
// scheme
aScheme = enumAttr.create("scheme", "sc", OsdPtexMeshData::kCatmark);
enumAttr.addField("Catmull-Clark", OsdPtexMeshData::kCatmark);
enumAttr.addField("Loop", OsdPtexMeshData::kLoop);
enumAttr.addField("Bilinear", OsdPtexMeshData::kBilinear);
enumAttr.setInternal(true);
// kernel
aKernel = enumAttr.create("kernel", "kn", OsdPtexMeshData::kCPU);
enumAttr.addField("CPU", OsdPtexMeshData::kCPU);
#ifdef OPENSUBDIV_HAS_OPENMP
enumAttr.addField("OpenMP", OsdPtexMeshData::kOPENMP);
#endif
#ifdef OPENSUBDIV_HAS_OPENCL
enumAttr.addField("CL", OsdPtexMeshData::kCL);
#endif
#ifdef OPENSUBDIV_HAS_CUDA
enumAttr.addField("CUDA", OsdPtexMeshData::kCUDA);
#endif
enumAttr.setInternal(true);
// interpolateBoundary
aInterpolateBoundary = enumAttr.create("interpolateBoundary", "ib",
OsdPtexMeshData::kInterpolateBoundaryNone);
enumAttr.addField("None", OsdPtexMeshData::kInterpolateBoundaryNone);
enumAttr.addField("Edge Only", OsdPtexMeshData::kInterpolateBoundaryEdgeOnly);
enumAttr.addField("Edge and Corner", OsdPtexMeshData::kInterpolateBoundaryEdgeAndCorner);
enumAttr.addField("Always Sharp", OsdPtexMeshData::kInterpolateBoundaryAlwaysSharp);
enumAttr.setInternal(true);
// adaptive
aAdaptive = numAttr.create("adaptive", "adp", MFnNumericData::kBoolean, true);
numAttr.setInternal(true);
// wireframe
aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean, false);
// material attributes
aDiffuse = numAttr.createColor("diffuse", "d");
numAttr.setDefault(0.6f, 0.6f, 0.7f);
aAmbient = numAttr.createColor("ambient", "a");
numAttr.setDefault(0.1f, 0.1f, 0.1f);
aSpecular = numAttr.createColor("specular", "s");
numAttr.setDefault(0.3f, 0.3f, 0.3f);
// Ptex Texture Attributes
//
// diffuseEnvironmentMapFile;
aDiffuseEnvironmentMapFile = typedAttr.create("diffuseEnvironmentMap", "difenv", MFnData::kString);
typedAttr.setInternal(true);
// don't let maya hold on to string when fileNode is disconnected
typedAttr.setDisconnectBehavior(MFnAttribute::kReset);
// specularEnvironmentMapFile;
aSpecularEnvironmentMapFile = typedAttr.create("specularEnvironmentMap", "specenv", MFnData::kString);
typedAttr.setInternal(true);
// don't let maya hold on to string when fileNode is disconnected
typedAttr.setDisconnectBehavior(MFnAttribute::kReset);
// colorFile;
aColorFile = typedAttr.create("colorFile", "cf", MFnData::kString);
typedAttr.setInternal(true);
// displacementFile;
aDisplacementFile = typedAttr.create("displacementFile", "df", MFnData::kString);
typedAttr.setInternal(true);
// occlusionFile;
aOcclusionFile = typedAttr.create("occlusionFile", "of", MFnData::kString);
typedAttr.setInternal(true);
// enableDisplacement;
aEnableDisplacement = numAttr.create("enableDisplacement", "end", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableColor;
aEnableColor = numAttr.create("enableColor", "enc", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableOcclusion;
aEnableOcclusion = numAttr.create("enableOcclusion", "eno", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableNormal;
aEnableNormal = numAttr.create("enableNormal", "enn", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// fresnelBias;
aFresnelBias = numAttr.create("fresnelBias", "fb", MFnNumericData::kFloat, 0.2f);
numAttr.setMin(0);
numAttr.setMax(1);
// fresnelScale;
aFresnelScale = numAttr.create("fresnelScale", "fs", MFnNumericData::kFloat, 1.0f);
numAttr.setMin(0);
numAttr.setSoftMax(1);
// fresnelPower;
aFresnelPower = numAttr.create("fresnelPower", "fp", MFnNumericData::kFloat, 5.0f);
numAttr.setMin(0);
numAttr.setSoftMax(10);
// shaderSource;
aShaderSource = typedAttr.create("shaderSource", "ssrc", MFnData::kString);
typedAttr.setInternal(true);
// add attributes
addAttribute(aLevel);
addAttribute(aTessFactor);
addAttribute(aScheme);
addAttribute(aKernel);
addAttribute(aInterpolateBoundary);
addAttribute(aAdaptive);
addAttribute(aWireframe);
addAttribute(aDiffuse);
addAttribute(aAmbient);
addAttribute(aSpecular);
addAttribute(aShaderSource);
addAttribute(aDiffuseEnvironmentMapFile);
addAttribute(aSpecularEnvironmentMapFile);
addAttribute(aColorFile);
addAttribute(aDisplacementFile);
addAttribute(aOcclusionFile);
addAttribute(aEnableDisplacement);
addAttribute(aEnableColor);
addAttribute(aEnableOcclusion);
addAttribute(aEnableNormal);
addAttribute(aFresnelBias);
addAttribute(aFresnelScale);
addAttribute(aFresnelPower);
return MS::kSuccess;
}
MStatus woodTexNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
woodTurbulence=numAttr.create("Turbulence","tl",MFnNumericData::kFloat,5.0);
MAKE_INPUT(numAttr);
numAttr.setMin(0.0);
numAttr.setMax(200.0);
woodSize=numAttr.create("WoodSize","ws",MFnNumericData::kFloat,4.0);
MAKE_INPUT(numAttr);
numAttr.setMin(0.0);
numAttr.setMax(32.0);
woodHard=numAttr.create("Hard","hr",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
woodType=enumAttr.create("WoodType","wt",0);
enumAttr.addField("bands",0);
enumAttr.addField("rings",1);
MAKE_INPUT(enumAttr);
woodShape=enumAttr.create("WoodShape","wosh",0);
enumAttr.addField("sin",0);
enumAttr.addField("saw",1);
enumAttr.addField("tri",2);
NoiseType=enumAttr.create("NoiseType","noty",0);
enumAttr.addField("newperlin",0);
enumAttr.addField("stdperlin",1);
enumAttr.addField("voronoi_f1",2);
enumAttr.addField("voronoi_f2",3);
enumAttr.addField("voronoi_f3",4);
enumAttr.addField("voronoi_f4",5);
enumAttr.addField("voronoi_f2fl",6);
enumAttr.addField("voronoi_crackle",7);
enumAttr.addField("cellnoise",8);
MAKE_INPUT(enumAttr);
mappingMethod=enumAttr.create("MappingMethod","mame",0);
enumAttr.addField("uv",0);
enumAttr.addField("orco",1);
enumAttr.addField("global",2);
enumAttr.addField("window",3);
MAKE_INPUT(enumAttr);
texCo=enumAttr.create("TextureCoordinate","texco",0);
enumAttr.addField("plain",0);
enumAttr.addField("cube",1);
enumAttr.addField("tube",2);
enumAttr.addField("sphere",3);
MAKE_INPUT(enumAttr);
//*******************************layer texture attribute*********************************//
layerMix=enumAttr.create("MixMethod","mm1",0);
enumAttr.addField("mix",0);
enumAttr.addField("add",1);
enumAttr.addField("multiply",2);
enumAttr.addField("subtract",3);
enumAttr.addField("screen",4);
enumAttr.addField("divide",5);
enumAttr.addField("difference",6);
enumAttr.addField("darken",7);
enumAttr.addField("lighten",8);
MAKE_INPUT(enumAttr);
textureColor=numAttr.createColor("TextureColor","teco");
numAttr.setDefault(1.0,0.0,1.0);
MAKE_INPUT(numAttr);
texColorFact=numAttr.create("TextureColorWeight","tcw",MFnNumericData::kFloat,1.0);
numAttr.setMin(0.0);
numAttr.setMax(1.0);
MAKE_INPUT(numAttr);
defVal=numAttr.create("DefValue","dev",MFnNumericData::kFloat,1.0);
numAttr.setMin(0.0);
numAttr.setMax(1.0);
MAKE_INPUT(numAttr);
valFact=numAttr.create("ValueWeight","vaw",MFnNumericData::kFloat,1.0);
numAttr.setMin(0.0);
numAttr.setMax(1.0);
MAKE_INPUT(numAttr);
doColor=numAttr.create("DoColor","doco",MFnNumericData::kBoolean,true);
MAKE_INPUT(numAttr);
negative=numAttr.create("Negative","nega",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
noRGB=numAttr.create("NoRGB","nr",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
stencil=numAttr.create("Stencil","sten",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
//*******************************layer texture attribute end*********************************//
MObject u=numAttr.create("uCoord","u",MFnNumericData::kFloat);
MObject v=numAttr.create("vCoord","v",MFnNumericData::kFloat);
UV=numAttr.create("uvCoord","uv",u,v);
MAKE_INPUT(numAttr);
MObject filterX=numAttr.create("uvFilterSizeX", "fsx", MFnNumericData::kFloat);
MObject filterY=numAttr.create( "uvFilterSizeY", "fsy", MFnNumericData::kFloat);
UVFilterSize=numAttr.create("uvFilterSize", "fs", filterX, filterY);
MAKE_INPUT(numAttr);
Output=numAttr.createColor("outColor","oc");
numAttr.setHidden(true);
MAKE_OUTPUT(numAttr);
addAttribute(woodTurbulence);
addAttribute(woodSize);
addAttribute(woodHard);
addAttribute(woodType);
addAttribute(woodShape);
addAttribute(NoiseType);
addAttribute(mappingMethod);
addAttribute(texCo);
addAttribute(layerMix);
addAttribute(textureColor);
addAttribute(texColorFact);
addAttribute(defVal);
addAttribute(valFact);
addAttribute(doColor);
addAttribute(negative);
addAttribute(noRGB);
addAttribute(stencil);
addAttribute(UV);
addAttribute(UVFilterSize);
addAttribute(Output);
attributeAffects(woodTurbulence,Output);
attributeAffects(woodSize,Output);
attributeAffects(woodHard,Output);
attributeAffects(woodType,Output);
attributeAffects(woodShape,Output);
attributeAffects(NoiseType,Output);
attributeAffects(mappingMethod,Output);
attributeAffects(texCo,Output);
attributeAffects(layerMix,Output);
attributeAffects(textureColor,Output);
attributeAffects(texColorFact,Output);
attributeAffects(defVal,Output);
attributeAffects(valFact,Output);
attributeAffects(doColor,Output);
attributeAffects(negative,Output);
attributeAffects(noRGB,Output);
attributeAffects(stencil,Output);
attributeAffects(UV,Output);
attributeAffects(UVFilterSize,Output);
return stat;
}
MStatus AlembicNode::initialize()
{
MStatus status;
MFnUnitAttribute uAttr;
MFnTypedAttribute tAttr;
MFnNumericAttribute nAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
// add the input attributes: time, file, sequence time
mTimeAttr = uAttr.create("time", "tm", MFnUnitAttribute::kTime, 0.0);
status = uAttr.setStorable(true);
status = addAttribute(mTimeAttr);
// input file name
MFnStringData fileFnStringData;
MObject fileNameDefaultObject = fileFnStringData.create("");
mAbcFileNameAttr = tAttr.create("abc_File", "fn",
MFnData::kString, fileNameDefaultObject);
status = tAttr.setStorable(true);
status = tAttr.setUsedAsFilename(true);
status = addAttribute(mAbcFileNameAttr);
// playback speed
mSpeedAttr = nAttr.create("speed", "sp",
MFnNumericData::kDouble, 1.0, &status);
status = nAttr.setWritable(true);
status = nAttr.setStorable(true);
status = nAttr.setKeyable(true);
status = addAttribute(mSpeedAttr);
// frame offset
mOffsetAttr = nAttr.create("offset", "of",
MFnNumericData::kDouble, 0, &status);
status = nAttr.setWritable(true);
status = nAttr.setStorable(true);
status = nAttr.setKeyable(true);
status = addAttribute(mOffsetAttr);
// cycle type
mCycleTypeAttr = eAttr.create("cycleType", "ct", 0, &status );
status = eAttr.addField("Hold", PLAYTYPE_HOLD);
status = eAttr.addField("Loop", PLAYTYPE_LOOP);
status = eAttr.addField("Reverse", PLAYTYPE_REVERSE);
status = eAttr.addField("Bounce", PLAYTYPE_BOUNCE);
status = eAttr.setWritable(true);
status = eAttr.setStorable(true);
status = eAttr.setKeyable(true);
status = addAttribute(mCycleTypeAttr);
// Regex Filter
// This is a hidden variable to preserve a regexIncludefilter string
// into a .ma file.
mIncludeFilterAttr = tAttr.create("regexIncludeFilter", "ift",
MFnData::kString);
status = tAttr.setStorable(true);
status = tAttr.setHidden(true);
status = addAttribute(mIncludeFilterAttr);
// Regex Filter
// This is a hidden variable to preserve a regexExcludefilter string
// into a .ma file.
mExcludeFilterAttr = tAttr.create("regexExcludeFilter", "eft",
MFnData::kString);
status = tAttr.setStorable(true);
status = tAttr.setHidden(true);
status = addAttribute(mExcludeFilterAttr);
// sequence min and max in frames
mStartFrameAttr = nAttr.create("startFrame", "sf",
MFnNumericData::kDouble, 0, &status);
status = nAttr.setWritable(false);
status = nAttr.setStorable(true);
status = addAttribute(mStartFrameAttr);
mEndFrameAttr = nAttr.create("endFrame", "ef",
MFnNumericData::kDouble, 0, &status);
status = nAttr.setWritable(false);
status = nAttr.setStorable(true);
status = addAttribute(mEndFrameAttr);
// add the output attributes
// sampled subD mesh
MFnMeshData fnMeshData;
MObject meshDefaultObject = fnMeshData.create(&status);
mOutSubDArrayAttr = tAttr.create("outSubDMesh", "osubd",
MFnData::kMesh, meshDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutSubDArrayAttr);
// sampled poly mesh
mOutPolyArrayAttr = tAttr.create("outPolyMesh", "opoly",
MFnData::kMesh, meshDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutPolyArrayAttr);
// sampled nurbs surface
MFnNurbsSurfaceData fnNSData;
MObject nsDefaultObject = fnNSData.create(&status);
mOutNurbsSurfaceArrayAttr = tAttr.create("outNSurface", "ons",
MFnData::kNurbsSurface, nsDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutNurbsSurfaceArrayAttr);
// sampled nurbs curve group
MFnNurbsCurveData fnNCData;
MObject ncDefaultObject = fnNCData.create(&status);
mOutNurbsCurveGrpArrayAttr = tAttr.create("outNCurveGrp", "onc",
MFnData::kNurbsCurve, ncDefaultObject);
status = tAttr.setStorable(false);
status = tAttr.setWritable(false);
status = tAttr.setKeyable(false);
status = tAttr.setArray(true);
status = tAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutNurbsCurveGrpArrayAttr);
// sampled locator
mOutLocatorPosScaleArrayAttr = nAttr.create("outLoc", "olo",
MFnNumericData::kDouble, 0.0, &status);
status = nAttr.setStorable(false);
status = nAttr.setWritable(false);
status = nAttr.setArray(true);
status = nAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutLocatorPosScaleArrayAttr);
// sampled transform operations
mOutTransOpArrayAttr = nAttr.create("transOp", "to",
MFnNumericData::kDouble, 0.0, &status);
status = nAttr.setStorable(false);
status = nAttr.setWritable(false);
status = nAttr.setArray(true);
status = nAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutTransOpArrayAttr);
// sampled camera
// assume the boolean variables cannot be keyed
mOutCameraArrayAttr = nAttr.create("outCamera", "ocam",
MFnNumericData::kDouble, 0.0, &status);
status = nAttr.setStorable(false);
status = nAttr.setWritable(false);
status = nAttr.setArray(true);
status = nAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutCameraArrayAttr);
// sampled custom-attributes
mOutPropArrayAttr = gAttr.create("prop", "pr", &status);
status = gAttr.addNumericDataAccept(MFnNumericData::kBoolean);
status = gAttr.addNumericDataAccept(MFnNumericData::kByte);
status = gAttr.addNumericDataAccept(MFnNumericData::kShort);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Short);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Short);
status = gAttr.addNumericDataAccept(MFnNumericData::kInt);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Int);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Int);
status = gAttr.addNumericDataAccept(MFnNumericData::kFloat);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Float);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Float);
status = gAttr.addNumericDataAccept(MFnNumericData::kDouble);
status = gAttr.addNumericDataAccept(MFnNumericData::k2Double);
status = gAttr.addNumericDataAccept(MFnNumericData::k3Double);
status = gAttr.addNumericDataAccept(MFnNumericData::k4Double);
status = gAttr.addDataAccept(MFnData::kString);
status = gAttr.addDataAccept(MFnData::kIntArray);
status = gAttr.addDataAccept(MFnData::kDoubleArray);
status = gAttr.addDataAccept(MFnData::kVectorArray);
status = gAttr.addDataAccept(MFnData::kPointArray);
status = gAttr.setWritable(false);
status = gAttr.setKeyable(false);
status = gAttr.setArray(true);
status = gAttr.setUsesArrayDataBuilder(true);
status = addAttribute(mOutPropArrayAttr);
// set up affection relationships
status = attributeAffects(mTimeAttr, mOutSubDArrayAttr);
status = attributeAffects(mTimeAttr, mOutPolyArrayAttr);
status = attributeAffects(mTimeAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mTimeAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mTimeAttr, mOutTransOpArrayAttr);
status = attributeAffects(mTimeAttr, mOutCameraArrayAttr);
status = attributeAffects(mTimeAttr, mOutPropArrayAttr);
status = attributeAffects(mTimeAttr, mOutLocatorPosScaleArrayAttr);
status = attributeAffects(mSpeedAttr, mOutSubDArrayAttr);
status = attributeAffects(mSpeedAttr, mOutPolyArrayAttr);
status = attributeAffects(mSpeedAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mSpeedAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mSpeedAttr, mOutTransOpArrayAttr);
status = attributeAffects(mSpeedAttr, mOutCameraArrayAttr);
status = attributeAffects(mSpeedAttr, mOutPropArrayAttr);
status = attributeAffects(mSpeedAttr, mOutLocatorPosScaleArrayAttr);
status = attributeAffects(mOffsetAttr, mOutSubDArrayAttr);
status = attributeAffects(mOffsetAttr, mOutPolyArrayAttr);
status = attributeAffects(mOffsetAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mOffsetAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mOffsetAttr, mOutTransOpArrayAttr);
status = attributeAffects(mOffsetAttr, mOutCameraArrayAttr);
status = attributeAffects(mOffsetAttr, mOutPropArrayAttr);
status = attributeAffects(mOffsetAttr, mOutLocatorPosScaleArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutSubDArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutPolyArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutNurbsSurfaceArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutNurbsCurveGrpArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutTransOpArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutCameraArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutPropArrayAttr);
status = attributeAffects(mCycleTypeAttr, mOutLocatorPosScaleArrayAttr);
MGlobal::executeCommand( UITemplateMELScriptStr );
return status;
}
MStatus sphericalBlendShape::initialize()
{
MStatus status;
MFnMatrixAttribute mAttr;
MFnEnumAttribute eAttr;
aSpaceMatrix = mAttr.create("spaceMatrix", "spaceMatrix", MFnMatrixAttribute::kDouble, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
aPoleAxis = eAttr.create("poleAxis", "poleAxis", 1, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(1);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
aSeamAxis = eAttr.create("seamAxis", "seamAxis", 0, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(0);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
aWarpMatrix = mAttr.create("warpMatrix", "warpMatrix", MFnMatrixAttribute::kDouble, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
aMethod = eAttr.create("conversionMethod", "conversionMethod", 0, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("xyzToSpherical", 0);
eAttr.addField("sphericalToXyz", 1);
eAttr.setDefault(0);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
addAttribute(aSpaceMatrix);
addAttribute(aPoleAxis);
addAttribute(aSeamAxis);
addAttribute(aWarpMatrix);
addAttribute(aMethod);
attributeAffects(aSpaceMatrix, outputGeom);
attributeAffects(aPoleAxis, outputGeom);
attributeAffects(aSeamAxis, outputGeom);
attributeAffects(aWarpMatrix, outputGeom);
attributeAffects(aMethod, outputGeom);
return MS::kSuccess;
}
//initialize
//-----------------------------------------------
MStatus Ocio_test::initialize()
{
//MFnSets
MFnEnumAttribute eAttr;
MFnNumericAttribute nAttr;
MFnCompoundAttribute cAttr;
MFnTypedAttribute tAttr;
//a_verbose
a_verbose = eAttr.create("verbose", "verbose", 0);
eAttr.addField("no verbose", 0);
eAttr.addField("verbose", 1);
addAttribute(a_verbose);
//a_change_list
a_change_list = eAttr.create("change_list", "change_list", 0);
eAttr.addField("type 1", 0);
eAttr.addField("type 2", 1);
addAttribute(a_change_list);
//a_last_change_index
a_last_change_index = nAttr.create("last_change_index", "last_change_index", MFnNumericData::kInt, 9999);
nAttr.setStorable(false);
addAttribute(a_last_change_index);
//a_input_color
a_input_color = nAttr.createColor("input_color", "input_color");
nAttr.setUsedAsColor(true);
nAttr.setStorable(false);
addAttribute(a_input_color);
//a_width
a_width = nAttr.create("width", "width", MFnNumericData::kInt);
nAttr.setStorable(false);
addAttribute(a_width);
//a_height
a_height = nAttr.create("height", "height", MFnNumericData::kInt);
nAttr.setStorable(false);
addAttribute(a_height);
//a_config_path
a_config_path = tAttr.create("config_path", "config_path", MFnData::kString);
tAttr.setUsedAsFilename(true);
tAttr.setStorable(true);
addAttribute(a_config_path);
//a_output_color
a_output_color = nAttr.createColor("output_color", "output_color");
nAttr.setStorable(false);
addAttribute(a_output_color);
//Attribute affects
attributeAffects(a_change_list, a_output_color);
attributeAffects(a_input_color, a_output_color);
attributeAffects(a_width, a_output_color);
attributeAffects(a_height, a_output_color);
return MStatus::kSuccess;
}
//
// DESCRIPTION:
MStatus marble::initialize()
{
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus status;
outColor = nAttr.createColor("outColor", "outColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( outColor ));
//---------------------------- automatically created attributes start ------------------------------------
scale = nAttr.create("scale", "scale", MFnNumericData::kFloat, 1);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( scale ));
octaves = nAttr.create("octaves", "octaves", MFnNumericData::kInt, 8);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( octaves ));
coordinates = eAttr.create("coordinates", "coordinates", 0, &status);
status = eAttr.addField( "global", 0 );
status = eAttr.addField( "local", 1 );
status = eAttr.addField( "global normal", 2 );
status = eAttr.addField( "localnormal", 3 );
status = eAttr.addField( "uv", 4 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( coordinates ));
roughness = nAttr.create("roughness", "roughness", MFnNumericData::kFloat, 0.5);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( roughness ));
MObject rotateX = nAttr.create("rotateX", "rotatex", MFnNumericData::kDouble, 0.0);
MObject rotateY = nAttr.create("rotateY", "rotatey", MFnNumericData::kDouble, 0.0);
MObject rotateZ = nAttr.create("rotateZ", "rotatez", MFnNumericData::kDouble, 0.0);
rotate = nAttr.create("rotate", "rotate", rotateX, rotateY, rotateZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(0,0,0);
CHECK_MSTATUS(addAttribute( rotate ));
variation = nAttr.create("variation", "variation", MFnNumericData::kFloat, 0.2);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( variation ));
MObject translateX = nAttr.create("translateX", "translatex", MFnNumericData::kDouble, 0.0);
MObject translateY = nAttr.create("translateY", "translatey", MFnNumericData::kDouble, 0.0);
MObject translateZ = nAttr.create("translateZ", "translatez", MFnNumericData::kDouble, 0.0);
translate = nAttr.create("translate", "translate", translateX, translateY, translateZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(0,0,0);
CHECK_MSTATUS(addAttribute( translate ));
luxOutColor = nAttr.createColor("luxOutColor", "luxOutColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( luxOutColor ));
CHECK_MSTATUS ( attributeAffects( scale, luxOutColor));
CHECK_MSTATUS ( attributeAffects( scale, outColor));
//---------------------------- automatically created attributes end ------------------------------------
return MS::kSuccess;
}
//
// DESCRIPTION:
MStatus brick::initialize()
{
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus status;
outColor = nAttr.createColor("outColor", "outColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( outColor ));
//---------------------------- automatically created attributes start ------------------------------------
MObject scaleX = nAttr.create("scaleX", "scalex", MFnNumericData::kDouble, 0.0);
MObject scaleY = nAttr.create("scaleY", "scaley", MFnNumericData::kDouble, 0.0);
MObject scaleZ = nAttr.create("scaleZ", "scalez", MFnNumericData::kDouble, 0.0);
scale = nAttr.create("scale", "scale", scaleX, scaleY, scaleZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(1,1,1);
CHECK_MSTATUS(addAttribute( scale ));
brickbevel = nAttr.create("brickbevel", "brickbevel", MFnNumericData::kFloat, 0.0);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( brickbevel ));
brickbond = eAttr.create("brickbond", "brickbond", 0, &status);
status = eAttr.addField( "stacked", 0 );
status = eAttr.addField( "flemish", 1 );
status = eAttr.addField( "english", 2 );
status = eAttr.addField( "herringbone", 3 );
status = eAttr.addField( "basket", 4 );
status = eAttr.addField( "chain link", 5 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( brickbond ));
mortarsize = nAttr.create("mortarsize", "mortarsize", MFnNumericData::kFloat, 0.01);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( mortarsize ));
brickwidth = nAttr.create("brickwidth", "brickwidth", MFnNumericData::kFloat, 0.3);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( brickwidth ));
bricktex = nAttr.createColor("bricktex", "bricktex");
MAKE_INPUT(nAttr);
nAttr.setDefault(1.0,1.0,1.0);
CHECK_MSTATUS(addAttribute( bricktex ));
brickdepth = nAttr.create("brickdepth", "brickdepth", MFnNumericData::kFloat, 0.15);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( brickdepth ));
coordinates = eAttr.create("coordinates", "coordinates", 0, &status);
status = eAttr.addField( "global", 0 );
status = eAttr.addField( "local", 1 );
status = eAttr.addField( "global normal", 2 );
status = eAttr.addField( "localnormal", 3 );
status = eAttr.addField( "uv", 4 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( coordinates ));
brickmodtex = nAttr.create("brickmodtex", "brickmodtex", MFnNumericData::kFloat, 1.0);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( brickmodtex ));
MObject rotateX = nAttr.create("rotateX", "rotatex", MFnNumericData::kDouble, 0.0);
MObject rotateY = nAttr.create("rotateY", "rotatey", MFnNumericData::kDouble, 0.0);
MObject rotateZ = nAttr.create("rotateZ", "rotatez", MFnNumericData::kDouble, 0.0);
rotate = nAttr.create("rotate", "rotate", rotateX, rotateY, rotateZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(0,0,0);
CHECK_MSTATUS(addAttribute( rotate ));
motartex = nAttr.createColor("motartex", "motartex");
MAKE_INPUT(nAttr);
nAttr.setDefault(0.2,0.2,0.2);
CHECK_MSTATUS(addAttribute( motartex ));
brickrun = nAttr.create("brickrun", "brickrun", MFnNumericData::kFloat, 0.75);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( brickrun ));
MObject translateX = nAttr.create("translateX", "translatex", MFnNumericData::kDouble, 0.0);
MObject translateY = nAttr.create("translateY", "translatey", MFnNumericData::kDouble, 0.0);
MObject translateZ = nAttr.create("translateZ", "translatez", MFnNumericData::kDouble, 0.0);
translate = nAttr.create("translate", "translate", translateX, translateY, translateZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(0,0,0);
CHECK_MSTATUS(addAttribute( translate ));
brickheight = nAttr.create("brickheight", "brickheight", MFnNumericData::kFloat, 0.1);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( brickheight ));
luxOutFloat = nAttr.create("luxOutFloat", "luxOutFloat", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( luxOutFloat ));
luxOutColor = nAttr.createColor("luxOutColor", "luxOutColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( luxOutColor ));
CHECK_MSTATUS ( attributeAffects( scale, luxOutFloat));
CHECK_MSTATUS ( attributeAffects( scale, luxOutColor));
CHECK_MSTATUS ( attributeAffects( scale, outColor));
//---------------------------- automatically created attributes end ------------------------------------
return MS::kSuccess;
}
//
// DESCRIPTION:
MStatus blender_marble::initialize()
{
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus status;
outColor = nAttr.createColor("outColor", "outColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( outColor ));
//---------------------------- automatically created attributes start ------------------------------------
noisesize = nAttr.create("noisesize", "noisesize", MFnNumericData::kFloat, 0.25);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( noisesize ));
noisebasis2 = eAttr.create("noisebasis2", "noisebasis2", 0, &status);
status = eAttr.addField( "blender_original", 0 );
status = eAttr.addField( "original_perlin", 1 );
status = eAttr.addField( "improved_perlin", 2 );
status = eAttr.addField( "voronoi_f1", 3 );
status = eAttr.addField( "voronoi_f2", 4 );
status = eAttr.addField( "voronoi_f3", 5 );
status = eAttr.addField( "voronoi_f4", 6 );
status = eAttr.addField( "voronoi_f2f1", 7 );
status = eAttr.addField( "voronoi_crackle", 8 );
status = eAttr.addField( "cell_noise", 9 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( noisebasis2 ));
noisebasis = eAttr.create("noisebasis", "noisebasis", 0, &status);
status = eAttr.addField( "sin", 0 );
status = eAttr.addField( "saw", 1 );
status = eAttr.addField( "tri", 2 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( noisebasis ));
MObject scaleX = nAttr.create("scaleX", "scalex", MFnNumericData::kDouble, 0.0);
MObject scaleY = nAttr.create("scaleY", "scaley", MFnNumericData::kDouble, 0.0);
MObject scaleZ = nAttr.create("scaleZ", "scalez", MFnNumericData::kDouble, 0.0);
scale = nAttr.create("scale", "scale", scaleX, scaleY, scaleZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(1,1,1);
CHECK_MSTATUS(addAttribute( scale ));
noisedepth = nAttr.create("noisedepth", "noisedepth", MFnNumericData::kInt, 2);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( noisedepth ));
turbulance = nAttr.create("turbulance", "turbulance", MFnNumericData::kFloat, 5.0);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( turbulance ));
coordinates = eAttr.create("coordinates", "coordinates", 0, &status);
status = eAttr.addField( "global", 0 );
status = eAttr.addField( "local", 1 );
status = eAttr.addField( "global normal", 2 );
status = eAttr.addField( "localnormal", 3 );
status = eAttr.addField( "uv", 4 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( coordinates ));
bright = nAttr.create("bright", "bright", MFnNumericData::kFloat, 1.0);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( bright ));
MObject rotateX = nAttr.create("rotateX", "rotatex", MFnNumericData::kDouble, 0.0);
MObject rotateY = nAttr.create("rotateY", "rotatey", MFnNumericData::kDouble, 0.0);
MObject rotateZ = nAttr.create("rotateZ", "rotatez", MFnNumericData::kDouble, 0.0);
rotate = nAttr.create("rotate", "rotate", rotateX, rotateY, rotateZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(0,0,0);
CHECK_MSTATUS(addAttribute( rotate ));
noisetype = eAttr.create("noisetype", "noisetype", 1, &status);
status = eAttr.addField( "soft_noise", 0 );
status = eAttr.addField( "hard_noise", 1 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( noisetype ));
MObject translateX = nAttr.create("translateX", "translatex", MFnNumericData::kDouble, 0.0);
MObject translateY = nAttr.create("translateY", "translatey", MFnNumericData::kDouble, 0.0);
MObject translateZ = nAttr.create("translateZ", "translatez", MFnNumericData::kDouble, 0.0);
translate = nAttr.create("translate", "translate", translateX, translateY, translateZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(0,0,0);
CHECK_MSTATUS(addAttribute( translate ));
type = eAttr.create("type", "type", 0, &status);
status = eAttr.addField( "soft", 0 );
status = eAttr.addField( "sharp", 1 );
status = eAttr.addField( "sharper", 2 );
MAKE_INPUT(eAttr);
CHECK_MSTATUS(addAttribute( type ));
contrast = nAttr.create("contrast", "contrast", MFnNumericData::kFloat, 1.0);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( contrast ));
luxOutFloat = nAttr.create("luxOutFloat", "luxOutFloat", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( luxOutFloat ));
CHECK_MSTATUS ( attributeAffects( noisesize, luxOutFloat));
CHECK_MSTATUS ( attributeAffects( noisesize, outColor));
//---------------------------- automatically created attributes end ------------------------------------
return MS::kSuccess;
}
MStatus n_tentacle::initialize()
{
MFnNumericAttribute numericAttr;
MFnMatrixAttribute matrixAttr;
MFnTypedAttribute typedAttr;
MFnUnitAttribute unitAttribute;
MFnEnumAttribute enumAttr;
MStatus stat;
stretch = numericAttr.create("stretch", "st", MFnNumericData::kDouble, 0.0);
numericAttr.setMin(0.0);
numericAttr.setMax(1.0);
globalScale = numericAttr.create("globalScale", "gs", MFnNumericData::kDouble, 1.0);
numericAttr.setMin(0.00001);
numericAttr.setMax(10.0);
iniLength = numericAttr.create("iniLength", "iln", MFnNumericData::kDouble, 0.01);
parameter = numericAttr.create("parameter", "prm", MFnNumericData::kDouble, 0.0);
numericAttr.setArray(true);
blendRot = numericAttr.create("blendRot", "blr", MFnNumericData::kDouble, 0.0);
numericAttr.setArray(true);
interval = numericAttr.create("interval", "itv", MFnNumericData::kInt, 0);
numericAttr.setArray(true);
matrix = matrixAttr.create("matrix", "mtx");
matrixAttr.setArray(true);
matrixAttr.setHidden(true);
curve = typedAttr.create("curve", "crv", MFnData::kNurbsCurve);
outTranslate = numericAttr.create("outTranslate", "ot", MFnNumericData::k3Double);
numericAttr.setArray(true);
numericAttr.setHidden(true);
numericAttr.setUsesArrayDataBuilder(true);
numericAttr.setHidden(true);
outRotateX = unitAttribute.create("outRotateX", "orx", MFnUnitAttribute::kAngle);
outRotateY = unitAttribute.create("outRotateY", "ory", MFnUnitAttribute::kAngle);
outRotateZ = unitAttribute.create("outRotateZ", "orz", MFnUnitAttribute::kAngle);
outRotate = numericAttr.create("outRotate", "or",outRotateX, outRotateY, outRotateZ);
numericAttr.setArray(true);
numericAttr.setHidden(true);
numericAttr.setUsesArrayDataBuilder(true);
numericAttr.setHidden(true);
tangentAxis = enumAttr.create("tangentAxis", "tga", 1);
enumAttr.addField("X", 0);
enumAttr.addField("Y", 1);
enumAttr.addField("Z", 2);
enumAttr.addField("negativeX", 3);
enumAttr.addField("negativeY", 4);
enumAttr.addField("negativeZ", 5);
// Add the attributes we have created to the node
//
stat = addAttribute( parameter );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( blendRot );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( interval );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( stretch );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( globalScale );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( iniLength );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( matrix );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( curve );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( outTranslate );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( outRotate );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( tangentAxis );
if (!stat) { stat.perror("addAttribute"); return stat;}
attributeAffects( parameter, outTranslate );
attributeAffects( blendRot, outTranslate );
attributeAffects( interval, outTranslate );
attributeAffects( stretch, outTranslate );
attributeAffects( globalScale, outTranslate );
attributeAffects( iniLength, outTranslate );
attributeAffects( matrix, outTranslate );
attributeAffects( curve, outTranslate );
attributeAffects( tangentAxis, outTranslate );
attributeAffects( parameter, outRotate );
attributeAffects( blendRot, outRotate );
attributeAffects( interval, outRotate );
attributeAffects( stretch, outRotate );
attributeAffects( globalScale, outRotate );
attributeAffects( iniLength, outRotate );
attributeAffects( matrix, outRotate );
attributeAffects( curve, outRotate );
attributeAffects( tangentAxis, outRotate );
attributeAffects( parameter, outRotateX );
attributeAffects( blendRot, outRotateX );
attributeAffects( interval, outRotateX );
attributeAffects( stretch, outRotateX );
attributeAffects( globalScale, outRotateX );
attributeAffects( iniLength, outRotateX );
attributeAffects( matrix, outRotateX );
attributeAffects( curve, outRotateX );
attributeAffects( tangentAxis, outRotateX );
attributeAffects( parameter, outRotateY );
attributeAffects( blendRot, outRotateY );
attributeAffects( interval, outRotateY );
attributeAffects( stretch, outRotateY );
attributeAffects( globalScale, outRotateY );
attributeAffects( iniLength, outRotateY );
attributeAffects( matrix, outRotateY );
attributeAffects( curve, outRotateY );
attributeAffects( tangentAxis, outRotateY );
attributeAffects( parameter, outRotateZ );
attributeAffects( blendRot, outRotateZ );
attributeAffects( interval, outRotateZ );
attributeAffects( stretch, outRotateZ );
attributeAffects( globalScale, outRotateZ );
attributeAffects( iniLength, outRotateZ );
attributeAffects( matrix, outRotateZ );
attributeAffects( curve, outRotateZ );
attributeAffects( tangentAxis, outRotateZ );
return MS::kSuccess;
}
MStatus mtmEnvLight::initialize()
{
MFnTypedAttribute tAttr;
MFnNumericAttribute nAttr;
MFnLightDataAttribute lAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus stat;
//aColor = nAttr.createColor( "color", "c" );
//CHECK_MSTATUS ( nAttr.setKeyable(true) );
//CHECK_MSTATUS ( nAttr.setStorable(true) );
//CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.58824f, 0.644f) );
aLightColor = nAttr.createColor( "lightColor", "lightColor" );
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
nAttr.setDefault(0.7f, 0.58824f, 0.344f);
aShadowColor = nAttr.createColor( "shadowColor", "sc" );
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.0f, 0.0f) );
aPosition = nAttr.createPoint( "position", "pos" );
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
aInputDirection = nAttr.createPoint( "inputDirection", "id" );
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) );
aInputAmbient = nAttr.create( "ambientOn", "an", MFnNumericData::kBoolean);
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setHidden(false) );
CHECK_MSTATUS ( nAttr.setDefault(true) );
aInputDiffuse = nAttr.create( "emitDiffuse", "dn", MFnNumericData::kBoolean);
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setHidden(false) );
CHECK_MSTATUS ( nAttr.setDefault(true) );
aInputSpecular = nAttr.create( "emitSpecular", "sn", MFnNumericData::kBoolean);
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setHidden(false) );
CHECK_MSTATUS ( nAttr.setDefault(true) );
aIntensity = nAttr.create( "intensity", "i", MFnNumericData::kFloat);
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setHidden(false) );
CHECK_MSTATUS ( nAttr.setDefault(1.0f) );
samplingquality = nAttr.create( "samplingquality", "samplingquality", MFnNumericData::kFloat, 1.0);
envmap = tAttr.create( "envmap", "envmap", MFnNumericData::kString);
tAttr.setUsedAsFilename(true);
areamap = tAttr.create( "areamap", "areamap", MFnNumericData::kString);
tAttr.setUsedAsFilename(true);
areafullsphere = nAttr.create( "areafullsphere", "areafullsphere", MFnNumericData::kBoolean, true);
envintensity = nAttr.createColor( "envintensity", "envintensity" );
nAttr.setDefault(1.0f, 1.0f, 1.0f);
raybackground = nAttr.create( "raybackground", "raybackground", MFnNumericData::kBoolean, false);
castshadow = nAttr.create( "castshadow", "castshadow", MFnNumericData::kBoolean, true);
envtype = eAttr.create( "envtype", "envtype", 0, &stat);
stat = eAttr.addField( "Direct Lighting", 0 );
stat = eAttr.addField( "Ambient Occlusion", 1 );
stat = eAttr.addField( "Full Irradiance", 2 );
stat = eAttr.addField( "Raytrace Background", 3 );
eAttr.setDefault(0);
doraysamples = nAttr.create( "doraysamples", "doraysamples", MFnNumericData::kBoolean, false);
doadaptive = nAttr.create( "doadaptive", "doadaptive", MFnNumericData::kBoolean, false);
domaxdist = nAttr.create( "domaxdist", "domaxdist", MFnNumericData::kBoolean, false);
maxdist = nAttr.create( "maxdist", "maxdist", MFnNumericData::kFloat, 10.0);
coneangle = nAttr.create( "coneangle", "coneangle", MFnNumericData::kFloat, 45.0);
envtint = nAttr.createColor( "envtint", "envtint" );
nAttr.setDefault(1.0f, 1.0f, 1.0f);
shadowI = nAttr.create( "shadowI", "shadowI", MFnNumericData::kFloat, 1.0);
samples = nAttr.create( "samples", "samples", MFnNumericData::kInt, 32);
MFnStringData fnStringData;
MObject defaultObjectMask;
defaultObjectMask = fnStringData.create( "*" );
objectmask = tAttr.create( "objectmask", "objectmask", MFnNumericData::kString, defaultObjectMask);
usePortalGeometry = nAttr.create( "usePortalGeometry", "usePortalGeometry", MFnNumericData::kBoolean, false);
portalGeometry = mAttr.create( "portalGeometry", "portalGeometry");
mAttr.setConnectable(true);
mAttr.accepts(MFnData::kAny);
// Outputs
aLightDirection = nAttr.createPoint( "lightDirection", "ld" );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) );
aLightIntensity = nAttr.createColor( "lightIntensity", "li" );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( nAttr.setDefault(1.0f, 0.5f, 0.2f) );
aLightAmbient = nAttr.create( "lightAmbient", "la",
MFnNumericData::kBoolean);
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
nAttr.setDefault(true);
aLightDiffuse = nAttr.create( "lightDiffuse", "ldf",
MFnNumericData::kBoolean);
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( nAttr.setDefault(true) );
aLightSpecular = nAttr.create( "lightSpecular", "ls",
MFnNumericData::kBoolean);
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( nAttr.setDefault(true) );
aLightShadowFraction = nAttr.create("lightShadowFraction","lsf",
MFnNumericData::kFloat);
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( nAttr.setDefault(0.0f) );
aPreShadowIntensity = nAttr.create("preShadowIntensity","psi",
MFnNumericData::kFloat);
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( nAttr.setDefault(0.0f) );
aLightBlindData = nAttr.createAddr("lightBlindData","lbld");
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
aLightData = lAttr.create( "lightData", "ltd",
aLightDirection, aLightIntensity,
aLightAmbient,
aLightDiffuse, aLightSpecular,
aLightShadowFraction,
aPreShadowIntensity, aLightBlindData);
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( lAttr.setStorable(false) );
CHECK_MSTATUS ( lAttr.setHidden(true) );
lAttr.setDefault(-1.0f, 0.0f, 0.0f, 1.0f, 0.5f, 0.2f, true, true,
true, 0.0f, 1.0f, NULL);
CHECK_MSTATUS ( addAttribute(coneangle) );
CHECK_MSTATUS ( addAttribute(samples) );
CHECK_MSTATUS ( addAttribute(objectmask) );
CHECK_MSTATUS ( addAttribute(shadowI) );
CHECK_MSTATUS ( addAttribute(envtint) );
CHECK_MSTATUS ( addAttribute(maxdist) );
CHECK_MSTATUS ( addAttribute(domaxdist) );
CHECK_MSTATUS ( addAttribute(doadaptive) );
CHECK_MSTATUS ( addAttribute(doraysamples) );
CHECK_MSTATUS ( addAttribute(envtype) );
CHECK_MSTATUS ( addAttribute(castshadow) );
CHECK_MSTATUS ( addAttribute(raybackground) );
CHECK_MSTATUS ( addAttribute(envintensity) );
CHECK_MSTATUS ( addAttribute(areafullsphere) );
CHECK_MSTATUS ( addAttribute(areamap) );
CHECK_MSTATUS ( addAttribute(envmap) );
CHECK_MSTATUS ( addAttribute(samplingquality) );
CHECK_MSTATUS ( addAttribute(usePortalGeometry) );
CHECK_MSTATUS ( addAttribute(portalGeometry) );
//CHECK_MSTATUS ( addAttribute(aColor) );
CHECK_MSTATUS ( addAttribute(aLightColor) );
CHECK_MSTATUS ( addAttribute(aShadowColor) );
CHECK_MSTATUS ( addAttribute(aPosition) );
CHECK_MSTATUS ( addAttribute(aInputDirection) );
CHECK_MSTATUS ( addAttribute(aInputAmbient) );
CHECK_MSTATUS ( addAttribute(aInputDiffuse) );
CHECK_MSTATUS ( addAttribute(aInputSpecular) );
CHECK_MSTATUS ( addAttribute(aIntensity) );
CHECK_MSTATUS ( addAttribute(aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightIntensity, aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightDirection, aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightAmbient, aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightDiffuse, aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightSpecular, aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightShadowFraction, aLightData) );
CHECK_MSTATUS ( attributeAffects (aPreShadowIntensity, aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightBlindData, aLightData) );
CHECK_MSTATUS ( attributeAffects (aLightData, aLightData) );
//CHECK_MSTATUS ( attributeAffects (aColor, aLightData) );
CHECK_MSTATUS ( attributeAffects (aPosition, aLightData) );
CHECK_MSTATUS ( attributeAffects (aInputDirection, aLightData) );
CHECK_MSTATUS ( attributeAffects (aInputAmbient, aLightData) );
CHECK_MSTATUS ( attributeAffects (aInputDiffuse, aLightData) );
CHECK_MSTATUS ( attributeAffects (aInputSpecular, aLightData) );
CHECK_MSTATUS ( attributeAffects (aIntensity, aLightData) );
return MS::kSuccess;
}
MStatus retargetLocator::initialize()
{
MFnNumericAttribute nAttr;
MFnMatrixAttribute mAttr;
MFnEnumAttribute eAttr;
MFnUnitAttribute uAttr;
MFnCompoundAttribute cAttr;
MFnTypedAttribute tAttr;
aOutput = nAttr.create( "output", "output", MFnNumericData::kDouble );
nAttr.setStorable( false );
CHECK_MSTATUS( addAttribute( aOutput ) );
aDiscMatrix = mAttr.create( "discMatrix", "discMatrix" );
mAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aDiscMatrix ) );
CHECK_MSTATUS( attributeAffects( aDiscMatrix, aOutput ) );
aDiscAxis = eAttr.create( "discAxis", "discAxis", 0 );
eAttr.addField( "X", 0 );
eAttr.addField( "Y", 1 );
eAttr.addField( "Z", 2 );
eAttr.setStorable( true );
eAttr.setChannelBox( true );
eAttr.setReadable( true );
CHECK_MSTATUS( addAttribute( aDiscAxis ) );
CHECK_MSTATUS( attributeAffects( aDiscAxis, aOutput ) );
aDiscDivision = nAttr.create( "discDivision", "discDivision", MFnNumericData::kInt, 32 );
nAttr.setMin( 1 );
nAttr.setMax( 32 );
nAttr.setStorable( true );
nAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscDivision ) );
CHECK_MSTATUS( attributeAffects( aDiscDivision, aOutput ) );
aDiscAngle = uAttr.create( "discAngle", "discAngle", MFnUnitAttribute::kAngle, 0.0 );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscAngle ) );
CHECK_MSTATUS( attributeAffects( aDiscAngle, aOutput ) );
aDiscOffsetX = nAttr.create( "discOffsetX", "discOffsetX", MFnNumericData::kDouble, 0.0 );
aDiscOffsetY = nAttr.create( "discOffsetY", "discOffsetY", MFnNumericData::kDouble, 0.0 );
aDiscOffsetZ = nAttr.create( "discOffsetZ", "discOffsetZ", MFnNumericData::kDouble, 0.0 );
aDiscOffset = nAttr.create( "discOffset", "discOffset", aDiscOffsetX, aDiscOffsetY, aDiscOffsetZ );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscOffset ) );
CHECK_MSTATUS( attributeAffects( aDiscOffset, aOutput ) );
aDiscSizeX = nAttr.create( "discSizeX", "discSizeX", MFnNumericData::kDouble, 1.0 );
aDiscSizeY = nAttr.create( "discSizeY", "discSizeY", MFnNumericData::kDouble, 1.0 );
aDiscSizeZ = nAttr.create( "discSizeZ", "discSizeZ", MFnNumericData::kDouble, 1.0 );
aDiscSize = nAttr.create( "discSize", "discSize", aDiscSizeX, aDiscSizeY, aDiscSizeZ );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscSize ) );
CHECK_MSTATUS( attributeAffects( aDiscSize, aOutput ) );
aDiscActiveColor = nAttr.createColor( "discActiveColor", "discActiveColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
CHECK_MSTATUS( addAttribute( aDiscActiveColor ) );
CHECK_MSTATUS( attributeAffects( aDiscActiveColor, aOutput ) );
aDiscLeadColor = nAttr.createColor( "discLeadColor", "discLeadColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.263f, 1.0f, .639f);
CHECK_MSTATUS( addAttribute( aDiscLeadColor ) );
CHECK_MSTATUS( attributeAffects( aDiscLeadColor, aOutput ) );
aDiscDefaultColor = nAttr.createColor( "discDefaultColor", "discDefaultColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.0f, .016f, .376f);
CHECK_MSTATUS( addAttribute( aDiscDefaultColor ) );
CHECK_MSTATUS( attributeAffects( aDiscDefaultColor, aOutput ) );
aDiscFillAlpha = nAttr.create( "discFillAlpha", "discFillAlpha", MFnNumericData::kFloat, 0.1f );
nAttr.setStorable( true );
nAttr.setMin( 0.0f );
nAttr.setMax( 1.0f );
CHECK_MSTATUS( addAttribute( aDiscFillAlpha ) );
CHECK_MSTATUS( attributeAffects( aDiscFillAlpha, aOutput ) );
aDiscLineAlpha = nAttr.create( "discLineAlpha", "discLineAlpha", MFnNumericData::kFloat, 1.0f );
nAttr.setStorable( true );
nAttr.setMin( 0.0f );
nAttr.setMax( 1.0f );
CHECK_MSTATUS( addAttribute( aDiscLineAlpha ) );
CHECK_MSTATUS( attributeAffects( aDiscLineAlpha, aOutput ) );
aArrow = cAttr.create( "arrow", "arrow" );
aInheritMatrix = nAttr.create( "inheritMatrix", "inheritMatrix", MFnNumericData::kBoolean, false );
aInputMesh = tAttr.create( "inputMesh", "inputMesh", MFnData::kMesh );
aAimMatrix = mAttr.create( "aimMatrix", "aimMatrix" );
aStartSize = nAttr.create( "startSize", "startSize", MFnNumericData::kFloat, 0.5f );
aSize = nAttr.create( "size", "size", MFnNumericData::kFloat, 1.0f );
aActiveColor = nAttr.createColor( "activeColor", "activeColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
aLeadColor = nAttr.createColor( "leadColor", "leadColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.263f, 1.0f, .639f);
aDefaultColor = nAttr.createColor( "defaultColor", "defaultColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.0f, .016f, .376f);
aFillAlpha = nAttr.create( "fillAlpha", "fillAlpha", MFnNumericData::kFloat, 0.1f );
aLineAlpha = nAttr.create( "lineAlpha", "lineAlpha", MFnNumericData::kFloat, 1.0f );
aOffsetX = nAttr.create( "offsetX", "offsetX", MFnNumericData::kDouble, 0.0 );
aOffsetY = nAttr.create( "offsetY", "offsetY", MFnNumericData::kDouble, 0.0 );
aOffsetZ = nAttr.create( "offsetZ", "offsetZ", MFnNumericData::kDouble, 0.0 );
aOffset = nAttr.create( "offset", "offset", aOffsetX, aOffsetY, aOffsetZ );
cAttr.addChild( aInheritMatrix );
cAttr.addChild( aAimMatrix );
cAttr.addChild( aInputMesh );
cAttr.addChild( aStartSize );
cAttr.addChild( aSize );
cAttr.addChild( aActiveColor );
cAttr.addChild( aLeadColor );
cAttr.addChild( aDefaultColor );
cAttr.addChild( aFillAlpha );
cAttr.addChild( aLineAlpha );
cAttr.addChild( aOffset );
cAttr.setArray( true );
cAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aArrow ) );
CHECK_MSTATUS( attributeAffects( aArrow, aOutput ) );
return MS::kSuccess;
}
MStatus MayaToIndigoGlobals::initialize()
{
MayaRenderGlobalsNode::initialize();
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus stat = MStatus::kSuccess;
// ------------- automatically created attributes start ----------- //
white_point = eAttr.create("white_point", "white_point", 4, &stat);
stat = eAttr.addField( "User", 0 );
stat = eAttr.addField( "A", 1 );
stat = eAttr.addField( "B", 2 );
stat = eAttr.addField( "C", 3 );
stat = eAttr.addField( "D50", 4 );
stat = eAttr.addField( "D55", 5 );
stat = eAttr.addField( "D65", 6 );
stat = eAttr.addField( "D75", 7 );
stat = eAttr.addField( "E", 8 );
stat = eAttr.addField( "F1", 9 );
stat = eAttr.addField( "F2", 10 );
stat = eAttr.addField( "F3", 11 );
stat = eAttr.addField( "F4", 12 );
stat = eAttr.addField( "F5", 13 );
stat = eAttr.addField( "F6", 14 );
stat = eAttr.addField( "F7", 15 );
stat = eAttr.addField( "F8", 16 );
stat = eAttr.addField( "F9", 17 );
stat = eAttr.addField( "F10", 18 );
stat = eAttr.addField( "F11", 19 );
stat = eAttr.addField( "F12", 20 );
CHECK_MSTATUS(addAttribute( white_point ));
white_pointX = nAttr.create("white_pointX", "white_pointX", MFnNumericData::kFloat, 0.0);
CHECK_MSTATUS(addAttribute( white_pointX ));
white_pointY = nAttr.create("white_pointY", "white_pointY", MFnNumericData::kFloat, 0.0);
CHECK_MSTATUS(addAttribute( white_pointY ));
bih_tri_threshold = nAttr.create("bih_tri_threshold", "bih_tri_threshold", MFnNumericData::kInt, 1100000);
CHECK_MSTATUS(addAttribute( bih_tri_threshold ));
metropolis = nAttr.create("metropolis", "metropolis", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( metropolis ));
large_mutation_prob = nAttr.create("large_mutation_prob", "large_mutation_prob", MFnNumericData::kFloat, 0.1);
CHECK_MSTATUS(addAttribute( large_mutation_prob ));
max_change = nAttr.create("max_change", "max_change", MFnNumericData::kFloat, .01);
CHECK_MSTATUS(addAttribute( max_change ));
max_num_consec_rejections = nAttr.create("max_num_consec_rejections", "max_num_consec_rejections", MFnNumericData::kInt, 1000);
CHECK_MSTATUS(addAttribute( max_num_consec_rejections ));
logging = nAttr.create("logging", "logging", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( logging ));
path_tracing = eAttr.create("path_tracing", "path_tracing", 0, &stat);
stat = eAttr.addField( "bidirectional", 0 );
stat = eAttr.addField( "backwards", 1 );
CHECK_MSTATUS(addAttribute( path_tracing ));
tone_mapper = eAttr.create("tone_mapper", "tone_mapper", 1, &stat);
stat = eAttr.addField( "linear", 0 );
stat = eAttr.addField( "reinhard", 1 );
stat = eAttr.addField( "camera", 2 );
CHECK_MSTATUS(addAttribute( tone_mapper ));
tone_linearScale = nAttr.create("tone_linearScale", "tone_linearScale", MFnNumericData::kFloat, 1.0);
nAttr.setMin(0.0001);
nAttr.setMax(100);
CHECK_MSTATUS(addAttribute( tone_linearScale ));
tone_reinhardPreScale = nAttr.create("tone_reinhardPreScale", "tone_reinhardPreScale", MFnNumericData::kFloat, 1.0);
CHECK_MSTATUS(addAttribute( tone_reinhardPreScale ));
tone_reinhardPostScale = nAttr.create("tone_reinhardPostScale", "tone_reinhardPostScale", MFnNumericData::kFloat, 1.0);
CHECK_MSTATUS(addAttribute( tone_reinhardPostScale ));
tone_reinhardBurn = nAttr.create("tone_reinhardBurn", "tone_reinhardBurn", MFnNumericData::kFloat, 10.0);
CHECK_MSTATUS(addAttribute( tone_reinhardBurn ));
tone_cameraResponse_function_path = tAttr.create("tone_cameraResponse_function_path", "tone_cameraResponse_function_path", MFnNumericData::kString);
CHECK_MSTATUS(addAttribute( tone_cameraResponse_function_path ));
tone_cameraEv_adjust = nAttr.create("tone_cameraEv_adjust", "tone_cameraEv_adjust", MFnNumericData::kFloat, 0.0);
CHECK_MSTATUS(addAttribute( tone_cameraEv_adjust ));
tone_cameraFilm_iso = nAttr.create("tone_cameraFilm_iso", "tone_cameraFilm_iso", MFnNumericData::kFloat, 200.0);
CHECK_MSTATUS(addAttribute( tone_cameraFilm_iso ));
save_untonemapped_exr = nAttr.create("save_untonemapped_exr", "save_untonemapped_exr", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( save_untonemapped_exr ));
save_tonemapped_exr = nAttr.create("save_tonemapped_exr", "save_tonemapped_exr", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( save_tonemapped_exr ));
save_igi = nAttr.create("save_igi", "save_igi", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( save_igi ));
image_save_period = nAttr.create("image_save_period", "image_save_period", MFnNumericData::kFloat, 60);
CHECK_MSTATUS(addAttribute( image_save_period ));
halt_time = nAttr.create("halt_time", "halt_time", MFnNumericData::kFloat, -1);
CHECK_MSTATUS(addAttribute( halt_time ));
halt_samples_per_pixel = nAttr.create("halt_samples_per_pixel", "halt_samples_per_pixel", MFnNumericData::kInt, -1);
CHECK_MSTATUS(addAttribute( halt_samples_per_pixel ));
hybrid = nAttr.create("hybrid", "hybrid", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( hybrid ));
auto_choose_num_threads = nAttr.create("auto_choose_num_threads", "auto_choose_num_threads", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( auto_choose_num_threads ));
num_threads = nAttr.create("num_threads", "num_threads", MFnNumericData::kBoolean, 1);
CHECK_MSTATUS(addAttribute( num_threads ));
super_sample_factor = nAttr.create("super_sample_factor", "super_sample_factor", MFnNumericData::kInt, 2);
CHECK_MSTATUS(addAttribute( super_sample_factor ));
watermark = nAttr.create("watermark", "watermark", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( watermark ));
info_overlay = nAttr.create("info_overlay", "info_overlay", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( info_overlay ));
cache_trees = nAttr.create("cache_trees", "cache_trees", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( cache_trees ));
aperture_diffraction = nAttr.create("aperture_diffraction", "aperture_diffraction", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( aperture_diffraction ));
post_process_diffraction = nAttr.create("post_process_diffraction", "post_process_diffraction", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( post_process_diffraction ));
render_foreground_alpha = nAttr.create("render_foreground_alpha", "render_foreground_alpha", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( render_foreground_alpha ));
splat_filter = eAttr.create("splat_filter", "splat_filter", 0, &stat);
stat = eAttr.addField( "fastbox", 0 );
stat = eAttr.addField( "radial", 1 );
stat = eAttr.addField( "mn_cubic", 2 );
CHECK_MSTATUS(addAttribute( splat_filter ));
splat_filter_cubic_b = nAttr.create("splat_filter_cubic_b", "splat_filter_cubic_b", MFnNumericData::kFloat, 0.6);
CHECK_MSTATUS(addAttribute( splat_filter_cubic_b ));
splat_filter_cubic_ring = nAttr.create("splat_filter_cubic_ring", "splat_filter_cubic_ring", MFnNumericData::kFloat, 0.2);
CHECK_MSTATUS(addAttribute( splat_filter_cubic_ring ));
downsize_filter = eAttr.create("downsize_filter", "downsize_filter", 0, &stat);
stat = eAttr.addField( "mn_cubic", 0 );
stat = eAttr.addField( "gauss", 1 );
stat = eAttr.addField( "sharp", 2 );
CHECK_MSTATUS(addAttribute( downsize_filter ));
downsize_filter_cubic_radius = nAttr.create("downsize_filter_cubic_radius", "downsize_filter_cubic_radius", MFnNumericData::kFloat, 2);
CHECK_MSTATUS(addAttribute( downsize_filter_cubic_radius ));
vignetting = nAttr.create("vignetting", "vignetting", MFnNumericData::kBoolean, true);
CHECK_MSTATUS(addAttribute( vignetting ));
gpu = nAttr.create("gpu", "gpu", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( gpu ));
selected_gpu_device = eAttr.create("selected_gpu_device", "selected_gpu_device", 0, &stat);
stat = eAttr.addField( "CUDA", 0 );
stat = eAttr.addField( "OPEN_CL", 1 );
CHECK_MSTATUS(addAttribute( selected_gpu_device ));
glass_acceleration = nAttr.create("glass_acceleration", "glass_acceleration", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( glass_acceleration ));
environmentType = eAttr.create("environmentType", "environmentType", 1, &stat);
stat = eAttr.addField( "Off", 0 );
stat = eAttr.addField( "Color/Map", 1 );
stat = eAttr.addField( "Sun", 2 );
CHECK_MSTATUS(addAttribute( environmentType ));
environmentColor = nAttr.createColor("environmentColor", "environmentColor");
nAttr.setDefault(0.4,0.4,1.0);
CHECK_MSTATUS(addAttribute( environmentColor ));
environmentSun = mAttr.create("environmentSun", "environmentSun");
CHECK_MSTATUS(addAttribute( environmentSun ));
turbidity = nAttr.create("turbidity", "turbidity", MFnNumericData::kFloat, 2.0);
CHECK_MSTATUS(addAttribute( turbidity ));
extra_atmospheric = nAttr.create("extra_atmospheric", "extra_atmospheric", MFnNumericData::kBoolean, false);
CHECK_MSTATUS(addAttribute( extra_atmospheric ));
sun_layer = nAttr.create("sun_layer", "sun_layer", MFnNumericData::kInt, 0);
CHECK_MSTATUS(addAttribute( sun_layer ));
sky_layer = nAttr.create("sky_layer", "sky_layer", MFnNumericData::kInt, 0);
CHECK_MSTATUS(addAttribute( sky_layer ));
sky_model = eAttr.create("sky_model", "sky_model", 0, &stat);
stat = eAttr.addField( "original", 0 );
stat = eAttr.addField( "captured-simulation", 1 );
CHECK_MSTATUS(addAttribute( sky_model ));
environmentMapType = eAttr.create("environmentMapType", "environmentMapType", 0, &stat);
stat = eAttr.addField( "Spherical", 0 );
stat = eAttr.addField( "Lat-Long", 1 );
CHECK_MSTATUS(addAttribute( environmentMapType ));
environmentMapMultiplier = nAttr.create("environmentMapMultiplier", "environmentMapMultiplier", MFnNumericData::kFloat, 1.0);
CHECK_MSTATUS(addAttribute( environmentMapMultiplier ));
MFnStringData fnStringData;
MObject defaultString;
defaultString = fnStringData.create( "notepad.exe" );
preferredTextEditor = tAttr.create("preferredTextEditor", "preferredTextEditor", MFnNumericData::kString, defaultString);
CHECK_MSTATUS(addAttribute( preferredTextEditor ));
// ------------- automatically created attributes end ----------- //
return stat;
}
bool ToMayaMeshConverter::setMeshInterpolationAttribute( MObject &object, std::string interpolation )
{
MStatus st;
MFnMesh fnMesh(object, &st);
if ( !st )
{
return false;
}
int interpolationValue = 0;
FromMayaMeshConverter fromMaya(object);
const IECore::Parameter::PresetsContainer &presets = fromMaya.interpolationParameter()->presets();
IECore::Parameter::PresetsContainer::const_iterator it;
if ( interpolation != "default" )
{
int index = 0;
for ( it = presets.begin(); it != presets.end(); it++, index++ )
{
if ( interpolation == it->first || interpolation == IECore::staticPointerCast< IECore::StringData >(it->second)->readable() )
{
interpolationValue = index;
break;
}
}
if ( it == presets.end() )
{
return false;
}
}
MPlug interpPlug = fnMesh.findPlug( "ieMeshInterpolation", &st );
if ( !st )
{
MFnEnumAttribute fnAttrib;
MObject newAttr = fnAttrib.create( "ieMeshInterpolation", "interp", 0, &st );
if ( !st )
{
return false;
}
int index = 0;
for ( it = presets.begin(); it != presets.end(); it++ )
{
if ( it->first == "default" )
{
continue;
}
fnAttrib.addField( it->first.c_str(), index );
index++;
}
// looks like the attribute does not exist yet..
st = fnMesh.addAttribute( newAttr );
if ( !st )
{
return false;
}
interpPlug = fnMesh.findPlug( "ieMeshInterpolation", &st );
if ( !st )
{
return false;
}
}
st = interpPlug.setValue( interpolationValue );
if ( !st )
{
return false;
}
return true;
}
MStatus ReduceArrayNode::initialize()
{
MStatus status;
MFnTypedAttribute T;
MFnNumericAttribute N;
MFnEnumAttribute E;
aInput = T.create("input", "i", MFnData::kDoubleArray);
T.setKeyable(false);
T.setChannelBox(false);
T.setStorable(true);
T.setWritable(true);
aOutput = N.create("output", "o", MFnNumericData::kDouble, 0.0);
T.setKeyable(false);
T.setChannelBox(false);
T.setWritable(true);
T.setStorable(true);
aOperation = E.create("operation", "operation");
E.addField("No Operation", kNO_OP);
E.addField("Sum", kSUM);
E.addField("Difference", kDIFFERENCE);
E.addField("Average", kAVERAGE);
E.addField("Product", kPRODUCT);
E.addField("Quotient", kQUOTIENT);
E.addField("Exponent", kEXPONENT);
E.addField("Minimum", kMIN);
E.addField("Maximum", kMAX);
E.addField("Length", kLENGTH);
E.setKeyable(true);
E.setStorable(true);
E.setWritable(true);
addAttribute(aOperation);
addAttribute(aInput);
addAttribute(aOutput);
attributeAffects(aOperation, aOutput);
attributeAffects(aInput, aOutput);
return MS::kSuccess;
}
MStatus asMicrofacet_brdf::initialize()
{
MFnNumericAttribute nAttr;
MFnLightDataAttribute lAttr;
MFnTypedAttribute tAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus status; // Status will be used to hold the MStatus value
// returned by each api function call. It is important
// to check the status returned by a call to aid in
// debugging. Failed API calls can result in subtle
// errors that can be difficult to track down, you may
// wish to use the CHECK_MSTATUS macro for any API
// call where you do not need to provide your own
// error handling.
//
//---------------------------- automatically created attributes start ------------------------------------
reflectance = nAttr.createColor("reflectance", "reflectance");
nAttr.setDefault(0.5,0.5,0.5);
CHECK_MSTATUS(addAttribute( reflectance ));
mdf = eAttr.create("mdf", "mdf", 1, &status);
status = eAttr.addField( "beckmann", 0 );
status = eAttr.addField( "blinn", 1 );
status = eAttr.addField( "ggx", 2 );
status = eAttr.addField( "ward", 3 );
CHECK_MSTATUS(addAttribute( mdf ));
glossiness_multiplier = nAttr.create("glossiness_multiplier", "glossiness_multiplier", MFnNumericData::kFloat, 1.0);
CHECK_MSTATUS(addAttribute( glossiness_multiplier ));
glossiness = nAttr.create("glossiness", "glossiness", MFnNumericData::kFloat, 0.5);
CHECK_MSTATUS(addAttribute( glossiness ));
fresnel_multiplier = nAttr.create("fresnel_multiplier", "fresnel_multiplier", MFnNumericData::kFloat, 1.0);
CHECK_MSTATUS(addAttribute( fresnel_multiplier ));
reflectance_multiplier = nAttr.create("reflectance_multiplier", "reflectance_multiplier", MFnNumericData::kFloat, 1.0);
CHECK_MSTATUS(addAttribute( reflectance_multiplier ));
//---------------------------- automatically created attributes end ------------------------------------
// Input Attributes
//
aTranslucenceCoeff = nAttr.create( "translucenceCoeff", "tc",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f ) );
aDiffuseReflectivity = nAttr.create( "diffuseReflectivity", "drfl",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.8f ) );
aColor = nAttr.createColor( "color", "c", &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.58824f, 0.644f ) );
aIncandescence = nAttr.createColor( "incandescence", "ic", &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.0f, 0.0f ) );
aInTransparency = nAttr.createColor( "transparency", "it", &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.0f, 0.0f ) );
// Color Output
//
aOutColor = nAttr.createColor( "outColor", "oc", &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setHidden( false ) );
CHECK_MSTATUS( nAttr.setReadable( true ) );
CHECK_MSTATUS( nAttr.setWritable( false ) );
aOutTransparency = nAttr.createColor( "outTransparency", "ot", &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setHidden( false ) );
CHECK_MSTATUS( nAttr.setReadable( true ) );
CHECK_MSTATUS( nAttr.setWritable( false ) );
// Camera Normals
//
aNormalCameraX = nAttr.create( "normalCameraX", "nx",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable( false ) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aNormalCameraY = nAttr.create( "normalCameraY", "ny",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable( false ) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aNormalCameraZ = nAttr.create( "normalCameraZ", "nz",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable( false ) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aNormalCamera = nAttr.create( "normalCamera","n", aNormalCameraX,
aNormalCameraY, aNormalCameraZ, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable( false ) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) );
CHECK_MSTATUS( nAttr.setHidden( true ) );
// Light Direction
//
aLightDirectionX = nAttr.create( "lightDirectionX", "ldx",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aLightDirectionY = nAttr.create( "lightDirectionY", "ldy",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aLightDirectionZ = nAttr.create( "lightDirectionZ", "ldz",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aLightDirection = nAttr.create( "lightDirection", "ld",
aLightDirectionX, aLightDirectionY, aLightDirectionZ,
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) );
// Light Intensity
//
aLightIntensityR = nAttr.create( "lightIntensityR", "lir",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aLightIntensityG = nAttr.create( "lightIntensityG", "lig",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aLightIntensityB = nAttr.create( "lightIntensityB", "lib",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aLightIntensity = nAttr.create( "lightIntensity", "li",
aLightIntensityR, aLightIntensityG, aLightIntensityB,
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) );
// Light
//
aLightAmbient = nAttr.create( "lightAmbient", "la",
MFnNumericData::kBoolean, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( true ) );
aLightDiffuse = nAttr.create( "lightDiffuse", "ldf",
MFnNumericData::kBoolean, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( true ) );
aLightSpecular = nAttr.create( "lightSpecular", "ls",
MFnNumericData::kBoolean, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( false ) );
aLightShadowFraction = nAttr.create( "lightShadowFraction", "lsf",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aPreShadowIntensity = nAttr.create( "preShadowIntensity", "psi",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
aLightBlindData = nAttr.createAddr( "lightBlindData", "lbld",
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
aLightData = lAttr.create( "lightDataArray", "ltd", aLightDirection,
aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular,
aLightShadowFraction, aPreShadowIntensity, aLightBlindData,
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( lAttr.setArray( true ) );
CHECK_MSTATUS( lAttr.setStorable( false ) );
CHECK_MSTATUS( lAttr.setHidden( true ) );
CHECK_MSTATUS( lAttr.setDefault( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
true, true, false, 1.0f, 1.0f, NULL ) );
// Next we will add the attributes we have defined to the node
//
CHECK_MSTATUS( addAttribute( aTranslucenceCoeff ) );
CHECK_MSTATUS( addAttribute( aDiffuseReflectivity ) );
CHECK_MSTATUS( addAttribute( aColor ) );
CHECK_MSTATUS( addAttribute( aIncandescence ) );
CHECK_MSTATUS( addAttribute( aInTransparency ) );
CHECK_MSTATUS( addAttribute( aOutColor ) );
CHECK_MSTATUS( addAttribute( aOutTransparency ) );
CHECK_MSTATUS( addAttribute( aNormalCamera ) );
// Only add the parent of the compound
CHECK_MSTATUS( addAttribute( aLightData ) );
// The attributeAffects() method is used to indicate when the input
// attribute affects the output attribute. This knowledge allows Maya
// to optimize dependencies in the graph in more complex nodes where
// there may be several inputs and outputs, but not all the inputs
// affect all the outputs.
//
CHECK_MSTATUS( attributeAffects( aTranslucenceCoeff, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aDiffuseReflectivity, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aColor, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aInTransparency, aOutTransparency ) );
CHECK_MSTATUS( attributeAffects( aInTransparency, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aIncandescence, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightIntensityR, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightIntensityB, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightIntensityG, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightIntensity, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aNormalCameraX, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aNormalCameraY, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aNormalCameraZ, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aNormalCamera, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightDirectionX, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightDirectionY, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightDirectionZ, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightDirection, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightAmbient, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightSpecular, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightDiffuse, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightShadowFraction, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aPreShadowIntensity, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightBlindData, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aLightData, aOutColor ) );
return( MS::kSuccess );
}
MStatus collisionShapeNode::initialize()
{
MStatus status;
MFnMessageAttribute fnMsgAttr;
MFnNumericAttribute fnNumericAttr;
MFnEnumAttribute fnEnumAttr;
ia_type = fnEnumAttr.create("type", "tp", 7, &status);
MCHECKSTATUS(status, "creating type attribute")
fnEnumAttr.addField("Convex Hull", 0);
fnEnumAttr.addField("Mesh", 1);
fnEnumAttr.addField("Cylinder", 2);
fnEnumAttr.addField("Capsule", 3);
fnEnumAttr.addField("Box", 4);
fnEnumAttr.addField("Sphere", 5);
fnEnumAttr.addField("Plane", 6);
fnEnumAttr.addField("BvhMesh", 7);
fnEnumAttr.addField("HACD", 8);
fnEnumAttr.setKeyable(true);
status = addAttribute(ia_type);
MCHECKSTATUS(status, "adding type attribute")
ia_scale = fnNumericAttr.createPoint("scale", "sc", &status);
MCHECKSTATUS(status, "creating ia_scale attribute")
fnNumericAttr.setDefault(1.0, 1.0, 1.0);
fnNumericAttr.setKeyable(true);
status = addAttribute(ia_scale);
MCHECKSTATUS(status, "adding ia_scale attribute")
oa_collisionShape = fnMsgAttr.create("outCollisionShape", "oucs", &status);
MCHECKSTATUS(status, "creating outCollisionShape attribute")
status = addAttribute(oa_collisionShape);
MCHECKSTATUS(status, "adding outCollisionShape attribute")
ia_shape = fnMsgAttr.create("inShape", "insh", &status);
MCHECKSTATUS(status, "creating inShape attribute")
status = addAttribute(ia_shape);
MCHECKSTATUS(status, "adding inShape attribute")
ca_collisionShape = fnNumericAttr.create("ca_collisionShape", "ccs", MFnNumericData::kBoolean, 0, &status);
MCHECKSTATUS(status, "creating ca_collisionShape attribute")
fnNumericAttr.setWorldSpace(true);
fnNumericAttr.setConnectable(false);
fnNumericAttr.setHidden(true);
fnNumericAttr.setStorable(false);
fnNumericAttr.setKeyable(false);
status = addAttribute(ca_collisionShape);
MCHECKSTATUS(status, "adding ca_collisionShape attribute")
ca_collisionShapeParam = fnNumericAttr.create("collisionShapeParam", "cspm", MFnNumericData::kBoolean, 0, &status);
MCHECKSTATUS(status, "creating ca_collisionShapeParam attribute")
fnNumericAttr.setConnectable(false);
fnNumericAttr.setHidden(true);
fnNumericAttr.setStorable(false);
fnNumericAttr.setKeyable(false);
status = addAttribute(ca_collisionShapeParam);
MCHECKSTATUS(status, "adding ca_collisionShapeParam attribute")
//
status = attributeAffects(ia_shape, oa_collisionShape);
MCHECKSTATUS(status, "adding attributeAffects(ia_shape, oa_collisionShape)")
status = attributeAffects(ia_type, oa_collisionShape);
MCHECKSTATUS(status, "adding attributeAffects(ia_type, oa_collisionShape)")
status = attributeAffects(ia_scale, oa_collisionShape);
MCHECKSTATUS(status, "adding attributeAffects(ia_scale, oa_collisionShape)")
//
status = attributeAffects(ia_shape, ca_collisionShape);
MCHECKSTATUS(status, "adding attributeAffects(ia_shape, ca_collisionShape)")
status = attributeAffects(ia_type, ca_collisionShape);
MCHECKSTATUS(status, "adding attributeAffects(ia_shape, ca_collisionShape)")
//
status = attributeAffects(ia_shape, ca_collisionShapeParam);
MCHECKSTATUS(status, "adding attributeAffects(ia_shape, oa_collisionShapeParam)")
status = attributeAffects(ia_scale, ca_collisionShapeParam);
MCHECKSTATUS(status, "adding attributeAffects(ia_scale, oa_collisionShapeParam)")
status = attributeAffects(ia_type, ca_collisionShapeParam);
MCHECKSTATUS(status, "adding attributeAffects(ia_type, oa_collisionShapeParam)")
return MS::kSuccess;
}
