polyRawExporter/polyRawWriter.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.
// ==========================================================================
//+

//
//

//polyRawWriter.cpp

//General Includes
//
#include <maya/MIOStream.h>
#include <maya/MGlobal.h>
#include <maya/MIntArray.h>
#include <maya/MFnSet.h>
#include <maya/MItDependencyGraph.h>
#include <maya/MDagPath.h>
#include <maya/MFnMesh.h>
#include <maya/MPlug.h>
#include <maya/MIOStream.h>
#include <time.h>

//Iterator Includes
//
#include <maya/MItMeshPolygon.h>


//Header File
//
#include "polyRawWriter.h"

//Macros
//
#define DELIMITER "\t"
#define SHAPE_DIVIDER "*******************************************************************************\n"
#define HEADER_LINE "===============================================================================\n"
#define LINE "-------------------------------------------------------------------------------\n"


polyRawWriter::polyRawWriter(const MDagPath& dagPath, MStatus& status):
polyWriter(dagPath, status),
fHeadUVSet(NULL)
//Summary:  creates and initializes an object of this class
//Args   :  dagPath - the DAG path of the current node
//          status - will be set to MStatus::kSuccess if the constructor was
//                   successful;  MStatus::kFailure otherwise
{
}


polyRawWriter::~polyRawWriter() 
//Summary:  deletes the objects created by this class
{
    if (NULL != fHeadUVSet) delete fHeadUVSet;
}


MStatus polyRawWriter::extractGeometry() 
//Summary:  extracts main geometry as well as all UV sets and each set's
//          coordinates
{

    if (MStatus::kFailure == polyWriter::extractGeometry()) {
        return MStatus::kFailure;
    }

    MStringArray uvSetNames;
    if (MStatus::kFailure == fMesh->getUVSetNames(uvSetNames)) {
        MGlobal::displayError("MFnMesh::getUVSetNames"); 
        return MStatus::kFailure;
    }

    unsigned int uvSetCount = uvSetNames.length();
    unsigned int i;

    UVSet* currUVSet = NULL;

    for (i = 0; i < uvSetCount; i++ ) {
        if (0 == i) {
            currUVSet = new UVSet;
            fHeadUVSet = currUVSet;
        } else {
            currUVSet->next = new UVSet;
            currUVSet = currUVSet->next;
        }

        currUVSet->name = uvSetNames[i];
        currUVSet->next = NULL;

        // Retrieve the UV values
        //
        if (MStatus::kFailure == fMesh->getUVs(currUVSet->uArray, currUVSet->vArray, &currUVSet->name)) {
            return MStatus::kFailure;
        }
    }

    return MStatus::kSuccess;
}


