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