shellNode.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.
// ==========================================================================
//+

//
// This plug-in is based, in part, upon the folloing literature:
//
//              Digital Seashells, M.B. Cortie,
//              Computer and Graphics, Vol. 17, No. 1, pp. 79-84, 1993
// 
//              _Shells_, S. Peter Dance,
//              Harper Collins Publishers 1992, ISBN 0 7322 0067 9
// 
//              Modeling Seashels, Deborah R. Fowler, Hans Meinhardt et al.
//              Siggraph Proceedings 92, pp. 379-387
// 
//              _The Algorithmic Beauty of Sea Shells_, Hans Meinhardt,
//              Springer-Verlag Berlin Heidelberg 1995, ISBN 3 540 57842 0
//


#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/MFnPlugin.h>
#include <maya/MAngle.h>
#include <maya/MFnUnitAttribute.h>
#include <maya/MFnNumericAttribute.h>
#include <maya/MFnTypedAttribute.h>
#include <maya/MFloatPoint.h>
#include <maya/MFloatPointArray.h>
#include <maya/MIntArray.h>
#include <maya/MDoubleArray.h>

#include <maya/MFnMesh.h>
#include <maya/MFnMeshData.h>
#include <maya/MItMeshVertex.h>

#include <math.h>
#include <maya/MIOStream.h>

#define Rad(x)  ((x)*FPI/180.0F)
#define Deg(x)  ((x)*180.0F/FPI)
#define FPI 3.14159265358979323846264338327950288419716939937510582F 

#define McheckErr(stat,msg)         \
    if ( MS::kSuccess != stat ) {   \
        cerr << msg;                \
        return MS::kFailure;        \
    }


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

    virtual MStatus             compute( const MPlug& plug, MDataBlock& data );

        static  void *          creator();
        static  MStatus         initialize();

public: 
        static  MTypeId         id;

        // Node attributes
        // ---------------

        // Main shape parameters
        //
        static  MObject alpha;          // Profile (Helico-spiral) param #1
        static  MObject beta;           // Profile (Helico-spiral) param #2
        static  MObject phi;            // Section Starting point
        static  MObject my;                 // Section Slant
        static  MObject omega;          // Section angle around Oz
        static  MObject omin;           // Spiral start angle
        static  MObject omax;           // Spiral end angle
        static  MObject od;                 // Spiral angle step
        static  MObject smin;           // Section start angle
        static  MObject smax;           // Section end angle
        static  MObject sd;                 // Section angle step
        static  MObject A;                  // Distance of section from Z-axis
        static  MObject a;                  // Section diameter #1
        static  MObject b;                  // Section diameter #2
        static  MObject scale;          // Overall scale
        
        // Nodule 1
        //
        static  MObject P;                      // Position on section
        static  MObject L;                      // Amplitude (extrusion) of nodule
        static  MObject N;                      // Nodules frequency on profile
        static  MObject W1;                     // Fatness of nodule
        static  MObject W2;                     // Fatness of nodule
        static  MObject nstart;         // Starting point on spiral

        
        // Nodule 2
        // 
        static  MObject P2;
        static  MObject L2;
        static  MObject N2;
        static  MObject W12;
        static  MObject W22;
        static  MObject off2;
        static  MObject nstart2;

        // Nodule 3
        // 
        static  MObject P3;
        static  MObject L3;
        static  MObject N3;
        static  MObject W13;
        static  MObject W23;
        static  MObject off3;
        static  MObject nstart3;

        // Ribs
        //
        static  MObject uamp;           // Section rib amplitude
        static  MObject ufreq;          // Section rib frequency
        static  MObject urib;           // Section rib/wave percent
        static  MObject vamp;           // Profile rib amplitude
        static  MObject vfreq;          // Profile rib frequency
        static  MObject vrib;           // Profile rib/wave percent
    
    // Output mesh
    //
    static  MObject outMesh;

