//-
// ==========================================================================
// 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;
}