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

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