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

#include "meshOpCmd.h"
#include "meshOpNode.h"

// Function Sets
//
#include <maya/MFnDependencyNode.h>
#include <maya/MFnMesh.h>
#include <maya/MFnSingleIndexedComponent.h>

// Iterators
//
#include <maya/MItSelectionList.h>
#include <maya/MItMeshPolygon.h>

// General Includes
//
#include <maya/MGlobal.h>
#include <maya/MSelectionList.h>
#include <maya/MPlug.h>
#include <maya/MArgList.h>

#include <maya/MIOStream.h>

// Status Checking Macro - MCheckStatus (Debugging tool)
//
#define MCheckStatus(status,message)    \
    if( MS::kSuccess != status ) {      \
        cerr << message << "\n";        \
        return status;                  \
    }


meshOp::meshOp()
//
//  Description:
//      meshOp constructor
//
{
    fOperation = (MeshOperation) 0;
}

meshOp::~meshOp()
//
//  Description:
//      meshOp destructor
//
{}

void* meshOp::creator()
//
//  Description:
//      this method exists to give Maya a way to create new objects
//      of this type. 
//
//  Return Value:
//      a new object of this type
//
{
    return new meshOp();
}

bool meshOp::isUndoable() const
//
//  Description:
//      this method tells Maya this command is undoable.  It is added to the 
//      undo queue if it is.
//
//  Return Value:
//      true if this command is undoable.
//
{
    return true;
}

MStatus meshOp::doIt( const MArgList& argList )
//
//  Description:
//      implements the MEL meshOp command.
//
//  Arguments:
//      argList - the argument list that was passes to the command from MEL
//
//  Return Value:
//      MS::kSuccess - command succeeded
//      MS::kFailure - command failed (returning this value will cause the 
//                     MEL script that is being run to terminate unless the
//                     error is caught using a "catch" statement.
//
{
    MStatus status;
    bool badArgument = false;

    // Only one parameter is expected to be passed to this command: the mesh
    // operation type. Get it, validate it or stop prematurely
    //
    if (argList.length() == 1)
    {
        int operationTypeArgument = argList.asInt(0);
        if (operationTypeArgument < 0
            || operationTypeArgument > kMeshOperationCount - 1)
        {
            badArgument = true;
        }
        else
        {
            fOperation = (MeshOperation)operationTypeArgument;
        }
    }
    else badArgument = true;

    if (badArgument)
    {
        cerr << "Expecting one parameter: the operation type." << endl;
        cerr << "Valid types are: " << endl;
        cerr << "   0 - Subdivide edge(s)." << endl;
        cerr << "   1 - Subdivide face(s)." << endl;
        cerr << "   2 - Extrude edge(s)." << endl;
        cerr << "   3 - Extrude face(s)." << endl;
        cerr << "   4 - Collapse edge(s)." << endl;
        cerr << "   5 - Collapse face(s)." << endl;
        cerr << "   6 - Duplicate face(s)." << endl;
        cerr << "   7 - Extract face(s)." << endl;
        cerr << "   8 - Split face(s)." << endl;
        displayError(" Expecting one parameter: the operation type.");
        return MS::kFailure;
    }

    // Each mesh operation only supports one type of components
    // 
    MFn::Type componentType = meshOpFty::getExpectedComponentType(fOperation);

    // Parse the selection list for selected components of the right type.
    // To simplify things, we only take the first object that we find with
    // selected components and operate on that object alone.
    //
    // All other objects are ignored and return warning messages indicating
    // this limitation.
    //
    MSelectionList selList;
    MGlobal::getActiveSelectionList( selList );
    MItSelectionList selListIter( selList );
    selListIter.setFilter( MFn::kMesh );

    // The meshOperation node only accepts a component list input, so we build
    // a component list using MFnComponentListData.
    //
    // MIntArrays could also be passed into the node to represent the ids,
    // but are less storage efficient than component lists, since consecutive 
    // components are bundled into a single entry in component lists.
    //
    MFnComponentListData compListFn;
    compListFn.create();
    bool found = false;
    bool foundMultiple = false;

    for( ; !selListIter.isDone(); selListIter.next() )
    {
        MDagPath dagPath;
        MObject component;
        selListIter.getDagPath( dagPath, component );

        // Check for selected components of the right type
        //
        if( component.apiType() == componentType )
        {
            if( !found )
            {
                // The variable 'component' holds all selected components 
                // on the selected object, thus only a single call to 
                // MFnComponentListData::add() is needed to store the selected
                // components for a given object.
                //
                compListFn.add( component );

                // Copy the component list created by MFnComponentListData
                // into our local component list MObject member.
                //
                fComponentList = compListFn.object();

                // Locally store the actual ids of the selected components so 
                // that this command can directly modify the mesh in the case 
                // when there is no history and history is turned off.
                //
                MFnSingleIndexedComponent compFn( component );

                // Ensure that this DAG path will point to the shape 
                // of our object. Set the DAG path for the polyModifierCmd.
                //
                dagPath.extendToShape();
                setMeshNode( dagPath );
                found = true;
            }
            else
            {
                // Break once we have found a multiple object holding 
                // selected components, since we are not interested in how 
                // many multiple objects there are, only the fact that there
                // are multiple objects.
                //
                foundMultiple = true;
                break;
            }
        }
    }
    if( foundMultiple )
    {
        displayWarning("Found more than one object with selected components.");
        displayWarning("Only operating on first found object.");
    }

    // Initialize the polyModifierCmd node type - mesh node already set
    //
    setModifierNodeType( meshOpNode::id );

    if( found )
    {
        // Now, pass control over to the polyModifierCmd::doModifyPoly() method
        // to handle the operation.
        //
        status = doModifyPoly();
        
        if( status == MS::kSuccess )
        {
            setResult( "meshOp command succeeded!" );
        }
        else
        {
            displayError( "meshOp command failed!" );
        }
    }
    else
    {
        displayError(
            "meshOp command failed: Unable to find selected components" );
        status = MS::kFailure;
    }
    
    return status;
}