MStatus polyRawWriter::writeToFile(ostream& os) 
//Summary:  outputs the geometry of this polygonal mesh in raw text format
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if the method succeeds
//          MStatus::kFailure if the method fails
{
    MGlobal::displayInfo("Exporting " + fMesh->partialPathName());

    os << SHAPE_DIVIDER;
    os << "Shape:  " << fMesh->partialPathName() << "\n";
    os << SHAPE_DIVIDER;
    os << "\n";

    if (MStatus::kFailure == outputFaces(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputVertices(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputVertexInfo(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputNormals(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputTangents(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputBinormals(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputColors(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputUVs(os)) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputSets(os)) {
        return MStatus::kFailure;
    }
    os << "\n\n";
    
    return MStatus::kSuccess;
}


MStatus polyRawWriter::outputFaces(ostream& os) 
//Summary:  outputs the vertex indices that comprise each face
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if all faces were outputted
//          MStatus::kFailure otherwise
{
    unsigned int faceCount = fMesh->numPolygons();
    if (0 == faceCount) {
        return MStatus::kFailure;
    }

    MStatus status;
    MIntArray indexArray;

    os << "Faces:  " << faceCount << "\n";
    os << HEADER_LINE;
    os << "Format:  Index|Vertex Indices\n";
    os << LINE;

    unsigned int i;
    for (i = 0; i < faceCount; i++) {
        os << i << DELIMITER;

        unsigned int indexCount = fMesh->polygonVertexCount(i, &status);
        if (MStatus::kFailure == status) {
            MGlobal::displayError("MFnMesh::polygonVertexCount");
            return MStatus::kFailure;
        }

        status = fMesh->getPolygonVertices (i, indexArray);
        if (MStatus::kFailure == status) {
            MGlobal::displayError("MFnMesh::getPolygonVertices");
            return MStatus::kFailure;
        }

        unsigned int j;
        for (j = 0; j < indexCount; j++) {
            os << indexArray[j] << " ";
        }

        os << "\n";
    }
    os << "\n\n";

    return MStatus::kSuccess;
}


MStatus polyRawWriter::outputVertices(ostream& os) 
//Summary:  outputs all vertex coordinates
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if all vertex coordinates were outputted
//          MStatus::kFailure otherwise
{
    unsigned int vertexCount = fVertexArray.length();
    unsigned i;

    if (0 == vertexCount) {
        return MStatus::kFailure;
    }

    os << "Vertices:  " << vertexCount << "\n";
    os << HEADER_LINE;
    os << "Format:  Vertex|(x, y, z)\n";
    os << LINE;
    for (i = 0; i < vertexCount; i++) {
        os << i << DELIMITER << "(" 
           << fVertexArray[i].x << ", " 
           << fVertexArray[i].y << ", " 
           << fVertexArray[i].z << ")\n";
    }
    os << "\n\n";

    return MStatus::kSuccess;
}


MStatus polyRawWriter::outputVertexInfo(ostream& os) 
//Summary:  outputs the per face per vertex information such as normal, color, and uv set
//          indices
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if all per face per vertex information was outputted
//          MStatus::kFailure otherwise
{
    unsigned int faceCount = fMesh->numPolygons();
    unsigned i, j, indexCount;

    MStatus status;
    MIntArray indexArray;

    //output the header
    os << "Vertex Info:\n";
    os << HEADER_LINE;
    os << "Format:  Face|faceVertexIndex|vertexIndex|normalIndex|colorIndex|";
    
    //Add each uv set to the header
    UVSet* currUVSet;
    for (currUVSet = fHeadUVSet; currUVSet != NULL; currUVSet = currUVSet->next) {
        os << "| UV_" << currUVSet->name;
    }
    os << "\n";

    os << LINE;

    MIntArray normalIndexArray;
    int colorIndex, uvID;

    for (i = 0; i < faceCount; i++) {

        indexCount = fMesh->polygonVertexCount(i, &status);
        if (MStatus::kFailure == status) {
            MGlobal::displayError("MFnMesh::polygonVertexCount");
            return MStatus::kFailure;
        }

        status = fMesh->getPolygonVertices (i, indexArray);
        if (MStatus::kFailure == status) {
            MGlobal::displayError("MFnMesh::getPolygonVertices");
            return MStatus::kFailure;
        }

        status = fMesh->getFaceNormalIds (i, normalIndexArray);
        if (MStatus::kFailure == status) {
            MGlobal::displayError("MFnMesh::getFaceNormalIds");
            return MStatus::kFailure;
        }

        for (j = 0; j < indexCount; j++) {
            status = fMesh->getFaceVertexColorIndex(i, j, colorIndex);

            //output the face, face vertex index, vertex index, normal index, color index
            //for the current vertex on the current face
            os << i << DELIMITER << j << DELIMITER << indexArray[j] << DELIMITER
               << normalIndexArray[j] << DELIMITER << colorIndex << DELIMITER;

            //output each uv set index for the current vertex on the current face
            for (currUVSet = fHeadUVSet; currUVSet != NULL; currUVSet = currUVSet->next) {
                status = fMesh->getPolygonUVid(i, j, uvID, &currUVSet->name);
                if (MStatus::kFailure == status) {
                    MGlobal::displayError("MFnMesh::getPolygonUVid");
                    return MStatus::kFailure;
                }
                os << DELIMITER << uvID;
            }
            os << "\n";
        }

        os << "\n";
    }
    os << "\n";

    return MStatus::kSuccess;
}


MStatus polyRawWriter::outputNormals(ostream& os) 
//Summary:  outputs the normals for this polygonal mesh
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if all normals were outputted
//          MStatus::kFailure otherwise
{
    unsigned int normalCount = fNormalArray.length();
    if (0 == normalCount) {
        return MStatus::kFailure;
    }

    os << "Normals:  " << normalCount << "\n";
    os << HEADER_LINE;
    os << "Format:  Index|[x, y, z]\n";
    os << LINE;

    unsigned int i;
    for (i = 0; i < normalCount; i++) {
        os << i << DELIMITER << "["
           << fNormalArray[i].x << ", "
           << fNormalArray[i].y << ", "
           << fNormalArray[i].z << "]\n";
    }
    os << "\n\n";

    return MStatus::kSuccess;
}

MStatus polyRawWriter::outputTangents(ostream& os) 
//Summary:  outputs the normals for this polygonal mesh
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if all normals were outputted
//          MStatus::kFailure otherwise
{
    unsigned int tangentCount = fTangentArray.length();
    if (0 == tangentCount) {
        return MStatus::kFailure;
    }

    os << "Tangents:  " << tangentCount << "\n";
    os << HEADER_LINE;
    os << "Format:  Index|[x, y, z]\n";
    os << LINE;

    unsigned int i;
    for (i = 0; i < tangentCount; i++) {
        os << i << DELIMITER << "["
           << fTangentArray[i].x << ", "
           << fTangentArray[i].y << ", "
           << fTangentArray[i].z << "]\n";
    }
    os << "\n\n";

    return MStatus::kSuccess;
}

MStatus polyRawWriter::outputBinormals(ostream& os) 
//Summary:  outputs the normals for this polygonal mesh
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if all normals were outputted
//          MStatus::kFailure otherwise
{
    unsigned int binormalCount = fBinormalArray.length();
    if (0 == binormalCount) {
        return MStatus::kFailure;
    }

    os << "Binormals:  " << binormalCount << "\n";
    os << HEADER_LINE;
    os << "Format:  Index|[x, y, z]\n";
    os << LINE;

    unsigned int i;
    for (i = 0; i < binormalCount; i++) {
        os << i << DELIMITER << "["
           << fBinormalArray[i].x << ", "
           << fBinormalArray[i].y << ", "
           << fBinormalArray[i].z << "]\n";
    }
    os << "\n\n";

    return MStatus::kSuccess;
}

MStatus polyRawWriter::outputColors(ostream& os) 
//Summary:  outputs the colors for this polygonal mesh
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if all colors were outputted
//          MStatus::kFailure otherwise
{
    unsigned int colorCount = fColorArray.length();
    if (0 == colorCount) {
        return MStatus::kFailure;
    }

    os << "Colors:  " << colorCount << "\n";
    os << HEADER_LINE;
    os << "Format:  Index|R G B A\n";
    os << LINE;
    
    unsigned int i;
    for (i = 0; i < colorCount; i++) {
        os << i << DELIMITER
           << fColorArray[i].r << " "
           << fColorArray[i].g << " "
           << fColorArray[i].b << " "
           << fColorArray[i].a << "\n";
    }
    os << "\n\n";

    return MStatus::kSuccess;
}


MStatus polyRawWriter::outputUVs(ostream& os) 
//Summary:  for each UV Set, outputs all uv coordinates
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if UV coordinates for all UV sets were outputted
//          MStatus::kFailure otherwise
{
    UVSet* currUVSet;
    unsigned int i, uvCount;
    for (currUVSet = fHeadUVSet; currUVSet != NULL; currUVSet = currUVSet->next) {
        if (currUVSet->name == fCurrentUVSetName) {
            os << "Current ";
        }

        os << "UV Set:  " << currUVSet->name << "\n";
        uvCount = currUVSet->uArray.length();
        os << "UV Count:  " << uvCount << "\n";
        os << HEADER_LINE;
        os << "Format:  Index|(u, v)\n";
        os << LINE;
        for (i = 0; i < uvCount; i++) {
            os << i << DELIMITER << "(" << currUVSet->uArray[i] << ", " << currUVSet->vArray[i] << ")\n";
        }
        os << "\n";
    }
    os << "\n";
    return MStatus::kSuccess;
}


MStatus polyRawWriter::outputSingleSet(ostream& os, MString setName, MIntArray faces, MString textureName)
//Summary:  outputs this mesh's sets and each sets face components, and any 
//          associated texture
//Args   :  os - an output stream to write to
//Returns:  MStatus::kSuccess if set information was outputted
//          MStatus::kFailure otherwise
{
    unsigned int i;
    unsigned int faceCount = faces.length();

    os << "Set:  " << setName << "\n";
    os << HEADER_LINE;
    os << "Faces:  ";
    for (i = 0; i < faceCount; i++) { 
        os << faces[i] << " ";
    }
    os << "\n";
    if (textureName == "") {
        textureName = "none";
    } 
    os << "Texture File: " << textureName << "\n";
    os << "\n\n";
    return MStatus::kSuccess;
}