private:

        struct ShellParams {
                float   alpha;          // Profile (Helico-spiral) param #1
                float   beta;           // Profile (Helico-spiral) param #2
                float   phi;            // Section Starting point
                float   my;                     // Section Slant
                float   omega;          // Section angle around Oz
                float   omin;           // Spiral start angle
                float   omax;           // Spiral end angle
                float   od;                     // Spiral angle step
                float   smin;           // Section start angle
                float   smax;           // Section end angle
                float   sd;                     // Section angle step
                float   A;                      // Distance of section from Z-axis
                float   a;                      // Section diameter #1
                float   b;                      // Section diameter #2
                float   scale;          // Overall scale

                // Nodule 1
                // --------
                float   P;                      // Position on section
                float   L;                      // Amplitude (extrusion) of nodule
                float   N;                      // Nodules frequency on profile
                float   W1;                     // Fatness of nodule
                float   W2;                     // Fatness of nodule
                float   nstart;         // Starting point on spiral

                // Nodule 2
                // --------
                float   P2;
                float   L2;
                float   N2;
                float   W12;
                float   W22;
                float   off2;
                float   nstart2;

                // Nodule 3
                // --------
                float   P3;
                float   L3;
                float   N3;
                float   W13;
                float   W23;
                float   off3;
                float   nstart3;

                // Ribs
                // ----
                float   uamp;           // Section rib amplitude
                float   ufreq;          // Section rib frequency
                float   urib;           // Section rib/wave percent
                float   vamp;           // Profile rib amplitude
                float   vfreq;          // Profile rib frequency
                float   vrib;           // Profile rib/wave percent
        };

        ShellParams shellParams;
        bool        redoTopology;
        bool        rebuild;

        // Precomputed shell points
        // 
        int     ni;
        int     nj;
        float   **pnts;

private:

        float GetFloatParameter( MObject node, MObject attr );
        float GetAngleParameter( MObject node, MObject attr );
        static void  addFloatParameter( MObject & attr, MString longName, 
                                                                        MString briefName, float attrDefault );
        static void  addAngleParameter( MObject & attr, MString longName, 
                                                                        MString briefName, float attrDefault );
        void  UpdateParameters(); 
        void  RedoTopology();
        void  Rebuild();
        float Nodules( float s, float o );
        float Ribs( float u, float v );
        void  Eval( float       *p, float o, float s );

};

MTypeId shellNode::id( 0x8000b );


shellNode::shellNode()
 :  rebuild( true ),
        redoTopology( true ),
    pnts( NULL ),
    ni( 0 ),
    nj( 0 )
{}

shellNode::~shellNode() {}

