1.7.3Please send us your comment about this page
//- // ========================================================================== // 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; }