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

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

    //
    // apiMeshCreator.cpp
    //

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

    #include <apiMeshCreator.h>
    #include <apiMeshData.h>
    #include <api_macros.h>

    #include <maya/MFnMesh.h>
    #include <maya/MFnPluginData.h>
    #include <maya/MFnTypedAttribute.h>
    #include <maya/MFnEnumAttribute.h>
    #include <maya/MFnNumericAttribute.h>

    #ifndef M_PI
    #define M_PI        3.14159265358979323846
    #endif

    #ifndef M_PI_2
    #define M_PI_2      1.57079632679489661923
    #endif

    //
    // Shape implementation
    //

    MObject apiMeshCreator::size;
    MObject apiMeshCreator::shapeType;
    MObject apiMeshCreator::inputMesh;
    MObject apiMeshCreator::outputSurface;

    MTypeId apiMeshCreator::id( 0x80089 );

    apiMeshCreator::apiMeshCreator() {}
    apiMeshCreator::~apiMeshCreator() {}

    //
    // Overrides
    //

    /* override */
    MStatus apiMeshCreator::compute( const MPlug& plug, MDataBlock& datablock )
    //
    // Description
    //
    //    When input attributes are dirty this method will be called to
    //    recompute the output attributes.
    //
    {
        MStatus stat;
        if ( plug == outputSurface ) {
            // Create some user defined geometry data and access the
            // geometry so we can set it
            //
            MFnPluginData fnDataCreator;
            MTypeId tmpid( apiMeshData::id );

            fnDataCreator.create( tmpid, &stat );
            MCHECKERROR( stat, "compute : error creating apiMeshData")

            apiMeshData * newData = (apiMeshData*)fnDataCreator.data( &stat );
            MCHECKERROR( stat, "compute : error gettin at proxy apiMeshData object")

            apiMeshGeom * geomPtr = newData->fGeometry;

            // If there is an input mesh then copy it's values
            // and construct some apiMeshGeom for it.
            //
            bool hasHistory = computeInputMesh( plug, datablock,
                                                geomPtr->vertices,
                                                geomPtr->face_counts,
                                                geomPtr->face_connects,
                                                geomPtr->normals,
                                                geomPtr->uvcoords
                );

            // There is no input mesh so check the shapeType attribute
            // and create either a cube or a sphere.
            //
            if ( !hasHistory ) {
                MDataHandle sizeHandle = datablock.inputValue( size );
                double shape_size = sizeHandle.asDouble();
                MDataHandle typeHandle = datablock.inputValue( shapeType );
                short shape_type = typeHandle.asShort();

                switch( shape_type )
                {
                    case 0 : // build a cube
                        buildCube( shape_size,
                                   geomPtr->vertices,
                                   geomPtr->face_counts,
                                   geomPtr->face_connects,
                                   geomPtr->normals,
                                   geomPtr->uvcoords
                            );
                        break;

                    case 1 : // buld a sphere
                        buildSphere( shape_size,
                                     32,
                                     geomPtr->vertices,
                                     geomPtr->face_counts,
                                     geomPtr->face_connects,
                                     geomPtr->normals,
                                     geomPtr->uvcoords
                            );
                        break;
                } // end switch
            }

            geomPtr->faceCount = geomPtr->face_counts.length();

            // Assign the new data to the outputSurface handle
            //
            MDataHandle outHandle = datablock.outputValue( outputSurface );
            outHandle.set( newData );
            datablock.setClean( plug );
            return MS::kSuccess;
        }
        else {
            return MS::kUnknownParameter;
        }
    }

    //
    // Helper routines
    //

    void apiMeshCreator::buildCube(
        double cube_size,
        MPointArray& pa,
        MIntArray& faceCounts,
        MIntArray& faceConnects,
        MVectorArray& normals,
        apiMeshGeomUV& uvs
    )
    //
    // Description
    //
    //    Constructs a cube
    //
    {
        const int num_faces         = 6;
        const int num_face_connects = 24;
        const double normal_value   = 0.5775;
        const int uv_count          = 14;

        pa.clear(); faceCounts.clear(); faceConnects.clear();
        uvs.reset();

        pa.append( MPoint( -cube_size, -cube_size, -cube_size ) );
        pa.append( MPoint(  cube_size, -cube_size, -cube_size ) );
        pa.append( MPoint(  cube_size, -cube_size,  cube_size ) );
        pa.append( MPoint( -cube_size, -cube_size,  cube_size ) );
        pa.append( MPoint( -cube_size,  cube_size, -cube_size ) );
        pa.append( MPoint( -cube_size,  cube_size,  cube_size ) );
        pa.append( MPoint(  cube_size,  cube_size,  cube_size ) );
        pa.append( MPoint(  cube_size,  cube_size, -cube_size ) );

        normals.append( MVector( -normal_value, -normal_value, -normal_value ) );
        normals.append( MVector(  normal_value, -normal_value, -normal_value ) );
        normals.append( MVector(  normal_value, -normal_value,  normal_value ) );
        normals.append( MVector( -normal_value, -normal_value,  normal_value ) );
        normals.append( MVector( -normal_value,  normal_value, -normal_value ) );
        normals.append( MVector( -normal_value,  normal_value,  normal_value ) );
        normals.append( MVector(  normal_value,  normal_value,  normal_value ) );
        normals.append( MVector(  normal_value,  normal_value, -normal_value ) );

        // Define the UVs for the cube.
        //
        float uv_pts[uv_count * 2] = { 0.375, 0.0,
                                       0.625, 0.0,
                                       0.625, 0.25,
                                       0.375, 0.25,
                                       0.625, 0.5,
                                       0.375, 0.5,
                                       0.625, 0.75,
                                       0.375, 0.75,
                                       0.625, 1.0,
                                       0.375, 1.0,
                                       0.875, 0.0,
                                       0.875, 0.25,
                                       0.125, 0.0,
                                       0.125, 0.25
        };

        // UV Face Vertex Id.
        //
        int uv_fvid [ num_face_connects ] = {  0, 1, 2, 3,
                                               3, 2, 4, 5,
                                               5, 4, 6, 7,
                                               7, 6, 8, 9,
                                               1, 10, 11, 2,
                                               12, 0, 3, 13 };

        int i;
        for ( i = 0; i < uv_count; i ++ ) {
            uvs.append_uv( uv_pts[i*2], uv_pts[i*2 + 1] );
        }

        for ( i = 0; i < num_face_connects; i ++ ) {
            uvs.faceVertexIndex.append( uv_fvid[i] );
        }

        // Set up an array containing the number of vertices
        // for each of the 6 cube faces (4 verticies per face)
        //
        int face_counts[num_faces] = { 4, 4, 4, 4, 4, 4 };

        for ( i=0; i<num_faces; i++ )
        {
            faceCounts.append( face_counts[i] );
        }

        // Set up and array to assign vertices from pa to each face
        //
        int face_connects[ num_face_connects ] = {  0, 1, 2, 3,
                                                    4, 5, 6, 7,
                                                    3, 2, 6, 5,
                                                    0, 3, 5, 4,
                                                    0, 4, 7, 1,
                                                    1, 7, 6, 2  };
        for ( i=0; i<num_face_connects; i++ )
        {
            faceConnects.append( face_connects[i] );
        }
    }

    void apiMeshCreator::buildSphere(
        double              rad,
        int                 div,
        MPointArray &       vertices,
        MIntArray &         counts,
        MIntArray &         connects,
        MVectorArray &      normals,
        apiMeshGeomUV &     uvs
    )
    //
    // Description
    //
    //    Create circles of vertices starting with
    //    the top pole ending with the botton pole
    //
    {
        double u = -M_PI_2;
        double v = -M_PI;
        double u_delta = M_PI / ((double)div);
        double v_delta = 2 * M_PI / ((double)div);

        MPoint topPole( 0.0, rad, 0.0 );
        MPoint botPole( 0.0, -rad, 0.0 );

        // Build the vertex and normal table
        //
        vertices.append( botPole );
        normals.append( botPole-MPoint::origin );
        int i;
        for ( i=0; i<(div-1); i++ )
        {
            u += u_delta;
            v = -M_PI;

            for ( int j=0; j<div; j++ )
            {
                double x = rad * cos(u) * cos(v);
                double y = rad * sin(u);
                double z = rad * cos(u) * sin(v) ;
                MPoint pnt( x, y, z );
                vertices.append( pnt );
                normals.append( pnt-MPoint::origin );
                v += v_delta;
            }
        }
        vertices.append( topPole );
        normals.append( topPole-MPoint::origin );

        // Create the connectivity lists
        //
        int vid = 1;
        int numV = 0;
        for ( i=0; i<div; i++ )
        {
            for ( int j=0; j<div; j++ )
            {
                if ( i==0 ) {
                    counts.append( 3 );
                    connects.append( 0 );
                    connects.append( j+vid );
                    connects.append( (j==(div-1)) ? vid : j+vid+1 );
                }
                else if ( i==(div-1) ) {
                    counts.append( 3 );
                    connects.append( j+vid+1-div );
                    connects.append( vid+1 );
                    connects.append( j==(div-1) ? vid+1-div : j+vid+2-div );
                }
                else {
                    counts.append( 4 );
                    connects.append( j + vid+1-div );
                    connects.append( j + vid+1 );
                    connects.append( j == (div-1) ? vid+1 : j+vid+2 );
                    connects.append( j == (div-1) ? vid+1-div : j+vid+2-div );
                }
                numV++;
            }
            vid = numV;
        }

        // TODO: Define UVs for sphere ...
        //
    }

    MStatus apiMeshCreator::computeInputMesh(
        const MPlug&        plug,
        MDataBlock&         datablock,
        MPointArray&        vertices,
        MIntArray&          counts,
        MIntArray&          connects,
        MVectorArray&       normals,
        apiMeshGeomUV&      uvs
    )
    //
    // Description
    //
    //     This function takes an input surface of type kMeshData and converts
    //     the geometry into this nodes attributes.
    //     Returns kFailure if nothing is connected.
    //
    {
        MStatus stat;

        // Get the input subdiv
        //
        MDataHandle inputData = datablock.inputValue( inputMesh, &stat );
        MCHECKERROR( stat, "compute get inputMesh")
        MObject surf = inputData.asMesh();

        // Check if anything is connected
        //
        MObject thisObj = thisMObject();
        MPlug surfPlug( thisObj, inputMesh );
        if ( !surfPlug.isConnected() ) {
            stat = datablock.setClean( plug );
            MCHECKERROR( stat, "compute setClean" )
            return MS::kFailure;
        }

        // Extract the mesh data
        //
        MFnMesh surfFn (surf, &stat);
        MCHECKERROR( stat, "compute - MFnMesh error" );
        stat = surfFn.getPoints( vertices, MSpace::kObject );
        MCHECKERROR( stat, "compute getPoints");

        // Check to see if we have UVs to copy.
        //
        bool hasUVs = surfFn.numUVs() > 0;
        surfFn.getUVs( uvs.ucoord, uvs.vcoord );

        for ( int i=0; i<surfFn.numPolygons(); i++ )
        {
            MIntArray polyVerts;
            surfFn.getPolygonVertices( i, polyVerts );
            int pvc = polyVerts.length();
            counts.append( pvc );
            int uvId;
            for ( int v=0; v<pvc; v++ ) {
                if ( hasUVs ) {
                    surfFn.getPolygonUVid( i, v, uvId );
                    uvs.faceVertexIndex.append( uvId );
                }
                connects.append( polyVerts[v] );
            }
        }

        for ( int n=0; n<(int)vertices.length(); n++ )
        {
            MVector normal;
            surfFn.getVertexNormal( n, normal );
            normals.append( normal );
        }

        return MS::kSuccess;
    }

    void* apiMeshCreator::creator()
    //
    // Description
    //    Called internally to create a new instance of the users MPx node.
    //
    {
        return new apiMeshCreator();
    }

    MStatus apiMeshCreator::initialize()
    //
    // Description
    //
    //    Attribute (static) initialization. See api_macros.h.
    //
    {
        MStatus             stat;
        MFnTypedAttribute   typedAttr;
        MFnEnumAttribute    enumAttr;

        // ----------------------- INPUTS -------------------------

        MAKE_NUMERIC_ATTR(  size, "size", "sz",
                            MFnNumericData::kDouble, 1,
                            false, false, true );

        shapeType = enumAttr.create( "shapeType", "st", 0, &stat );
        MCHECKERROR( stat, "create shapeType attribute" );
        stat = enumAttr.addField( "cube", 0 );
        MCHECKERROR( stat, "add enum type cube" );
        stat = enumAttr.addField( "sphere", 1 );
        MCHECKERROR( stat, "add enum type sphere" );
        CHECK_MSTATUS( enumAttr.setHidden( false ) );
        CHECK_MSTATUS( enumAttr.setKeyable( true ) );
        ADD_ATTRIBUTE( shapeType );

        MAKE_TYPED_ATTR( inputMesh, "inputMesh", "im", MFnData::kMesh, NULL );

        // ----------------------- OUTPUTS -------------------------
        outputSurface = typedAttr.create( "outputSurface", "os",
                                          apiMeshData::id,
                                          MObject::kNullObj, &stat );
        MCHECKERROR( stat, "create outputSurface attribute" )
        typedAttr.setWritable( false );
        ADD_ATTRIBUTE( outputSurface );

        // ---------- Specify what inputs affect the outputs ----------
        //
        ATTRIBUTE_AFFECTS( inputMesh, outputSurface );
        ATTRIBUTE_AFFECTS( size, outputSurface );
        ATTRIBUTE_AFFECTS( shapeType, outputSurface );

        return MS::kSuccess;
    }