class InterpNode : public MPxNode 
{
public:
    InterpNode();
    virtual ~InterpNode();
    virtual MStatus compute( const MPlug&, MDataBlock& );
    static void * creator();
    static MStatus initialize();
    static MTypeId id;
protected:
    static MObject InputValue;
    static MObject color1R,color1G,color1B,color1;
    static MObject color2R,color2G,color2B,color2;
    static MObject aNormalCameraX, aNormalCameraY,
    aNormalCameraZ, aNormalCamera;
    static MObject aPointCameraX, aPointCameraY,
    aPointCameraZ, aPointCamera;
    static MObject aOutColorR, aOutColorG, aOutColorB,
    aOutColor;
};
MObject InterpNode::InputValue;
MObject InterpNode::color1R;
MObject InterpNode::color1G;
MObject InterpNode::color1B;
MObject InterpNode::color1;
MObject InterpNode::color2R;
MObject InterpNode::color2G;
MObject InterpNode::color2B;
MObject InterpNode::color2;
MObject InterpNode::aNormalCameraX;
MObject InterpNode::aNormalCameraY;
MObject InterpNode::aNormalCameraZ;
MObject InterpNode::aNormalCamera;
MObject InterpNode::aPointCameraX;
MObject InterpNode::aPointCameraY;
MObject InterpNode::aPointCameraZ;
MObject InterpNode::aPointCamera;
MObject InterpNode::aOutColorR;
MObject InterpNode::aOutColorG;
MObject InterpNode::aOutColorB;
MObject InterpNode::aOutColor;

InterpNode::InterpNode() { }
InterpNode::~InterpNode() { }

void* InterpNode::creator()
{
    return new InterpNode();
}

MStatus initializePlugin( MObject obj )
{
    const MString UserClassify( "utility/general" );
    MFnPlugin plugin( obj, "Autodesk", "1.0",
    "Any");
    plugin.registerNode( "Interp", InterpNode::id,
    InterpNode::creator,
    InterpNode::initialize,
    MPxNode::kDependNode, &UserClassify);
    return MS::kSuccess;
}

MStatus uninitializePlugin( MObject obj)
{
    MFnPlugin plugin( obj );
    plugin.deregisterNode( InterpNode::id );
    return MS::kSuccess;
}

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
    InputValue = nAttr.create( "Power", "pow",
    MFnNumericData::kFloat);
    nAttr.setDefault(1.0f);
    nAttr.setMin(0.0f);
    nAttr.setMax(3.0f);
    nAttr.setStorable(true);
    // User defined color attribute
    color1R = nAttr.create( "color1R", "c1r",
    MFnNumericData::kFloat);
    color1G = nAttr.create( "color1G", "c1g",
    MFnNumericData::kFloat);
    color1B = nAttr.create( "color1B", "c1b",
    MFnNumericData::kFloat);
    color1 = nAttr.create( "Sides", "c1", color1R, color1G,
    color1B);
    nAttr.setStorable(true);
    nAttr.setUsedAsColor(true);
    nAttr.setDefault(1.0f, 1.0f, 1.0f);
    color2R = nAttr.create( "color2R", "c2r",
    MFnNumericData::kFloat);
    color2G = nAttr.create( "color2G", "c2g",
    MFnNumericData::kFloat);
    color2B = nAttr.create( "color2B", "c2b",
    MFnNumericData::kFloat);
    color2 = nAttr.create( "Facing", "c2", color2R,
    color2G, color2B);
    nAttr.setStorable(true);
    nAttr.setUsedAsColor(true);
    nAttr.setDefault(0.0f, 0.0f, 0.0f);
    // Surface Normal supplied by the render sampler
    aNormalCameraX = nAttr.create( "normalCameraX", "nx",
    MFnNumericData::kFloat);
    nAttr.setStorable(false);
    nAttr.setDefault(1.0f);
    aNormalCameraY = nAttr.create( "normalCameraY", "ny",
    MFnNumericData::kFloat);
    nAttr.setStorable(false);
    nAttr.setDefault(1.0f);
    aNormalCameraZ = nAttr.create( "normalCameraZ", "nz",
    MFnNumericData::kFloat);
    nAttr.setStorable(false);
    nAttr.setDefault(1.0f);
    aNormalCamera = nAttr.create( "normalCamera","n",
    aNormalCameraX, 
    aNormalCameraY, aNormalCameraZ);
    nAttr.setStorable(false);
    nAttr.setHidden(true);
    // Point on surface in camera space, will be used to compute view vector
    aPointCameraX = nAttr.create( "pointCameraX", "px",
    MFnNumericData::kFloat);
    nAttr.setStorable(false);
    nAttr.setDefault(1.0f);
    aPointCameraY = nAttr.create( "pointCameraY", "py",
    MFnNumericData::kFloat);
    nAttr.setStorable(false);
    nAttr.setDefault(1.0f);
    aPointCameraZ = nAttr.create( "pointCameraZ", "pz",
    MFnNumericData::kFloat);
    nAttr.setStorable(false);
    nAttr.setDefault(1.0f);
    aPointCamera = nAttr.create( "pointCamera","p",
    aPointCameraX, 
    aPointCameraY, aPointCameraZ);
    nAttr.setStorable(false);
    nAttr.setHidden(true);
    // Outputs
    aOutColorR = nAttr.create( "outColorR", "ocr",
    MFnNumericData::kFloat);
    aOutColorG = nAttr.create( "outColorG", "ocg",
    MFnNumericData::kFloat);
    aOutColorB = nAttr.create( "outColorB", "ocb",
    MFnNumericData::kFloat);
    aOutColor = nAttr.create( "outColor", "oc",
    aOutColorR, aOutColorG, aOutColorB);
    nAttr.setStorable(false);
    nAttr.setHidden(false);
    nAttr.setReadable(true);
    nAttr.setWritable(false);
    addAttribute(InputValue);
    addAttribute(color1R);
    addAttribute(color1G);
    addAttribute(color1B);
    addAttribute(color1);
    addAttribute(color2R);
    addAttribute(color2G);
    addAttribute(color2B);
    addAttribute(color2);
    addAttribute(aNormalCameraX);
    addAttribute(aNormalCameraY);
    addAttribute(aNormalCameraZ);
    addAttribute(aNormalCamera);
    addAttribute(aPointCameraX);
    addAttribute(aPointCameraY);
    addAttribute(aPointCameraZ);
    addAttribute(aPointCamera);
    addAttribute(aOutColorR);
    addAttribute(aOutColorG);
    addAttribute(aOutColorB);
    addAttribute(aOutColor);
    attributeAffects (InputValue, aOutColor);
    attributeAffects (color1R, color1);
    attributeAffects (color1G, color1);
    attributeAffects (color1B, color1);
    attributeAffects (color1, aOutColor);
    attributeAffects (color2R, color2);
    attributeAffects (color2G, color2);
    attributeAffects (color2B, color2);
    attributeAffects (color2, aOutColor);
    attributeAffects (aNormalCameraX, aOutColor);
    attributeAffects (aNormalCameraY, aOutColor);
    attributeAffects (aNormalCameraZ, aOutColor);
    attributeAffects (aNormalCamera, aOutColor);
    attributeAffects (aPointCameraX, aOutColor);
    attributeAffects (aPointCameraY, aOutColor);
    attributeAffects (aPointCameraZ, aOutColor);
    attributeAffects (aPointCamera, aOutColor);
    return MS::kSuccess;
}

