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

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

    //
    // meshMapUtils.cpp
    //
    // Description:
    //    Utility functions for the meshRemap and meshReorder commands
    //       moveToolContext
    //

    #include <assert.h>

    #include "meshMapUtils.h"

    #include <maya/MIntArray.h>
    #include <maya/MFnMesh.h>
    #include <maya/MItMeshEdge.h>
    #include <maya/MItMeshPolygon.h>
    #include <maya/MGlobal.h>
    #include <maya/MFloatPointArray.h>
    #include <maya/MDagPath.h>
    #include <maya/MDagPathArray.h>
    #include <maya/MObjectArray.h>
    #include <maya/MItMeshVertex.h>

    //
    // Modulating index, will return 0..l-1, for any integer value
    #define IDX(i, l) ( ( i + l ) % l )

    //
    // Intersect the current face list with the one provided, keep only the common elements
    //
    void meshMapUtils::intersectArrays( MIntArray& selection, MIntArray& moreFaces )
    {
        int j = selection.length() - 1;
        while ( j >= 0 )
        {
            bool found = false;;

            // For each item in moreFaces, try find it in fSelectedFaces
            for( unsigned int i = 0 ; i < moreFaces.length(); i++ )
            {
                if( selection[j] == moreFaces[i] )
                {
                    found = true;
                    break;
                }
            }

            if( !found )
            {
                selection.remove(j);
            }

            j--;
        }
    }

    //
    //  Recursively traverse a mesh by processing each face, and the neighbouring faces along it's edges.
    //  The initial invocation of this routine provides the basis for the new first vertex/edge
    //  and faces.
    //
    //  The result of this routine is an array of values that map the old CV indices to the new ones. Along
    //  the a new list of reindexed CVs is built, along with a list of poly counts and connetions. These
    //  can be used to build a new mesh with the reordering specfied by the seed face and vertices.
    //
    //
    //  Inputs:
    //      path                : Path to the object being traversed
    //      faceIdx             : Current face being traversed
    //      v0, v1              : Veretices that define the direction of travel along the face
    //      faceTraversal       : An array booleans to track which faces have been
    //                          : traversed, controls the recursion
    //      origVertices        : The vertices from the original mesh. The could be obtained
    //                          : from the path, but are passed in for efficiency
    //
    //  Outputs:
    //      cvMapping           : Mapping of the existing vertices to their new indices
    //                          : the fist values in the final array will be the intial v0, v1
    //      cvMappingInverse    : The inverse of the cvMapping
    //                          : the value of items v0 and v1 will be 0 and 1 respectively
    //      newPolygonCounts    : Vertex counts for each of the new faces
    //      newPolygonConnects  : Connections, specified in terms of new CV indices
    //      newVertices         : The orginal vertices resorted based on the reindexing
    //
    //
    MStatus meshMapUtils::traverseFace(
        MDagPath&   path,
        int faceIdx,
        int v0,
        int v1,
        MIntArray& faceTraversal,
        MIntArray& cvMapping,
        MIntArray& cvMappingInverse,
        MIntArray& newPolygonCounts,
        MIntArray& newPolygonConnects,
        MFloatPointArray& origVertices,
        MFloatPointArray& newVertices
    )
    {
        int vtxCnt = -1;
        int dir = 0;
        int dummy;      // For setIndex calls

        MStatus stat = MStatus::kSuccess;

        MFnMesh theMesh( path, &stat );
        MItMeshPolygon polyIt( path );
        MItMeshEdge edgeIt( path );

        if( stat != MStatus::kSuccess )
        {
            MGlobal::displayError( " theMesh.getPoint failed");
            return stat;
        }

        //
        // Skip over any faces already processed, this is not a failure
        //
        if( faceTraversal[faceIdx] )
        {
            return MStatus::kSuccess;
        }

        //
        // get the vertex/edge information and sort it based on the user seed
        //
        MIntArray vtxOrig;
        MIntArray edgeOrig;

        polyIt.setIndex( faceIdx, dummy );
        polyIt.getEdges( edgeOrig );
        polyIt.getVertices( vtxOrig );

        vtxCnt = vtxOrig.length();

        //
        // the sorted V/E info
        //
        MIntArray vtxSorted( vtxCnt );
        MIntArray edgeSorted( vtxCnt );

        //
        // Build a new array ordered with v0, then v1, first figure out the
        // starting point, and direction
        //
        int v0Idx = -1;
        int i;
        for( i = 0; i < vtxCnt; i++ )
        {
            if( vtxOrig[i] == v0 )
            {
                // We've found v0, now find in what direction we need to travel to find v1

                v0Idx = i;

                if( vtxOrig[IDX(i+1, vtxCnt)] == v1 )
                {
                    dir = 1;
                }
                else if( vtxOrig[IDX(i-1, vtxCnt)] == v1 )
                {
                    dir = -1;
                }
                break;
            }
        }

        if (dir == 0)
        {
            MGlobal::displayError("Selected vertices are not adjacent");
            return MS::kFailure;
        }

        // Now sort the vertex/edge arrays
        for( i = 0; i < vtxCnt; i++ )
        {
            vtxSorted[i] = vtxOrig[IDX( v0Idx + i * dir, vtxCnt )];
            if( dir == 1 )
            {
                edgeSorted[i] = edgeOrig[IDX( v0Idx + i * dir, vtxCnt )];
            }
            else
            {
                edgeSorted[i] = edgeOrig[IDX( v0Idx - 1 + i * dir, vtxCnt )];
            }
        }

        // Add any new CVs to the vertex array being constructed
        for ( i = 0; i < vtxCnt; i++ )
        {
            MPoint pos;
            int index = vtxSorted[i];

            if( cvMapping[index] == -1  )
            {
                if( stat != MStatus::kSuccess )
                {
                    MGlobal::displayError( " theMesh.getPoint failed");
                    return stat;
                }

                // Added the new CV, and mark it as transferred
                newVertices.append( origVertices[index] );

                // Store the mapping from the old CV indices to the new ones
                cvMapping[index] = newVertices.length()-1;
                cvMappingInverse[newVertices.length()-1] = index;
            }

        }

        //
        //  Add the new face count
        //
        newPolygonCounts.append( vtxCnt );

        //
        //  Add the new polyConnects

        for ( i = 0; i < vtxCnt; i++ )
        {
            newPolygonConnects.append( cvMapping[vtxSorted[i]] );
        }

        // Mark this face as complete
        faceTraversal[faceIdx] = true;

        //
        //  Now recurse over the edges of this face
        //
        for( i = 0; i < (int)edgeSorted.length(); i++ )
        {
            int nextEdge = edgeSorted[i];

            int2 nextEdgeVtx;
            stat = theMesh.getEdgeVertices(nextEdge, nextEdgeVtx );

            //
            // Find the vertex, in the sorted array, that starts the next edge
            int baseIdx = -1;
            bool swap = false;
            int j;
            for( j = 0; j < (int)vtxSorted.length(); j++ )
            {
                if( vtxSorted[j] == nextEdgeVtx[0] )
                {
                    baseIdx = j;
                    break;
                }
            }

            assert( baseIdx != -1 );

            //
            // Now look forward and backward in the vertex array to find the
            // edge's other point, this indicates the edges direction. This
            // is needed to guide the next recursion level, and keep the
            // normals pointed consistenly
            //
            if( vtxSorted[IDX(baseIdx+1, vtxCnt)] == nextEdgeVtx[1] )
            {
                // Nothing
            }
            else if ( vtxSorted[IDX(baseIdx-1, vtxCnt)] == nextEdgeVtx[1] )
            {
                swap = true;
            }

            MIntArray connectedFaces;
            edgeIt.setIndex( nextEdge, dummy );
            edgeIt.getConnectedFaces( connectedFaces );

            // A single face is simply the current one. Recurse over the others
            if( connectedFaces.length() > 1 )
            {
                int nextFace;
                if( connectedFaces[0] == faceIdx )
                {
                    nextFace = connectedFaces[1];
                }
                else
                {
                    nextFace = connectedFaces[0];
                }

                int nextVtx0 = -1;
                int nextVtx1 = -1;
                if ( !swap )
                {
                    nextVtx0 = nextEdgeVtx[1];
                    nextVtx1 = nextEdgeVtx[0];
                }
                else
                {
                    nextVtx0 = nextEdgeVtx[0];
                    nextVtx1 = nextEdgeVtx[1];
                }

                stat = traverseFace( path, nextFace, nextVtx0, nextVtx1, faceTraversal,
                        cvMapping, cvMappingInverse,
                        newPolygonCounts, newPolygonConnects,
                        origVertices, newVertices );

                // Break out of edge loop on error
                if( stat != MStatus::kSuccess )
                {
                    break;
                }
            }
        }

        return stat;
    }

    //
    //  Given a list of 3 paths and compoents find the face they define and store their indices
    //
    MStatus meshMapUtils::validateFaceSelection( MDagPathArray& paths, MObjectArray& components, int *faceIdx, MIntArray *seedVtx )
    {
        MStatus stat = MStatus::kSuccess;
        MIntArray finalFaceList;

        if ( paths.length() != 3 || components.length() != 3 )
        {
            return MStatus::kFailure;
        }

        seedVtx->clear();

        for (unsigned int i = 0; i < 3; i++)
        {
            MItMeshVertex fIt ( paths[i], components[i], &stat );
            if( stat != MStatus::kSuccess || fIt.isDone() )
            {
                MGlobal::displayError( " MItMeshVertex failed");
                return MStatus::kFailure;
            }

            seedVtx->append( fIt.index() ); // The  cv's location

            MIntArray  faceList;
            stat = fIt.getConnectedFaces ( faceList );
            if( stat != MStatus::kSuccess )
            {
                MGlobal::displayError( " getConnectedFaces failed");
                return MStatus::kFailure;
            }

            if( i == 0 )
            {
                finalFaceList = faceList;
            }
            else
            {
                meshMapUtils::intersectArrays( finalFaceList, faceList );
            }
        }

        if( finalFaceList.length() != 1 )
        {
            return MStatus::kFailure;
        }
        else
        {
            *faceIdx = finalFaceList[0];
        }

        MDagPath p0( paths[0] );
        MDagPath p1( paths[1] );
        MDagPath p2( paths[2] );

        if( !(p0 == p1 ) || !(p0 == p2 ))
        {
            return MStatus::kFailure;
        }

        return MStatus::kSuccess;
    }