meshOpCmd/meshOpFtyAction.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 "meshOpFty.h"

// General Includes
//
#include <maya/MGlobal.h>
#include <maya/MIOStream.h>
#include <maya/MFloatPointArray.h>

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

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

#define CHECK_STATUS(st) if ((st) != MS::kSuccess) { break; }

MStatus meshOpFty::doIt()
//
//  Description:
//      Performs the operation on the selected mesh and components
//
{
    MStatus status;
    unsigned int i, j;

    // Get access to the mesh's function set
    //
    MFnMesh meshFn(fMesh);

    // The division count argument is used in many of the operations
    // to execute the operation multiple subsequent times. For example,
    // with a division count of 2 in subdivide face, the given faces will be
    // divide once and then the resulting inner faces will be divided again.
    //
    int divisionCount = 2;

    MFloatVector translation;
    if (fOperationType == kExtrudeEdges
        || fOperationType == kExtrudeFaces
        || fOperationType == kDuplicateFaces
        || fOperationType == kExtractFaces)
    {
        // The translation vector is used for the extrude, extract and 
        // duplicate operations to move the result to a new position. For 
        // example, if you extrude an edge on a mesh without a subsequent 
        // translation, the extruded edge will be on at the position of the 
        // orignal edge and the created faces will have no area.
        // 
        // Here, we provide a translation that is in the same direction as the
        // average normal of the given components.
        //
        MFn::Type componentType = getExpectedComponentType(fOperationType);
        MIntArray adjacentVertexList;
        switch (componentType)
        {
        case MFn::kMeshEdgeComponent:
            for (i = 0; i < fComponentIDs.length(); ++i)
            {
                int2 vertices;
                meshFn.getEdgeVertices(fComponentIDs[i], vertices);
                adjacentVertexList.append(vertices[0]);
                adjacentVertexList.append(vertices[1]);
            }
            break;

        case MFn::kMeshPolygonComponent:
            for (i = 0; i < fComponentIDs.length(); ++i)
            {
                MIntArray vertices;
                meshFn.getPolygonVertices(fComponentIDs[i], vertices);
                for (j = 0; j < vertices.length(); ++j)
                    adjacentVertexList.append(vertices[j]);
            }
            break;
        default:    
            break;
        }
        MVector averageNormal(0, 0, 0);
        for (i = 0; i < adjacentVertexList.length(); ++i)
        {
            MVector vertexNormal;
            meshFn.getVertexNormal(adjacentVertexList[i], vertexNormal,
                MSpace::kWorld);
            averageNormal += vertexNormal;
        }
        if (averageNormal.length() < 0.001)
            averageNormal = MVector(0.0, 1.0, 0.0);
        else averageNormal.normalize();
        translation = averageNormal;
    }

    // When doing an extrude operation, there is a choice of extrude the
    // faces/edges individually or together. If extrudeTogether is true and 
    // multiple adjacent components are selected, they will be extruded as if
    // it were one more complex component.
    //
    // The following variable sets that option.
    //
    bool extrudeTogether = true;

    // Execute the requested operation
    //
    switch (fOperationType)
    {
    case kSubdivideEdges: {
        status = meshFn.subdivideEdges(fComponentIDs, divisionCount);
        CHECK_STATUS(status);
        break; }

    case kSubdivideFaces: {
        status = meshFn.subdivideFaces(fComponentIDs, divisionCount);
        CHECK_STATUS(status);
        break; }

    case kExtrudeEdges: {
        status = meshFn.extrudeEdges(fComponentIDs, divisionCount,
            &translation, extrudeTogether);
        CHECK_STATUS(status);
        break; }

    case kExtrudeFaces: {
        status = meshFn.extrudeFaces(fComponentIDs, divisionCount,
            &translation, extrudeTogether);
        CHECK_STATUS(status);
        break; }

    case kCollapseEdges: {
        status = meshFn.collapseEdges(fComponentIDs);
        CHECK_STATUS(status);
        break; }

    case kCollapseFaces: {
        status = meshFn.collapseFaces(fComponentIDs);
        CHECK_STATUS(status);
        break; }

    case kDuplicateFaces: {
        status = meshFn.duplicateFaces(fComponentIDs, &translation);
        CHECK_STATUS(status);
        break; }

    case kExtractFaces: {
        status = meshFn.extractFaces(fComponentIDs, &translation);
        CHECK_STATUS(status);
        break; }

    case kSplitLightning: {
        status = doLightningSplit(meshFn);
        CHECK_STATUS(status);
        break; }

    default:
        status = MS::kFailure;
        break;
    }

    return status;
}

