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;
}
Example #3
0
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;
}