MStatus
OpenSubdivShader::initialize()
{
MStatus stat;
MFnTypedAttribute typedAttr;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 1);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setSoftMax(5);
aScheme = enumAttr.create("scheme", "sc");
enumAttr.addField("Catmull-Clark", kCatmark);
enumAttr.addField("Loop", kLoop);
enumAttr.addField("Bilinear", kBilinear);
enumAttr.setInternal(true);
aKernel = enumAttr.create("kernel", "kn");
enumAttr.addField("CPU", OpenSubdiv::OsdKernelDispatcher::kCPU);
if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kOPENMP))
enumAttr.addField("OpenMP", OpenSubdiv::OsdKernelDispatcher::kOPENMP);
if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kCL))
enumAttr.addField("CL", OpenSubdiv::OsdKernelDispatcher::kCL);
if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kCUDA))
enumAttr.addField("CUDA", OpenSubdiv::OsdKernelDispatcher::kCUDA);
enumAttr.setInternal(true);
aDiffuse = numAttr.createColor("diffuse", "d");
numAttr.setDefault(1.0f, 1.0f, 1.0f);
aSpecular = numAttr.createColor("specular", "s");
numAttr.setDefault(1.0f, 1.0f, 1.0f);
aAmbient = numAttr.createColor("ambient", "a");
numAttr.setDefault(1.0f, 1.0f, 1.0f);
aShininess = numAttr.create("shininess", "shin", MFnNumericData::kFloat, 16.0f);
numAttr.setMin(0);
numAttr.setMax(128.0f);
aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean);
addAttribute(aLevel);
addAttribute(aScheme);
addAttribute(aKernel);
addAttribute(aDiffuse);
addAttribute(aSpecular);
addAttribute(aAmbient);
addAttribute(aShininess);
addAttribute(aWireframe);
return MS::kSuccess;
}
MStatus
OpenSubdivPtexShader::initialize()
{
MFnTypedAttribute typedAttr;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
// level
aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 3);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setSoftMax(5);
numAttr.setMax(10);
// tessFactor
aTessFactor = numAttr.create("tessFactor", "tessf", MFnNumericData::kLong, 2);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setMax(10);
// scheme
aScheme = enumAttr.create("scheme", "sc", OsdPtexMeshData::kCatmark);
enumAttr.addField("Catmull-Clark", OsdPtexMeshData::kCatmark);
enumAttr.addField("Loop", OsdPtexMeshData::kLoop);
enumAttr.addField("Bilinear", OsdPtexMeshData::kBilinear);
enumAttr.setInternal(true);
// kernel
aKernel = enumAttr.create("kernel", "kn", OsdPtexMeshData::kCPU);
enumAttr.addField("CPU", OsdPtexMeshData::kCPU);
#ifdef OPENSUBDIV_HAS_OPENMP
enumAttr.addField("OpenMP", OsdPtexMeshData::kOPENMP);
#endif
#ifdef OPENSUBDIV_HAS_OPENCL
enumAttr.addField("CL", OsdPtexMeshData::kCL);
#endif
#ifdef OPENSUBDIV_HAS_CUDA
enumAttr.addField("CUDA", OsdPtexMeshData::kCUDA);
#endif
enumAttr.setInternal(true);
// interpolateBoundary
aInterpolateBoundary = enumAttr.create("interpolateBoundary", "ib",
OsdPtexMeshData::kInterpolateBoundaryNone);
enumAttr.addField("None", OsdPtexMeshData::kInterpolateBoundaryNone);
enumAttr.addField("Edge Only", OsdPtexMeshData::kInterpolateBoundaryEdgeOnly);
enumAttr.addField("Edge and Corner", OsdPtexMeshData::kInterpolateBoundaryEdgeAndCorner);
enumAttr.addField("Always Sharp", OsdPtexMeshData::kInterpolateBoundaryAlwaysSharp);
enumAttr.setInternal(true);
// adaptive
aAdaptive = numAttr.create("adaptive", "adp", MFnNumericData::kBoolean, true);
numAttr.setInternal(true);
// wireframe
aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean, false);
// material attributes
aDiffuse = numAttr.createColor("diffuse", "d");
numAttr.setDefault(0.6f, 0.6f, 0.7f);
aAmbient = numAttr.createColor("ambient", "a");
numAttr.setDefault(0.1f, 0.1f, 0.1f);
aSpecular = numAttr.createColor("specular", "s");
numAttr.setDefault(0.3f, 0.3f, 0.3f);
// Ptex Texture Attributes
//
// diffuseEnvironmentMapFile;
aDiffuseEnvironmentMapFile = typedAttr.create("diffuseEnvironmentMap", "difenv", MFnData::kString);
typedAttr.setInternal(true);
// don't let maya hold on to string when fileNode is disconnected
typedAttr.setDisconnectBehavior(MFnAttribute::kReset);
// specularEnvironmentMapFile;
aSpecularEnvironmentMapFile = typedAttr.create("specularEnvironmentMap", "specenv", MFnData::kString);
typedAttr.setInternal(true);
// don't let maya hold on to string when fileNode is disconnected
typedAttr.setDisconnectBehavior(MFnAttribute::kReset);
// colorFile;
aColorFile = typedAttr.create("colorFile", "cf", MFnData::kString);
typedAttr.setInternal(true);
// displacementFile;
aDisplacementFile = typedAttr.create("displacementFile", "df", MFnData::kString);
typedAttr.setInternal(true);
// occlusionFile;
aOcclusionFile = typedAttr.create("occlusionFile", "of", MFnData::kString);
typedAttr.setInternal(true);
// enableDisplacement;
aEnableDisplacement = numAttr.create("enableDisplacement", "end", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableColor;
aEnableColor = numAttr.create("enableColor", "enc", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableOcclusion;
aEnableOcclusion = numAttr.create("enableOcclusion", "eno", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// enableNormal;
aEnableNormal = numAttr.create("enableNormal", "enn", MFnNumericData::kBoolean, 1);
numAttr.setInternal(true);
// fresnelBias;
aFresnelBias = numAttr.create("fresnelBias", "fb", MFnNumericData::kFloat, 0.2f);
numAttr.setMin(0);
numAttr.setMax(1);
// fresnelScale;
aFresnelScale = numAttr.create("fresnelScale", "fs", MFnNumericData::kFloat, 1.0f);
numAttr.setMin(0);
numAttr.setSoftMax(1);
// fresnelPower;
aFresnelPower = numAttr.create("fresnelPower", "fp", MFnNumericData::kFloat, 5.0f);
numAttr.setMin(0);
numAttr.setSoftMax(10);
// shaderSource;
aShaderSource = typedAttr.create("shaderSource", "ssrc", MFnData::kString);
typedAttr.setInternal(true);
// add attributes
addAttribute(aLevel);
addAttribute(aTessFactor);
addAttribute(aScheme);
addAttribute(aKernel);
addAttribute(aInterpolateBoundary);
addAttribute(aAdaptive);
addAttribute(aWireframe);
addAttribute(aDiffuse);
addAttribute(aAmbient);
addAttribute(aSpecular);
addAttribute(aShaderSource);
addAttribute(aDiffuseEnvironmentMapFile);
addAttribute(aSpecularEnvironmentMapFile);
addAttribute(aColorFile);
addAttribute(aDisplacementFile);
addAttribute(aOcclusionFile);
addAttribute(aEnableDisplacement);
addAttribute(aEnableColor);
addAttribute(aEnableOcclusion);
addAttribute(aEnableNormal);
addAttribute(aFresnelBias);
addAttribute(aFresnelScale);
addAttribute(aFresnelPower);
return MS::kSuccess;
}
MStatus wingVizNode::initialize()
{
MStatus stat;
MFnNumericAttribute numAttr;
MFnTypedAttribute meshAttr;
awidth0 = numAttr.create( "width0", "w0", MFnNumericData::kFloat, 0.5 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( awidth0 );
awidth1 = numAttr.create( "width1", "w1", MFnNumericData::kFloat, 0.2 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( awidth1 );
aedge0 = numAttr.create( "edge0", "e0", MFnNumericData::kFloat, 0.9 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( aedge0 );
aedge1 = numAttr.create( "edge1", "e1", MFnNumericData::kFloat, 0.2 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( aedge1 );
atwist0 = numAttr.create( "twist0", "tw0", MFnNumericData::kFloat, 0.0 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( atwist0 );
atwist1 = numAttr.create( "twist1", "tw1", MFnNumericData::kFloat, 60.0 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( atwist1 );
areverse = numAttr.create( "reverse", "re", MFnNumericData::kInt, 0 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( areverse );
astep = numAttr.create( "step", "st", MFnNumericData::kInt, 4 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
numAttr.setMin(1);
addAttribute( astep );
ashaft0 = numAttr.create( "shaftWidth0", "shw0", MFnNumericData::kFloat, 0.25 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( ashaft0 );
ashaft1 = numAttr.create( "shaftWidth1", "shw1", MFnNumericData::kFloat, 0.20 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( ashaft1 );
aminframe = numAttr.create( "startFrame", "sf", MFnNumericData::kInt, 1 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( aminframe );
amaxframe = numAttr.create( "saveCache", "saveCache", MFnNumericData::kInt, 0 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( amaxframe );
aratio = numAttr.create( "scale", "sc", MFnNumericData::kFloat, 1.0 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
numAttr.setMin(0.01f);
numAttr.setInternal(true);
addAttribute( aratio );
awind = numAttr.create( "wind", "wnd", MFnNumericData::kFloat, 1.0 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
numAttr.setMin(0.01f);
numAttr.setInternal(true);
addAttribute( awind );
aoutval = numAttr.create( "outval", "ov", MFnNumericData::kInt, 1 );
numAttr.setStorable(false);
numAttr.setWritable(false);
numAttr.setKeyable(false);
addAttribute( aoutval );
MFnTypedAttribute stringAttr;
acachename = stringAttr.create( "cachePath", "cp", MFnData::kString );
stringAttr.setStorable(true);
stringAttr.setInternal(true);
addAttribute( acachename );
zCheckStatus(zWorks::createTypedAttr(agrowth, MString("growMesh"), MString("gm"), MFnData::kNurbsSurface ), "ERROR creating grow mesh");
zCheckStatus(addAttribute(agrowth), "ERROR adding ing base");
zCheckStatus(zWorks::createTypedAttr(acollision, MString("collideMesh"), MString("cm"), MFnData::kMesh), "ERROR creating collide mesh");
zCheckStatus(addAttribute(acollision), "ERROR adding collide mesh");
zCheckStatus(zWorks::createTimeAttr(atime, MString("currentTime"), MString("ct"), 1.0), "ERROR creating time");
zCheckStatus(addAttribute(atime), "ERROR adding time");
zCheckStatus(zWorks::createTypedAttr(outMesh, MString("outMesh"), MString("om"), MFnData::kMesh), "ERROR creating out mesh");
zCheckStatus(addAttribute(outMesh), "ERROR adding out mesh");
aouttexcoordoffsetpp = meshAttr.create( "outTexcoordOffset", "oto", MFnData::kDoubleArray );
meshAttr.setStorable(false);
meshAttr.setWritable(false);
addAttribute( aouttexcoordoffsetpp );
anoisize = numAttr.create( "noiseSize", "nsz", MFnNumericData::kFloat, 1.0 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
addAttribute( anoisize );
anoifreq = numAttr.create( "noiseFrequency", "nfq", MFnNumericData::kFloat, 8.0 );
numAttr.setStorable(true);
numAttr.setMin(0.01);
numAttr.setKeyable(true);
addAttribute( anoifreq );
anoiseed = numAttr.create( "noiseSeed", "nsd", MFnNumericData::kInt, 19 );
numAttr.setStorable(true);
numAttr.setKeyable(true);
numAttr.setMin(10);
addAttribute( anoiseed );
attributeAffects( areverse, aoutval );
attributeAffects( awidth0, aoutval );
attributeAffects( awidth1, aoutval );
attributeAffects( aedge0, aoutval );
attributeAffects( aedge1, aoutval );
attributeAffects( atwist0, aoutval );
attributeAffects( atwist1, aoutval );
attributeAffects( ashaft0, aoutval );
attributeAffects( ashaft1, aoutval );
attributeAffects( atime, aoutval );
attributeAffects( aratio, aoutval );
attributeAffects( agrowth, aoutval );
attributeAffects( acollision, aoutval );
attributeAffects( astep, aoutval );
attributeAffects( areverse, outMesh );
attributeAffects( awidth0, outMesh );
attributeAffects( awidth1, outMesh );
attributeAffects( aedge0, outMesh );
attributeAffects( aedge1, outMesh );
attributeAffects( atwist0, outMesh );
attributeAffects( atwist1, outMesh );
attributeAffects( ashaft0, outMesh );
attributeAffects( ashaft1, outMesh );
attributeAffects( atime, outMesh );
attributeAffects( aratio, outMesh );
attributeAffects( agrowth, outMesh );
attributeAffects( acollision, outMesh );
attributeAffects( astep, outMesh );
attributeAffects( anoisize, outMesh );
attributeAffects( anoifreq, outMesh );
attributeAffects( anoiseed, outMesh );
attributeAffects( areverse, aouttexcoordoffsetpp );
attributeAffects( agrowth, aouttexcoordoffsetpp );
attributeAffects( astep, aouttexcoordoffsetpp );
return MS::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 BPT_InsertVtx::initialize()
//----------------------------------------------------------------------------
{
MFnEnumAttribute FnEnumAttr;
MFnTypedAttribute FnTypedAttr;
MFnNumericAttribute FnFloatAttr;
MStatus status;
IVinMesh = FnTypedAttr.create("inMesh","in",MFnData::kMesh);
FnTypedAttr.setStorable(true);
//FnTypedAttr.setCached(false);
FnTypedAttr.setInternal(true);
IVoutMesh = FnTypedAttr.create("outMesh","out",MFnData::kMesh);
FnTypedAttr.setStorable(true);
FnTypedAttr.setWritable(false);
IVcount = FnFloatAttr.create("count","c",MFnNumericData::kLong);
FnFloatAttr.setStorable(true);
FnFloatAttr.setInternal(true);
FnFloatAttr.setKeyable(true);
FnFloatAttr.setMin(1);
FnFloatAttr.setSoftMax(15);
IVselEdgeIDs = FnTypedAttr.create("edgeIDs","eID",MFnData::kIntArray);
FnTypedAttr.setStorable(true);
FnTypedAttr.setHidden(true);
FnTypedAttr.setConnectable(false);
IVselVertIDs = FnTypedAttr.create("vertIDs","vID",MFnData::kIntArray);
FnTypedAttr.setStorable(true);
FnTypedAttr.setHidden(true);
FnTypedAttr.setConnectable(false);
IVoptions = FnTypedAttr.create("options","op",MFnData::kIntArray);
FnTypedAttr.setStorable(true);
FnTypedAttr.setHidden(true);
FnTypedAttr.setConnectable(false);
IVslide = FnFloatAttr.create("slide","sl",MFnNumericData::kDouble);
FnFloatAttr.setStorable(true);
FnFloatAttr.setInternal(true);
// FnFloatAttr.setMin(0.0);
// FnFloatAttr.setMax(1.0);
FnFloatAttr.setKeyable(true);
IVnormal = FnFloatAttr.create("alongNormal","an",MFnNumericData::kDouble);
FnFloatAttr.setStorable(true);
FnFloatAttr.setDefault(0.0);
FnFloatAttr.setKeyable(true);
IVslideRelative = FnFloatAttr.create("slideRelative","sr",MFnNumericData::kLong);
FnFloatAttr.setStorable(true);
FnFloatAttr.setMin(0.0);
FnFloatAttr.setMax(1.0);
FnFloatAttr.setKeyable(true);
IVnormalRelative = FnFloatAttr.create("normalRelative","nr",MFnNumericData::kLong);
FnFloatAttr.setStorable(true);
FnFloatAttr.setMin(0.0);
FnFloatAttr.setMax(1.0);
FnFloatAttr.setKeyable(true);
IVwhichSide = FnFloatAttr.create("side","si",MFnNumericData::kLong);
FnFloatAttr.setStorable(true);
FnFloatAttr.setMin(0.0);
FnFloatAttr.setMax(1.0);
FnFloatAttr.setKeyable(true);
IVSlideLimited = FnFloatAttr.create("slideLimited","sll",MFnNumericData::kLong);
FnFloatAttr.setStorable(true);
FnFloatAttr.setMin(0.0);
FnFloatAttr.setMax(1.0);
FnFloatAttr.setKeyable(false);
IVspin = FnFloatAttr.create("spin","sp",MFnNumericData::kLong);
FnFloatAttr.setStorable(true);
FnFloatAttr.setMin(0.0);
FnFloatAttr.setKeyable(true);
FnFloatAttr.setInternal(true);
// Add attributes
status = addAttribute(IVslideRelative);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVnormalRelative);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVwhichSide);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVnormal);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVslide);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVSlideLimited);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVoptions);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVspin);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVcount);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVselEdgeIDs);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVselVertIDs);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVoutMesh);
MCheckStatus(status, "AddAttrIVNode");
status = addAttribute(IVinMesh);
MCheckStatus(status, "AddAttrIVNode");
// Add attribute affects
status = attributeAffects( IVspin, IVoutMesh );
MCheckStatus(status, "AddAttrAffectsIVNode");
status = attributeAffects( IVcount, IVoutMesh );
MCheckStatus(status, "AddAttrAffectsIVNode");
status = attributeAffects( IVinMesh, IVoutMesh );
MCheckStatus(status, "AddAttrAffectsIVNode");
status = attributeAffects( IVslide, IVoutMesh);
MCheckStatus(status, "AddAttrAffectsIVNode");
status = attributeAffects( IVslideRelative, IVoutMesh);
MCheckStatus(status, "AddAttrAffectsIVNode");
status = attributeAffects( IVnormalRelative, IVoutMesh);
MCheckStatus(status, "AddAttrAffectsIVNode");
status = attributeAffects( IVwhichSide, IVoutMesh);
MCheckStatus(status, "AddAttrAffectsIVNode");
status = attributeAffects( IVnormal, IVoutMesh);
MCheckStatus(status, "AddAttrAffectsIVNode");
// Zuletzt die SoftTransformationAttribute hinzufuegen
// Per Macro - dirty, aber funktioniert - wie machen die ALIAS Typen das ??? Die leiten auch stuendig von einer BaseNode ab, und da gehen dann keine Attribute flueten
// Oder werden unbrauchbar so wie bei mir, so dass im Endeffekt suemtliche Attribute ein eindeutiges statisches Attribut haben muessen
STE_ADD_ATTRIBUTES(IV)
return status;
}
MStatus
OpenSubdivShader::initialize()
{
MFnTypedAttribute typedAttr;
MFnNumericAttribute numAttr;
MFnEnumAttribute enumAttr;
// Subdivision level
aLevel = numAttr.create("level", "lv", MFnNumericData::kLong, 3);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setSoftMax(5);
numAttr.setMax(10);
addAttribute(aLevel);
// GPU tesselation factor
aTessFactor = numAttr.create("tessFactor", "tessf", MFnNumericData::kLong, 2);
numAttr.setInternal(true);
numAttr.setMin(1);
numAttr.setMax(10);
addAttribute(aTessFactor);
// Subdivision scheme
aScheme = enumAttr.create("scheme", "sc", OsdMeshData::kCatmark);
enumAttr.setInternal(true);
enumAttr.addField("Catmull-Clark", OsdMeshData::kCatmark);
enumAttr.addField("Loop", OsdMeshData::kLoop);
enumAttr.addField("Bilinear", OsdMeshData::kBilinear);
addAttribute(aScheme);
// Computation kernel
aKernel = enumAttr.create("kernel", "kn", OsdMeshData::kCPU);
enumAttr.setInternal(true);
enumAttr.addField("CPU", OsdMeshData::kCPU);
#ifdef OPENSUBDIV_HAS_OPENMP
enumAttr.addField("OpenMP", OsdMeshData::kOPENMP);
#endif
#ifdef OPENSUBDIV_HAS_OPENCL
enumAttr.addField("CL", OsdMeshData::kCL);
#endif
#ifdef OPENSUBDIV_HAS_CUDA
enumAttr.addField("CUDA", OsdMeshData::kCUDA);
#endif
addAttribute(aKernel);
// Boundary interpolation flag
aInterpolateBoundary = enumAttr.create("interpolateBoundary", "ib",
OsdMeshData::kInterpolateBoundaryNone);
enumAttr.addField("None", OsdMeshData::kInterpolateBoundaryNone);
enumAttr.addField("Edge Only", OsdMeshData::kInterpolateBoundaryEdgeOnly);
enumAttr.addField("Edge and Corner", OsdMeshData::kInterpolateBoundaryEdgeAndCorner);
enumAttr.addField("Always Sharp", OsdMeshData::kInterpolateBoundaryAlwaysSharp);
enumAttr.setInternal(true);
addAttribute(aInterpolateBoundary);
// Feature-adaptive toggle
aAdaptive = numAttr.create("adaptive", "adp", MFnNumericData::kBoolean, true);
numAttr.setInternal(true);
addAttribute(aAdaptive);
// Wireframe display toggle
aWireframe = numAttr.create("wireframe", "wf", MFnNumericData::kBoolean, false);
addAttribute(aWireframe);
// Material attributes
aDiffuse = numAttr.createColor("diffuse", "d");
numAttr.setDefault(0.6f, 0.6f, 0.7f);
addAttribute(aDiffuse);
aAmbient = numAttr.createColor("ambient", "a");
numAttr.setDefault(0.1f, 0.1f, 0.1f);
addAttribute(aAmbient);
aSpecular = numAttr.createColor("specular", "s");
numAttr.setDefault(0.3f, 0.3f, 0.3f);
addAttribute(aSpecular);
aShininess = numAttr.create("shininess", "shin", MFnNumericData::kFloat, 50.0f);
numAttr.setMin(0);
numAttr.setSoftMax(128.0f);
addAttribute(aShininess);
// Texture attributes
aDiffuseMapFile = typedAttr.create("diffuseMap", "difmap", MFnData::kString);
typedAttr.setInternal(true);
/* don't let maya hold on to string when fileNode is disconnected */
typedAttr.setDisconnectBehavior(MFnAttribute::kReset);
addAttribute(aDiffuseMapFile);
// UV set (defaults to current UV set)
aUVSet = typedAttr.create("uvSet", "uvs", MFnData::kString);
typedAttr.setInternal(true);
addAttribute(aUVSet);
// Boundary interpolation flag for face-varying data (UVs)
aInterpolateUVBoundary = enumAttr.create("interpolateUVBoundary", "iuvb",
OsdMeshData::kInterpolateBoundaryNone);
enumAttr.addField("None", OsdMeshData::kInterpolateBoundaryNone);
enumAttr.addField("Edge Only", OsdMeshData::kInterpolateBoundaryEdgeOnly);
enumAttr.addField("Edge and Corner", OsdMeshData::kInterpolateBoundaryEdgeAndCorner);
enumAttr.addField("Always Sharp", OsdMeshData::kInterpolateBoundaryAlwaysSharp);
enumAttr.setInternal(true);
addAttribute(aInterpolateUVBoundary);
// Optional shader source filename
aShaderSource = typedAttr.create("shaderSource", "ssrc", MFnData::kString);
typedAttr.setInternal(true);
addAttribute(aShaderSource);
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 pnTriangles::initialize()
//
// Description:
// Initialize class
// Return Values:
// MS::kSuccess
// MS::kFailure
//
{
MFnNumericAttribute nAttr;
MStatus stat;
// Subivision attribute
attrSubdivisions = nAttr.create( "subdivisions", "sd", MFnNumericData::kInt, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setMin(0);
nAttr.setMax(10);
nAttr.setDefault(1);
nAttr.setKeyable(true);
attrColored = nAttr.create( "colored", "cl", MFnNumericData::kBoolean, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setDefault( false );
nAttr.setKeyable(true);
attrTextured = nAttr.create( "textured", "tx", MFnNumericData::kBoolean, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setDefault( false );
nAttr.setKeyable(true);
attrWireframe = nAttr.create( "wireframe", "wf", MFnNumericData::kBoolean, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setDefault( false );
nAttr.setKeyable(true);
// Normal mode attribute
attrNormalMode = nAttr.create( "quadraticNormals", "qn", MFnNumericData::kInt, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setMin(0); // Linear
nAttr.setMax(1); // Quadratic
nAttr.setDefault(1);
nAttr.setKeyable(true);
// Point mode attribute
attrPointMode= nAttr.create( "cubicPoints", "cp", MFnNumericData::kInt, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setMin(0); // Linear
nAttr.setMax(1); // Cubic
nAttr.setDefault(1);
nAttr.setKeyable(true);
// Enable vertex program
attrEnableVertexProgram = nAttr.create( "vertexProgram", "vp", MFnNumericData::kBoolean, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setDefault( false );
nAttr.setKeyable(true);
// Enable pixel program
attrEnablePixelProgram = nAttr.create( "pixelProgram", "pp", MFnNumericData::kBoolean, 1 );
nAttr.setStorable(true);
nAttr.setInternal(true);
nAttr.setDefault( false );
nAttr.setKeyable(true);
// Add the attributes we have created to the node
//
stat = addAttribute( attrSubdivisions );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( attrColored );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( attrWireframe );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( attrTextured );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( attrNormalMode );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( attrPointMode );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( attrEnableVertexProgram );
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute( attrEnablePixelProgram );
if (!stat) { stat.perror("addAttribute"); return stat;}
return MS::kSuccess;
}
MStatus hwPhongShader::initialize()
{
// Make sure that all attributes are cached internal for
// optimal performance !
TRACE_API_CALLS("initialize");
MFnNumericAttribute nAttr;
// Create input attributes
aColor = nAttr.createColor( "color", "c");
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.1f, 0.1f, 0.1f);
nAttr.setCached( true );
nAttr.setInternal( true );
aDiffuseColor = nAttr.createColor( "diffuseColor", "dc" );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(1.f, 0.5f, 0.5f);
nAttr.setCached( true );
nAttr.setInternal( true );
aSpecularColor = nAttr.createColor( "specularColor", "sc" );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0.5f, 0.5f, 0.5f);
nAttr.setCached( true );
nAttr.setInternal( true );
// This is defined as a point, so that users can easily enter
// values beyond 1.
aShininess = nAttr.createPoint( "shininess", "sh" );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(100.0f, 100.0f, 100.0f);
nAttr.setCached( true );
nAttr.setInternal( true );
aGeometryShape = nAttr.create( "geometryShape", "gs", MFnNumericData::kInt );
nAttr.setStorable(true);
nAttr.setKeyable(true);
nAttr.setDefault(0);
nAttr.setCached( true );
nAttr.setInternal( true );
// create output attributes here
// outColor is the only output attribute and it is inherited
// so we do not need to create or add it.
//
// Add the attributes here
addAttribute(aColor);
addAttribute(aDiffuseColor);
addAttribute(aSpecularColor);
addAttribute(aShininess);
addAttribute(aGeometryShape);
attributeAffects (aColor, outColor);
attributeAffects (aDiffuseColor, outColor);
attributeAffects (aSpecularColor, outColor);
attributeAffects (aShininess, outColor);
return MS::kSuccess;
}
