1.7.3Please send us your comment about this page
//- // ========================================================================== // Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved. // // Use of this software is subject to the terms of the Autodesk // license agreement provided at the time of installation or download, // or which otherwise accompanies this software in either electronic // or hard copy form. // ========================================================================== //+ // // 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; }