MStatus shellNode::compute( const MPlug& plug, MDataBlock& data )
{    
    MStatus returnStatus;
    int i, j;
    
    // Read updated input parameters
    //
        UpdateParameters();
    bool createNewMesh = redoTopology;
    RedoTopology();
    Rebuild();
    
    if( !pnts || ni<2 || nj<2 ) return MS::kSuccess;

    if (plug == outMesh) {  
        if( !pnts || ni<2 || nj<2 ) return MS::kSuccess;
        
                MDataHandle outputHandle = data.outputValue(outMesh, &returnStatus);
                McheckErr(returnStatus, "ERROR getting polygon data handle\n");
        MObject mesh = outputHandle.asMesh();
               
        if ( createNewMesh || mesh.isNull() ) {
            MFnMeshData dataCreator;
            MObject newOutputData = dataCreator.create(&returnStatus);
            McheckErr(returnStatus, "ERROR creating outputData");
            
                    MFloatPointArray vertices;

            // Build vertices array
            //
            for( j=0; j<nj; ++j ) {
                        for( i=0; i<ni; ++i ) {
                                const float *p= pnts[j] + 3*i;
                                vertices.append( MFloatPoint(p[0],p[1],p[2]) );
                        }
            }

            // Build poly vertex count array
            //
            MIntArray pcounts;
            i= (nj-1)*(ni-1);
            while( i-- ) {
                pcounts.append(4);
            }

            // Build poly connectivity array
            //
            MIntArray pconnect;
            for( j=0; j<nj-1; ++j ) {
                        for( i=0; i<ni-1; ++i ) {
                                int corner= i+j*ni;
                                pconnect.append(corner);
                                pconnect.append(corner+1);
                                pconnect.append(corner+1+ni);
                                pconnect.append(corner+ni);
                        }
            }

            // Create some stuff needed by the mesh
                    //
            MIntArray           fec;
            MDoubleArray        sp;
            MDoubleArray        tp;

            // Build maya poly object
            //
            MFnMesh meshFn;
            mesh= meshFn.create(
                        nj*ni,                          // number of vertices
                        (nj-1)*(ni-1),          // number of polygons
                        vertices,                       // The points
                        pcounts,                        // # of vertex for each poly
                        pconnect,                       // Vertices index for each poly
                        newOutputData,      // Dependency graph data object
                        &returnStatus
            );

            // Update surface 
            //
            outputHandle.set(newOutputData);
        } else {
                // The topology hasn't changed, so we can just set the points
            // in the existing mesh
            //
            MItMeshVertex vertIt( mesh, &returnStatus);
                    McheckErr(returnStatus, "ERROR creating iterator\n");
            
            for( j=0; j<nj; ++j ) {
                        for( i=0; i<ni; ++i ) {
                    if ( vertIt.isDone() ) break;
                                const float *p= pnts[j] + 3*i;
                                vertIt.setPosition( MPoint(p[0],p[1],p[2]) );
                    vertIt.next();
                        }
                if ( vertIt.isDone() ) break;
            }
        }
        data.setClean( plug );
    }   

        return MS::kSuccess;
}

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


// Shell Algorithms //

void shellNode::RedoTopology()
//
//  Description:
//      Adjust our data storage to reflect new parameters
//
{
    if( !redoTopology ) return;

        redoTopology = false;

    int oldnj= pnts ? nj : 0;

    ni= 0;
    nj= 0;
    for( float s = shellParams.smin; 
                 s < shellParams.smax; 
                 s += shellParams.sd )  
        {
                ni++;   // Lazy
        }

    for( float o = shellParams.omin; 
                 o < shellParams.omax; 
                 o += shellParams.od )  
        {
                nj++;   // Lazy
        }

    if( nj<oldnj ) {
                for( int i = nj; i < oldnj; ++i ) {
                        if( pnts[i] ) free( pnts[i] );
                }
        }

    if( nj!=oldnj) {
                pnts = (float**) realloc(pnts, nj*sizeof(float*));
        }

    if( nj>oldnj ) {
                memset( pnts+oldnj, 0, (nj-oldnj)*sizeof(float*) );
        }
        
    for(int j=0;j<nj;++j) {
                pnts[j] = (float*) realloc(pnts[j],3*ni*sizeof(float));
        }
}

void shellNode::Rebuild()
//
//  Description:
//      Rebuild the mesh geometry given the new inputs
//
{
    if( !rebuild ) return;
    rebuild= 0;

    int         i;
    int         j;
    float       s;
    float       o;
    float       *p;

    o= shellParams.omin;
    for( j=0; j<nj; ++j )
    {
                s= shellParams.smin;
                p= pnts[j];
                for( i=0; i<ni; ++i )
                {
                        Eval( p, o, s );
                        s+=shellParams.sd;
                        p+=3;
                }
                o+=shellParams.od;
    }
}

inline float SafeCot( float x )
{
    float s= sinf(x);
    return s ? cosf(x)/s : 0.0F;
}

inline float G( float a, float n )
{
    if( !n ) return n;
    float z= 2.0F*FPI;
    a*=n/z;
    return z/n*(a-floorf(0.5F+a));
}

