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

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

    //
    // File: flipUVCmd.cpp
    //
    // MEL Command: flipUV
    //

    #include <flipUVCmd.h>

    #include <maya/MIOStream.h>
    #include <maya/MSyntax.h>
    #include <maya/MArgDatabase.h>
    #include <maya/MIntArray.h>
    #include <maya/MFloatArray.h>
    #include <maya/MFnMesh.h>

    // Flags for this command
    static const char * horizFlag           = "-h";
    static const char * horizFlagLong       = "-horizontal";
    static const char * globalFlag          = "-fg";
    static const char * globalFlagLong      = "-flipGlobal";
    static const char * extendFlag          = "-es";
    static const char * extendFlagLong      = "-extendToShell";

    const char * flipUVCmd::cmdName = "flipUV";
    //
    flipUVCmd::flipUVCmd() :
        horizontal(false),
        extendToShell(false),
        flipGlobal(false)
    {}

    //
    flipUVCmd::~flipUVCmd() {}

    //
    // Method to create a flipUVCmd object
    void *flipUVCmd::creator() { return new flipUVCmd; }

    //
    // Add additionnal flags for this command. The default setting of the
    // syntax is done in the base class.
    MSyntax flipUVCmd::newSyntax ()
    {
        MStatus status;

        // Get the base class syntax, and append to it.
        MSyntax syntax = MPxPolyTweakUVCommand::newSyntax();

        status = syntax.addFlag(horizFlag, horizFlagLong, MSyntax::kBoolean);
        CHECK_MSTATUS_AND_RETURN(status, syntax);

        status = syntax.addFlag(globalFlag, globalFlagLong, MSyntax::kBoolean);
        CHECK_MSTATUS_AND_RETURN(status, syntax);

        status = syntax.addFlag(extendFlag, extendFlagLong, MSyntax::kBoolean);
        CHECK_MSTATUS_AND_RETURN(status, syntax);

        return syntax;
    }

    //
    // Read the values of the additionnal flags for this command.
    MStatus flipUVCmd::parseSyntax (MArgDatabase &argData)
    {
        MStatus status;

        // Get the flag values, otherwise the default values are used.

        if (argData.isFlagSet(horizFlag)) {
            status = argData.getFlagArgument(horizFlag, 0, horizontal);
            CHECK_MSTATUS_AND_RETURN_IT(status);
        }

        if (argData.isFlagSet(globalFlag)) {
            status = argData.getFlagArgument(globalFlag, 0, flipGlobal);
            CHECK_MSTATUS_AND_RETURN_IT(status);
        }

        if (argData.isFlagSet(extendFlag)) {
            status = argData.getFlagArgument(extendFlag, 0, extendToShell);
            CHECK_MSTATUS_AND_RETURN_IT(status);
        }

        return MS::kSuccess;
    }

    //
    // Change the UVS for the given selection on this mesh object.
    //
    MStatus flipUVCmd::getTweakedUVs(
        const MObject & meshObj,                    // Object
        MIntArray & uvList,                     // UVs to move
        MFloatArray & uPos,                     // Moved UVs
        MFloatArray & vPos )                    // Moved UVs
    {
        MStatus status;
        unsigned int i;
        MFloatArray uArray;
        MFloatArray vArray;

        MFnMesh mesh( meshObj );

        // Read all UVs from the poly object
        status = mesh.getUVs(uArray, vArray);
        CHECK_MSTATUS_AND_RETURN_IT(status);

        unsigned int nbUvShells = 1;
        MIntArray uvShellIds;
        if ((!flipGlobal) || extendToShell)
        {
            // First, extract the UV shells.
            status = mesh.getUvShellsIds(uvShellIds, nbUvShells);
            CHECK_MSTATUS_AND_RETURN_IT(status);
        }

        if (extendToShell)
        {
            // Find all shells that have at least a selected UV.
            bool *selected = new bool[nbUvShells];
            for (i = 0 ; i<nbUvShells ; i++)
                selected[i] = false;

            for (i = 0 ; i<uvList.length() ; i++)
            {
                int indx = uvList[i];
                selected[uvShellIds[indx]] = true;
            }

            // Now recompute a new list of UVs to modify.

            unsigned int numUvs = mesh.numUVs();
            unsigned int numSelUvs = 0;

            // Preallocate a buffer, large enough to hold all Ids. This
            // prevents multiple reallocation from happening when growing
            // the array.
            uvList.setLength(numUvs);

            for (i = 0 ; i<numUvs ; i++)
            {
                if (selected[uvShellIds[i]])
                    uvList[numSelUvs++] = i;
            }

            // clamp the array to the proper size.
            uvList.setLength(numSelUvs);

            delete [] selected;
        }

        // For global flips, just pretend there is only one shell
        if (flipGlobal) nbUvShells = 1;

        float *minMax = new float[nbUvShells*4];

        for (i = 0 ; i<nbUvShells ; i++)
        {
            minMax[4*i+0] =  1e30F;             // Min U
            minMax[4*i+1] =  1e30F;             // Min V
            minMax[4*i+2] = -1e30F;             // Max U
            minMax[4*i+3] = -1e30F;             // Max V
        }

        // Get the bounding box of the UVs, for each shell if flipGlobal
        // is true, or for the whole selection if false.
        for (i = 0 ; i<uvList.length() ; i++)
        {
            int indx = uvList[i];
            int shellId = 0;
            if (!flipGlobal) shellId = uvShellIds[indx];

            if (uArray[indx] < minMax[4*shellId+0])
                minMax[4*shellId+0] = uArray[indx];
            if (vArray[indx] < minMax[4*shellId+1])
                minMax[4*shellId+1] = vArray[indx];
            if (uArray[indx] > minMax[4*shellId+2])
                minMax[4*shellId+2] = uArray[indx];
            if (vArray[indx] > minMax[4*shellId+3])
                minMax[4*shellId+3] = vArray[indx];
        }

        // Adjust the size of the output arrays
        uPos.setLength(uvList.length());
        vPos.setLength(uvList.length());

        for (i = 0 ; i<uvList.length() ; i++)
        {
            int shellId = 0;
            int indx = uvList[i];
            if (!flipGlobal) shellId = uvShellIds[indx];

            // Flip U or V along the bounding box center.
            if (horizontal)
            {
                uPos[i] = minMax[4*shellId+0] + minMax[4*shellId+2] -
                    uArray[indx];
                vPos[i] = vArray[indx];
            }
            else
            {
                uPos[i] = uArray[indx];
                vPos[i] = minMax[4*shellId+1] + minMax[4*shellId+3] -
                    vArray[indx];
            }
        }

        delete [] minMax;

        return MS::kSuccess;
    }