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

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

    //
    // File: polyModifierCmd.cpp
    //
    // MEL Command: polyModifierCmd
    //
    // Author: Lonnie Li
    //

    /* Includes */

    #include "polyModifierCmd.h"

    // General Includes
    //
    #include <maya/MGlobal.h>
    #include <maya/MFloatVector.h>
    #include <maya/MObjectArray.h>
    #include <maya/MPlugArray.h>

    #include <maya/MIOStream.h>

    // Function Sets
    //
    #include <maya/MFnDependencyNode.h>
    #include <maya/MFnDagNode.h>
    #include <maya/MFnNumericData.h>

    /* Macros */

    // MCheckStatus (Debugging tool)
    //
    #ifdef _DEBUG
    #   define MCheckStatus(status,message)         \
            if( MS::kSuccess != status ) {          \
                MString error("Status failed: ");   \
                error += message;                   \
                MGlobal::displayError(error);       \
                return status;                      \
            }
    #else
    #   define MCheckStatus(status,message)
    #endif

    // MAssert (Debugging tool)
    //
    #ifdef _DEBUG
    #   define MAssert(state,message)                   \
            if( !state ) {                              \
                MString error("Assertion failed: ");    \
                error += message;                       \
                MGlobal::displayError(error);           \
                return;                                 \
            }
    #else
    #   define MAssert(state,message)
    #endif

    // MStatusAssert (Debugging tool)
    //
    #ifdef _DEBUG
    #   define MStatusAssert(state,message)             \
            if( !state ) {                              \
                MString error("Assertion failed: ");    \
                error += message;                       \
                MGlobal::displayError(error);           \
                return MS::kFailure;                    \
            }
    #else
    #   define MStatusAssert(state,message)
    #endif

    /* polyModifierCmd Implementation */

    polyModifierCmd::polyModifierCmd()
    {
        fDagPathInitialized = false;
        fModifierNodeTypeInitialized = false;
        fModifierNodeNameInitialized = false;
    }

    polyModifierCmd::~polyModifierCmd()
    {}

    // Protected Methods //

    MStatus polyModifierCmd::initModifierNode( MObject /* modifierNode */ )
    //
    //  Description:
    //
    //      Override this method in a derived class to set input attributes on the
    //      modifier node. If not overidden, the modifier node will remain in it's
    //      default state upon construction.
    //
    //      The argument 'MObject modifierNode', is not used by this base class
    //      implementation. However, it may be used by derived classes. To avoid
    //      compiler warnings of unreferenced parameters, we comment out the parameter
    //      name.
    //
    {
        return MS::kSuccess;
    }

    MStatus polyModifierCmd::directModifier( MObject /* mesh */ )
    //
    //  Description:
    //
    //      Override this method in a derived class to provide an implementation for
    //      directly modifying the mesh (writing on the mesh itself). This method is
    //      only called in the case where history does not exist and history is turned
    //      off (ie. DG operations are not desirable).
    //
    //      The argument 'MObject mesh', is not used by this base class implementation.
    //      However, it may be used by derived classes. To avoid compiler warnings
    //      of unreferenced parameters, we comment out the parameter name.
    //
    {
        return MS::kSuccess;
    }

    MStatus polyModifierCmd::doModifyPoly()
    {
        MStatus status = MS::kFailure;

        if( isCommandDataValid() )
        {
            // Get the state of the polyMesh
            //
            collectNodeState();

            if( !fHasHistory && !fHasRecordHistory )
            {
                MObject meshNode = fDagPath.node();

                // Pre-process the mesh - Cache old mesh (including tweaks, if applicable)
                //
                cacheMeshData();
                cacheMeshTweaks();

                // Call the directModifier
                //
                status = directModifier( meshNode );
            }
            else
            {
                MObject modifierNode;
                createModifierNode( modifierNode );
                initModifierNode( modifierNode );
                status = connectNodes( modifierNode );
            }
        }

        return status;
    }

    MStatus polyModifierCmd::redoModifyPoly()
    {
        MStatus status = MS::kSuccess;

        if( !fHasHistory && !fHasRecordHistory )
        {
            MObject meshNode = fDagPath.node();

            // Call the directModifier - No need to pre-process the mesh data again
            //                           since we already have it.
            //
            status = directModifier( meshNode );
        }
        else
        {
            // Call the redo on the DG and DAG modifiers
            //
            if( !fHasHistory )
            {
                fDagModifier.doIt();
            }
            status = fDGModifier.doIt();
        }

        return status;
    }

    MStatus polyModifierCmd::undoModifyPoly()
    {
        MStatus status = MS::kSuccess;

        if( !fHasHistory && !fHasRecordHistory )
        {
            status = undoDirectModifier();
        }
        else
        {
            fDGModifier.undoIt();

            // undoCachedMesh must be called before undoTweakProcessing because
            // undoCachedMesh copies the original mesh *without* tweaks back onto
            // the existing mesh. Any changes done before the copy will be lost.
            //
            if( !fHasHistory )
            {
                status = undoCachedMesh();
                MCheckStatus( status, "undoCachedMesh" );
                fDagModifier.undoIt();
            }

            status = undoTweakProcessing();
            MCheckStatus( status, "undoTweakProcessing" );
        }

        return status;
    }

    // Private Methods //

    bool polyModifierCmd::isCommandDataValid()
    {
        bool valid = true;

        // Check the validity of the DAG path
        //
        if( fDagPathInitialized )
        {
            fDagPath.extendToShape();
            if( !fDagPath.isValid() || fDagPath.apiType() != MFn::kMesh )
            {
                valid = false;
            }
        }
        else
        {
            valid = false;
        }

        // Check the validity of the Modifier node type/name
        //
        if( !fModifierNodeTypeInitialized && !fModifierNodeNameInitialized )
        {
            valid = false;
        }

        return valid;
    }

    void polyModifierCmd::collectNodeState()
    {
        MStatus status;

        // Collect node state information on the given polyMeshShape
        //
        // - HasHistory (Construction History exists)
        // - HasTweaks
        // - HasRecordHistory (Construction History is turned on)
        //
        fDagPath.extendToShape();
        MObject meshNodeShape = fDagPath.node();

        MFnDependencyNode depNodeFn;
        depNodeFn.setObject( meshNodeShape );

        MPlug inMeshPlug = depNodeFn.findPlug( "inMesh" );
        fHasHistory = inMeshPlug.isConnected();

        // Tweaks exist only if the multi "pnts" attribute contains plugs
        // which contain non-zero tweak values. Use false, until proven true
        // search algorithm.
        //
        fHasTweaks = false;
        MPlug tweakPlug = depNodeFn.findPlug( "pnts" );
        if( !tweakPlug.isNull() )
        {
            // ASSERT: tweakPlug should be an array plug!
            //
            MAssert( (tweakPlug.isArray()),
                     "tweakPlug.isArray() -- tweakPlug is not an array plug" );

            MPlug tweak;
            MFloatVector tweakData;
            int i;
            int numElements = tweakPlug.numElements();

            for( i = 0; i < numElements; i++ )
            {
                tweak = tweakPlug.elementByPhysicalIndex( i, &status );
                if( status == MS::kSuccess && !tweak.isNull() )
                {
                    getFloat3PlugValue( tweak, tweakData );
                    if( 0 != tweakData.x ||
                        0 != tweakData.y ||
                        0 != tweakData.z )
                    {
                        fHasTweaks = true;
                        break;
                    }
                }
            }
        }

        int result;
        MGlobal::executeCommand( "constructionHistory -q -tgl", result );
        fHasRecordHistory = (0 != result);
    }

    MStatus polyModifierCmd::createModifierNode( MObject& modifierNode )
    {
        MStatus status = MS::kFailure;

        if( fModifierNodeTypeInitialized || fModifierNodeNameInitialized )
        {
            if( fModifierNodeTypeInitialized )
            {
                modifierNode = fDGModifier.createNode( fModifierNodeType, &status );
            }
            else if( fModifierNodeNameInitialized )
            {
                modifierNode = fDGModifier.createNode( fModifierNodeName, &status );
            }

            // Check to make sure that we have a modifier node of the appropriate type.
            // Requires an inMesh and outMesh attribute.
            //
            MFnDependencyNode depNodeFn( modifierNode );
            MObject inMeshAttr;
            MObject outMeshAttr;
            inMeshAttr = depNodeFn.attribute( "inMesh" );
            outMeshAttr = depNodeFn.attribute( "outMesh" );

            if( inMeshAttr.isNull() || outMeshAttr.isNull() )
            {
                displayError( "Invalid Modifier Node: inMesh and outMesh attributes are required." );
                status = MS::kFailure;
            }
        }

        return status;
    }

    MStatus polyModifierCmd::processMeshNode( modifyPolyData& data )
    {
        MStatus status = MS::kSuccess;

        // Declare our function sets. Use MFnDagNode here so
        // we can retrieve the parent transform.
        //
        MFnDagNode dagNodeFn;

        // Use the DAG path to retrieve our mesh shape node.
        //
        data.meshNodeShape = fDagPath.node();
        dagNodeFn.setObject( data.meshNodeShape );

        // ASSERT: meshNodeShape node should have a parent transform!
        //
        MStatusAssert( (0 < dagNodeFn.parentCount()),
                       "0 < dagNodeFn.parentCount() -- meshNodeshape has no parent transform" );
        data.meshNodeTransform = dagNodeFn.parent(0);

        data.meshNodeDestPlug = dagNodeFn.findPlug( "inMesh" );
        data.meshNodeDestAttr = data.meshNodeDestPlug.attribute();

        return status;
    }

    MStatus polyModifierCmd::processUpstreamNode( modifyPolyData& data )
    {
        MStatus status = MS::kSuccess;

        // Declare our function sets - Although dagNodeFn derives from depNodeFn, we need
        //                             both since dagNodeFn can only refer to DAG objects.
        //                             We will use depNodeFn for all times other when dealing
        //                             with the DAG.
        //
        MFnDependencyNode   depNodeFn;
        MFnDagNode          dagNodeFn;

        // Use the selected node's plug connections to find the upstream plug.
        // Since we are looking at the selected node's inMesh attribute, it will
        // always have only one connection coming in if it has history, and none
        // otherwise.
        //
        // If there is no history, copy the selected node and place it ahead of the
        // modifierNode as the new upstream node so that the modifierNode has an
        // input mesh to operate on.
        //
        MPlugArray tempPlugArray;

        if( fHasHistory )
        {
            // Since we have history, look for what connections exist on the
            // meshNode "inMesh" plug. "inMesh" plugs should only ever have one
            // connection.
            //
            data.meshNodeDestPlug.connectedTo( tempPlugArray, true, false);

            // ASSERT: Only one connection should exist on meshNodeShape.inMesh!
            //
            MStatusAssert( (tempPlugArray.length() == 1),
                           "tempPlugArray.length() == 1 -- 0 or >1 connections on meshNodeShape.inMesh" );
            data.upstreamNodeSrcPlug = tempPlugArray[0];

            // Construction history only deals with shapes, so we can grab the
            // upstreamNodeShape off of the source plug.
            //
            data.upstreamNodeShape = data.upstreamNodeSrcPlug.node();
            depNodeFn.setObject( data.upstreamNodeShape );
            data.upstreamNodeSrcAttr = data.upstreamNodeSrcPlug.attribute();

            // Disconnect the upstream node and the selected node, so we can
            // replace them with our own connections below.
            //
            fDGModifier.disconnect( data.upstreamNodeSrcPlug,
                                    data.meshNodeDestPlug );

        }
        else    // No History (!fHasHistory)
        {
            // Use the DAG node function set to duplicate the shape of the meshNode.
            // The duplicate method will return an MObject handle to the transform
            // of the duplicated shape, so traverse the dag to locate the shape. Store
            // this duplicate shape as our "upstream" node to drive the input for the
            // modifierNode.
            //
            dagNodeFn.setObject( data.meshNodeShape );
            data.upstreamNodeTransform = dagNodeFn.duplicate( false, false );
            dagNodeFn.setObject( data.upstreamNodeTransform );

            // Ensure that our upstreamNode is pointing to a shape.
            //
            MStatusAssert( (0 < dagNodeFn.childCount()),
                           "0 < dagNodeFn.childCount() -- Duplicate meshNode transform has no shape." );
            data.upstreamNodeShape = dagNodeFn.child(0);

            // Re-parent the upstreamNodeShape under our original transform
            //
            status = fDagModifier.reparentNode( data.upstreamNodeShape, data.meshNodeTransform );
            MCheckStatus( status, "reparentNode" );

            // Perform the DAG re-parenting
            //
            // Note: This reparent must be performed before the deleteNode() is called.
            //       See polyModifierCmd.h (see definition of fDagModifier) for more details.
            //
            status = fDagModifier.doIt();
            MCheckStatus( status, "fDagModifier.doIt()" );

            // Mark the upstreamNodeShape (the original shape) as an intermediate object
            // (making it invisible to the user)
            //
            dagNodeFn.setObject( data.upstreamNodeShape );
            dagNodeFn.setIntermediateObject( true );

            // Get the upstream node source attribute
            //
            data.upstreamNodeSrcAttr = dagNodeFn.attribute( "outMesh" );
            data.upstreamNodeSrcPlug = dagNodeFn.findPlug( "outMesh", &status );

            // Remove the duplicated transform node (clean up)
            //
            status = fDagModifier.deleteNode( data.upstreamNodeTransform );
            MCheckStatus( status, "deleteNode" );

            // Perform the DAG delete node
            //
            // Note: This deleteNode must be performed after the reparentNode() method is
            //       completed. See polyModifierCmd.h (see definition of fDagModifier) for
            //       details.
            //
            status = fDagModifier.doIt();
            MCheckStatus( status, "fDagModifier.doIt()" );

            // Cache the DAG path to the duplicate shape
            //
            dagNodeFn.getPath( fDuplicateDagPath );
        }

        return status;
    }

    MStatus polyModifierCmd::processModifierNode( MObject modifierNode,
                                                  modifyPolyData& data )
    {
        MStatus status = MS::kSuccess;

        MFnDependencyNode depNodeFn ( modifierNode );
        data.modifierNodeSrcAttr = depNodeFn.attribute( "outMesh" );
        data.modifierNodeDestAttr = depNodeFn.attribute( "inMesh" );

        return status;
    }

    MStatus polyModifierCmd::processTweaks( modifyPolyData& data )
    {
        MStatus status = MS::kSuccess;

        // Clear tweak undo information (to be rebuilt)
        //
        fTweakIndexArray.clear();
        fTweakVectorArray.clear();

        // Extract the tweaks and place them into a polyTweak node. This polyTweak node
        // will be placed ahead of the modifier node to maintain the order of operations.
        // Special care must be taken into recreating the tweaks:
        //
        //      1) Copy tweak info (including connections!)
        //      2) Remove tweak info from both meshNode and a duplicate meshNode (if applicable)
        //      3) Cache tweak info for undo operations
        //
        if( fHasTweaks )
        {
            // Declare our function sets
            //
            MFnDependencyNode depNodeFn;

            // Declare our attributes and plugs
            //
            MPlug   meshTweakPlug;
            MPlug   upstreamTweakPlug;
            MObject tweakNodeTweakAttr;

            // Declare our tweak processing variables
            //
            MPlug               tweak;
            MPlug               tweakChild;
            MObject             tweakData;
            MObjectArray        tweakDataArray;
            MFloatVector        tweakVector;

            MIntArray           tweakSrcConnectionCountArray;
            MPlugArray          tweakSrcConnectionPlugArray;
            MIntArray           tweakDstConnectionCountArray;
            MPlugArray          tweakDstConnectionPlugArray;

            MPlugArray          tempPlugArray;

            unsigned i;
            unsigned j;
            unsigned k;

            // Create the tweak node and get its attributes
            //
            data.tweakNode = fDGModifier.createNode( "polyTweak" );
            depNodeFn.setObject( data.tweakNode );
            data.tweakNodeSrcAttr = depNodeFn.attribute( "output" );
            data.tweakNodeDestAttr = depNodeFn.attribute( "inputPolymesh" );
            tweakNodeTweakAttr = depNodeFn.attribute( "tweak" );

            depNodeFn.setObject( data.meshNodeShape );
            meshTweakPlug = depNodeFn.findPlug( "pnts" );

            // ASSERT: meshTweakPlug should be an array plug!
            //
            MStatusAssert( (meshTweakPlug.isArray()),
                           "meshTweakPlug.isArray() -- meshTweakPlug is not an array plug" );
            unsigned numElements = meshTweakPlug.numElements();

            // Gather meshTweakPlug data
            //
            for( i = 0; i < numElements; i++ )
            {
                // MPlug::numElements() only returns the number of physical elements
                // in the array plug. Thus we must use elementByPhysical index when using
                // the index i.
                //
                tweak = meshTweakPlug.elementByPhysicalIndex(i);

                // If the method fails, the element is NULL. Only append the index
                // if it is a valid plug.
                //
                if( !tweak.isNull() )
                {
                    // Cache the logical index of this element plug
                    //
                    unsigned logicalIndex = tweak.logicalIndex();

                    // Collect tweak data and cache the indices and float vectors
                    //
                    tweak.getValue( tweakData );
                    tweakDataArray.append( tweakData );
                    getFloat3PlugValue( tweak, tweakVector );
                    fTweakIndexArray.append( logicalIndex );
                    fTweakVectorArray.append( tweakVector );

                    // Collect tweak connection data
                    //
                    // Parse down to the deepest level of the plug tree and check
                    // for connections - look at the child nodes of the element plugs.
                    // If any connections are found, record the connection and disconnect
                    // it.
                    //

                    // ASSERT: The element plug should be compound!
                    //
                    MStatusAssert( (tweak.isCompound()),
                                   "tweak.isCompound() -- Element tweak plug is not compound" );

                    unsigned numChildren = tweak.numChildren();
                    for( j = 0; j < numChildren; j++ )
                    {
                        tweakChild = tweak.child(j);
                        if( tweakChild.isConnected() )
                        {
                            // Get all connections with this plug as source, if they exist
                            //
                            tempPlugArray.clear();
                            if( tweakChild.connectedTo( tempPlugArray, false, true ) )
                            {
                                unsigned numSrcConnections = tempPlugArray.length();
                                tweakSrcConnectionCountArray.append( numSrcConnections );

                                for( k = 0; k < numSrcConnections; k++ )
                                {
                                    tweakSrcConnectionPlugArray.append( tempPlugArray[k] );
                                    fDGModifier.disconnect( tweakChild, tempPlugArray[k] );
                                }
                            }
                            else
                            {
                                tweakSrcConnectionCountArray.append(0);
                            }

                            // Get the connection with this plug as destination, if it exists
                            //
                            tempPlugArray.clear();
                            if( tweakChild.connectedTo( tempPlugArray, true, false ) )
                            {
                                // ASSERT: tweakChild should only have one connection as destination!
                                //
                                MStatusAssert( (tempPlugArray.length() == 1),
                                               "tempPlugArray.length() == 1 -- 0 or >1 connections on tweakChild" );

                                tweakDstConnectionCountArray.append(1);
                                tweakDstConnectionPlugArray.append( tempPlugArray[0] );
                                fDGModifier.disconnect( tempPlugArray[0], tweakChild );
                            }
                            else
                            {
                                tweakDstConnectionCountArray.append(0);
                            }
                        }
                        else
                        {
                            tweakSrcConnectionCountArray.append(0);
                            tweakDstConnectionCountArray.append(0);
                        }
                    }
                }
            }

            // Apply meshTweakPlug data to our polyTweak node
            //
            MPlug polyTweakPlug( data.tweakNode, tweakNodeTweakAttr );
            unsigned numTweaks = fTweakIndexArray.length();
            int srcOffset = 0;
            int dstOffset = 0;

            for( i = 0; i < numTweaks; i++ )
            {
                // Apply tweak data
                //
                tweak = polyTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
                tweak.setValue( tweakDataArray[i] );

                // ASSERT: Element plug should be compound!
                //
                MStatusAssert( (tweak.isCompound()),
                               "tweak.isCompound() -- Element plug, 'tweak', is not compound" );

                unsigned numChildren = tweak.numChildren();
                for( j = 0; j < numChildren; j++ )
                {
                    tweakChild = tweak.child(j);

                    // Apply tweak source connection data
                    //
                    if( 0 < tweakSrcConnectionCountArray[i*numChildren + j] )
                    {
                        for( k = 0;
                             k < (unsigned) tweakSrcConnectionCountArray[i*numChildren + j];
                             k++ )
                        {
                            fDGModifier.connect( tweakChild,
                                                 tweakSrcConnectionPlugArray[srcOffset] );
                            srcOffset++;
                        }
                    }

                    // Apply tweak destination connection data
                    //
                    if( 0 < tweakDstConnectionCountArray[i*numChildren + j] )
                    {
                        fDGModifier.connect( tweakDstConnectionPlugArray[dstOffset],
                                             tweakChild );
                        dstOffset++;
                    }
                }
            }

    /*      // Now, set the tweak values on the meshNode(s) to zero (History dependent)
            //
            MFnNumericData numDataFn;
            MObject nullVector;

            // Create a NULL vector (0,0,0) using MFnNumericData to pass into the plug
            //
            numDataFn.create( MFnNumericData::k3Float );
            numDataFn.setData( 0, 0, 0 );
            nullVector = numDataFn.object();

            for( i = 0; i < numTweaks; i++ )
            {
                // Access using logical indices since they are the only plugs guaranteed
                // to hold tweak data.
                //
                tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
                tweak.setValue( nullVector );
            }

            // Only have to clear the tweaks off the duplicate mesh if we do not have history
            // and we want history.
            //
            if( !fHasHistory && fHasRecordHistory )
            {
                depNodeFn.setObject( data.upstreamNodeShape );
                upstreamTweakPlug = depNodeFn.findPlug( "pnts" );

                if( !upstreamTweakPlug.isNull() )
                {
                    for( i = 0; i < numTweaks; i++ )
                    {
                        tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
                        tweak.setValue( nullVector );
                    }
                }
            }
    */  }

        return status;
    }

    MStatus polyModifierCmd::connectNodes( MObject modifierNode )
    //
    //  Description:
    //
    //      This method connects up the modifier nodes, while accounting for DG factors
    //      such as construction history and tweaks. The method has a series of steps which
    //      it runs through to process nodes under varying circumstances:
    //
    //      1) Gather meshNode connection data (ie. attributes and plugs)
    //
    //      2) Gather upstreamNode data - This is history-dependent. If the node has history,
    //                                    an actual upstreamNode exists and that is used to
    //                                    drive the input of our modifierNode.
    //
    //                                    Otherwise, if the node does not have history, the
    //                                    meshNode is duplicated, set as an intermediate object
    //                                    and regarded as our new upstreamNode which will drive
    //                                    the input of our modifierNode. The case with history
    //                                    already has this duplicate meshNode at the top, driving
    //                                    all other history nodes and serving as a reference
    //                                    to the "original state" of the node before any
    //                                    modifications.
    //
    //      3) Gather modifierNode connection data
    //
    //      4) Process tweak data (if it exists) - This is history-dependent. If there is
    //                                             history, the tweak data is extracted and deleted
    //                                             from the meshNode and encapsulated inside a
    //                                             polyTweak node. The polyTweak node is then
    //                                             inserted ahead of the modifier node.
    //
    //                                             If there is no history, the same is done as
    //                                             in the history case, except the tweaks are
    //                                             deleted from the duplicate meshNode in addition
    //                                             to the actual meshNode.
    //
    //      5) Connect the nodes
    //
    //      6) Collapse/Bake nodes into the actual meshNode if the meshNode had no previous
    //         construction history and construction history recording is turned off.
    //         (ie. (!fHasHistory && !fHasRecordHistory) == true )
    //
    {
        MStatus status;

        // Declare our internal processing data structure (see polyModifierCmd.h for definition)
        //
        modifyPolyData data;

        // Get the mesh node, plugs and attributes
        //
        status = processMeshNode( data );
        MCheckStatus( status, "processMeshNode" );

        // Get upstream node, plugs and attributes
        //
        status = processUpstreamNode( data );
        MCheckStatus( status, "processUpstreamNode" );

        // Get the modifierNode attributes
        //
        status = processModifierNode( modifierNode,
                             data );
        MCheckStatus( status, "processModifierNode" );

        // Process tweaks on the meshNode
        //
        status = processTweaks( data );
        MCheckStatus( status, "processTweaks" );

        // Connect the nodes
        //
        if( fHasTweaks )
        {
            MPlug tweakDestPlug( data.tweakNode, data.tweakNodeDestAttr );
            status = fDGModifier.connect( data.upstreamNodeSrcPlug, tweakDestPlug );
            MCheckStatus( status, "upstream-tweak connect failed" );

            MPlug tweakSrcPlug( data.tweakNode, data.tweakNodeSrcAttr );
            MPlug modifierDestPlug( modifierNode, data.modifierNodeDestAttr );
            status = fDGModifier.connect( tweakSrcPlug, modifierDestPlug );
            MCheckStatus( status, "tweak-modifier connect failed" );
        }
        else
        {
            MPlug modifierDestPlug( modifierNode, data.modifierNodeDestAttr );
            status = fDGModifier.connect( data.upstreamNodeSrcPlug, modifierDestPlug );
            MCheckStatus( status, "upstream-modifier connect failed" );
        }

        MPlug modifierSrcPlug( modifierNode, data.modifierNodeSrcAttr );
        MPlug meshDestAttr( data.meshNodeShape, data.meshNodeDestAttr );
        status = fDGModifier.connect( modifierSrcPlug, meshDestAttr );
        MCheckStatus( status, "modifier-mesh connect failed" );

        status = fDGModifier.doIt();

        return status;
    }

    MStatus polyModifierCmd::cacheMeshData()
    {
        MStatus status = MS::kSuccess;

        MFnDependencyNode depNodeFn;
        MFnDagNode dagNodeFn;

        MObject meshNode = fDagPath.node();
        MObject dupMeshNode;
        MPlug dupMeshNodeOutMeshPlug;

        // Duplicate the mesh
        //
        dagNodeFn.setObject( meshNode );
        dupMeshNode = dagNodeFn.duplicate();

        MDagPath dupMeshDagPath;
        MDagPath::getAPathTo( dupMeshNode, dupMeshDagPath );
        dupMeshDagPath.extendToShape();

        depNodeFn.setObject( dupMeshDagPath.node() );
        dupMeshNodeOutMeshPlug = depNodeFn.findPlug( "outMesh", &status );
        MCheckStatus( status, "Could not retrieve outMesh" );

        // Retrieve the meshData
        //
        status = dupMeshNodeOutMeshPlug.getValue( fMeshData );
        MCheckStatus( status, "Could not retrieve meshData" );

        // Delete the duplicated node
        //
        MGlobal::deleteNode( dupMeshNode );

        return status;
    }

    MStatus polyModifierCmd::cacheMeshTweaks()
    {
        MStatus status = MS::kSuccess;

        // Clear tweak undo information (to be rebuilt)
        //
        fTweakIndexArray.clear();
        fTweakVectorArray.clear();

        // Extract the tweaks and store them in our local tweak cache members
        //
        if( fHasTweaks )
        {
            // Declare our function sets
            //
            MFnDependencyNode depNodeFn;

            MObject meshNode = fDagPath.node();
            MPlug   meshTweakPlug;

            // Declare our tweak processing variables
            //
            MPlug               tweak;
            MPlug               tweakChild;
            MObject             tweakData;
            MObjectArray        tweakDataArray;
            MFloatVector        tweakVector;

            MPlugArray          tempPlugArray;

            unsigned i;

            depNodeFn.setObject( meshNode );
            meshTweakPlug = depNodeFn.findPlug( "pnts" );

            // ASSERT: meshTweakPlug should be an array plug!
            //
            MStatusAssert( (meshTweakPlug.isArray()),
                           "meshTweakPlug.isArray() -- meshTweakPlug is not an array plug" );
            unsigned numElements = meshTweakPlug.numElements();

            // Gather meshTweakPlug data
            //
            for( i = 0; i < numElements; i++ )
            {
                // MPlug::numElements() only returns the number of physical elements
                // in the array plug. Thus we must use elementByPhysical index when using
                // the index i.
                //
                tweak = meshTweakPlug.elementByPhysicalIndex(i);

                // If the method fails, the element is NULL. Only append the index
                // if it is a valid plug.
                //
                if( !tweak.isNull() )
                {
                    // Cache the logical index of this element plug
                    //
                    unsigned logicalIndex = tweak.logicalIndex();

                    // Collect tweak data and cache the indices and float vectors
                    //
                    getFloat3PlugValue( tweak, tweakVector );
                    fTweakIndexArray.append( logicalIndex );
                    fTweakVectorArray.append( tweakVector );
                }
            }
        }

        return status;
    }

    MStatus polyModifierCmd::undoCachedMesh()
    {
        MStatus status;

        // Only need to restore the cached mesh if there was no history. Also
        // check to make sure that we are in the record history state.
        //
        MStatusAssert( (fHasRecordHistory), "fHasRecordHistory == true" );

        if( !fHasHistory )
        {
            MFnDependencyNode depNodeFn;

            MString meshNodeName;
            MObject meshNodeShape;
            MPlug   meshNodeDestPlug;
            MPlug   meshNodeOutMeshPlug;
            MObject dupMeshNodeShape;
            MPlug   dupMeshNodeSrcPlug;

            meshNodeShape = fDagPath.node();
            dupMeshNodeShape = fDuplicateDagPath.node();

            depNodeFn.setObject( meshNodeShape );
            meshNodeName = depNodeFn.name();
            meshNodeDestPlug = depNodeFn.findPlug( "inMesh", &status );
            MCheckStatus( status, "Could not retrieve inMesh" );
            meshNodeOutMeshPlug = depNodeFn.findPlug( "outMesh", &status );
            MCheckStatus( status, "Could not retrieve outMesh" );

            depNodeFn.setObject( dupMeshNodeShape );
            dupMeshNodeSrcPlug = depNodeFn.findPlug( "outMesh", &status );
            MCheckStatus( status, "Could not retrieve outMesh" );

            // For the case with tweaks, we cannot write the mesh directly back onto
            // the cachedInMesh, since the shape can have out of date information from the
            // cachedInMesh, thus we temporarily connect the duplicate mesh shape to the
            // mesh shape and force a DG evaluation.
            //
            // For the case without tweaks, we can simply write onto the outMesh, since
            // the shape relies solely on an outMesh when there is no history nor tweaks.
            //
            if( fHasTweaks )
            {
                MDGModifier dgModifier;
                dgModifier.connect( dupMeshNodeSrcPlug, meshNodeDestPlug );
                status = dgModifier.doIt();
                MCheckStatus( status, "Could not connect dupMeshNode -> meshNode" );

                // Need to force a DG evaluation now that the input has been changed.
                //
                MString cmd( "dgeval -src " );
                cmd += meshNodeName;
                cmd += ".inMesh";
                status = MGlobal::executeCommand( cmd, false, false );
                MCheckStatus( status, "Could not force DG eval" );

                // Disconnect the duplicate meshNode now
                //
                dgModifier.undoIt();
            }
            else
            {
                MObject meshData;
                status = dupMeshNodeSrcPlug.getValue( meshData );
                MCheckStatus( status, "Could not retrieve meshData" );
                status = meshNodeOutMeshPlug.setValue( meshData );
                MCheckStatus( status, "Could not set outMesh" );
            }
        }

        return status;
    }

    MStatus polyModifierCmd::undoTweakProcessing()
    {
        MStatus status = MS::kSuccess;

        if( fHasTweaks )
        {
            MFnDependencyNode depNodeFn;

            MObject meshNodeShape;
            MPlug   meshTweakPlug;
            MPlug   tweak;
            MObject tweakData;

            meshNodeShape = fDagPath.node();
            depNodeFn.setObject( meshNodeShape );
            meshTweakPlug = depNodeFn.findPlug( "pnts" );

            MStatusAssert( (meshTweakPlug.isArray()),
                           "meshTweakPlug.isArray() -- meshTweakPlug is not an array plug" );

            unsigned i;
            unsigned numElements = fTweakIndexArray.length();

            for( i = 0; i < numElements; i++ )
            {
                tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
                getFloat3asMObject( fTweakVectorArray[i], tweakData );
                tweak.setValue( tweakData );
            }

            // In the case of no history, the duplicate node shape will be disconnected on undo
            // so, there is no need to undo the tweak processing on it.
            //
        }

        return status;
    }

    MStatus polyModifierCmd::undoDirectModifier()
    {
        MStatus status;

        MFnDependencyNode depNodeFn;
        MFnDagNode dagNodeFn;

        MObject meshNode = fDagPath.node();
        depNodeFn.setObject( meshNode );

        // For the case with tweaks, we cannot write the mesh directly back onto
        // the cachedInMesh, since the shape can have out of date information from the
        // cachedInMesh. Thus we temporarily create an duplicate mesh, place our
        // old mesh on the outMesh attribute of our duplicate mesh, connect the
        // duplicate mesh shape to the mesh shape, and force a DG evaluation.
        //
        // For the case without tweaks, we can simply write onto the outMesh, since
        // the shape relies solely on an outMesh when there is no history nor tweaks.
        //
        if( fHasTweaks )
        {
            // Retrieve the inMesh and name of our mesh node (for the DG eval)
            //
            depNodeFn.setObject( meshNode );
            MPlug meshNodeInMeshPlug = depNodeFn.findPlug( "inMesh", &status );
            MCheckStatus( status, "Could not retrieve inMesh" );
            MString meshNodeName = depNodeFn.name();

            // Duplicate our current mesh
            //
            dagNodeFn.setObject( meshNode );
            MObject dupMeshNode = dagNodeFn.duplicate();

            // The dagNodeFn::duplicate() returns a transform, but we need a shape
            // so retrieve the DAG path and extend it to the shape.
            //
            MDagPath dupMeshDagPath;
            MDagPath::getAPathTo( dupMeshNode, dupMeshDagPath );
            dupMeshDagPath.extendToShape();

            // Retrieve the outMesh of the duplicate mesh and set our mesh data back
            // on it.
            //
            depNodeFn.setObject( dupMeshDagPath.node() );
            MPlug dupMeshNodeOutMeshPlug = depNodeFn.findPlug( "outMesh", &status );
            MCheckStatus( status, "Could not retrieve outMesh" );
            status = dupMeshNodeOutMeshPlug.setValue( fMeshData );

            // Temporarily connect the duplicate mesh node to our mesh node
            //
            MDGModifier dgModifier;
            dgModifier.connect( dupMeshNodeOutMeshPlug, meshNodeInMeshPlug );
            status = dgModifier.doIt();
            MCheckStatus( status, "Could not connect dupMeshNode -> meshNode" );

            // Need to force a DG evaluation now that the input has been changed.
            //
            MString cmd("dgeval -src ");
            cmd += meshNodeName;
            cmd += ".inMesh";
            status = MGlobal::executeCommand( cmd, false, false );
            MCheckStatus( status, "Could not force DG eval" );

            // Disconnect and delete the duplicate mesh node now
            //
            dgModifier.undoIt();
            MGlobal::deleteNode( dupMeshNode );

            // Restore the tweaks on the mesh
            //
            status = undoTweakProcessing();
        }
        else
        {
            // Restore the original mesh by writing the old mesh data (fMeshData) back
            // onto the outMesh of our meshNode
            //
            depNodeFn.setObject( meshNode );
            MPlug meshNodeOutMeshPlug = depNodeFn.findPlug( "outMesh", &status );
            MCheckStatus( status, "Could not retrieve outMesh" );
            status = meshNodeOutMeshPlug.setValue( fMeshData );
            MCheckStatus( status, "Could not set meshData" );
        }

        return status;
    }

    MStatus polyModifierCmd::getFloat3PlugValue( MPlug plug, MFloatVector & value )
    {
        // Retrieve the value as an MObject
        //
        MObject object;
        plug.getValue( object );

        // Convert the MObject to a float3
        //
        MFnNumericData numDataFn( object );
        numDataFn.getData( value[0], value[1], value[2] );
        return MS::kSuccess;
    }

    MStatus polyModifierCmd::getFloat3asMObject( MFloatVector value, MObject& object )
    {
        // Convert the float value into an MObject
        //
        MFnNumericData numDataFn;
        numDataFn.create( MFnNumericData::k3Float );
        numDataFn.setData( value[0], value[1], value[2] );
        object = numDataFn.object();
        return MS::kSuccess;
    }