MTypeId InterpNode::id( 0x81005 );

MStatus InterpNode::compute( const MPlug& plug, MDataBlock& block )
{
    int k=0;
    float gamma,scalar;
    k |= (plug == aOutColor);
    k |= (plug == aOutColorR);
    k |= (plug == aOutColorG);
    k |= (plug == aOutColorB);
    if (!k) return MS::kUnknownParameter;
    MFloatVector resultColor(0.0,0.0,0.0);
    MFloatVector& Side = block.inputValue( color1 ).
    asFloatVector();
    MFloatVector& Face = block.inputValue( color2 ).
    asFloatVector();
    MFloatVector& surfaceNormal = block.
    inputValue( aNormalCamera ).
    asFloatVector();
    MFloatVector& viewVector = block.
    inputValue( aPointCamera ).
    asFloatVector();
    float power = block.inputValue( InputValue ).asFloat();
    // Normalize the view vector
    double d = sqrt((viewVector[0] * viewVector[0]) +
    (viewVector[1] * viewVector[1]) +
    (viewVector[2] * viewVector[2]));
    if (d != (double)0.0) {
        viewVector[0] /= d;
        viewVector[1] /= d;
        viewVector[2] /= d;
    }
 
    // find dot product
    float scalarNormal = ((viewVector[0]*surfaceNormal[0])
                       + (viewVector[1]*surfaceNormal[1])
                       + (viewVector[2]*surfaceNormal[2]));
    // take the absolute value
    if (scalarNormal < 0.0) scalarNormal *= -1.0;
    // Use InputValue to change interpolation
    // power == 1.0 linear
    // power >= 0.0 use gamma function
    //
    if (power > 0.0) {
        gamma = 1.0 / power;
        scalar = pow(scalarNormal,gamma);
    }
    else { scalar = 0.0; }
    // Interpolate the colors
    MFloatVector interp(0.0,0.0,0.0);
    interp[0] = scalar * (Face[0] - Side[0]);
    interp[1] = scalar * (Face[1] - Side[1]);
    interp[2] = scalar * (Face[2] - Side[2]);
    resultColor[0] = Side[0] + interp[0];
    resultColor[1] = Side[1] + interp[1];
    resultColor[2] = Side[2] + interp[2];
    // set ouput color attribute
    MDataHandle outColorHandle = block.
    outputValue( aOutColor );
    MFloatVector& outColor = outColorHandle.
    asFloatVector();
    outColor = resultColor;
    outColorHandle.setClean();
    return MS::kSuccess;
}