MStatus meshOpFty::doLightningSplit(MFnMesh& meshFn)
//
//  Description:
//      Performs the kSplitLightning operation on the selected mesh
//      and components. It may not split all the selected components.
//
{
    unsigned int i, j;

    // These are the input arrays to the split function. The following
    // algorithm fills them in with the arguments for a continuous
    // split that goes through some of the selected faces.
    //
    MIntArray placements;
    MIntArray edgeIDs;
    MFloatArray edgeFactors;
    MFloatPointArray internalPoints;
    
    // The following array is going to be used to determine which faces
    // have been split. Since the split function can only split faces
    // which are adjacent to the earlier face, we may not split
    // all the faces
    //
    bool* faceTouched = new bool[fComponentIDs.length()];
    for (i = 0; i < fComponentIDs.length(); ++i)
        faceTouched[i] = false;
    
    // We need a starting point. For this example, the first face in
    // the component list is picked. Also get a polygon iterator
    // to this face.
    // 
    MItMeshPolygon itPoly(fMesh);
    for (; !itPoly.isDone(); itPoly.next())
    {
        if (fComponentIDs[0] == (int)itPoly.index()) break;
    }
    if (itPoly.isDone())
    {
        // Should never happen.
        //
        delete [] faceTouched;
        return MS::kFailure;
    }
    
    // In this example, edge0 is called the starting edge and
    // edge1 is called the destination edge. This algorithm will split
    // each face from the starting edge to the destination edge
    // while going through two inner points inside each face.
    //
    int edge0, edge1;
    MPoint innerVert0, innerVert1;
    int nextFaceIndex = 0;
    
    // We need a starting edge. For this example, the first edge in the
    // edge list is used.
    //
    MIntArray edgeList;
    itPoly.getEdges(edgeList);
    edge0 = edgeList[0];
    
    bool done = false;
    while (!done)
    {
        // Set this face as touched so that we don't try to split it twice
        //
        faceTouched[nextFaceIndex] = true;
        
        // Get the current face's center. It is used later in the
        // algorithm to calculate inner vertices.
        //
        MPoint faceCenter = itPoly.center();
            
        // Iterate through the connected faces to find an untouched,
        // selected face and get the ID of the shared edge. That face
        // will become the next face to be split.
        //
        MIntArray faceList;
        itPoly.getConnectedFaces(faceList);
        nextFaceIndex = -1;
        for (i = 0; i < fComponentIDs.length(); ++i)
        {
            for (j = 0; j < faceList.length(); ++j)
            {
                if (fComponentIDs[i] == faceList[j] && !faceTouched[i])
                {
                    nextFaceIndex = i;
                    break;
                }
            }
            if (nextFaceIndex != -1) break;
        }
        
        if (nextFaceIndex == -1)
        {
            // There is no selected and untouched face adjacent to this
            // face, so this algorithm is done. Pick the first edge that
            // is not the starting edge as the destination edge.
            //
            done = true;
            edge1 = -1;
            for (i = 0; i < edgeList.length(); ++i)
            {
                if (edgeList[i] != edge0)
                {
                    edge1 = edgeList[i];
                    break;
                }
            }
            if (edge1 == -1)
            {
                // This should not happen, since there should be more than
                // one edge for each face
                //
                delete [] faceTouched;
                return MS::kFailure;
            }
        }
        else
        {
            // The next step is to find out which edge is shared between
            // the two faces and use it as the destination edge. To do
            // that, we need to iterate through the faces and get the
            // next face's list of edges.
            //
            itPoly.reset();
            for (; !itPoly.isDone(); itPoly.next())
            {
                if (fComponentIDs[nextFaceIndex] == (int)itPoly.index()) break;
            }
            if (itPoly.isDone()) 
            {
                // Should never happen.
                //
                delete [] faceTouched;
                return MS::kFailure;
            }
            
            // Look for a common edge ID in the two faces edge lists
            //
            MIntArray nextFaceEdgeList;
            itPoly.getEdges(nextFaceEdgeList);
            edge1 = -1;
            for (i = 0; i < edgeList.length(); ++i)
            {
                for (j = 0; j < nextFaceEdgeList.length(); ++j)
                {
                    if (edgeList[i] == nextFaceEdgeList[j])
                    {
                        edge1 = edgeList[i];
                        break;
                    }
                }
                if (edge1 != -1) break;
            }
            if (edge1 == -1)
            {
                // Should never happen.
                //
                delete [] faceTouched;
                return MS::kFailure;
            }
            
            // Save the edge list for the next iteration
            //
            edgeList = nextFaceEdgeList;
        }
        
        // Calculate the two inner points that the split will go through.
        // For this example, the midpoints between the center and the two
        // farthest vertices of the edges are used.
        //
        // Find the 3D positions of the edges' vertices
        //
        MPoint edge0vert0, edge0vert1, edge1vert0, edge1vert1;
        MItMeshEdge itEdge(fMesh, MObject::kNullObj );
        for (; !itEdge.isDone(); itEdge.next())
        {
            if (itEdge.index() == edge0)
            {
                edge0vert0 = itEdge.point(0);
                edge0vert1 = itEdge.point(1);
            }
            if (itEdge.index() == edge1)
            {
                edge1vert0 = itEdge.point(0);
                edge1vert1 = itEdge.point(1);
            }
        }
        
        // Figure out which are the farthest from each other
        //
        double distMax = edge0vert0.distanceTo(edge1vert0);
        MPoint max0, max1;
        max0 = edge0vert0;
        max1 = edge1vert0;
        double newDist = edge0vert1.distanceTo(edge1vert0);
        if (newDist > distMax)
        {
            max0 = edge0vert1;
            max1 = edge1vert0;
            distMax = newDist;
        }
        newDist = edge0vert0.distanceTo(edge1vert1);
        if (newDist > distMax)
        {
            max0 = edge0vert0;
            max1 = edge1vert1;
            distMax = newDist;
        }
        newDist = edge0vert1.distanceTo(edge1vert1);
        if (newDist > distMax)
        {
            max0 = edge0vert1;
            max1 = edge1vert1;
        }
        
        // Calculate the two inner points
        //
        innerVert0 = (faceCenter + max0) / 2.0;
        innerVert1 = (faceCenter + max1) / 2.0;
        
        // Add this split's information to the input arrays. If this is
        // the last split, also add the destination edge's split information.
        //
        placements.append((int) MFnMesh::kOnEdge);
        placements.append((int) MFnMesh::kInternalPoint);
        placements.append((int) MFnMesh::kInternalPoint);
        if (done) placements.append((int) MFnMesh::kOnEdge);
        
        edgeIDs.append(edge0);
        if (done) edgeIDs.append(edge1);
        
        edgeFactors.append(0.5f);
        if (done) edgeFactors.append(0.5f);
        
        MFloatPoint point1((float)innerVert0[0], (float)innerVert0[1],
            (float)innerVert0[2], (float)innerVert0[3]);
        MFloatPoint point2((float)innerVert1[0], (float)innerVert1[1],
            (float)innerVert1[2], (float)innerVert1[3]);
        internalPoints.append(point1);
        internalPoints.append(point2);
        
        // For the next iteration, the current destination
        // edge becomes the start edge.
        //
        edge0 = edge1;
    }

    // Release the dynamically-allocated memory and do the actual split
    //
    delete [] faceTouched;
    return meshFn.split(placements, edgeIDs, edgeFactors, internalPoints);
}