//
// DESCRIPTION:
MStatus OSLNode::initialize()
{
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnGenericAttribute gAttr;
MFnEnumAttribute eAttr;
MFnMessageAttribute mAttr;
MStatus status;
color = nAttr.createColor("color", "color");
MAKE_INPUT(nAttr);
CHECK_MSTATUS(addAttribute( color ));
script = tAttr.create("script", "script", MFnNumericData::kString);
MAKE_INPUT(tAttr);
CHECK_MSTATUS(addAttribute( script ));
outColor = nAttr.createColor("outColor", "outColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( outColor ));
//---------------------------- automatically created attributes start ------------------------------------
//---------------------------- automatically created attributes end ------------------------------------
attributeAffects(color, outColor);
attributeAffects(script, outColor);
return MS::kSuccess;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus Gamma::initialize()
{
MFnNumericAttribute nAttr;
// Input attributes
aColor = nAttr.createColor( "color", "c" );
MAKE_INPUT(nAttr);
aGamma = nAttr.createPoint( "gamma", "g" );
MAKE_INPUT(nAttr);
CHECK_MSTATUS ( nAttr.setDefault(1.f, 1.f, 1.f) );
// Output attributes
aOutColor= nAttr.createColor( "outColor", "oc" );
MAKE_OUTPUT(nAttr);
// Add attributes to the node database.
CHECK_MSTATUS ( addAttribute(aColor) );
CHECK_MSTATUS ( addAttribute(aGamma) );
CHECK_MSTATUS ( addAttribute(aOutColor) );
// All input affect the output color
CHECK_MSTATUS ( attributeAffects( aColor, aOutColor ));
CHECK_MSTATUS ( attributeAffects( aGamma, aOutColor ));
return MS::kSuccess;
}
// initializes attribute information
MStatus myComp::initialize()
{
MFnNumericAttribute nAttr;
// Create input attributes
aForegroundColor = nAttr.createColor("foreground", "fg");
MAKE_INPUT(nAttr);
aBackgroundColor = nAttr.createColor("background", "bg");
MAKE_INPUT(nAttr);
CHECK_MSTATUS( nAttr.setDefault(1., 1., 1.));
aBackColor = nAttr.createColor("backColor", "bk");
MAKE_INPUT(nAttr);
CHECK_MSTATUS( nAttr.setDefault(1., 1., 1.));
aMask = nAttr.create( "mask", "ms", MFnNumericData::kFloat);
CHECK_MSTATUS( nAttr.setMin(0.f));
CHECK_MSTATUS( nAttr.setMax(1.f));
MAKE_INPUT(nAttr);
// Create output attributes here
aOutColor = nAttr.createColor("outColor", "oc");
MAKE_OUTPUT(nAttr);
aOutAlpha = nAttr.create( "outAlpha", "oa", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
// Add the attributes here
CHECK_MSTATUS( addAttribute(aForegroundColor) );
CHECK_MSTATUS( addAttribute(aBackgroundColor) );
CHECK_MSTATUS( addAttribute(aBackColor) );
CHECK_MSTATUS( addAttribute(aMask) );
CHECK_MSTATUS( addAttribute(aOutColor) );
CHECK_MSTATUS( addAttribute(aOutAlpha) );
// all input affect the output color and alpha
CHECK_MSTATUS( attributeAffects(aForegroundColor, aOutColor) );
CHECK_MSTATUS( attributeAffects(aForegroundColor, aOutAlpha) );
CHECK_MSTATUS( attributeAffects(aBackgroundColor, aOutColor) );
CHECK_MSTATUS( attributeAffects(aBackgroundColor, aOutAlpha) );
CHECK_MSTATUS( attributeAffects(aBackColor, aOutColor) );
CHECK_MSTATUS( attributeAffects(aBackColor, aOutAlpha) );
CHECK_MSTATUS( attributeAffects(aMask, aOutColor) );
CHECK_MSTATUS( attributeAffects(aMask, aOutAlpha) );
return MS::kSuccess;
}
MStatus texLayerNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
layerInput1=numAttr.createColor("LayerInput1","li1");
numAttr.setDefault(1.0,1.0,1.0);
MAKE_INPUT(numAttr);
layerInput2=numAttr.createColor("LayerInput2","li2");
MAKE_INPUT(numAttr);
numAttr.setDefault(1.0,1.0,1.0);
layerInput3=numAttr.createColor("LayerInput3","li3");
MAKE_INPUT(numAttr);
numAttr.setDefault(1.0,1.0,1.0);
layerInput4=numAttr.createColor("LayerInput4","li4");
MAKE_INPUT(numAttr);
numAttr.setDefault(1.0,1.0,1.0);
MObject u=numAttr.create("uCoord","u",MFnNumericData::kFloat);
MObject v=numAttr.create("vCoord","v",MFnNumericData::kFloat);
layerUV=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);
layerUVFilterSize=numAttr.create("uvFilterSize", "fs", filterX, filterY);
MAKE_INPUT(numAttr);
layerOutput=numAttr.createColor("outColor","oc");
MAKE_OUTPUT(numAttr);
numAttr.setHidden(true);
addAttribute(layerInput1);
addAttribute(layerInput2);
addAttribute(layerInput3);
addAttribute(layerInput4);
addAttribute(layerUV);
addAttribute(layerUVFilterSize);
addAttribute(layerOutput);
attributeAffects(layerInput1,layerOutput);
attributeAffects(layerInput2,layerOutput);
attributeAffects(layerInput3,layerOutput);
attributeAffects(layerInput4,layerOutput);
attributeAffects(layerUV,layerOutput);
attributeAffects(layerUVFilterSize,layerOutput);
return stat;
}
MStatus
OpenSubdivShader::initialize()
{
MStatus stat;
MFnTypedAttribute typedAttr;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 1);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setSoftMax(5);
aScheme = enumAttr.create("scheme", "sc");
enumAttr.addField("Catmull-Clark", kCatmark);
enumAttr.addField("Loop", kLoop);
enumAttr.addField("Bilinear", kBilinear);
enumAttr.setInternal(true);
aKernel = enumAttr.create("kernel", "kn");
enumAttr.addField("CPU", OpenSubdiv::OsdKernelDispatcher::kCPU);
if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kOPENMP))
enumAttr.addField("OpenMP", OpenSubdiv::OsdKernelDispatcher::kOPENMP);
if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kCL))
enumAttr.addField("CL", OpenSubdiv::OsdKernelDispatcher::kCL);
if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kCUDA))
enumAttr.addField("CUDA", OpenSubdiv::OsdKernelDispatcher::kCUDA);
enumAttr.setInternal(true);
aDiffuse = numAttr.createColor("diffuse", "d");
numAttr.setDefault(1.0f, 1.0f, 1.0f);
aSpecular = numAttr.createColor("specular", "s");
numAttr.setDefault(1.0f, 1.0f, 1.0f);
aAmbient = numAttr.createColor("ambient", "a");
numAttr.setDefault(1.0f, 1.0f, 1.0f);
aShininess = numAttr.create("shininess", "shin", MFnNumericData::kFloat, 16.0f);
numAttr.setMin(0);
numAttr.setMax(128.0f);
aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean);
addAttribute(aLevel);
addAttribute(aScheme);
addAttribute(aKernel);
addAttribute(aDiffuse);
addAttribute(aSpecular);
addAttribute(aAmbient);
addAttribute(aShininess);
addAttribute(aWireframe);
return MS::kSuccess;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus DispNode::initialize()
{
MFnNumericAttribute nAttr;
// Inputs
aColor = nAttr.createColor( "color", "c" );
CHECK_MSTATUS(nAttr.setKeyable(true));
CHECK_MSTATUS(nAttr.setStorable(true));
CHECK_MSTATUS(nAttr.setDefault(1.0f, 1.0f, 1.0f));
aInputValue = nAttr.create( "factor", "f", MFnNumericData::kFloat);
CHECK_MSTATUS(nAttr.setKeyable(true));
CHECK_MSTATUS(nAttr.setStorable(true));
CHECK_MSTATUS(nAttr.setDefault(1.0f));
// Outputs
aOutColor = nAttr.createColor( "outColor", "oc" );
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(false));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
aOutTransparency = nAttr.createColor( "outTransparency", "ot" );
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(false));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
aOutDisplacement = nAttr.create( "displacement", "od",
MFnNumericData::kFloat);
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(false));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
CHECK_MSTATUS(addAttribute(aColor));
CHECK_MSTATUS(addAttribute(aInputValue));
CHECK_MSTATUS(addAttribute(aOutColor));
CHECK_MSTATUS(addAttribute(aOutTransparency));
CHECK_MSTATUS(addAttribute(aOutDisplacement));
CHECK_MSTATUS(attributeAffects (aColor, aOutColor));
CHECK_MSTATUS(attributeAffects (aColor, aOutDisplacement));
return MS::kSuccess;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus depthShader::initialize()
{
MFnNumericAttribute nAttr;
// Create input attributes
aColorNear = nAttr.createColor("color", "c");
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setDefault(0., 1., 0.)); // Green
aColorFar = nAttr.createColor("colorFar", "cf");
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setDefault(0., 0., 1.)); // Blue
aNear = nAttr.create("near", "n", MFnNumericData::kFloat);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setMin(0.0f));
CHECK_MSTATUS(nAttr.setSoftMax(1000.0f));
aFar = nAttr.create("far", "f", MFnNumericData::kFloat);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setMin(0.0f));
CHECK_MSTATUS(nAttr.setSoftMax(1000.0f));
CHECK_MSTATUS(nAttr.setDefault(2.0f));
aPointCamera = nAttr.createPoint("pointCamera", "p");
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setHidden(true));
// Create output attributes
aOutColor = nAttr.createColor("outColor", "oc");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute(aColorNear));
CHECK_MSTATUS(addAttribute(aColorFar));
CHECK_MSTATUS(addAttribute(aNear) );
CHECK_MSTATUS(addAttribute(aFar));
CHECK_MSTATUS(addAttribute(aPointCamera));
CHECK_MSTATUS(addAttribute(aOutColor));
CHECK_MSTATUS(attributeAffects(aColorNear, aOutColor));
CHECK_MSTATUS(attributeAffects(aColorFar, aOutColor));
CHECK_MSTATUS(attributeAffects(aNear, aOutColor));
CHECK_MSTATUS(attributeAffects(aFar, aOutColor));
CHECK_MSTATUS(attributeAffects(aPointCamera, aOutColor));
return MS::kSuccess;
}
MStatus mapBlendShape::initialize()
{
MStatus status;
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
aBlendMesh = tAttr.create("blendMesh", "blendMesh", MFnData::kMesh);
addAttribute(aBlendMesh);
aBlendMap = nAttr.createColor("blendMap", "blendMap");
addAttribute(aBlendMap);
aUseBlendMap = nAttr.create("useBlendMap", "useBlendMap", MFnNumericData::kBoolean);
nAttr.setDefault(true);
addAttribute(aUseBlendMap);
aBlendMapMultiplier = nAttr.create("blendMapMultiplier", "blendMapMultiplier", MFnNumericData::kFloat);
nAttr.setDefault(1.0);
nAttr.setMin(0.0);
addAttribute(aBlendMapMultiplier);
attributeAffects(aBlendMesh, outputGeom);
attributeAffects(aBlendMap, outputGeom);
attributeAffects(aUseBlendMap, outputGeom);
attributeAffects(aBlendMapMultiplier, outputGeom);
MGlobal::executeCommand( "makePaintable -attrType multiFloat -sm deformer blendNode weights;" );
return MS::kSuccess;
}
MStatus PRTAttrs::addColorParameter(MFnDependencyNode & node, MObject & attr, const MString & name, MString & value ) {
MStatus stat;
MFnNumericAttribute nAttr;
const wchar_t* s = value.asWChar();
attr = nAttr.createColor(longName(name), briefName(name), &stat );
MCHECK(stat);
double r = 0.0;
double g = 0.0;
double b = 0.0;
if (s[0] == '#' && wcslen(s) >= 7) {
r = (double)((prtu::fromHex(s[1]) << 4) + prtu::fromHex(s[2])) / 255.0;
g = (double)((prtu::fromHex(s[3]) << 4) + prtu::fromHex(s[4])) / 255.0;
b = (double)((prtu::fromHex(s[5]) << 4) + prtu::fromHex(s[6])) / 255.0;
nAttr.setDefault(r, g, b);
}
MCHECK(addParameter(node, attr, nAttr));
MFnNumericData fnData;
MObject rgb = fnData.create(MFnNumericData::k3Double, &stat);
MCHECK(stat);
fnData.setData(r, g, b);
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(rgb));
return MS::kSuccess;
}
MStatus areaLightNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
areaLightColor=numAttr.createColor("LightColor","lico");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(0.5,0.5,0.5);
areaPower=numAttr.create("Power","ap",MFnNumericData::kFloat,1.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10000.0);
areaSamples=numAttr.create("Samples","as",MFnNumericData::kInt,1);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0);
numAttr.setMax(512);
areaMakeGeo=numAttr.create("MakeGeometry","mg",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
addAttribute(areaLightColor);
addAttribute(areaPower);
addAttribute(areaSamples);
addAttribute(areaMakeGeo);
return stat;
}
MStatus 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;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus MixtureNode::initialize()
{
MFnNumericAttribute nAttr;
// Input attributes
aColor1 = nAttr.createColor( "color1", "c1" );
MAKE_INPUT(nAttr);
CHECK_MSTATUS ( nAttr.setDefault(0.0f, 1.0f, 0.0f) ); // Green
aColor2 = nAttr.createColor( "color2", "c2" );
MAKE_INPUT(nAttr);
CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.0f, 1.0f) ); // Blue
aAlphaInput1= nAttr.createColor( "mask1", "m1" );
MAKE_INPUT(nAttr);
CHECK_MSTATUS ( nAttr.setDefault(.5f, .5f, .5f) );
aAlphaInput2= nAttr.createColor( "mask2", "m2" );
MAKE_INPUT(nAttr);
CHECK_MSTATUS ( nAttr.setDefault(.5f, .5f, .5f) );
// Output attributes
aOutColor = nAttr.createColor( "outColor", "oc" );
MAKE_OUTPUT(nAttr);
// Add attributes to the node database.
CHECK_MSTATUS ( addAttribute(aColor1) );
CHECK_MSTATUS ( addAttribute(aColor2) );
CHECK_MSTATUS ( addAttribute(aAlphaInput1) );
CHECK_MSTATUS ( addAttribute(aAlphaInput2) );
CHECK_MSTATUS ( addAttribute(aOutColor) );
// All input affect the output color
CHECK_MSTATUS ( attributeAffects(aColor1, aOutColor) );
CHECK_MSTATUS ( attributeAffects(aColor2, aOutColor) );
CHECK_MSTATUS ( attributeAffects(aAlphaInput1, aOutColor) );
CHECK_MSTATUS ( attributeAffects(aAlphaInput2, aOutColor) );
return MS::kSuccess;
}
//
// DESCRIPTION:
MStatus constant::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 ------------------------------------
color = nAttr.createColor("color", "color");
MAKE_INPUT(nAttr);
nAttr.setDefault(1.0,1.0,1.0);
CHECK_MSTATUS(addAttribute( color ));
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 ));
luxOutFresnel = nAttr.create("luxOutFresnel", "luxOutFresnel", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( luxOutFresnel ));
CHECK_MSTATUS ( attributeAffects( color, luxOutFloat));
CHECK_MSTATUS ( attributeAffects( color, luxOutColor));
CHECK_MSTATUS ( attributeAffects( color, luxOutFresnel));
CHECK_MSTATUS ( attributeAffects( color, outColor));
//---------------------------- automatically created attributes end ------------------------------------
return MS::kSuccess;
}
MStatus DynamicEnum::initialize()
{
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnStringData sData;
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.
//
// Attribute Initialization:
aFilePath = tAttr.create( "filepath", "file", MFnData::kString, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( tAttr.setKeyable( true ) );
CHECK_MSTATUS( tAttr.setStorable( true ) );
CHECK_MSTATUS( tAttr.setDefault( sData.create("") ) );
aGridName = tAttr.create( "grid", "grd", MFnData::kString, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( tAttr.setKeyable( true ) );
CHECK_MSTATUS( tAttr.setStorable( true ) );
CHECK_MSTATUS( tAttr.setDefault( sData.create("") ) );
aOutColor = nAttr.createColor( "outColor", "oc", &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setHidden( false ) );
CHECK_MSTATUS( nAttr.setReadable( true ) );
CHECK_MSTATUS( nAttr.setWritable( false ) );
// Next we will add the attributes we have defined to the node
//
CHECK_MSTATUS( addAttribute( aFilePath ) );
CHECK_MSTATUS( addAttribute( aGridName ) );
CHECK_MSTATUS( addAttribute( aOutColor ) );
// 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( aFilePath, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aGridName, aOutColor ) );
return( MS::kSuccess );
}
//
// DESCRIPTION:
MStatus Gradient::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 ------------------------------------
high = nAttr.createColor("high", "high");
nAttr.setDefault(0,0,0);
CHECK_MSTATUS(addAttribute( high ));
low = nAttr.createColor("low", "low");
nAttr.setDefault(1,1,1);
CHECK_MSTATUS(addAttribute( low ));
MObject directionX = nAttr.create("directionX", "directionx", MFnNumericData::kDouble, 0.0);
MObject directionY = nAttr.create("directionY", "directiony", MFnNumericData::kDouble, 0.0);
MObject directionZ = nAttr.create("directionZ", "directionz", MFnNumericData::kDouble, 0.0);
direction = nAttr.create("direction", "direction", directionX, directionY, directionZ);
MAKE_INPUT(nAttr);
nAttr.setDefault(1,0,0);
CHECK_MSTATUS(addAttribute( direction ));
//---------------------------- automatically created attributes end ------------------------------------
return MS::kSuccess;
}
//
// DESCRIPTION:
MStatus uv::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 ------------------------------------
luxOutColor = nAttr.createColor("luxOutColor", "luxOutColor");
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(addAttribute( luxOutColor ));
//---------------------------- automatically created attributes end ------------------------------------
return MS::kSuccess;
}
MStatus curvedArrows::initialize()
{
MFnNumericAttribute nAttr;
aTheColor = nAttr.createColor( "theColor", "tc" );
nAttr.setDefault( 0.1, 0.1, 0.8 );
nAttr.setKeyable( true );
nAttr.setReadable( true );
nAttr.setWritable( true );
nAttr.setStorable( true );
aTransparency = nAttr.create( "transparency", "t", MFnNumericData::kFloat );
nAttr.setDefault( 0.5 );
nAttr.setKeyable( true );
nAttr.setReadable( true );
nAttr.setWritable( true );
nAttr.setStorable( true );
aEnableTransparencySort =
nAttr.create( "transparencySort", "ts", MFnNumericData::kBoolean );
nAttr.setDefault( true );
nAttr.setKeyable( true );
nAttr.setReadable( true );
nAttr.setWritable( true );
nAttr.setStorable( true );
aEnableDrawLast =
nAttr.create( "drawLast", "dL", MFnNumericData::kBoolean );
nAttr.setDefault( false );
nAttr.setKeyable( true );
nAttr.setReadable( true );
nAttr.setWritable( true );
nAttr.setStorable( true );
MStatus stat1, stat2, stat3, stat4;
stat1 = addAttribute( aTheColor );
stat2 = addAttribute( aEnableTransparencySort );
stat3 = addAttribute( aEnableDrawLast );
stat4 = addAttribute( aTransparency );
if ( !stat1 || !stat2 || !stat3 || !stat4) {
stat1.perror("addAttribute");
stat2.perror("addAttribute");
stat3.perror("addAttribute");
stat4.perror("addAttribute");
return MS::kFailure;
}
return MS::kSuccess;
}
MStatus sphereLightNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
sphereColor=numAttr.createColor("LightColor","lico");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(1.0,1.0,1.0);
spherePower=numAttr.create("Power","pw",MFnNumericData::kFloat,1.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10000.0);
sphereRadius=numAttr.create("Radius","ra",MFnNumericData::kFloat,1.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(100.0);
sphereSamples=numAttr.create("Samples","sam",MFnNumericData::kInt,16);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0);
numAttr.setMax(512);
sphereMakeGeometry=numAttr.create("MakeGeometry","mg",MFnNumericData::kBoolean,0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
addAttribute(sphereColor);
addAttribute(spherePower);
addAttribute(sphereRadius);
addAttribute(sphereSamples);
addAttribute(sphereMakeGeometry);
return stat;
}
MStatus pointLightNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
pointLightColor=numAttr.createColor("LightColor","plico");
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setDefault(1.0,1.0,1.0);
pointPower=numAttr.create("Power","pp",MFnNumericData::kFloat,1.0);
numAttr.setKeyable(true);
numAttr.setStorable(true);
numAttr.setMin(0.0);
numAttr.setMax(10000.0);
addAttribute(pointLightColor);
addAttribute(pointPower);
return stat=MStatus::kSuccess;
}
//
// 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
OpenSubdivPtexShader::initialize()
{
MFnTypedAttribute typedAttr;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
// level
aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 3);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setSoftMax(5);
numAttr.setMax(10);
// tessFactor
aTessFactor = numAttr.create("tessFactor", "tessf", MFnNumericData::kLong, 2);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setMax(10);
// scheme
aScheme = enumAttr.create("scheme", "sc", OsdPtexMeshData::kCatmark);
enumAttr.addField("Catmull-Clark", OsdPtexMeshData::kCatmark);
enumAttr.addField("Loop", OsdPtexMeshData::kLoop);
enumAttr.addField("Bilinear", OsdPtexMeshData::kBilinear);
enumAttr.setInternal(true);
// kernel
aKernel = enumAttr.create("kernel", "kn", OsdPtexMeshData::kCPU);
enumAttr.addField("CPU", OsdPtexMeshData::kCPU);
#ifdef OPENSUBDIV_HAS_OPENMP
enumAttr.addField("OpenMP", OsdPtexMeshData::kOPENMP);
#endif
#ifdef OPENSUBDIV_HAS_OPENCL
enumAttr.addField("CL", OsdPtexMeshData::kCL);
#endif
#ifdef OPENSUBDIV_HAS_CUDA
enumAttr.addField("CUDA", OsdPtexMeshData::kCUDA);
#endif
enumAttr.setInternal(true);
// interpolateBoundary
aInterpolateBoundary = enumAttr.create("interpolateBoundary", "ib",
OsdPtexMeshData::kInterpolateBoundaryNone);
enumAttr.addField("None", OsdPtexMeshData::kInterpolateBoundaryNone);
enumAttr.addField("Edge Only", OsdPtexMeshData::kInterpolateBoundaryEdgeOnly);
enumAttr.addField("Edge and Corner", OsdPtexMeshData::kInterpolateBoundaryEdgeAndCorner);
enumAttr.addField("Always Sharp", OsdPtexMeshData::kInterpolateBoundaryAlwaysSharp);
enumAttr.setInternal(true);
// adaptive
aAdaptive = numAttr.create("adaptive", "adp", MFnNumericData::kBoolean, true);
numAttr.setInternal(true);
// wireframe
aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean, false);
// material attributes
aDiffuse = numAttr.createColor("diffuse", "d");
numAttr.setDefault(0.6f, 0.6f, 0.7f);
aAmbient = numAttr.createColor("ambient", "a");
numAttr.setDefault(0.1f, 0.1f, 0.1f);
aSpecular = numAttr.createColor("specular", "s");
numAttr.setDefault(0.3f, 0.3f, 0.3f);
// Ptex Texture Attributes
//
// diffuseEnvironmentMapFile;
aDiffuseEnvironmentMapFile = typedAttr.create("diffuseEnvironmentMap", "difenv", MFnData::kString);
typedAttr.setInternal(true);
// don't let maya hold on to string when fileNode is disconnected
typedAttr.setDisconnectBehavior(MFnAttribute::kReset);
// specularEnvironmentMapFile;
aSpecularEnvironmentMapFile = typedAttr.create("specularEnvironmentMap", "specenv", MFnData::kString);
typedAttr.setInternal(true);
// don't let maya hold on to string when fileNode is disconnected
typedAttr.setDisconnectBehavior(MFnAttribute::kReset);
// colorFile;
aColorFile = typedAttr.create("colorFile", "cf", MFnData::kString);
typedAttr.setInternal(true);
// displacementFile;
aDisplacementFile = typedAttr.create("displacementFile", "df", MFnData::kString);
typedAttr.setInternal(true);
// occlusionFile;
aOcclusionFile = typedAttr.create("occlusionFile", "of", MFnData::kString);
typedAttr.setInternal(true);
// enableDisplacement;
aEnableDisplacement = numAttr.create("enableDisplacement", "end", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableColor;
aEnableColor = numAttr.create("enableColor", "enc", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableOcclusion;
aEnableOcclusion = numAttr.create("enableOcclusion", "eno", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableNormal;
aEnableNormal = numAttr.create("enableNormal", "enn", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// fresnelBias;
aFresnelBias = numAttr.create("fresnelBias", "fb", MFnNumericData::kFloat, 0.2f);
numAttr.setMin(0);
numAttr.setMax(1);
// fresnelScale;
aFresnelScale = numAttr.create("fresnelScale", "fs", MFnNumericData::kFloat, 1.0f);
numAttr.setMin(0);
numAttr.setSoftMax(1);
// fresnelPower;
aFresnelPower = numAttr.create("fresnelPower", "fp", MFnNumericData::kFloat, 5.0f);
numAttr.setMin(0);
numAttr.setSoftMax(10);
// shaderSource;
aShaderSource = typedAttr.create("shaderSource", "ssrc", MFnData::kString);
typedAttr.setInternal(true);
// add attributes
addAttribute(aLevel);
addAttribute(aTessFactor);
addAttribute(aScheme);
addAttribute(aKernel);
addAttribute(aInterpolateBoundary);
addAttribute(aAdaptive);
addAttribute(aWireframe);
addAttribute(aDiffuse);
addAttribute(aAmbient);
addAttribute(aSpecular);
addAttribute(aShaderSource);
addAttribute(aDiffuseEnvironmentMapFile);
addAttribute(aSpecularEnvironmentMapFile);
addAttribute(aColorFile);
addAttribute(aDisplacementFile);
addAttribute(aOcclusionFile);
addAttribute(aEnableDisplacement);
addAttribute(aEnableColor);
addAttribute(aEnableOcclusion);
addAttribute(aEnableNormal);
addAttribute(aFresnelBias);
addAttribute(aFresnelScale);
addAttribute(aFresnelPower);
return MS::kSuccess;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus Cell3D::initialize()
{
MFnMatrixAttribute mAttr;
MFnNumericAttribute nAttr;
// Input attributes
aColorGain = nAttr.createColor("colorGain", "cg");
MAKE_INPUT(nAttr);
CHECK_MSTATUS( nAttr.setDefault(1.0f,1.0f,1.0f) );
aColorOffset = nAttr.createColor("colorOffset", "co");
MAKE_INPUT(nAttr);
aPlaceMat = mAttr.create("placementMatrix", "pm",
MFnMatrixAttribute::kFloat);
MAKE_INPUT(mAttr);
// Implicit shading network attributes
aPointWorld = nAttr.createPoint("pointWorld", "pw");
MAKE_INPUT(nAttr);
CHECK_MSTATUS( nAttr.setHidden(true) );
// Create output attributes
aOutF0 = nAttr.create( "F0", "f0", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
aOutF1 = nAttr.create( "F1", "f1", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
aOutN0 = nAttr.create( "N0", "n0", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
aOutBorderDist = nAttr.create("borderDistance", "bd",
MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
aOutColor = nAttr.createColor("outColor", "oc");
MAKE_OUTPUT(nAttr);
aOutAlpha = nAttr.create( "outAlpha", "oa", MFnNumericData::kFloat);
MAKE_OUTPUT(nAttr);
// Add attributes to the node database.
CHECK_MSTATUS( addAttribute(aColorGain) );
CHECK_MSTATUS( addAttribute(aColorOffset) );
CHECK_MSTATUS( addAttribute(aPointWorld) );
CHECK_MSTATUS( addAttribute(aPlaceMat) );
CHECK_MSTATUS( addAttribute(aOutAlpha) );
CHECK_MSTATUS( addAttribute(aOutColor) );
CHECK_MSTATUS( addAttribute(aOutF0) );
CHECK_MSTATUS( addAttribute(aOutF1) );
CHECK_MSTATUS( addAttribute(aOutN0) );
CHECK_MSTATUS( addAttribute(aOutBorderDist) );
// All input affect the output color and alpha
CHECK_MSTATUS( attributeAffects (aColorGain, aOutColor) );
CHECK_MSTATUS( attributeAffects (aColorOffset, aOutColor) );
CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutColor) );
CHECK_MSTATUS( attributeAffects (aPointWorld, aOutColor) );
CHECK_MSTATUS( attributeAffects (aColorGain, aOutAlpha) );
CHECK_MSTATUS( attributeAffects (aColorOffset, aOutAlpha) );
CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutAlpha) );
CHECK_MSTATUS( attributeAffects (aPointWorld, aOutAlpha) );
// Geometry attribute affect all other outputs.
CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutF0) );
CHECK_MSTATUS( attributeAffects (aPointWorld, aOutF0) );
CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutF1) );
CHECK_MSTATUS( attributeAffects (aPointWorld, aOutF1) );
CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutN0) );
CHECK_MSTATUS( attributeAffects (aPointWorld, aOutN0) );
CHECK_MSTATUS( attributeAffects (aPlaceMat, aOutBorderDist) );
CHECK_MSTATUS( attributeAffects (aPointWorld, aOutBorderDist) );
return MS::kSuccess;
}
MStatus retargetLocator::initialize()
{
MFnNumericAttribute nAttr;
MFnMatrixAttribute mAttr;
MFnEnumAttribute eAttr;
MFnUnitAttribute uAttr;
MFnCompoundAttribute cAttr;
MFnTypedAttribute tAttr;
aOutput = nAttr.create( "output", "output", MFnNumericData::kDouble );
nAttr.setStorable( false );
CHECK_MSTATUS( addAttribute( aOutput ) );
aDiscMatrix = mAttr.create( "discMatrix", "discMatrix" );
mAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aDiscMatrix ) );
CHECK_MSTATUS( attributeAffects( aDiscMatrix, aOutput ) );
aDiscAxis = eAttr.create( "discAxis", "discAxis", 0 );
eAttr.addField( "X", 0 );
eAttr.addField( "Y", 1 );
eAttr.addField( "Z", 2 );
eAttr.setStorable( true );
eAttr.setChannelBox( true );
eAttr.setReadable( true );
CHECK_MSTATUS( addAttribute( aDiscAxis ) );
CHECK_MSTATUS( attributeAffects( aDiscAxis, aOutput ) );
aDiscDivision = nAttr.create( "discDivision", "discDivision", MFnNumericData::kInt, 32 );
nAttr.setMin( 1 );
nAttr.setMax( 32 );
nAttr.setStorable( true );
nAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscDivision ) );
CHECK_MSTATUS( attributeAffects( aDiscDivision, aOutput ) );
aDiscAngle = uAttr.create( "discAngle", "discAngle", MFnUnitAttribute::kAngle, 0.0 );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscAngle ) );
CHECK_MSTATUS( attributeAffects( aDiscAngle, aOutput ) );
aDiscOffsetX = nAttr.create( "discOffsetX", "discOffsetX", MFnNumericData::kDouble, 0.0 );
aDiscOffsetY = nAttr.create( "discOffsetY", "discOffsetY", MFnNumericData::kDouble, 0.0 );
aDiscOffsetZ = nAttr.create( "discOffsetZ", "discOffsetZ", MFnNumericData::kDouble, 0.0 );
aDiscOffset = nAttr.create( "discOffset", "discOffset", aDiscOffsetX, aDiscOffsetY, aDiscOffsetZ );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscOffset ) );
CHECK_MSTATUS( attributeAffects( aDiscOffset, aOutput ) );
aDiscSizeX = nAttr.create( "discSizeX", "discSizeX", MFnNumericData::kDouble, 1.0 );
aDiscSizeY = nAttr.create( "discSizeY", "discSizeY", MFnNumericData::kDouble, 1.0 );
aDiscSizeZ = nAttr.create( "discSizeZ", "discSizeZ", MFnNumericData::kDouble, 1.0 );
aDiscSize = nAttr.create( "discSize", "discSize", aDiscSizeX, aDiscSizeY, aDiscSizeZ );
uAttr.setStorable( true );
uAttr.setChannelBox( true );
CHECK_MSTATUS( addAttribute( aDiscSize ) );
CHECK_MSTATUS( attributeAffects( aDiscSize, aOutput ) );
aDiscActiveColor = nAttr.createColor( "discActiveColor", "discActiveColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
CHECK_MSTATUS( addAttribute( aDiscActiveColor ) );
CHECK_MSTATUS( attributeAffects( aDiscActiveColor, aOutput ) );
aDiscLeadColor = nAttr.createColor( "discLeadColor", "discLeadColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.263f, 1.0f, .639f);
CHECK_MSTATUS( addAttribute( aDiscLeadColor ) );
CHECK_MSTATUS( attributeAffects( aDiscLeadColor, aOutput ) );
aDiscDefaultColor = nAttr.createColor( "discDefaultColor", "discDefaultColor" );
nAttr.setStorable( true );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.0f, .016f, .376f);
CHECK_MSTATUS( addAttribute( aDiscDefaultColor ) );
CHECK_MSTATUS( attributeAffects( aDiscDefaultColor, aOutput ) );
aDiscFillAlpha = nAttr.create( "discFillAlpha", "discFillAlpha", MFnNumericData::kFloat, 0.1f );
nAttr.setStorable( true );
nAttr.setMin( 0.0f );
nAttr.setMax( 1.0f );
CHECK_MSTATUS( addAttribute( aDiscFillAlpha ) );
CHECK_MSTATUS( attributeAffects( aDiscFillAlpha, aOutput ) );
aDiscLineAlpha = nAttr.create( "discLineAlpha", "discLineAlpha", MFnNumericData::kFloat, 1.0f );
nAttr.setStorable( true );
nAttr.setMin( 0.0f );
nAttr.setMax( 1.0f );
CHECK_MSTATUS( addAttribute( aDiscLineAlpha ) );
CHECK_MSTATUS( attributeAffects( aDiscLineAlpha, aOutput ) );
aArrow = cAttr.create( "arrow", "arrow" );
aInheritMatrix = nAttr.create( "inheritMatrix", "inheritMatrix", MFnNumericData::kBoolean, false );
aInputMesh = tAttr.create( "inputMesh", "inputMesh", MFnData::kMesh );
aAimMatrix = mAttr.create( "aimMatrix", "aimMatrix" );
aStartSize = nAttr.create( "startSize", "startSize", MFnNumericData::kFloat, 0.5f );
aSize = nAttr.create( "size", "size", MFnNumericData::kFloat, 1.0f );
aActiveColor = nAttr.createColor( "activeColor", "activeColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
aLeadColor = nAttr.createColor( "leadColor", "leadColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.263f, 1.0f, .639f);
aDefaultColor = nAttr.createColor( "defaultColor", "defaultColor" );
nAttr.setUsedAsColor(true);
nAttr.setDefault(.0f, .016f, .376f);
aFillAlpha = nAttr.create( "fillAlpha", "fillAlpha", MFnNumericData::kFloat, 0.1f );
aLineAlpha = nAttr.create( "lineAlpha", "lineAlpha", MFnNumericData::kFloat, 1.0f );
aOffsetX = nAttr.create( "offsetX", "offsetX", MFnNumericData::kDouble, 0.0 );
aOffsetY = nAttr.create( "offsetY", "offsetY", MFnNumericData::kDouble, 0.0 );
aOffsetZ = nAttr.create( "offsetZ", "offsetZ", MFnNumericData::kDouble, 0.0 );
aOffset = nAttr.create( "offset", "offset", aOffsetX, aOffsetY, aOffsetZ );
cAttr.addChild( aInheritMatrix );
cAttr.addChild( aAimMatrix );
cAttr.addChild( aInputMesh );
cAttr.addChild( aStartSize );
cAttr.addChild( aSize );
cAttr.addChild( aActiveColor );
cAttr.addChild( aLeadColor );
cAttr.addChild( aDefaultColor );
cAttr.addChild( aFillAlpha );
cAttr.addChild( aLineAlpha );
cAttr.addChild( aOffset );
cAttr.setArray( true );
cAttr.setStorable( true );
CHECK_MSTATUS( addAttribute( aArrow ) );
CHECK_MSTATUS( attributeAffects( aArrow, aOutput ) );
return MS::kSuccess;
}
MStatus woodTexNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
woodTurbulence=numAttr.create("Turbulence","tl",MFnNumericData::kFloat,5.0);
MAKE_INPUT(numAttr);
numAttr.setMin(0.0);
numAttr.setMax(200.0);
woodSize=numAttr.create("WoodSize","ws",MFnNumericData::kFloat,4.0);
MAKE_INPUT(numAttr);
numAttr.setMin(0.0);
numAttr.setMax(32.0);
woodHard=numAttr.create("Hard","hr",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
woodType=enumAttr.create("WoodType","wt",0);
enumAttr.addField("bands",0);
enumAttr.addField("rings",1);
MAKE_INPUT(enumAttr);
woodShape=enumAttr.create("WoodShape","wosh",0);
enumAttr.addField("sin",0);
enumAttr.addField("saw",1);
enumAttr.addField("tri",2);
NoiseType=enumAttr.create("NoiseType","noty",0);
enumAttr.addField("newperlin",0);
enumAttr.addField("stdperlin",1);
enumAttr.addField("voronoi_f1",2);
enumAttr.addField("voronoi_f2",3);
enumAttr.addField("voronoi_f3",4);
enumAttr.addField("voronoi_f4",5);
enumAttr.addField("voronoi_f2fl",6);
enumAttr.addField("voronoi_crackle",7);
enumAttr.addField("cellnoise",8);
MAKE_INPUT(enumAttr);
mappingMethod=enumAttr.create("MappingMethod","mame",0);
enumAttr.addField("uv",0);
enumAttr.addField("orco",1);
enumAttr.addField("global",2);
enumAttr.addField("window",3);
MAKE_INPUT(enumAttr);
texCo=enumAttr.create("TextureCoordinate","texco",0);
enumAttr.addField("plain",0);
enumAttr.addField("cube",1);
enumAttr.addField("tube",2);
enumAttr.addField("sphere",3);
MAKE_INPUT(enumAttr);
//*******************************layer texture attribute*********************************//
layerMix=enumAttr.create("MixMethod","mm1",0);
enumAttr.addField("mix",0);
enumAttr.addField("add",1);
enumAttr.addField("multiply",2);
enumAttr.addField("subtract",3);
enumAttr.addField("screen",4);
enumAttr.addField("divide",5);
enumAttr.addField("difference",6);
enumAttr.addField("darken",7);
enumAttr.addField("lighten",8);
MAKE_INPUT(enumAttr);
textureColor=numAttr.createColor("TextureColor","teco");
numAttr.setDefault(1.0,0.0,1.0);
MAKE_INPUT(numAttr);
texColorFact=numAttr.create("TextureColorWeight","tcw",MFnNumericData::kFloat,1.0);
numAttr.setMin(0.0);
numAttr.setMax(1.0);
MAKE_INPUT(numAttr);
defVal=numAttr.create("DefValue","dev",MFnNumericData::kFloat,1.0);
numAttr.setMin(0.0);
numAttr.setMax(1.0);
MAKE_INPUT(numAttr);
valFact=numAttr.create("ValueWeight","vaw",MFnNumericData::kFloat,1.0);
numAttr.setMin(0.0);
numAttr.setMax(1.0);
MAKE_INPUT(numAttr);
doColor=numAttr.create("DoColor","doco",MFnNumericData::kBoolean,true);
MAKE_INPUT(numAttr);
negative=numAttr.create("Negative","nega",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
noRGB=numAttr.create("NoRGB","nr",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
stencil=numAttr.create("Stencil","sten",MFnNumericData::kBoolean,false);
MAKE_INPUT(numAttr);
//*******************************layer texture attribute end*********************************//
MObject u=numAttr.create("uCoord","u",MFnNumericData::kFloat);
MObject v=numAttr.create("vCoord","v",MFnNumericData::kFloat);
UV=numAttr.create("uvCoord","uv",u,v);
MAKE_INPUT(numAttr);
MObject filterX=numAttr.create("uvFilterSizeX", "fsx", MFnNumericData::kFloat);
MObject filterY=numAttr.create( "uvFilterSizeY", "fsy", MFnNumericData::kFloat);
UVFilterSize=numAttr.create("uvFilterSize", "fs", filterX, filterY);
MAKE_INPUT(numAttr);
Output=numAttr.createColor("outColor","oc");
numAttr.setHidden(true);
MAKE_OUTPUT(numAttr);
addAttribute(woodTurbulence);
addAttribute(woodSize);
addAttribute(woodHard);
addAttribute(woodType);
addAttribute(woodShape);
addAttribute(NoiseType);
addAttribute(mappingMethod);
addAttribute(texCo);
addAttribute(layerMix);
addAttribute(textureColor);
addAttribute(texColorFact);
addAttribute(defVal);
addAttribute(valFact);
addAttribute(doColor);
addAttribute(negative);
addAttribute(noRGB);
addAttribute(stencil);
addAttribute(UV);
addAttribute(UVFilterSize);
addAttribute(Output);
attributeAffects(woodTurbulence,Output);
attributeAffects(woodSize,Output);
attributeAffects(woodHard,Output);
attributeAffects(woodType,Output);
attributeAffects(woodShape,Output);
attributeAffects(NoiseType,Output);
attributeAffects(mappingMethod,Output);
attributeAffects(texCo,Output);
attributeAffects(layerMix,Output);
attributeAffects(textureColor,Output);
attributeAffects(texColorFact,Output);
attributeAffects(defVal,Output);
attributeAffects(valFact,Output);
attributeAffects(doColor,Output);
attributeAffects(negative,Output);
attributeAffects(noRGB,Output);
attributeAffects(stencil,Output);
attributeAffects(UV,Output);
attributeAffects(UVFilterSize,Output);
return stat;
}
//
// 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;
}
//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;
}
// The initialize routine is called after the node has been created.
// It sets up the input and output attributes and adds them to the node.
// Finally the dependencies are arranged so that when the inputs
// change Maya knowns to call compute to recalculate the output values.
//
MStatus hwColorPerVertexShader::initialize()
{
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MStatus status;
// Create input attributes.
// All attributes are cached internal
//
aColorGain = nAttr.createColor( "colorGain", "cg", &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(true));
CHECK_MSTATUS( nAttr.setDefault(1.f, 1.f, 1.f));
nAttr.setCached( true );
nAttr.setInternal( true );
aTranspGain = nAttr.create("transparencyGain", "tg",
MFnNumericData::kFloat, 1.f, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(true));
CHECK_MSTATUS( nAttr.setDefault(1.f));
CHECK_MSTATUS( nAttr.setSoftMin(0.f));
CHECK_MSTATUS( nAttr.setSoftMax(2.f));
nAttr.setCached( true );
nAttr.setInternal( true );
aColorBias = nAttr.createColor( "colorBias", "cb", &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(true));
CHECK_MSTATUS( nAttr.setDefault(0.f, 0.f, 0.f));
nAttr.setCached( true );
nAttr.setInternal( true );
aTranspBias = nAttr.create( "transparencyBias", "tb",
MFnNumericData::kFloat, 0.f, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(true));
CHECK_MSTATUS( nAttr.setDefault(0.f));
CHECK_MSTATUS( nAttr.setSoftMin(-1.f));
CHECK_MSTATUS( nAttr.setSoftMax(1.f));
nAttr.setCached( true );
nAttr.setInternal( true );
aNormalsPerVertex = nAttr.create("normalsPerVertex", "nv",
MFnNumericData::kInt, 0, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(false));
CHECK_MSTATUS( nAttr.setDefault(0));
CHECK_MSTATUS( nAttr.setSoftMin(0));
CHECK_MSTATUS( nAttr.setSoftMax(3));
nAttr.setCached( true );
nAttr.setInternal( true );
aColorsPerVertex = nAttr.create("colorsPerVertex", "cv",
MFnNumericData::kInt, 0, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(false));
CHECK_MSTATUS( nAttr.setDefault(0));
CHECK_MSTATUS( nAttr.setSoftMin(0));
CHECK_MSTATUS( nAttr.setSoftMax(5));
nAttr.setCached( true );
nAttr.setInternal( true );
aColorSetName = tAttr.create("colorSetName", "cs",
MFnData::kString, MObject::kNullObj, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( tAttr.setStorable(true));
CHECK_MSTATUS( tAttr.setKeyable(false));
tAttr.setCached( true );
tAttr.setInternal( true );
aTexRotateX = nAttr.create( "texRotateX", "tx",
MFnNumericData::kFloat, 0.f, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(true));
CHECK_MSTATUS( nAttr.setDefault(0.f));
nAttr.setCached( true );
nAttr.setInternal( true );
aTexRotateY = nAttr.create( "texRotateY", "ty",
MFnNumericData::kFloat, 0.f, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(true));
CHECK_MSTATUS( nAttr.setDefault(0.f));
nAttr.setCached( true );
nAttr.setInternal( true );
aTexRotateZ = nAttr.create( "texRotateZ", "tz",
MFnNumericData::kFloat, 0.f, &status);
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setStorable(true));
CHECK_MSTATUS( nAttr.setKeyable(true));
CHECK_MSTATUS( nAttr.setDefault(0.f));
nAttr.setCached( true );
nAttr.setInternal( true );
// create output attributes here
// outColor is the only output attribute and it is inherited
// so we do not need to create or add it.
//
// Add the attributes here
CHECK_MSTATUS( addAttribute(aColorGain));
CHECK_MSTATUS( addAttribute(aTranspGain));
CHECK_MSTATUS( addAttribute(aColorBias));
CHECK_MSTATUS( addAttribute(aTranspBias));
CHECK_MSTATUS( addAttribute(aNormalsPerVertex));
CHECK_MSTATUS( addAttribute(aColorsPerVertex));
CHECK_MSTATUS( addAttribute(aColorSetName));
CHECK_MSTATUS( addAttribute(aTexRotateX));
CHECK_MSTATUS( addAttribute(aTexRotateY));
CHECK_MSTATUS( addAttribute(aTexRotateZ));
CHECK_MSTATUS( attributeAffects (aColorGain, outColor));
CHECK_MSTATUS( attributeAffects (aTranspGain, outColor));
CHECK_MSTATUS( attributeAffects (aColorBias, outColor));
CHECK_MSTATUS( attributeAffects (aTranspBias, outColor));
CHECK_MSTATUS( attributeAffects (aNormalsPerVertex, outColor));
CHECK_MSTATUS( attributeAffects (aColorsPerVertex, outColor));
CHECK_MSTATUS( attributeAffects (aColorSetName, outColor));
CHECK_MSTATUS( attributeAffects (aTexRotateX, outColor));
CHECK_MSTATUS( attributeAffects (aTexRotateY, outColor));
CHECK_MSTATUS( attributeAffects (aTexRotateZ, outColor));
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 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;
}
