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

# meshReorderCmd.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 "meshMapUtils.h"
    #include "meshReorderCmd.h"

    #include <maya/MArgList.h>
    #include <maya/MDagPathArray.h>
    #include <maya/MFnMesh.h>
    #include <maya/MFnMeshData.h>
    #include <maya/MIOStream.h>
    #include <maya/MItSelectionList.h>
    #include <maya/MItMeshVertex.h>
    #include <maya/MPlug.h>
    #include <maya/MString.h>

    // CONSTRUCTOR DEFINITION:
    meshReorderCommand::meshReorderCommand()
    {
        fClampedArray = NULL;
        fRepArray = NULL;
        fColorArrays = NULL;
        fVertexColorArrays = NULL;
        fColorIdsArrays = NULL;
        fUArrays = NULL;
        fVArrays = NULL;
        fUVIdsArrays = NULL;
    }

    // DESTRUCTOR DEFINITION:
    meshReorderCommand::~meshReorderCommand()
    {
        resetColorsUVsMemory();
    }

    // METHOD FOR CREATING AN INSTANCE OF THIS COMMAND:
    void* meshReorderCommand::creator()
    {
        return new meshReorderCommand;
    }

    MStatus meshReorderCommand::parseArgs(const MArgList& args)
    {
        MStatus stat;
        MString err;

        if( args.length() != 3 )
        {
            displayError("3 vertices must be specified");
            return MS::kFailure;
        }

        MObjectArray selectedComponent(3);
        MDagPathArray selectedPath;

        selectedPath.setLength(3);

        int argIdx = 0;
        for (unsigned int j = 0; j < 3; j++)
        {
            MString arg;

            if( ( stat = args.get( argIdx, arg )) != MStatus::kSuccess )
            {
                displayError( "Can't parse arg");
                return stat;
            }

            MSelectionList list;
            if (! list.add( arg ) )
            {
                err = arg + ": no such component";
                displayError(err);
                return MS::kFailure; // no such component
            }

            MItSelectionList selectionIt (list, MFn::kComponent);
            if (selectionIt.isDone ())
            {
                err = arg + ": not a component";
                displayError (err);
                return MS::kFailure;
            }

            if( selectionIt.getDagPath (selectedPath[j], selectedComponent[j]) != MStatus::kSuccess )
            {
                displayError( "Can't get path for");
                return stat;
            }

            if (!selectedPath[j].node().hasFn(MFn::kMesh) && !(selectedPath[j].node().hasFn(MFn::kTransform) && selectedPath[j].hasFn(MFn::kMesh)))
            {
                err = arg + ": Invalid type!  Only a mesh or its transform can be specified!";
                displayError (err);
                return MStatus::kFailure;
            }

            argIdx++;
        }

        if( ( stat = meshMapUtils::validateFaceSelection( selectedPath, selectedComponent, &fFaceIdxSrc, &fFaceVtxSrc ) ) != MStatus::kSuccess )
        {
            displayError("Selected vertices don't define a unique face on source mesh");
            return stat;
        }

        fDagPathSrc = selectedPath[0];

        return stat;
    }

    // FIRST INVOKED WHEN COMMAND IS CALLED, PARSING THE COMMAND ARGUMENTS, INITIALIZING DEFAULT PARAMETERS, THEN CALLING redoIt():
    MStatus meshReorderCommand::doIt(const MArgList& args)
    {
        MStatus  stat = MStatus::kSuccess;

        if ( ( stat = parseArgs( args ) ) != MStatus::kSuccess )
        {
            displayError ("Error parsing arguments");
            return stat;
        }

        return redoIt();
    }

    MStatus meshReorderCommand::redoIt()
    {
        MStatus  stat = MStatus::kSuccess;

        MIntArray           newPolygonCounts;
        MIntArray           newPolygonConnects;
        MFloatPointArray    origVertices;
        MFloatPointArray    newVertices;

        unsigned i;

        MFnMesh theMesh( fDagPathSrc, &stat );
        if( stat != MStatus::kSuccess )
        {
            displayError(" MFnMesh creation");
            return stat;
        }

        //  The mesh cannot have history or this won't work.
        MPlug   historyPlug = theMesh.findPlug("inMesh", true);

        if (historyPlug.isDestination()) {
            displayError("The mesh has history. Its geometry cannot be modified.");
            return MS::kInvalidParameter;
        }

        stat = theMesh.getPoints (origVertices, MSpace::kObject );
        if( stat != MStatus::kSuccess )
        {
            displayError(" MFnMesh getPoints");
            return stat;
        }

        // Initialize the traversal flags and CV mappings for this shape
        MIntArray           faceTraversal( theMesh.numPolygons(), false );
        MIntArray cvMapping(theMesh.numVertices(), -1);
        MIntArray cvMappingInverse(theMesh.numVertices(), -1);

        //
        //  Starting with the user selected face, recursively rebuild the entire mesh
        //
        stat = meshMapUtils::traverseFace( fDagPathSrc, fFaceIdxSrc, fFaceVtxSrc[0], fFaceVtxSrc[1], faceTraversal,
                        cvMapping, cvMappingInverse,
                        newPolygonCounts, newPolygonConnects,
                        origVertices, newVertices );

        if ( stat != MStatus::kSuccess )
        {
            displayError(" could not process all the mesh faces.");
            return stat;
        }

        // Store mesh vertices and connectivity information for undo. Must collect the information here before it is
        // modified by createInPlace() call.
        fVertices.copy(origVertices);
        MItMeshPolygon polyIter(fDagPathSrc.node());
        while(!polyIter.isDone())
        {
            fPolygonCounts.append(polyIter.polygonVertexCount());
            for(i = 0; i < polyIter.polygonVertexCount(); i++)
            {
                fPolygonConnects.append(polyIter.vertexIndex(i));
            }
            polyIter.next();
        }

        fColorSetNames.clear();
        theMesh.getColorSetNames(fColorSetNames);
        int numColorSets = fColorSetNames.length();
        fColorArrays = new MColorArray[numColorSets];
        fColorIdsArrays = new MIntArray[numColorSets];

        collectColorsUVs(theMesh, false);

        stat = theMesh.createInPlace( newVertices.length(), newPolygonCounts.length(), newVertices, newPolygonCounts, newPolygonConnects );

        if ( stat != MStatus::kSuccess )
        {
            displayError(" MFnMesh::createInPlace failed.");

            fCVMapping.clear();
            fCVMappingInverse.clear();
            fVertices.clear();
            fPolygonCounts.clear();
            fPolygonConnects.clear();
            delete [] fColorArrays;  fColorArrays = NULL;
            delete [] fColorIdsArrays;fColorIdsArrays = NULL;

            // Free memeory allocated in collectColorsUVs()
            resetColorsUVsMemory();

            return stat;
        }

        assignColorsUVs(theMesh, cvMapping, cvMappingInverse, false);

        // Store fCVMapping and fCVMappingInverse for undo
        fCVMapping = cvMapping;
        fCVMappingInverse = cvMappingInverse;

        return stat;
    }

    MStatus meshReorderCommand::undoIt()
    {
        MStatus  stat = MStatus::kSuccess;
        MFnMesh theMesh( fDagPathSrc );

        fColorSetNames.clear();
        theMesh.getColorSetNames(fColorSetNames);

        collectColorsUVs(theMesh, true);

        stat = theMesh.createInPlace( fVertices.length(), fPolygonCounts.length(), fVertices, fPolygonCounts, fPolygonConnects );

        assignColorsUVs(theMesh, fCVMappingInverse, fCVMapping, true);

        fCVMapping.clear();
        fCVMappingInverse.clear();
        fVertices.clear();
        fPolygonCounts.clear();
        fPolygonConnects.clear();
        delete [] fColorArrays;  fColorArrays = NULL;
        delete [] fColorIdsArrays;fColorIdsArrays = NULL;

        return stat;
    }

    void meshReorderCommand::collectColorsUVs(MFnMesh &theMesh, bool isUndo)
    {
        int i;
        // Store Colors
        int numColorSets = fColorSetNames.length();
        fClampedArray = new bool[numColorSets];
        fRepArray = new MFnMesh::MColorRepresentation[numColorSets];
        fVertexColorArrays = new MColorArray[numColorSets];

        for (i = 0; i < numColorSets; i++)
        {
            fClampedArray[i] = theMesh.isColorClamped(fColorSetNames[i]);
            fRepArray[i] = theMesh.getColorRepresentation(fColorSetNames[i]);
            // We need to use two different approaches to set colors because unfortunately
            // setVertexColors() doesn't work in the case of undo and setColors() will
            // require a huge effort to construct the colorIds in the non undo case.
            theMesh.getVertexColors(fVertexColorArrays[i], &(fColorSetNames[i]));

            if(!isUndo) {
                theMesh.getColors(fColorArrays[i], &(fColorSetNames[i]));
                unsigned nth = 0;
                fColorIdsArrays[i].setLength(theMesh.numColors(fColorSetNames[i]));
                MItMeshPolygon polyIter(fDagPathSrc.node());
                while(!polyIter.isDone())
                {
                    for(unsigned j = 0; j < polyIter.polygonVertexCount(); j++)
                    {
                        unsigned polygonIdx = polyIter.index();
                        int colorId;
                        theMesh.getColorIndex(polygonIdx, j, colorId, &(fColorSetNames[i]));
                        fColorIdsArrays[i][nth] = colorId;
                        nth++;
                    }
                    polyIter.next();
                }
            }
            theMesh.deleteColorSet(fColorSetNames[i]);
        }

        // Store UVs
        fUVSetNames.clear();
        theMesh.getUVSetNames(fUVSetNames);
        int numUVSets = fUVSetNames.length();
        fUArrays = new MFloatArray[numUVSets];
        fVArrays = new MFloatArray[numUVSets];
        fUVIdsArrays = new MIntArray[numUVSets];

        for (i = 0; i < numUVSets; i++)
        {
            MIntArray uvCounts;
            MIntArray uvIds;
            theMesh.getAssignedUVs(uvCounts, uvIds, &(fUVSetNames[i]));

            unsigned nth = 0;
            fUVIdsArrays[i].setLength(fVertices.length());
            MItMeshPolygon polyIter(fDagPathSrc.node());
            while(!polyIter.isDone())
            {
                for(unsigned j = 0; j < polyIter.polygonVertexCount(); j++)
                {
                    unsigned vertexIdx = polyIter.vertexIndex(j);
                    fUVIdsArrays[i][vertexIdx] = uvIds[nth];
                    nth++;
                }
                polyIter.next();
            }

            theMesh.getUVs(fUArrays[i], fVArrays[i], &(fUVSetNames[i]));
            theMesh.deleteUVSet(fUVSetNames[i]);
        }
    }

    void meshReorderCommand::assignColorsUVs(MFnMesh &theMesh, MIntArray &colorMapping, MIntArray &uvMapping, bool isUndo)
    {
        int i;

        // Copy Colors
        MString defaultColorSetName;
        theMesh.getCurrentColorSetName(defaultColorSetName);
        int numColorSets = fColorSetNames.length();
        for (i = 0; i < numColorSets; i++)
        {
            // Not to duplicate default color set
            if (fColorSetNames[i] != defaultColorSetName)
            {
                theMesh.createColorSet(fColorSetNames[i], NULL, fClampedArray[i], fRepArray[i]);
            }

            if (fVertexColorArrays[i].length() > 0 && fVertexColorArrays[i].length() == fVertices.length())
            {
                // We need to use two different approaches to set colors because unfortunately
                // setVertexColors() doesn't work in the case of undo and setColors() will
                // require a huge effort to construct the colorIds in the non undo case.
                if(!isUndo)
                {
                    theMesh.setVertexColors(fVertexColorArrays[i], colorMapping, NULL, fRepArray[i]);
                } else {
                    theMesh.setColors(fColorArrays[i], NULL, fRepArray[i]);
                    theMesh.assignColors(fColorIdsArrays[i], &(fColorSetNames[i]));
                }
            }
        }

        // Copy UVs
        MString defaultUVSetName;
        theMesh.getCurrentUVSetName(defaultUVSetName);
        int numUVSets = fUVSetNames.length();
        for (i = 0; i < numUVSets; i++)
        {
            // Not to duplicate default uv set
            if (fUVSetNames[i] != defaultUVSetName)
            {
                theMesh.createUVSet(fUVSetNames[i]);
            }

            if (fUArrays[i].length() > 0 && fUArrays[i].length() == fVArrays[i].length())
            {
                theMesh.setUVs(fUArrays[i], fVArrays[i], &(fUVSetNames[i]));
                MItMeshPolygon polyIter(fDagPathSrc.node());
                while(!polyIter.isDone())
                {
                    for(unsigned j = 0; j < polyIter.polygonVertexCount(); j++)
                    {
                        unsigned polygonIdx = polyIter.index();
                        unsigned vertexIdx = polyIter.vertexIndex(j);
                        int uvId = fUVIdsArrays[i][uvMapping[vertexIdx]];
                        theMesh.assignUV(polygonIdx, j, uvId);
                    }
                    polyIter.next();
                }
            }
        }

        resetColorsUVsMemory();
    }

    void meshReorderCommand::resetColorsUVsMemory()
    {
        if (fClampedArray != NULL)
        {
            delete [] fClampedArray;
            fClampedArray = NULL;
        }
        if (fRepArray != NULL)
        {
            delete [] fRepArray;
            fRepArray = NULL;
        }
        if (fVertexColorArrays != NULL)
        {
            delete [] fVertexColorArrays;
            fVertexColorArrays = NULL;
        }
        if (fUArrays != NULL)
        {
            delete [] fUArrays;
            fUArrays = NULL;
        }
        if (fVArrays != NULL)
        {
            delete [] fVArrays;
            fVArrays = NULL;
        }
        if (fUVIdsArrays != NULL)
        {
            delete [] fUVIdsArrays;
            fUVIdsArrays = NULL;
        }
        fColorSetNames.clear();
        fUVSetNames.clear();
    }