float shellNode::Ribs( float u, float v )
{
        ShellParams & sp = shellParams;

    float zu=0.0F;
    if( sp.uamp )
    {
                zu= sp.uamp*cosf(2.0F*FPI*sp.ufreq*u);
                if( zu<0 ) zu*= (1.0F-2.0F*sp.urib);
    }

    float zv=0.0F;
    if( sp.vamp )
    {
                zv= sp.vamp*cosf(2.0F*FPI*sp.vfreq*v);
                if( zv<0 ) zv*= (1.0F-2.0F*sp.vrib);
    }

    return zu+zv;
}

float shellNode::Nodules( float s, float o )
{
        ShellParams & sp = shellParams;

    float p1;
    float p2;
    float k=0.0F;
    float g=0.0F;

    if( sp.L && sp.N && o>=sp.nstart )
    {
                g= G(o,sp.N);
                p1= g/sp.W2;
                p2= (s-sp.P)/sp.W1;
                k= sp.L*expf( -4.0F*(p1*p1+p2*p2) );
    }

    if( sp.L2 && sp.N2 && o>=sp.nstart2 )
    {
                g= G(o+sp.off2,sp.N2); 
                p1= g/sp.W22;
                p2= (s-sp.P2)/sp.W12;
                k+= sp.L2*expf( -4.0F*(p1*p1+p2*p2) );
    }

    if( sp.L3 && sp.N3 && o>= sp.nstart3 )
    {
                g= G(o+sp.off3, sp.N3);
                p1= g/sp.W23;
                p2= (s-sp.P3)/sp.W13;
                k+= sp.L3*expf( -4.0F*(p1*p1+p2*p2) );
    }

    return k;
}

void shellNode::Eval( float     *p, float o, float s )
{
        ShellParams & sp = shellParams;

    float ss = sinf(s);
    float cs = cosf(s);
    float re = 1.0F/sqrtf(cs*cs/(sp.a*sp.a) 
               + ss*ss/(sp.b*sp.b));
    float sc = sp.scale*expf(o*SafeCot(sp.alpha));
    float csphi = cosf(s+sp.phi);
    float ssphi = sinf(s+sp.phi);
    float sbeta = sinf(sp.beta);
    float smy = sinf(sp.my);
    float r = re+Nodules(s,o)+Ribs(s,o);

    float x = sp.A*sbeta*cosf(o)                
              + r*csphi*cosf(o+sp.omega)        
              - r*smy*ssphi*sinf(o);

    float y = - sp.A*sbeta*sinf(o)      
                      - r*csphi*sinf(o+sp.omega)        
              - r*smy*ssphi*cosf(o);

    float z = - sp.A*cosf(sp.beta)              
              + r*ssphi*cosf(sp.my);

    p[0] =  x*sc;
    p[1] = -z*sc;
    p[2] =  y*sc;
}

