- Main Page
- Related Pages
- Modules
- Classes
- Examples

# lambertShader.cpp

    //-
    // ==========================================================================
    // Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
    //
    // Use of this software is subject to the terms of the Autodesk
    // license agreement provided at the time of installation or download,
    // or which otherwise accompanies this software in either electronic
    // or hard copy form.
    // ==========================================================================
    //+

    // Example Plugin: lambertShader.cpp
    //
    // Produces dependency graph node LambertShader
    // This node is an example of a Lambert shader and how to build a
    // dependency node as a surface shader in Maya. The inputs for this node
    // are many, and can be found in the Maya UI on the Attribute Editor for
    // the node. The output attributes for the node are "outColor" and
    // "outTransparency". To use this shader, create a lambertShader with
    // Shading Group or connect the outputs to a Shading Group's
    // "SurfaceShader" attribute.
    //

    #include <maya/MIOStream.h>
    #include <maya/MPxNode.h>
    #include <maya/MString.h>
    #include <maya/MTypeId.h>
    #include <maya/MPlug.h>
    #include <maya/MDataBlock.h>
    #include <maya/MDataHandle.h>
    #include <maya/MArrayDataHandle.h>
    #include <maya/MFnNumericAttribute.h>
    #include <maya/MFnLightDataAttribute.h>
    #include <maya/MFloatVector.h>
    #include <maya/MFnPlugin.h>
    #include <maya/MGlobal.h>

    // Plugin Lambert Shader Class //

    // This class will create a new shader. Shaders are custom dependency
    // graph objects so we will derive this class from the basic DG node
    // type MPxNode
    //

    class lambert : public MPxNode
    {
    public:
                        lambert();
        virtual         ~lambert();

        static  void *  creator();
        virtual MStatus compute( const MPlug&, MDataBlock& );
        static  MStatus initialize();

        // postConstructor:
        // The postConstructor method allows us to call MPxNode member
        // functions during initialization. Internally maya creates two
        // objects when a user defined node is created, the internal MObject
        // and the user derived object. The association between the these
        // two objects is not made until after the MPxNode constructor is
        // called. This implies that no MPxNode member function can be called
        // from the MPxNode constructor. The postConstructor will get called
        // immediately after the constructor when it is safe to call any
        // MPxNode member function.
        //

        virtual void    postConstructor();

        static  MTypeId   id;  // The IFF type id

    protected:

       // Translucence coefficient
       static MObject  aTranslucenceCoeff;

       // Diffuse Reflectivity
       static MObject  aDiffuseReflectivity;

       // Red component of surface color
       static MObject  aColorR;

       // Green component of surface color
       static MObject  aColorG;

       // Blue component of surface color
       static MObject  aColorB;

       // Surface color
       static MObject  aColor;

       // Red component of incandescence
       static MObject  aIncandescenceR;

       // Green component of incandescence
       static MObject  aIncandescenceG;

       // Blue component of incandescence
       static MObject  aIncandescenceB;

       // Incandescence
       static MObject  aIncandescence;

       // Red component of surface transparency
       static MObject  aInTransR;

       // Green component of surface transparency
       static MObject  aInTransG;

       // Blue component of surface transparency
       static MObject  aInTransB;

       // Surface transparency
       static MObject  aInTransparency;

       // Red component of output color
       static MObject  aOutColorR;

       // Green component of output color
       static MObject  aOutColorG;

       // Blue component of output color
       static MObject  aOutColorB;

       // Output color
       static MObject  aOutColor;

       // Red component of output transparency
       static MObject  aOutTransR;

       // Green component of output transparency
       static MObject  aOutTransG;

       // Blue component of output transparency
       static MObject  aOutTransB;

       // Output transparency
       static MObject  aOutTransparency;

       // X component of surface normal
       static MObject  aNormalCameraX;

       // Y component of surface normal
       static MObject  aNormalCameraY;

       // Z component of surface normal
       static MObject  aNormalCameraZ;

       // Surface normal
       static MObject  aNormalCamera;

       // X component of light direction vector
       static MObject  aLightDirectionX;

       // Y component of light direction vector
       static MObject  aLightDirectionY;

       // Z component of light direction vector
       static MObject  aLightDirectionZ;

       // Light direction vector
       static MObject  aLightDirection;

       // Red component of light intensity
       static MObject  aLightIntensityR;

       // Green component of light intensity
       static MObject  aLightIntensityG;

       // Blue component of light intensity
       static MObject  aLightIntensityB;

       // Light Intensity vector
       static MObject  aLightIntensity;

       // Ambient flag
       static MObject  aLightAmbient;

       // Diffuse flag
       static MObject  aLightDiffuse;

       // Specular flag
       static MObject  aLightSpecular;

       // Shadow Fraction flag
       static MObject   aLightShadowFraction;

       // Pre Shadow Intensity
       static MObject   aPreShadowIntensity;

       // Light blind data
       static MObject   aLightBlindData;

       // Light data array
       static MObject   aLightData;

    };

    // IFF type ID
    // Each node requires a unique identifier which is used by
    // MFnDependencyNode::create() to identify which node to create, and by
    // the Maya file format.
    //
    // For local testing of nodes you can use any identifier between
    // 0x00000000 and 0x0007ffff, but for any node that you plan to use for
    // more permanent purposes, you should get a universally unique id from
    // Autodesk Support. You will be assigned a unique range that you
    // can manage on your own.
    //
    MTypeId lambert::id( 0x81000 );

    // the postConstructor() function is called immediately after the objects
    // constructor. It is not safe to call MPxNode member functions from the
    // constructor, instead they should be called here.
    //
    void lambert::postConstructor( )
    {
        // setMPSafe indicates that this shader can be used for multiprocessor
        // rendering. For a shading node to be MP safe, it cannot access any
        // shared global data and should only use attributes in the datablock
        // to get input data and store output data.
        //
        setMPSafe( true );
    }

    // DESCRIPTION: attribute information
    //
    MObject  lambert::aTranslucenceCoeff;
    MObject  lambert::aDiffuseReflectivity;
    MObject  lambert::aInTransparency;
    MObject  lambert::aInTransR;
    MObject  lambert::aInTransG;
    MObject  lambert::aInTransB;
    MObject  lambert::aColor;
    MObject  lambert::aColorR;
    MObject  lambert::aColorG;
    MObject  lambert::aColorB;
    MObject  lambert::aIncandescence;
    MObject  lambert::aIncandescenceR;
    MObject  lambert::aIncandescenceG;
    MObject  lambert::aIncandescenceB;
    MObject  lambert::aOutColor;
    MObject  lambert::aOutColorR;
    MObject  lambert::aOutColorG;
    MObject  lambert::aOutColorB;
    MObject  lambert::aOutTransparency;
    MObject  lambert::aOutTransR;
    MObject  lambert::aOutTransG;
    MObject  lambert::aOutTransB;
    MObject  lambert::aNormalCamera;
    MObject  lambert::aNormalCameraX;
    MObject  lambert::aNormalCameraY;
    MObject  lambert::aNormalCameraZ;
    MObject  lambert::aLightData;
    MObject  lambert::aLightDirection;
    MObject  lambert::aLightDirectionX;
    MObject  lambert::aLightDirectionY;
    MObject  lambert::aLightDirectionZ;
    MObject  lambert::aLightIntensity;
    MObject  lambert::aLightIntensityR;
    MObject  lambert::aLightIntensityG;
    MObject  lambert::aLightIntensityB;
    MObject  lambert::aLightAmbient;
    MObject  lambert::aLightDiffuse;
    MObject  lambert::aLightSpecular;
    MObject  lambert::aLightShadowFraction;
    MObject  lambert::aPreShadowIntensity;
    MObject  lambert::aLightBlindData;

    // This node does not need to perform any special actions on creation or
    // destruction
    //

    lambert::lambert() { }
    lambert::~lambert() { }

    // The creator() method allows Maya to instantiate instances of this node.
    // It is called every time a new instance of the node is requested by
    // either the createNode command or the MFnDependencyNode::create()
    // method.
    //
    // In this case creator simply returns a new lambert object.
    //

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

    // The initialize method is called only once when the node is first
    // registered with Maya. In this method you define the attributes of the
    // node, what data comes in and goes out of the node that other nodes may
    // want to connect to.
    //

    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 );
    }

    // The compute() method does the actual work of the node using the inputs
    // of the node to generate its output.
    //
    // Compute takes two parameters: plug and data.
    // - Plug is the the data value that needs to be recomputed
    // - Data provides handles to all of the nodes attributes, only these
    //   handles should be used when performing computations.
    //
    MStatus lambert::compute( const MPlug& plug, MDataBlock& block )
    {
        // The plug parameter will allow us to determine which output attribute
        // needs to be calculated.
        //
        if( plug == aOutColor
                || plug == aOutColorR
                || plug == aOutColorG
                || plug == aOutColorB
                || plug == aOutTransparency
                || plug == aOutTransR
                || plug == aOutTransG
                || plug == aOutTransB )
        {
            MStatus status;
            MFloatVector resultColor( 0.0, 0.0, 0.0 );

            // Get surface shading parameters from input block
            //
            MFloatVector& surfaceNormal = block.inputValue( aNormalCamera,
                    &status ).asFloatVector();
            CHECK_MSTATUS( status );

            MFloatVector& surfaceColor = block.inputValue( aColor,
                    &status ).asFloatVector();
            CHECK_MSTATUS( status );

            MFloatVector& incandescence = block.inputValue( aIncandescence,
                    &status ).asFloatVector();
            CHECK_MSTATUS( status );

            float diffuseReflectivity = block.inputValue(
                    aDiffuseReflectivity, &status ).asFloat();
            CHECK_MSTATUS( status );

    //      float translucenceCoeff = block.inputValue( aTranslucenceCoeff,
    //              &status ).asFloat();
    //      CHECK_MSTATUS( status );

            // Get light list
            //
            MArrayDataHandle lightData = block.inputArrayValue( aLightData,
                    &status );
            CHECK_MSTATUS( status );

            int numLights = lightData.elementCount( &status );
            CHECK_MSTATUS( status );

            // Calculate the effect of the lights in the scene on the color
            //

            // Iterate through light list and get ambient/diffuse values
            //
            for( int count=1; count <= numLights; count++ )
            {
                // Get the current light out of the array
                //
                MDataHandle currentLight = lightData.inputValue( &status );
                CHECK_MSTATUS( status );

                // Get the intensity of that light
                //
                MFloatVector& lightIntensity = currentLight.child(
                        aLightIntensity ).asFloatVector();

                // Find ambient component
                //
                if ( currentLight.child( aLightAmbient ).asBool() )
                {
                    resultColor += lightIntensity;
                }

                // Find diffuse component
                //
                if ( currentLight.child( aLightDiffuse ).asBool() )
                {
                    MFloatVector& lightDirection = currentLight.child(
                            aLightDirection ).asFloatVector();
                    float cosln = lightDirection * surfaceNormal;

                   if ( cosln > 0.0f ) {
                        resultColor += lightIntensity
                                * ( cosln * diffuseReflectivity );
                   }
                }

                // Advance to the next light.
                //
                if ( count < numLights ) {
                    status = lightData.next();
                    CHECK_MSTATUS( status );
                }
            }

            // Factor incident light with surface color and add incandescence
            //
            resultColor[0] = resultColor[0] * surfaceColor[0] + incandescence[0];
            resultColor[1] = resultColor[1] * surfaceColor[1] + incandescence[1];
            resultColor[2] = resultColor[2] * surfaceColor[2] + incandescence[2];

            // Set ouput color attribute
            //
            if ( plug == aOutColor || plug == aOutColorR || plug == aOutColorG
                    || plug == aOutColorB)
            {
                // Get the handle to the attribute
                //
                MDataHandle outColorHandle = block.outputValue( aOutColor,
                        &status );
                CHECK_MSTATUS( status );
                MFloatVector& outColor = outColorHandle.asFloatVector();

                outColor = resultColor;     // Set the output value
                outColorHandle.setClean(); // Mark the output value as clean
            }

            // Set ouput transparency
            //
            if ( plug == aOutTransparency || plug == aOutTransR
                    || plug == aOutTransG || plug == aOutTransB )
            {
                MFloatVector& transparency = block.inputValue(
                        aInTransparency, &status ).asFloatVector();
                CHECK_MSTATUS( status );

                // Get the handle to the attribute
                //
                MDataHandle outTransHandle = block.outputValue(
                        aOutTransparency, &status );
                CHECK_MSTATUS( status );
                MFloatVector& outTrans = outTransHandle.asFloatVector();

                outTrans = transparency;   // Set the output value
                outTransHandle.setClean(); // Mark the output value as clean
            }
        }
        else
        {
            return( MS::kUnknownParameter ); // We got an unexpected plug
        }

        return( MS::kSuccess );
    }

    // These methods load and unload the plugin, registerNode registers the
    // new node type with maya
    //

    MStatus initializePlugin( MObject obj )
    {
        const MString   UserClassify( "shader/surface" );

        MString command( "if( `window -exists createRenderNodeWindow` ) {refreshCreateRenderNodeWindow(\"" );

        MFnPlugin plugin( obj, PLUGIN_COMPANY, "4.5", "Any" );

        CHECK_MSTATUS( plugin.registerNode( "lambertShader", lambert::id,
                lambert::creator, lambert::initialize, MPxNode::kDependNode,
                &UserClassify ) );

       command += UserClassify;

       command += "\");}\n";

       CHECK_MSTATUS( MGlobal::executeCommand( command ) );

       return( MS::kSuccess );
    }

    MStatus uninitializePlugin( MObject obj )
    {
        const MString UserClassify( "shader/surface" );

        MString command( "if( `window -exists createRenderNodeWindow` ) {refreshCreateRenderNodeWindow(\"" );

        MFnPlugin plugin( obj );

        CHECK_MSTATUS( plugin.deregisterNode( lambert::id ) );

        command += UserClassify;
        command += "\");}\n";

        CHECK_MSTATUS( MGlobal::executeCommand( command ) );

        return MS::kSuccess;
    }