// Initialize the plug-in. Called once when the plug-in is loaded.
// This mostly involve creating attributes.
MStatus hwRefractReflectShader_NV20::initialize()
{
MFnNumericAttribute nAttr;
MStatus status;
MFnTypedAttribute sAttr; // For string attributes
// Create input attributes
colorR = nAttr.create( "colorR", "cr",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
colorG = nAttr.create( "colorG", "cg",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
colorB = nAttr.create( "colorB", "cb",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
color = nAttr.create( "color", "c", colorR, colorG, colorB);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f, 0.5f, 0.5f);
nAttr.setUsedAsColor(true);
refractionIndex = nAttr.create( "refractionIndex", "ri", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setMin(1.0f);
nAttr.setMax(2.0f);
nAttr.setDefault(1.1f);
reflectivity = nAttr.create( "reflectivity", "rfl", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setMin(0.0f);
nAttr.setMax(1.0f);
nAttr.setDefault(0.5f);
// Add the attributes here
addAttribute(color);
addAttribute(refractionIndex);
addAttribute(reflectivity);
attributeAffects (colorR, outColor);
attributeAffects (colorG, outColor);
attributeAffects (colorB, outColor);
attributeAffects (color, outColor);
attributeAffects (refractionIndex, outColor);
attributeAffects (reflectivity, outColor);
return MS::kSuccess;
}
MStatus lambert::initialize()
{
MFnNumericAttribute nAttr;
MFnLightDataAttribute lAttr;
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:
//
// create - The create function creates a new attribute for the
// node, it takes a long name for the attribute, a short
// name for the attribute, the type of the attribute,
// and a status object to determine if the api call was
// successful.
//
// setKeyable - Sets whether this attribute should accept keyframe
// data, Attributes are not keyable by default.
//
// setStorable - Sets whether this attribute should be storable. If an
// attribute is storable, then it will be writen out
// when the node is stored to a file. Attributes are
// storable by default.
//
// setDefault - Sets the default value for this attribute.
//
// setUsedAsColor - Sets whether this attribute should be presented as
// a color in the UI.
//
// setHidden - Sets whether this attribute should be hidden from the
// UI. This is useful if the attribute is being used for
// blind data, or if it is being used as scratch space
// for a geometry calculation (should also be marked
// non-connectable in that case). Attributes are not
// hidden by default.
//
// setReadable - Sets whether this attribute should be readable. If an
// attribute is readable, then it can be used as the
// source in a dependency graph connection. Attributes
// are readable by default.
//
// setWritable - Sets whether this attribute should be readable. If an
// attribute is writable, then it can be used as the
// destination in a dependency graph connection. If an
// attribute is not writable then setAttr commands will
// fail to change the attribute. If both keyable and
// writable for an attribute are set to true it will be
// displayed in the channel box when the node is
// selected. Attributes are writable by default.
//
// setArray - Sets whether this attribute should have an array of
// data. This should be set to true if the attribute
// needs to accept multiple incoming connections.
// Attributes are single elements by default.
//
// 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 ) );
aColorR = nAttr.create( "colorR", "cr",MFnNumericData::kFloat, 0,
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f ) );
aColorG = nAttr.create( "colorG", "cg", MFnNumericData::kFloat, 0,
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.58824f ) );
aColorB = nAttr.create( "colorB", "cb",MFnNumericData::kFloat, 0,
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.644f ) );
aColor = nAttr.create( "color", "c", aColorR, aColorG, aColorB,
&status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.58824f, 0.644f ) );
CHECK_MSTATUS( nAttr.setUsedAsColor( true ) );
aIncandescenceR = nAttr.create( "incandescenceR", "ir",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f ) );
aIncandescenceG = nAttr.create( "incandescenceG", "ig",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f ) );
aIncandescenceB = nAttr.create( "incandescenceB", "ib",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status);
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f ) );
aIncandescence = nAttr.create( "incandescence", "ic", aIncandescenceR,
aIncandescenceG, aIncandescenceB, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.0f, 0.0f ) );
CHECK_MSTATUS( nAttr.setUsedAsColor( true ) );
aInTransR = nAttr.create( "transparencyR", "itr",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
aInTransG = nAttr.create( "transparencyG", "itg",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
aInTransB = nAttr.create( "transparencyB", "itb",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status);
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
aInTransparency = nAttr.create( "transparency", "it", aInTransR,
aInTransG, aInTransB, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setKeyable( true ) );
CHECK_MSTATUS( nAttr.setStorable( true ) );
CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.0f, 0.0f ) );
CHECK_MSTATUS( nAttr.setUsedAsColor( true ) );
// Output Attributes
//
// Color Output
//
aOutColorR = nAttr.create( "outColorR", "ocr", MFnNumericData::kFloat,
0, &status );
CHECK_MSTATUS( status );
aOutColorG = nAttr.create( "outColorG", "ocg", MFnNumericData::kFloat,
0, &status );
CHECK_MSTATUS( status );
aOutColorB = nAttr.create( "outColorB", "ocb", MFnNumericData::kFloat,
0, &status );
CHECK_MSTATUS( status );
aOutColor = nAttr.create( "outColor", "oc", aOutColorR, aOutColorG,
aOutColorB, &status );
CHECK_MSTATUS( status );
CHECK_MSTATUS( nAttr.setHidden( false ) );
CHECK_MSTATUS( nAttr.setReadable( true ) );
CHECK_MSTATUS( nAttr.setWritable( false ) );
// Transparency Output
//
aOutTransR = nAttr.create( "outTransparencyR", "otr",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
aOutTransG = nAttr.create( "outTransparencyG", "otg",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
aOutTransB = nAttr.create( "outTransparencyB", "otb",
MFnNumericData::kFloat, 0, &status );
CHECK_MSTATUS( status );
aOutTransparency = nAttr.create( "outTransparency", "ot",
aOutTransR,aOutTransG,aOutTransB, &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( aColorR, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aColorG, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aColorB, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aColor, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aInTransR, aOutTransparency ) );
CHECK_MSTATUS( attributeAffects( aInTransG, aOutTransparency ) );
CHECK_MSTATUS( attributeAffects( aInTransB, aOutTransparency ) );
CHECK_MSTATUS( attributeAffects( aInTransparency, aOutTransparency ) );
CHECK_MSTATUS( attributeAffects( aInTransparency, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aIncandescenceR, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aIncandescenceG, aOutColor ) );
CHECK_MSTATUS( attributeAffects( aIncandescenceB, 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 );
}
//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;
}
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;
}
bool
DXMAnchor::AddAnchor(MObject& site, const MString& longAnchorName, const MString& shortAnchorName, DXMAnchor* anchor)
{
DXCC_ASSERT( DXMAnchor::GetAnchor(site, shortAnchorName) == NULL );
DXCC_ASSERT(anchor != NULL);
DXCC_ASSERT(anchor->GetSite().isNull());
DXCC_ASSERT(anchor->GetPoint().length() == 0);
DXCC_ASSERT(longAnchorName.length() > 0);
DXCC_ASSERT(shortAnchorName.length() > 0);
DXCC_ASSERT(!site.isNull());
MFnDependencyNode depNode(site);
MString name= depNode.name();
#ifdef DEBUG
anchor->Name= name.asChar();
#endif
if( g_DebugBasic )
{
DXCC_DPFA_REPORT("%s", name.asChar());
}
//this attribute may exist if you had asked for this node to be duplicated or instanced :(
if( depNode.attribute( shortAnchorName ).isNull() )
{
MFnNumericAttribute numeric;
MObject anchorAttrib= numeric.create(longAnchorName, shortAnchorName, MFnNumericData::kInt, 0);
numeric.setReadable(false);
numeric.setWritable(false);
numeric.setConnectable(false);
numeric.setStorable(false);
numeric.setCached(true);
numeric.setArray(false);
numeric.setKeyable(false);
numeric.setHidden(true);
numeric.setUsedAsColor(false);
numeric.setIndeterminant(true);
numeric.setRenderSource(false);
numeric.setInternal(false);
DXCC_ASSERT(!anchorAttrib.isNull());
DXCHECK_MSTATUS( depNode.addAttribute(anchorAttrib) );
}
MPlug anchorPlug= depNode.findPlug( shortAnchorName );
DXCC_ASSERT(!anchorPlug.isNull());
anchorPlug.setValue( *reinterpret_cast<int*>(&anchor) );
anchor->AnchorSite= site;
anchor->AnchorPoint= shortAnchorName;
// anchor->NodeDestroyedCID= MNodeMessage::addNodeDestroyedCallback(site, DXMAnchor::DispatchNodeDestroyed, anchor);
// anchor->AboutToDeleteCID= MNodeMessage::addNodeAboutToDeleteCallback(site, DXMAnchor::DispatchAboutToDelete, anchor);
anchor->OnPostAddAnchor(longAnchorName, shortAnchorName);
return true;
}
MStatus uiDrawManager::initialize()
{
MStatus status;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
MFnTypedAttribute typedAttr;
// Add ui type attribute
aUIType = eAttr.create("uiType", "ut", uiDrawManager::kText);
eAttr.addField("text", uiDrawManager::kText);
eAttr.addField("line", uiDrawManager::kLine);
eAttr.addField("point", uiDrawManager::kPoint);
eAttr.addField("rect", uiDrawManager::kRect);
eAttr.addField("quad", uiDrawManager::kQuad);
eAttr.addField("sphere", uiDrawManager::kSphere);
eAttr.addField("circle", uiDrawManager::kCircle);
eAttr.addField("arc", uiDrawManager::kArc);
eAttr.addField("line list", uiDrawManager::kLineList);
eAttr.addField("line strip", uiDrawManager::kLineStrip);
eAttr.addField("point list", uiDrawManager::kPointList);
eAttr.addField("icon", uiDrawManager::kIcon);
eAttr.addField("cone", uiDrawManager::kCone);
eAttr.addField("box", uiDrawManager::kBox);
MPxNode::addAttribute(aUIType);
// Add color attribute
aPrimitiveColor = nAttr.create("primitiveColor", "pc", MFnNumericData::k3Float);
nAttr.setDefault(1.0f, 0.0f, 0.0f);
nAttr.setUsedAsColor(true);
MPxNode::addAttribute(aPrimitiveColor);
// Add transparency attribute
aPrimitiveTransparency = nAttr.create("primitiveTransparency", "pt", MFnNumericData::kFloat, 0.0);
nAttr.setSoftMin(0.0);
nAttr.setSoftMax(1.0);
MPxNode::addAttribute(aPrimitiveTransparency);
// add line width and line style attributes
aLineWidth = nAttr.create("lineWidth", "lw", MFnNumericData::kFloat, 2.0);
MPxNode::addAttribute(aLineWidth);
aLineStyle = eAttr.create("lineStyle", "ls", MUIDrawManager::kSolid);
eAttr.addField("solid", MUIDrawManager::kSolid);
eAttr.addField("shortdotted", MUIDrawManager::kShortDotted);
eAttr.addField("shortdashed", MUIDrawManager::kShortDashed);
eAttr.addField("dashed", MUIDrawManager::kDashed);
eAttr.addField("dotted", MUIDrawManager::kDotted);
MPxNode::addAttribute(aLineStyle);
// Add filled attribute
aIsFilled = nAttr.create("isFilled", "if", MFnNumericData::kBoolean, 0);
MPxNode::addAttribute(aIsFilled);
// Add shaded attribute
aShaded = nAttr.create("shaded", "sd", MFnNumericData::kBoolean, 0);
MPxNode::addAttribute(aShaded);
// Add radius attribute
aRadius = nAttr.create("radius", "ra", MFnNumericData::kDouble, 1.0);
MPxNode::addAttribute(aRadius);
// add 2D attributes
aDraw2D = nAttr.create("draw2D", "d2", MFnNumericData::kBoolean, 0);
MPxNode::addAttribute(aDraw2D);
aPosition = nAttr.create("position", "pos", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 0.0, 0.001);
MPxNode::addAttribute(aPosition);
// Add text attributes.
MFnStringData stringFn;
MObject defaultText = stringFn.create("uiDrawManager-Text");
aText = typedAttr.create("text", "t", MFnData::kString, defaultText);
MPxNode::addAttribute(aText);
aTextFontSize = nAttr.create("textFontSize", "tfs", MFnNumericData::kInt, MUIDrawManager::kDefaultFontSize);
nAttr.setMin(-1);
nAttr.setMax(99);
MPxNode::addAttribute(aTextFontSize);
unsigned int nFont = MUIDrawManager::getFontList(uiDrawManagerData::fFontList);
if (nFont == 0)
{
perror("No font available!");
}
aFontFaceName = eAttr.create("fontFaceName", "ffn", 0);
for (unsigned int i = 0; i < nFont; i++)
{
MString str = uiDrawManagerData::fFontList[i];
eAttr.addField(str, (short)i);
}
MPxNode::addAttribute(aFontFaceName);
aTextAlignment = eAttr.create("textAlignment", "ta", MUIDrawManager::kLeft);
eAttr.addField("left", MUIDrawManager::kLeft);
eAttr.addField("center", MUIDrawManager::kCenter);
eAttr.addField("right", MUIDrawManager::kRight);
MPxNode::addAttribute(aTextAlignment);
eTextIncline = eAttr.create("textIncline", "tic", MUIDrawManager::kInclineNormal);
eAttr.addField("normal", MUIDrawManager::kInclineNormal);
eAttr.addField("italic", MUIDrawManager::kInclineItalic);
MPxNode::addAttribute(eTextIncline);
aTextWeight = eAttr.create("textWeight", "tw", MUIDrawManager::kWeightBold);
eAttr.addField("light", MUIDrawManager::kWeightLight);
eAttr.addField("normal", MUIDrawManager::kWeightNormal);
eAttr.addField("demiBold", MUIDrawManager::kWeightDemiBold);
eAttr.addField("bold", MUIDrawManager::kWeightBold);
eAttr.addField("black", MUIDrawManager::kWeightBlack);
MPxNode::addAttribute(aTextWeight);
aTextStretch = nAttr.create("textStretch", "ts", MFnNumericData::kInt, MUIDrawManager::kStretchUnstretched);
nAttr.setMin(50);
nAttr.setMax(200);
MPxNode::addAttribute(aTextStretch);
aTextLine = eAttr.create("textLine", "tl", 0);
eAttr.addField("none", 0);
eAttr.addField("overline", MUIDrawManager::kLineOverline);
eAttr.addField("underline", MUIDrawManager::kLineUnderline);
eAttr.addField("strikeout", MUIDrawManager::kLineStrikeoutLine);
MPxNode::addAttribute(aTextLine);
aTextBoxSize = nAttr.create("textBoxSize", "tbs", MFnNumericData::k2Int);
nAttr.setDefault(0, 0);
MPxNode::addAttribute(aTextBoxSize);
aTextBoxColor = nAttr.create("textBoxColor", "tbc", MFnNumericData::k3Float);
nAttr.setDefault(0.0f, 1.0f, 1.0f);
nAttr.setUsedAsColor(true);
MPxNode::addAttribute(aTextBoxColor);
aTextBoxTransparency = nAttr.create("textBoxTransparency", "tbt", MFnNumericData::kFloat, 0.0);
nAttr.setSoftMin(0.0);
nAttr.setSoftMax(1.0);
MPxNode::addAttribute(aTextBoxTransparency);
// add point attributes
aPointSize = nAttr.create("pointSize", "ps", MFnNumericData::kFloat, 2.0);
MPxNode::addAttribute(aPointSize);
// add line attributes
aLineStartPoint = nAttr.create("lineStartPoint", "lsp", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 0.0, 0.0);
MPxNode::addAttribute(aLineStartPoint);
aLineEndPoint = nAttr.create("lineEndPoint", "lep", MFnNumericData::k3Double);
nAttr.setDefault(1.0, 1.0, 1.0);
MPxNode::addAttribute(aLineEndPoint);
// add rect attributes
aRectUp = nAttr.create("rectUp", "ru", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 1.0, 0.0);
MPxNode::addAttribute(aRectUp);
aRectNormal = nAttr.create("rectNormal", "rn", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 0.0, 1.0);
MPxNode::addAttribute(aRectNormal);
aRectScale = nAttr.create("rectScale", "rs", MFnNumericData::k2Double);
nAttr.setDefault(1.0, 1.0);
MPxNode::addAttribute(aRectScale);
// add quad attributes
double defaultPosition[4][3] =
{
{0.0, 0.0, 0.0},
{1.0, 0.0, 0.0},
{1.0, 1.0, 0.0},
{0.0, 1.0, 0.0}
};
for (int i = 0; i < 4; ++i)
{
MString fullName = "quadVertex";
MString shortName = "qv";
aQuadVertex[i] = nAttr.create(fullName + i, shortName + i, MFnNumericData::k3Double);
nAttr.setDefault(defaultPosition[i][0], defaultPosition[i][1], defaultPosition[i][2]);
MPxNode::addAttribute(aQuadVertex[i]);
}
// add circle attributes
aCircleNormal = nAttr.create("circleNormal", "cn", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 0.0, 1.0);
MPxNode::addAttribute(aCircleNormal);
// add arc attributes
aArcStart = nAttr.create("arcStartVector", "asv", MFnNumericData::k3Double);
nAttr.setDefault(1.0, 0.0, 0.0);
MPxNode::addAttribute(aArcStart);
aArcEnd = nAttr.create("arcEndVector", "aev", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 1.0, 0.0);
MPxNode::addAttribute(aArcEnd);
aArcNormal = nAttr.create("arcNormal", "an", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 0.0, 1.0);
MPxNode::addAttribute(aArcNormal);
// icon attributes
aIconName = eAttr.create("icon", "i", 0 );
unsigned int iconCount = MUIDrawManager::getIconNames(uiDrawManagerData::fIconList);
for (unsigned int i=0; i<iconCount; i++)
{
MString str = uiDrawManagerData::fIconList[i];
eAttr.addField(str, (short)i);
}
MPxNode::addAttribute(aIconName);
aIconScale = nAttr.create("iconScale", "cs", MFnNumericData::kFloat, 1.0);
MPxNode::addAttribute(aIconScale);
// cone attributes
aConeDirection = nAttr.create("coneDirection", "cd", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 0.0, 1.0);
MPxNode::addAttribute(aConeDirection);
aConeHeight = nAttr.create("coneHeight", "ch", MFnNumericData::kDouble);
nAttr.setDefault(1.0);
MPxNode::addAttribute(aConeHeight);
// box attributes
aBoxUp = nAttr.create("boxUp", "bu", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 0.0, 1.0);
MPxNode::addAttribute(aBoxUp);
aBoxRight = nAttr.create("boxRight", "br", MFnNumericData::k3Double);
nAttr.setDefault(0.0, 1.0, 0.0);
MPxNode::addAttribute(aBoxRight);
aBoxScale = nAttr.create("boxScale", "bs", MFnNumericData::k3Double);
nAttr.setDefault(1.0, 1.0, 1.0);
MPxNode::addAttribute(aBoxScale);
return MS::kSuccess;
}
MStatus hwUnlitShader::initialize()
{
MFnNumericAttribute nAttr;
MStatus status;
MFnTypedAttribute sAttr; // For string attributes
// Create COLOR input attributes
colorR = nAttr.create( "colorR", "cr",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
colorG = nAttr.create( "colorG", "cg",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
colorB = nAttr.create( "colorB", "cb",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
color = nAttr.create( "color", "c", colorR, colorG, colorB);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f, 0.5f, 0.5f); // ugly pink-salmon color. You can't miss it.
nAttr.setUsedAsColor(true);
// Create TRANSPARENCY input attributes
transparencyR = nAttr.create( "transparencyR", "itr",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
transparencyG = nAttr.create( "transparencyG", "itg",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
transparencyB = nAttr.create( "transparencyB", "itb",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
transparency = nAttr.create( "transparency", "it", transparencyR, transparencyG, transparencyB);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.0001f, 0.0001f, 0.0001f); // very light gray.
nAttr.setUsedAsColor(true);
// Add the attributes here
addAttribute(color);
addAttribute(transparency);
// create output attributes here
// outColor is the only output attribute and it is inherited
// so we do not need to create or add it.
//
return MS::kSuccess;
}
MStatus slopeShaderNode::initialize()
//
// Description:
// Initializes the attributes for this node.
//
{
MFnNumericAttribute nAttr;
MFnMatrixAttribute nMAttr;
MFnTypedAttribute nTAttr;
MFnGenericAttribute nGAttr;
// Input Attributes
//
aAngle = nAttr.create( "angle", "ang", MFnNumericData::kFloat);
nAttr.setDefault(30.0f);
nAttr.setMin(0.0f);
nAttr.setMax(100.0f);
nAttr.setKeyable(true);
nAttr.setStorable(true);
nAttr.setReadable(true);
nAttr.setWritable(true);
aColor1 = nAttr.createColor( "walkableColor", "w" );
nAttr.setDefault(0.0f, 1.0f, 0.0f);
nAttr.setKeyable(true);
nAttr.setStorable(true);
nAttr.setUsedAsColor(true);
nAttr.setReadable(true);
nAttr.setWritable(true);
aColor2 = nAttr.createColor( "nonWalkableColor", "nw" );
nAttr.setDefault(1.0f, 0.0f, 0.0f);
nAttr.setKeyable(true);
nAttr.setStorable(true);
nAttr.setUsedAsColor(true);
nAttr.setReadable(true);
nAttr.setWritable(true);
// Surface Normal supplied by the render sampler
//
aTriangleNormalCamera = nAttr.createPoint( "triangleNormalCamera", "n" );
nAttr.setStorable(false);
nAttr.setHidden(true);
nAttr.setReadable(true);
nAttr.setWritable(true);
//View matrix from the camera into world space
//
aMatrixEyeToWorld = nMAttr.create( "matrixEyeToWorld", "mew",
MFnMatrixAttribute::kFloat );
nAttr.setHidden(true);
nMAttr.setWritable(true);
// Output Attributes
//
aOutColor = nAttr.createColor( "outColor", "oc" );
nAttr.setStorable(false);
nAttr.setHidden(false);
nAttr.setReadable(true);
nAttr.setWritable(false);
//dummy plug for forcing evaluation
//
aDirtyShaderAttr = nGAttr.create( "dirtyShaderPlug", "dsp");
nGAttr.setArray(true);
nGAttr.setHidden(false);
nGAttr.setUsesArrayDataBuilder(true);
nGAttr.setReadable(false);
nGAttr.setStorable(true);
nGAttr.setIndexMatters(false);
nGAttr.addAccept(MFnData::kMesh);
//Add attribues
addAttribute(aAngle);
addAttribute(aColor1);
addAttribute(aColor2);
addAttribute(aTriangleNormalCamera);
addAttribute(aOutColor);
addAttribute(aMatrixEyeToWorld);
addAttribute(aDirtyShaderAttr);
attributeAffects (aAngle, aOutColor);
attributeAffects (aColor1, aOutColor);
attributeAffects (aColor2, aOutColor);
attributeAffects (aTriangleNormalCamera, aOutColor);
attributeAffects (aDirtyShaderAttr, aOutColor);
return MS::kSuccess;
}
//initialize
MStatus Ocio_log_convert::initialize()
{
//MFnSets
MFnEnumAttribute eAttr;
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
//a_verbose
a_verbose = eAttr.create("verbose", "verbose", 1);
eAttr.addField("no verbose", 0);
eAttr.addField("verbose", 1);
addAttribute(a_verbose);
//a_input_color
a_input_color = nAttr.createColor("input_color", "input_color");
nAttr.setUsedAsColor(true);
nAttr.setStorable(true);
addAttribute(a_input_color);
//a_output_color
a_output_color = nAttr.createColor("output_color", "output_color");
nAttr.setUsedAsColor(true);
nAttr.setStorable(false);
addAttribute(a_output_color);
//a_env_or_file
a_env_or_file = eAttr.create("env_or_file", "env_or_file", 0);
eAttr.addField("OCIO Environment Variable", 0);
eAttr.addField("Custom Path", 1);
eAttr.setStorable(true);
addAttribute(a_env_or_file);
//a_last_env_or_file
a_last_env_or_file = nAttr.create("last_env_or_file", "last_env_or_file", MFnNumericData::kInt, 0);
nAttr.setHidden(true);
nAttr.setStorable(true);
addAttribute(a_last_env_or_file);
//a_config_file_path
a_config_file_path = tAttr.create("config_file_path", "config_file_path", MFnData::kString);
tAttr.setUsedAsFilename(true);
tAttr.setStorable(true);
addAttribute(a_config_file_path);
//a_last_config_file_path
a_last_config_file_path = tAttr.create("last_config_file_path", "last_config_file_path", MFnData::kString);
tAttr.setHidden(true);
tAttr.setStorable(true);
addAttribute(a_last_config_file_path);
//a_operation
a_operation = eAttr.create("operation", "operation", 0);
eAttr.addField("Log to Lin", 0);
eAttr.addField("Lin to Log", 1);
addAttribute(a_operation);
//a_last_operation
a_last_operation = nAttr.create("last_operation", "last_operation", MFnNumericData::kInt, 0);
nAttr.setHidden(true);
nAttr.setStorable(true);
addAttribute(a_last_operation);
//Attribute affects
attributeAffects(a_input_color, a_output_color);
attributeAffects(a_env_or_file, a_output_color);
attributeAffects(a_config_file_path, a_output_color);
attributeAffects(a_operation, a_output_color);
return MStatus::kSuccess;
}
MStatus unCreateRibbonSystem::doIt( const MArgList& args )
{
bool create = true;
MSelectionList activeList;
MStatus stat = MGlobal::getActiveSelectionList(activeList);
if (MS::kSuccess != stat)
{
MessageBox(0,"please select one joint first!",0,0);
return MS::kFailure;
}
if(activeList.length() != 1)
{
MessageBox(0,"please select ONLY one joint!",0,0);
return MS::kFailure;
}
MItSelectionList iter(activeList);
MDagPath dagPath;
for ( ; !iter.isDone(); iter.next())
{
stat = iter.getDagPath(dagPath);
break;
}
if(!stat)
{
MessageBox(0,"can't getDagPath!",0,0);
return MS::kFailure;
}
if(!dagPath.hasFn(MFn::kJoint))
{
MessageBox(0,"muse select joint node!",0,0);
return MS::kFailure;
}
MFnIkJoint joint(dagPath);
if(args.length())
create = args.asBool(0);
if(!create)
{
if(!joint.hasAttribute("unRibbonEnabled"))
{
MessageBox(0,"no ribbon system exists!",0,0);
return MS::kFailure;
}
removeRibbonAttributes(joint);
return MS::kSuccess;
}
if(joint.hasAttribute("unRibbonEnabled"))
{
MessageBox(0,"ribbon system already exists!",0,0);
return MS::kSuccess;
}
if(joint.hasAttribute("unParticleEnabled"))
{
if(MessageBox(0,"will delete particle system and attach a ribbon system to the joint,continue?",0,MB_YESNO) == IDNO)return MS::kFailure;
removeParticleAttributes(joint);
}
MFnNumericAttribute attr;
unRibbonEnabled = attr.create("unRibbonEnabled","enabled",MFnNumericData::kBoolean,true);
attr.setStorable(true);
unRibbonVisible = attr.create("unRibbonVisible","visible",MFnNumericData::kBoolean,true);
attr.setStorable(true);
attr.setKeyable(true);
unRibbonAbove = attr.create("unRibbonAbove","above",MFnNumericData::kFloat,20.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(5000.0f);
attr.setKeyable(true);
unRibbonBelow = attr.create("unRibbonBelow","below",MFnNumericData::kFloat,20.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(5000.0f);
attr.setKeyable(true);
unRibbonEdgesPerSecond = attr.create("unRibbonEdgesPerSecond","EdgePerSec",MFnNumericData::kShort,10);
attr.setStorable(true);
attr.setMin(0);
attr.setMax(100);
unRibbonEdgeLife = attr.create("unRibbonEdgeLife","EdgeLife",MFnNumericData::kFloat,2.0f);
attr.setStorable(true);
attr.setMin(0.001f);
attr.setMax(100.0f);
unRibbonGravity = attr.create("unRibbonGravity","Gravity",MFnNumericData::kFloat,0.0f);
attr.setStorable(true);
attr.setMin(-1000.0f);
attr.setMax(1000.0f);
unRibbonTextureRows = attr.create("unRibbonTextureRows","TextureRows",MFnNumericData::kShort,1);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(16);
unRibbonTextureCols = attr.create("unRibbonTextureCols","TextureCols",MFnNumericData::kShort,1);
attr.setStorable(true);
attr.setMin(1);
attr.setMax(16);
unRibbonTextureSlot = attr.create("unRibbonTextureSlot","TextureSlot",MFnNumericData::kShort,0);
attr.setStorable(true);
attr.setMin(0);
attr.setMax(255);
attr.setKeyable(true);
unRibbonVertexColor = attr.create("unRibbonVertexColor","VertexColor",MFnNumericData::k3Float);
attr.setStorable(true);
attr.setDefault(1.0f,0.0f,0.0f);
attr.setUsedAsColor(true);
attr.setKeyable(true);
unRibbonVertexAlpha = attr.create("unRibbonVertexAlpha","VertexAlpha",MFnNumericData::kFloat,1.0f);
attr.setStorable(true);
attr.setMin(0.0f);
attr.setMax(1.0f);
attr.setKeyable(true);
MFnEnumAttribute eAttr;
unRibbonBlendMode = eAttr.create("unRibbonBlendMode","BlendMode",3);
eAttr.setStorable(true);
eAttr.addField("Opaque",0);
eAttr.addField("Transparent",1);
eAttr.addField("AlphaBlend",2);
eAttr.addField("Additive",3);
eAttr.addField("AdditiveAlpha",4);
eAttr.addField("Modulate",5);
{
MFnEnumAttribute eAttr;
unRibbonWanderMode = eAttr.create("unRibbonWanderMode","WanderMode",0);
eAttr.setStorable(true);
eAttr.addField("0",0);
eAttr.addField("1",1);
}
/*unRibbonBlendModeSrc = eAttr.create("unRibbonBlendModeSrc","BlendModeSrc",3);
eAttr.setStorable(true);
eAttr.addField("SBF_ONE",0);
eAttr.addField("SBF_ZERO",1);
eAttr.addField("SBF_DEST_COLOR",2);
eAttr.addField("SBF_SOURCE_COLOR",3);
eAttr.addField("SBF_ONE_MINUS_DEST_COLOR",4);
eAttr.addField("SBF_ONE_MINUS_SOURCE_COLOR",5);
eAttr.addField("SBF_DEST_ALPHA",6);
eAttr.addField("SBF_SOURCE_ALPHA",7);
eAttr.addField("SBF_ONE_MINUS_DEST_ALPHA",8);
eAttr.addField("SBF_ONE_MINUS_SOURCE_ALPHA",9);
unRibbonBlendModeDst = eAttr.create("unRibbonBlendModeDst","BlendModeDst",0);
eAttr.setStorable(true);
eAttr.addField("SBF_ONE",0);
eAttr.addField("SBF_ZERO",1);
eAttr.addField("SBF_DEST_COLOR",2);
eAttr.addField("SBF_SOURCE_COLOR",3);
eAttr.addField("SBF_ONE_MINUS_DEST_COLOR",4);
eAttr.addField("SBF_ONE_MINUS_SOURCE_COLOR",5);
eAttr.addField("SBF_DEST_ALPHA",6);
eAttr.addField("SBF_SOURCE_ALPHA",7);
eAttr.addField("SBF_ONE_MINUS_DEST_ALPHA",8);
eAttr.addField("SBF_ONE_MINUS_SOURCE_ALPHA",9);*/
unRibbonTextureFilename = attr.createColor("unRibbonTextureFilename","TextureFilename");
attr.setStorable(true);
addRibbonAttributes(joint);
return MS::kSuccess;
}
MStatus OnbShader::initialize()
{
MFnNumericAttribute nAttr;
MFnLightDataAttribute lAttr;
// Outputs
MObject outcR = nAttr.create("outColorR", "ocr", MFnNumericData::kFloat, 0.0);
MObject outcG = nAttr.create("outColorG", "ocg", MFnNumericData::kFloat, 0.0);
MObject outcB = nAttr.create("outColorB", "ocb", MFnNumericData::kFloat, 0.0);
aOutColor = nAttr.create("outColor", "oc", outcR, outcG, outcB);
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(nAttr.setUsedAsColor(true));
MObject outtR = nAttr.create("outTransparencyR", "otr", MFnNumericData::kFloat, 0.0);
MObject outtG = nAttr.create("outTransparencyG", "otg", MFnNumericData::kFloat, 0.0);
MObject outtB = nAttr.create("outTransparencyB", "otb", MFnNumericData::kFloat, 0.0);
aOutTransparency = nAttr.create("outTransparency", "ot", outtR, outtG, outtB);
MAKE_OUTPUT(nAttr);
CHECK_MSTATUS(nAttr.setUsedAsColor(true));
// Inputs
MObject cR = nAttr.create("colorR", "cr", MFnNumericData::kFloat, 0.5);
MObject cG = nAttr.create("colorG", "cg", MFnNumericData::kFloat, 0.5);
MObject cB = nAttr.create("colorB", "cb", MFnNumericData::kFloat, 0.5);
aColor = nAttr.create("color", "c", cR, cG, cB);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setUsedAsColor(true));
aRoughness = nAttr.create("roughness", "r", MFnNumericData::kFloat);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setMin(0.0f));
CHECK_MSTATUS(nAttr.setMax(1.0f));
CHECK_MSTATUS(nAttr.setDefault(0.3f));
MObject tR = nAttr.create("transparencyR", "itr", MFnNumericData::kFloat, 0.0);
MObject tG = nAttr.create("transparencyG", "itg", MFnNumericData::kFloat, 0.0);
MObject tB = nAttr.create("transparencyB", "itb", MFnNumericData::kFloat, 0.0);
aTransparency = nAttr.create("transparency", "it", tR, tG, tB);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setUsedAsColor(true));
MObject aR = nAttr.create("ambientColorR", "acr", MFnNumericData::kFloat, 0.0);
MObject aG = nAttr.create("ambientColorG", "acg", MFnNumericData::kFloat, 0.0);
MObject aB = nAttr.create("ambientColorB", "acb", MFnNumericData::kFloat, 0.0);
aAmbientColor = nAttr.create("ambientColor", "ambc", aR, aG, aB);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setUsedAsColor(true));
MObject iR = nAttr.create("incandescenceR", "ir", MFnNumericData::kFloat, 0.0);
MObject iG = nAttr.create("incandescenceG", "ig", MFnNumericData::kFloat, 0.0);
MObject iB = nAttr.create("incandescenceB", "ib", MFnNumericData::kFloat, 0.0);
aIncandescence = nAttr.create("incandescence", "ic", iR, iG, iB);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setUsedAsColor(true));
MObject sR = nAttr.create("specularColorR", "sr", MFnNumericData::kFloat, 1.0);
MObject sG = nAttr.create("specularColorG", "sg", MFnNumericData::kFloat, 1.0);
MObject sB = nAttr.create("specularColorB", "sb", MFnNumericData::kFloat, 1.0);
aSpecularColor = nAttr.create("specularColor", "sc", sR, sG, sB);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setUsedAsColor(true));
aEccentricity = nAttr.create("eccentricity", "ecc", MFnNumericData::kFloat);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setMin(0.0f));
CHECK_MSTATUS(nAttr.setMax(1.0f));
CHECK_MSTATUS(nAttr.setDefault(0.1f));
aSpecularRollOff = nAttr.create("specularRollOff", "sro", MFnNumericData::kFloat);
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setMin(0.0f));
CHECK_MSTATUS(nAttr.setMax(1.0f));
CHECK_MSTATUS(nAttr.setDefault(0.7f));
aNormalCamera = nAttr.createPoint("normalCamera", "n");
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setDefault(1.0f, 1.0f, 1.0f));
// Attributes for compute()
aRayDirection = nAttr.createPoint("rayDirection", "rd");
MAKE_INPUT(nAttr);
CHECK_MSTATUS(nAttr.setHidden(true));
aLightDirection = nAttr.createPoint("lightDirection", "ld");
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
CHECK_MSTATUS(nAttr.setDefault(1.0f, 1.0f, 1.0f));
aLightIntensity = nAttr.createColor("lightIntensity", "li");
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
CHECK_MSTATUS(nAttr.setDefault(1.0f, 1.0f, 1.0f));
aLightAmbient = nAttr.create("lightAmbient", "la", MFnNumericData::kBoolean);
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
aLightDiffuse = nAttr.create("lightDiffuse", "ldf", MFnNumericData::kBoolean);
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
aLightSpecular = nAttr.create("lightSpecular", "ls", MFnNumericData::kBoolean);
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
aLightShadowFraction = nAttr.create("lightShadowFraction", "lsf", MFnNumericData::kFloat);
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
aPreShadowIntensity = nAttr.create("preShadowIntensity", "psi", MFnNumericData::kFloat);
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
aLightBlindData = nAttr.createAddr("lightBlindData", "lbld");
CHECK_MSTATUS(nAttr.setStorable(false));
CHECK_MSTATUS(nAttr.setHidden(true));
CHECK_MSTATUS(nAttr.setReadable(true));
CHECK_MSTATUS(nAttr.setWritable(false));
aLightData = lAttr.create("lightDataArray", "ltd",
aLightDirection,
aLightIntensity,
aLightAmbient,
aLightDiffuse,
aLightSpecular,
aLightShadowFraction,
aPreShadowIntensity,
aLightBlindData);
CHECK_MSTATUS(lAttr.setArray(true));
CHECK_MSTATUS(lAttr.setStorable(false));
CHECK_MSTATUS(lAttr.setHidden(true));
CHECK_MSTATUS(lAttr.setDefault(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, true, false, 0.0f, 1.0f, NULL));
// Add Attributes
CHECK_MSTATUS(addAttribute(aOutColor));
CHECK_MSTATUS(addAttribute(aOutTransparency));
CHECK_MSTATUS(addAttribute(aColor));
CHECK_MSTATUS(addAttribute(aRoughness));
CHECK_MSTATUS(addAttribute(aTransparency));
CHECK_MSTATUS(addAttribute(aAmbientColor));
CHECK_MSTATUS(addAttribute(aIncandescence));
CHECK_MSTATUS(addAttribute(aSpecularColor));
CHECK_MSTATUS(addAttribute(aEccentricity));
CHECK_MSTATUS(addAttribute(aSpecularRollOff));
CHECK_MSTATUS(addAttribute(aNormalCamera));
CHECK_MSTATUS(addAttribute(aRayDirection));
CHECK_MSTATUS(addAttribute(aLightData));
// Attribute affects relationships
CHECK_MSTATUS(attributeAffects(aColor, aOutColor));
CHECK_MSTATUS(attributeAffects(aColor, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aRoughness, aOutColor));
CHECK_MSTATUS(attributeAffects(aRoughness, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aTransparency, aOutColor));
CHECK_MSTATUS(attributeAffects(aTransparency, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aAmbientColor, aOutColor));
CHECK_MSTATUS(attributeAffects(aAmbientColor, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aIncandescence, aOutColor));
CHECK_MSTATUS(attributeAffects(aIncandescence, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aSpecularColor, aOutColor));
CHECK_MSTATUS(attributeAffects(aSpecularColor, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aEccentricity, aOutColor));
CHECK_MSTATUS(attributeAffects(aEccentricity, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aNormalCamera, aOutColor));
CHECK_MSTATUS(attributeAffects(aNormalCamera, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aRayDirection, aOutColor));
CHECK_MSTATUS(attributeAffects(aRayDirection, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aSpecularRollOff, aOutColor));
CHECK_MSTATUS(attributeAffects(aSpecularRollOff, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightDirection, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightDirection, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightIntensity, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightIntensity, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightAmbient, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightAmbient, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightDiffuse, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightDiffuse, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightSpecular, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightSpecular, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightShadowFraction, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightShadowFraction, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aPreShadowIntensity, aOutColor));
CHECK_MSTATUS(attributeAffects(aPreShadowIntensity, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightBlindData, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightBlindData, aOutTransparency));
CHECK_MSTATUS(attributeAffects(aLightData, aOutColor));
CHECK_MSTATUS(attributeAffects(aLightData, aOutTransparency));
return MS::kSuccess;
}
//
// DESCRIPTION:
///////////////////////////////////////////////////////
MStatus InterpNode::initialize()
{
MFnNumericAttribute nAttr;
// Inputs and Attributes
//
// User defined attributes require a long-name and short-name that
// are required to be unique within the node.
// (See the compound attribute color1 named "Sides".)
//
// Rendering attributes that your node wants to get from the sampler
// require them to be defined given the pre-defined unique long-name.
// (See the compound attribute aNormalCamera named "normalCamera".)
//
// User defined Attributes are generally something that you want
// to store in the Maya file. The setStorable(true) method enables
// an attribute to be stored into the Maya scene file.
//
// Rendering attributes are primarily data that is generated per sample and
// not something that you want to store in a file. To disable an
// attribute from being recorded to the Maya scene file use
// the setStorable(false) method.
//
// Simple attributes that represent a range of values can enable a
// slider on the Attribute Editor by using the methods setMin() and
// setMax().
// (See the simple attribute InputValue named "Power".)
//
// Compound attributes that represent a vector of 3 floats can enable
// a color swatch on the Attribute Editor that will launch a color picker
// tool by using the method setUsedAsColor(true).
// (See the compound attribute color1 name "Sides".)
//
// Both Simple and Compound attributes can be initialized with a
// default value using the method setDefault().
//
// Attributes by default show up in the Attribute Editor and
// in the Connection Editor unless they are specified as being hidden
// by using the method setHidden(true).
//
// Attributes by default have both read/write access in the dependency graph.
// To change an attributes behaviour you can use the methods
// setReadable() and setWritable(). The method setReadable(true)
// indicates that the attribute can be used as the source in
// a dependency graph connection. The method setWritable(true)
// indicates that the attribute can be used as the destination
// in a dependency graph connection.
// (See the compound attribute aOutColor named "outColor" below.
// It has been marked as a read-only attribute since it is
// the computed result of the node, it is not stored in the Maya file since
// it is always computed, and it is marked as hidden to prevent it
// from being displayed in the user interface.)
//
//
// User defined input value
aInputValue = nAttr.create( "power", "pow", MFnNumericData::kFloat);
CHECK_MSTATUS ( nAttr.setDefault(1.0f) );
CHECK_MSTATUS ( nAttr.setMin(0.0f) );
CHECK_MSTATUS ( nAttr.setMax(3.0f) );
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(true) );
// User defined color attribute
aColor1 = nAttr.createColor( "sideColor", "sc");
CHECK_MSTATUS ( nAttr.setDefault(1.0f, 1.0f, 1.0f) );
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setUsedAsColor(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(true) );
aColor2 = nAttr.createColor( "facingColor", "fc");
CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.0f, 0.0f) );
CHECK_MSTATUS ( nAttr.setKeyable(true) );
CHECK_MSTATUS ( nAttr.setStorable(true) );
CHECK_MSTATUS ( nAttr.setUsedAsColor(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(true) );
// Surface Normal supplied by the render sampler
aNormalCamera = nAttr.createPoint( "normalCamera", "n");
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(true) );
// Point on surface in camera space, will be used to compute view vector
aPointCamera = nAttr.createPoint( "pointCamera", "p");
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(true) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(true) );
// Outputs
//
// Always set your output attributes to be read-only
// You should also mark any internal attributes that your node
// computes to be read-only also, this will prevent any connections.
aOutColor = nAttr.createColor( "outColor", "oc" );
CHECK_MSTATUS ( nAttr.setStorable(false) );
CHECK_MSTATUS ( nAttr.setHidden(false) );
CHECK_MSTATUS ( nAttr.setReadable(true) );
CHECK_MSTATUS ( nAttr.setWritable(false) );
CHECK_MSTATUS ( addAttribute(aInputValue) );
CHECK_MSTATUS ( addAttribute(aColor1) );
CHECK_MSTATUS ( addAttribute(aColor2) );
CHECK_MSTATUS ( addAttribute(aNormalCamera) );
CHECK_MSTATUS ( addAttribute(aPointCamera) );
CHECK_MSTATUS ( addAttribute(aOutColor) );
CHECK_MSTATUS ( attributeAffects (aInputValue, aOutColor) );
CHECK_MSTATUS ( attributeAffects (aColor1, aOutColor) );
CHECK_MSTATUS ( attributeAffects (aColor2, aOutColor) );
CHECK_MSTATUS ( attributeAffects (aNormalCamera, aOutColor) );
CHECK_MSTATUS ( attributeAffects (aPointCamera, aOutColor) );
return MS::kSuccess;
}
// Initialize the plug-in. Called once when the plug-in is loaded.
// This mostly involve creating attributes.
MStatus hwDecalBumpShader_NV20::initialize()
{
MFnNumericAttribute nAttr;
MStatus status;
MFnTypedAttribute sAttr; // For string attributes
// Create input attributes
colorR = nAttr.create( "colorR", "cr",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
colorG = nAttr.create( "colorG", "cg",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
colorB = nAttr.create( "colorB", "cb",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
color = nAttr.create( "color", "c", colorR, colorG, colorB);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f, 0.5f, 0.5f);
nAttr.setUsedAsColor(true);
bumpR = nAttr.create( "bumpR", "c2r",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
bumpG = nAttr.create( "bumpG", "c2g",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
bumpB = nAttr.create( "bumpB", "c2b",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
bump = nAttr.create( "bump", "c2", bumpR, bumpG, bumpB);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
nAttr.setUsedAsColor(true);
uCoord = nAttr.create( "uCoord", "u", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
vCoord = nAttr.create( "vCoord", "v", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
uvCoord = nAttr.create( "uvCoord","uv", uCoord, vCoord);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f, 0.5f );
nAttr.setHidden(true);
uBias = nAttr.create( "uBias", "bu", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setMin(0.0f);
nAttr.setMax(1.0f);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f);
vBias = nAttr.create( "vBias", "bv", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setMin(0.0f);
nAttr.setMax(1.0f);
nAttr.setDefault(0.5f);
uvFilterSizeX = nAttr.create( "uvFilterSizeX", "fsx", MFnNumericData::kFloat);
nAttr.setStorable(false);
nAttr.setReadable(true);
nAttr.setWritable(true);
nAttr.setHidden(true);
uvFilterSizeY = nAttr.create( "uvFilterSizeY", "fsy", MFnNumericData::kFloat);
nAttr.setStorable(false);
nAttr.setReadable(true);
nAttr.setWritable(true);
nAttr.setHidden(true);
uvFilterSize = nAttr.create("uvFilterSize","fs",uvFilterSizeX,uvFilterSizeY);
nAttr.setStorable(false);
nAttr.setReadable(true);
nAttr.setWritable(true);
nAttr.setHidden(true);
lightX = nAttr.create( "lightX", "lgtx",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.0f);
lightY = nAttr.create( "lightY", "lgty",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
lightZ = nAttr.create( "lightZ", "lgtz",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
light = nAttr.create( "light", "lgt", lightX, lightY, lightZ);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.0f, 1.0f, 1.0f);
cameraX = nAttr.create( "cameraX", "camx",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.0f);
cameraY = nAttr.create( "cameraY", "camy",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.0f);
cameraZ = nAttr.create( "cameraZ", "camz",MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
camera = nAttr.create( "camera", "cam", cameraX, cameraY, cameraZ);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.0f, 0.0f, 1.0f);
shininess = nAttr.create( "shininess", "sn", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setMin(0.0f);
nAttr.setMax(1.0f);
nAttr.setDefault(0.5f);
lightColorR = nAttr.create( "lightColorR", "lcr", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
lightColorG = nAttr.create( "lightColorG", "lcg", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
lightColorB = nAttr.create( "lightColorB", "lcb", MFnNumericData::kFloat);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f);
lightColor = nAttr.create( "lightColor", "lc", lightColorR, lightColorG, lightColorB);
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.0f, 1.0f, 1.0f);
nAttr.setUsedAsColor(true);
// create output attributes here
// outColor is the only output attribute and it is inherited
// so we do not need to create or add it.
//
// Add the attributes here
addAttribute(color);
addAttribute(bump);
addAttribute(uvCoord);
addAttribute(uBias);
addAttribute(vBias);
addAttribute(uvFilterSize);
addAttribute(light);
addAttribute(camera);
addAttribute(shininess);
addAttribute(lightColor);
attributeAffects (colorR, outColor);
attributeAffects (colorG, outColor);
attributeAffects (colorB, outColor);
attributeAffects (color, outColor);
attributeAffects (bumpR, outColor);
attributeAffects (bumpG, outColor);
attributeAffects (bumpB, outColor);
attributeAffects (bump, outColor);
attributeAffects (uCoord, outColor);
attributeAffects (vCoord, outColor);
attributeAffects (uvCoord, outColor);
attributeAffects (uBias, outColor);
attributeAffects (vBias, outColor);
attributeAffects (lightX, outColor);
attributeAffects (lightY, outColor);
attributeAffects (lightZ, outColor);
attributeAffects (light, outColor);
attributeAffects (cameraX, outColor);
attributeAffects (cameraY, outColor);
attributeAffects (cameraZ, outColor);
attributeAffects (camera, outColor);
attributeAffects (shininess, outColor);
attributeAffects (lightColorR, outColor);
attributeAffects (lightColorG, outColor);
attributeAffects (lightColorB, outColor);
attributeAffects (lightColor, outColor);
return MS::kSuccess;
}