// Attribute Setup and Maintenance //

        // Main shape parameters
        //
        MObject shellNode::alpha;               // Profile (Helico-spiral) param #1
        MObject shellNode::beta;                // Profile (Helico-spiral) param #2
        MObject shellNode::phi;             // Section Starting point
        MObject shellNode::my;              // Section Slant
        MObject shellNode::omega;               // Section angle around Z
        MObject shellNode::omin;                // Spiral start angle
        MObject shellNode::omax;                // Spiral end angle
        MObject shellNode::od;              // Spiral angle step
        MObject shellNode::smin;                // Section start angle
        MObject shellNode::smax;                // Section end angle
        MObject shellNode::sd;              // Section angle step
        MObject shellNode::A;               // Distance of section from Z-axis
        MObject shellNode::a;               // Section diameter #1
        MObject shellNode::b;               // Section diameter #2
        MObject shellNode::scale;               // Overall scale
        
        // Nodule 1
        //
        MObject shellNode::P;                   // Position on section
        MObject shellNode::L;                   // Amplitude (extrusion) of nodule
        MObject shellNode::N;                   // Nodules frequency on profile
        MObject shellNode::W1;                  // Fatness of nodule
        MObject shellNode::W2;                  // Fatness of nodule
        MObject shellNode::nstart;              // Starting point on spiral

        
        // Nodule 2
        // 
        MObject shellNode::P2;
        MObject shellNode::L2;
        MObject shellNode::N2;
        MObject shellNode::W12;
        MObject shellNode::W22;
        MObject shellNode::off2;
        MObject shellNode::nstart2;

        // Nodule 3
        // 
        MObject shellNode::P3;
        MObject shellNode::L3;
        MObject shellNode::N3;
        MObject shellNode::W13;
        MObject shellNode::W23;
        MObject shellNode::off3;
        MObject shellNode::nstart3;

        // Ribs
        //
        MObject shellNode::uamp;                // Section rib amplitude
        MObject shellNode::ufreq;               // Section rib frequency
        MObject shellNode::urib;                // Section rib/wave percent
        MObject shellNode::vamp;                // Profile rib amplitude
        MObject shellNode::vfreq;               // Profile rib frequency
        MObject shellNode::vrib;                // Profile rib/wave percent

    // Output mesh
    //
        MObject shellNode::outMesh;
    
void shellNode::addFloatParameter( MObject & attr, MString longName, 
                                                                   MString briefName, float attrDefault )
//
//  Description:
//      Add a float input parameter to the node
//
{
        MStatus stat;
        MFnNumericAttribute nAttr;
        attr = nAttr.create( longName, briefName, MFnNumericData::kFloat, 
                                                 0.0, &stat );
        if ( stat != MS::kSuccess ) throw stat;

        stat = nAttr.setDefault  ( attrDefault );
        if ( stat != MS::kSuccess ) throw stat;

        stat = nAttr.setKeyable  ( true );
        if ( stat != MS::kSuccess ) throw stat;

        stat = nAttr.setCached   ( true );
        if ( stat != MS::kSuccess ) throw stat;

        stat = nAttr.setStorable ( true );
        if ( stat != MS::kSuccess ) throw stat;

        stat = addAttribute( attr );
        if ( stat != MS::kSuccess ) throw stat;
    
        stat = attributeAffects( attr, outMesh );
        if ( stat != MS::kSuccess ) throw stat;
}

void shellNode::addAngleParameter( MObject & attr, MString longName, 
                                                                   MString briefName, float attrDefault )
//
//  Description:
//      Add an angle input parameter to the node
//
{
        MStatus stat;
        MFnUnitAttribute uAttr;

        MAngle defaultAngle( (double)attrDefault, MAngle::kDegrees );
    
        attr = uAttr.create( longName, briefName, defaultAngle, &stat );
        if ( stat != MS::kSuccess ) throw stat;

        stat = uAttr.setKeyable  ( true );
        if ( stat != MS::kSuccess ) throw stat;

        stat = uAttr.setCached   ( true );
        if ( stat != MS::kSuccess ) throw stat;

        stat = uAttr.setStorable ( true );
        if ( stat != MS::kSuccess ) throw stat;

        stat = addAttribute( attr );
        if ( stat != MS::kSuccess ) throw stat;
    
        stat = attributeAffects( attr, outMesh );
        if ( stat != MS::kSuccess ) throw stat;
}