MStatus meshOp::redoIt()
//
//  Description:
//      Implements redo for the MEL meshOp command. 
//
//      This method is called when the user has undone a command of this type
//      and then redoes it.  No arguments are passed in as all of the necessary
//      information is cached by the doIt method.
//
//  Return Value:
//      MS::kSuccess - command succeeded
//      MS::kFailure - redoIt failed.  this is a serious problem that will
//                     likely cause the undo queue to be purged
//
{
    MStatus status;

    // Process the polyModifierCmd
    //
    status = redoModifyPoly();

    if( status == MS::kSuccess )
    {
        setResult( "meshOp command succeeded!" );
    }
    else
    {
        displayError( "meshOp command failed!" );
    }

    return status;
}

MStatus meshOp::undoIt()
//
//  Description:
//      implements undo for the MEL meshOp command.  
//
//      This method is called to undo a previous command of this type.  The 
//      system should be returned to the exact state that it was it previous 
//      to this command being executed.  That includes the selection state.
//
//  Return Value:
//      MS::kSuccess - command succeeded
//      MS::kFailure - redoIt failed.  this is a serious problem that will
//                     likely cause the undo queue to be purged
//
{
    MStatus status;

    status = undoModifyPoly();

    if( status == MS::kSuccess )
    {
        setResult( "meshOp undo succeeded!" );
    }
    else
    {
        setResult( "meshOp undo failed!" );
    }
    
    return status;
}

MStatus meshOp::initModifierNode( MObject modifierNode )
{
    MStatus status;

    // We need to tell the meshOp node which components to operate on.
    // By overriding, the polyModifierCmd::initModifierNode() method,
    // we can insert our own modifierNode initialization code.
    //
    MFnDependencyNode depNodeFn( modifierNode );
    MObject cpListAttr = depNodeFn.attribute( "inputComponents" );

    // Pass the component list down to the meshOp node
    //
    MPlug cpListPlug( modifierNode, cpListAttr );
    status = cpListPlug.setValue( fComponentList );
    if (status != MS::kSuccess) return status;

    // Similarly for the operation type
    //
    MObject opTypeAttr = depNodeFn.attribute( "operationType" );
    MPlug opTypePlug( modifierNode, opTypeAttr );
    status = opTypePlug.setValue( fOperation );

    return status;
}

MStatus meshOp::directModifier( MObject mesh )
{
    MStatus status;

    fmeshOpFactory.setMesh( mesh );
    fmeshOpFactory.setComponentList( fComponentList );
    fmeshOpFactory.setComponentIDs( fComponentIDs );
    fmeshOpFactory.setMeshOperation( fOperation );

    // Now, perform the meshOp
    //
    status = fmeshOpFactory.doIt();

    return status;
}