MStatus shellNode::initialize()
//
//  Description
//      Set up node attributes
//
{
    MFnTypedAttribute   typedFn;
        MStatus                     stat;

    outMesh = typedFn.create( "outMesh", "o", MFnData::kMesh,
                              &stat ); 
    if ( MS::kSuccess != stat ) {
        cerr << "ERROR creating animCube output attribute\n";
        return stat;
    }
    typedFn.setStorable(false);
    typedFn.setWritable(false);
    stat = addAttribute( outMesh );
    McheckErr(stat, "ERROR adding attribute");  
    
        try {
                addAngleParameter( alpha,   "profileParam1",           "pp1",   80.0F );
                addAngleParameter( beta,    "profileParam2",           "pp2",   90.0F );
                addAngleParameter( phi,     "sectionStartingPoint",    "ssp",    1.0F );
                addAngleParameter( my,      "sectionSlant",            "ss",     1.0F );
                addAngleParameter( omega,   "sectionAngleZ",           "saz",    1.0F );
                addAngleParameter( omin,    "spiralStartAngle",        "sps",    0.0F );
                addAngleParameter( omax,    "spiralEndAngle",          "spe", 1200.0F );
                addAngleParameter( od,      "spiralAngleStep",         "spa",    4.0F );
                addAngleParameter( smin,    "sectionStartAngle",       "ssa", -190.0F );
                addAngleParameter( smax,    "sectionEndAngle",         "sea",  190.0F );
                addAngleParameter( sd,      "sectionAngleStep",        "sas",   17.0F );

                addFloatParameter( A,       "distanceFromZ",           "dfz",    1.9F );
                addFloatParameter( a,       "sectionDiameter1",        "sd1",    1.0F );
                addFloatParameter( b,       "sectionDiameter2",        "sd2",    0.9F );
                addFloatParameter( scale,   "scale",                   "s",      0.03F );

                addAngleParameter( P,       "positionOnSection1",      "ps1",   10.0F );
                addFloatParameter( L,       "noduleAmplitude1",        "na1",    1.0F );
                addFloatParameter( N,       "noduleProfileFrequency1", "nf1",   15.0F );
                addAngleParameter( W1,      "noduleFatness11",         "f11",  100.0F );
                addAngleParameter( W2,      "noduleFatness21",         "f21",   20.0F );
                addAngleParameter( nstart,  "spiralStartingPoint1",    "sp1",    0.0F );

                addAngleParameter( P2,      "positionOnSection2",      "ps2",    0.0F );
                addFloatParameter( L2,      "noduleAmplitude2",        "na2",    0.0F );
                addFloatParameter( N2,      "noduleProfileFrequency2", "nf2",    0.0F );
                addAngleParameter( W12,     "noduleFatness12",         "f12",   30.0F );
                addAngleParameter( W22,     "noduleFatness22",         "f22",   30.0F );
                addAngleParameter( off2,    "noduleOffset2",           "no2",    0.0F );
                addAngleParameter( nstart2, "spiralStartingPoint2",    "sp2",    0.0F );

                addAngleParameter( P3,      "positionOnSection3",      "ps3",    0.0F );
                addFloatParameter( L3,      "noduleAmplitude3",        "na3",    0.0F );
                addFloatParameter( N3,      "noduleProfileFrequency3", "nf3",    0.0F );
                addAngleParameter( W13,     "noduleFatness13",         "f13",   30.0F );
                addAngleParameter( W23,     "noduleFatness23",         "f23",   30.0F );
                addAngleParameter( off3,    "noduleOffset3",           "no3",    0.0F );
                addAngleParameter( nstart3, "spiralStartingPoint3",    "sp3",    0.0F );

                addFloatParameter( uamp,    "sectionRibAmplitude",     "sra",    0.0F );
                addFloatParameter( ufreq,   "sectionRibFrequency",     "srf",    0.0F );
                addFloatParameter( urib,    "sectionRibWavePercent",   "srw",    0.0F );
                addFloatParameter( vamp,    "profileRibAmplitude",     "pra",    0.0F );
                addFloatParameter( vfreq,   "profileRibFrequency",     "prf",    0.0F );
                addFloatParameter( vrib,    "profileRibWavePercent",   "prw",    0.0F );
        } catch ( MStatus stat ) {
                fprintf(stderr,"Attribute Initialize Failed\n");
                return stat;
        }

        return MS::kSuccess;
}

inline float shellNode::GetFloatParameter( MObject node, MObject attr )
{
        MPlug plug( node, attr );
        float value;
        plug.getValue( value );
        return value;
}

inline float shellNode::GetAngleParameter( MObject node, MObject attr )
{
        MPlug plug( node, attr );
        MAngle angle;
        plug.getValue( angle );
        return (float)angle.asRadians();
}

#define UpdateFloatAttr(ATTR,TOPOLOGY)                                                  \
    oldValue = shellParams. ATTR;                                                       \
    shellParams. ATTR = GetFloatParameter( thisObj, ATTR );     \
    if ( shellParams. ATTR != oldValue ) {                                      \
            rebuild = true;                                                                                     \
                redoTopology = TOPOLOGY ? true : redoTopology;                  \
        }

#define UpdateAngleAttr(ATTR,TOPOLOGY)                                                  \
    oldValue = shellParams. ATTR;                                                       \
    shellParams. ATTR = GetAngleParameter( thisObj, ATTR );     \
    if ( shellParams. ATTR != oldValue ) {                                      \
            rebuild = true;                                                                                     \
                redoTopology = TOPOLOGY ? true : redoTopology;                  \
        }

void shellNode::UpdateParameters( ) 
//
//  Description
//      Read all of the shell parameters and determine what has changed
//
{
        MObject thisObj = thisMObject();
        float oldValue;

        UpdateAngleAttr(alpha,false);
        UpdateAngleAttr(beta,false);
        UpdateAngleAttr(phi,false);
        UpdateAngleAttr(my,false);
        UpdateAngleAttr(omega,false);
        UpdateFloatAttr(A,false);
        UpdateFloatAttr(a,false);
        UpdateFloatAttr(b,false);
        UpdateFloatAttr(scale,false);

        UpdateAngleAttr(P,false);
        UpdateFloatAttr(L,false);
        UpdateFloatAttr(N,false);
        UpdateAngleAttr(W1,false);
        UpdateAngleAttr(W2,false);
        UpdateAngleAttr(nstart,false);

        UpdateAngleAttr(P2,false);
        UpdateFloatAttr(L2,false);
        UpdateFloatAttr(N2,false);
        UpdateAngleAttr(W12,false);
        UpdateAngleAttr(W22,false);
        UpdateAngleAttr(off2,false);
        UpdateAngleAttr(nstart2,false);
        UpdateAngleAttr(P3,false);
        UpdateFloatAttr(L3,false);
        UpdateFloatAttr(N3,false);
        UpdateAngleAttr(W13,false);
        UpdateAngleAttr(W23,false);
        UpdateAngleAttr(off3,false);
        UpdateAngleAttr(nstart3,false);
        UpdateFloatAttr(uamp,false);
        UpdateFloatAttr(ufreq,false);
        UpdateFloatAttr(urib,false);
        UpdateFloatAttr(vamp,false);
        UpdateFloatAttr(vfreq,false);
        UpdateFloatAttr(vrib,false);

        // These settings change the topology of the geometry
        //
        UpdateAngleAttr(omin,true);
        UpdateAngleAttr(omax,true);
        UpdateAngleAttr(od,true);
        UpdateAngleAttr(smin,true);
        UpdateAngleAttr(smax,true);
        UpdateAngleAttr(sd,true);
}


// Plug-in Initialization //

MStatus initializePlugin( MObject obj )
{ 
        MStatus   status;
        MFnPlugin plugin( obj, PLUGIN_COMPANY, "3.0", "Any");

        status = plugin.registerNode( "shell", shellNode::id, 
                                                 &shellNode::creator, &shellNode::initialize,
                                                 MPxNode::kDependNode );
        if (!status) {
                status.perror("registerNode");
                return status;
        }
        return status;
}

MStatus uninitializePlugin( MObject obj)
{
        MStatus   status;
        MFnPlugin plugin( obj );

        status = plugin.deregisterNode( shellNode::id );
        if (!status) {
                status.perror("deregisterNode");
                return status;
        }

        return status;
}