polyX3DExporter/polyX3DWriter.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.
// ==========================================================================
//+

//
//

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

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

//polyX3DWriter.cpp
#include "polyX3DWriter.h"


//Macros

//used as the default color for vertices which have no color assigned
//
#define DEFAULT_COLOR   "0.2 0.2 0.2"

//used as default values for the Material tag when outputting a texture
//
#define DIFFUSE_COLOR   "0 0 0"
#define SHININESS       "0.8"
#define SPECULAR_COLOR  "0.5 0.5 0.5"

//flags used to indicate which tags have been outputted already, so to
//minimize data duplication
//
#define COORDINATE_FLAG 0x0001
#define NORMAL_FLAG     0x0010
#define TEXTURE_FLAG    0x0100
#define COLOR_FLAG      0x1000

//number of spaces per tab
#define INITIAL_TAB_COUNT 2

polyX3DWriter::polyX3DWriter(const MDagPath& dagPath, MStatus& status):
    polyWriter(dagPath, status),
    fTagFlags(0),
    fInitialTabCount(INITIAL_TAB_COUNT)
//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
{
}


polyX3DWriter::~polyX3DWriter()
{
//Summary:  destructor method - does nothing
//
}


MStatus polyX3DWriter::extractGeometry() 
//Summary:  extracts main geometry as well as the current UV set and UV set 
//          coordinates
{
    if (MStatus::kFailure == polyWriter::extractGeometry()) {
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == fMesh->getUVs(fUArray, fVArray, &fCurrentUVSetName)) {
        MGlobal::displayError("MFnMesh::getUVs"); 
        return MStatus::kFailure;
    }

    return MStatus::kSuccess;
}


MStatus polyX3DWriter::writeToFile(ostream& os) 
//Summary:  outputs the geometry of this polygonal mesh in X3D compliant format
//Args   :  os - an output stream to write to
//          tabCount - the initial number of tabs to print
//Returns:  MStatus::kSuccess if the method succeeds
//          MStatus::kFailure if the method fails
{
    MGlobal::displayInfo("Exporting " + fMesh->partialPathName());
    unsigned int setCount = fPolygonSets.length();

    if (0 == setCount) {
        return MStatus::kFailure;
    } else if (1 == setCount) {
        if (MStatus::kFailure == outputSets(os)) {
            return MStatus::kFailure;
        }
    } else {
        outputTabs(os, INITIAL_TAB_COUNT);
        fInitialTabCount++;
        os << "<Group DEF=\"" << fMesh->partialPathName() << "\">\n";
        if (MStatus::kFailure == outputSets(os)) {
            return MStatus::kFailure;
        }
        outputTabs(os, INITIAL_TAB_COUNT);
        os << "</Group>\n";
    }
    return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputSingleSet (ostream& os, MString setName, MIntArray faces, MString textureName) {
//Summary:  outputs a single set of polygons grouped under a Shape tag
//Args   :  os - an output stream to write to
//          shapeName - the value for the DEF attribute
//          faces - an MIntArray containing the indices of the faces to include
//                  in this shape
//          textureName - the full path for the texture file
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
    if (0 == fPolygonSets.length()) {
        return MStatus::kFailure;
    } else if (1 == fPolygonSets.length()) {
        setName = fMesh->partialPathName();
    } else {
        setName = fMesh->partialPathName() + "_" + setName;
    }
    return outputX3DShapeTag (os, setName, faces, textureName, fInitialTabCount);
}


MStatus polyX3DWriter::outputX3DShapeTag(ostream & os,
                                     const MString shapeName,
                                     const MIntArray& faces,
                                     const MString textureName,
                                     const unsigned int tabCount) 
//Summary:  outputs the X3D Shape tag with the DEF attribute
//Args   :  os - an output stream to write to
//          shapeName - the value for the DEF attribute
//          faces - an MIntArray containing the indices of the faces to include
//                  in this shape
//          textureName - the full path for the texture file
//          tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
{
    outputTabs(os, tabCount);
    os << "<Shape DEF=\"" << shapeName << "\">\n";

    if (MStatus::kFailure == outputX3DAppearanceTag(os, textureName, tabCount + 1)) { 
        return MStatus::kFailure;
    }

    if (MStatus::kFailure == outputX3DIndexedFaceSetTag(os, faces, textureName, tabCount + 1)) {
        return MStatus::kFailure;
    }

    outputTabs(os, tabCount);
    os << "</Shape>\n";

    return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DAppearanceTag(ostream & os, 
                                          const MString textureName, 
                                          const unsigned int tabCount) 
//Summary:  outputs the X3D Appearance Tag.  If textureName is an empty string, 
//          outputs the default Material tag;  otherwise outputs a Material tag 
//          with diffuseColor, shininess, and specularColor values set, along 
//          with an ImageTexture tag with the url attribute value set to 
//          textureName
//Args   :  os - an output stream to write to
//          textureName - the full path of the texture file
//          tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
{
    outputTabs(os, tabCount);

    //No texture name given, output default apperance and material tags
    //
    if (textureName == MString("")) {
        os << "<Appearance><Material/></Appearance>\n";

    //Texture name was given, output an ImageTexture tag with the texture name 
    //as the value of the url attribute, and output default values for the 
    //diffuseColor, shininess, and specularColor of the material node
    //
    } else {
        os << "<Appearance>\n";
        outputTabs(os, tabCount + 1);
        os << "<ImageTexture url=\"" << textureName << "\"/>\n";
        outputTabs(os, tabCount + 1);
        os << "<Material diffuseColor=\"" << DIFFUSE_COLOR 
           << "\" shininess=\"" << SHININESS 
           << "\" specularColor=\"" << SPECULAR_COLOR 
           << "\"/>\n";
        outputTabs(os, tabCount);
        os << "</Appearance>\n";
    }
    return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DIndexedFaceSetTag(ostream & os, 
                                              const MIntArray& faces,
                                              const MString textureName, 
                                              const unsigned int tabCount) 
//Summary:  outputs the X3D IndexedFaceSet tag along with the Coordinate and
//          Normal tags.  If textureName is an empty string, also outputs the
//          Color tag and IndexedFaceSet's colorIndex and colorPerVertex 
//          attributes; otherwise outputs the TextureCoordinate tag and
//          IndexedFaceSet's texCoordIndex attribute
//Args   :  os - an output stream to write to
//          faces - an MIntArray containing the indices of the faces to include
//                  in this IndexedFaceSet
//          textureName - the full path for the texture file
//          tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
{
    outputTabs(os, tabCount);
    os << "<IndexedFaceSet coordIndex=\"";

    unsigned int faceCount = faces.length();

    //if there are no faces to output return an error status
    //
    if (0 == faceCount) {
        return MStatus::kFailure;
    }

    MStatus status;
    //general purpose counters
    //
    unsigned int i, j, indexCount;

    //general int array storage
    //
    MIntArray indexList;

    //For every face in the faces array, retrieve and output its vertices.
    //getPolygonVertices() returns the indices of the vertices of a given face,
    //and orders the vertex indices in the array in the manner required for the
    //X3D IndexedFaceSet tag.  Note, these indices refer to the array fVertexArray.
    //
    for (i = 0; i < faceCount; i++) {

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

        //store those vertices for face[i] and output them
        //
        status = fMesh->getPolygonVertices (faces[i], indexList);
        if (MStatus::kFailure == status) {
            MGlobal::displayError("MFnMesh::getPolygonVertices");
            return MStatus::kFailure;
        }

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

        os << "-1 ";
    }

    //For every face in the faces array, retrieve and output its vertex normals.
    //getNormalIDs() returns the indices of the normals of a given face.  Note, 
    //these indices refer to the array fNormalArray.
    //
    os << "\" normalPerVertex=\"true\" normalIndex=\"";
    for (i = 0; i < faceCount; i++) {
        //store the vertex normals for face[i]
        //
        status = fMesh->getFaceNormalIds (faces[i], indexList);
        if (MStatus::kFailure == status) {
            MGlobal::displayError("MFnMesh::getFaceNormalIds");
            return MStatus::kFailure;
        }

        //determine the number of vertex normals for face[i] 
        //and output them
        indexCount = indexList.length();
        for (j = 0; j < indexCount; j++) {
            os << indexList[j] << " ";
        }
        os << "-1 ";
    }
    os << "\" ";

    //If a texture name is not given, output colorIndex attribute
    if (textureName == MString("")) {
        os << "colorPerVertex=\"true\" ";
        //output the color indices for each per polygon vertex.  These indices
        //refer to the array fColorArray
        //
        os << "colorIndex=\"";
        int colorIndex = 0;
        for (i = 0; i < faceCount; i++) {
            indexCount = fMesh->polygonVertexCount(faces[i], &status);
            if (MStatus::kFailure == status) {
                MGlobal::displayError("MFnMesh::polygonVertexCount");
                return MStatus::kFailure;
            }

            for (j = 0; j < indexCount; j++) {
                if (MStatus::kFailure == fMesh->getFaceVertexColorIndex(faces[i], j, colorIndex)) {
                    MGlobal::displayError("MFnMesh::getFaceVertexColorIndex");
                    return MStatus::kFailure;
                }
                os << colorIndex << " ";
            }
            os << "-1 ";
        }
        os << "\">\n";

        //output the X3D color tag to correspond with the indices
        //
        if (MStatus::kFailure == outputX3DColorTag(os, tabCount + 1)) {
            return MStatus::kFailure;
        }

    //A texture name was given, output the texCoordIndex attribute
    //
    } else {
        os << " texCoordIndex=\"";

        //output the uv indicies for each polygon per vertex.  These indices
        //refer to the arrays fUArray and fVArray
        //
        

        for (i = 0; i < faceCount; i++) {
            indexCount = fMesh->polygonVertexCount(faces[i], &status);
            if (MStatus::kFailure == status) {
                MGlobal::displayError("MFnMesh::polygonVertexCount");
                return MStatus::kFailure;
            }

            for (j = 0; j < indexCount; j++) {
                int uvID;
                status = fMesh->getPolygonUVid(faces[i], j, uvID, &fCurrentUVSetName);
                if (MStatus::kFailure == status) {
                    MGlobal::displayError("MFnMesh::getPolygonUVid");
                    return MStatus::kFailure;
                }
                os << uvID << " ";
            }
            os << "-1 ";
        }

        os << "\">\n";

        //output the X3D TextureCoordinateTag to correspond with the indices
        //
        if (MStatus::kFailure == outputX3DTextureCoordinateTag(os, tabCount + 1)) {
            return MStatus::kFailure;
        }
    }

    //output the vertex coordinates using the X3D Coordinate tag and
    //output the vertex normals using the X3D Normal tag
    //
    if (MStatus::kFailure == outputX3DCoordinateTag(os, tabCount + 1)
        || MStatus::kFailure == outputX3DNormalTag(os, tabCount + 1)) {
        return MStatus::kFailure;
    }
    
    outputTabs(os, tabCount);
    os << "</IndexedFaceSet>\n";

    return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DCoordinateTag(ostream & os, 
                                          const unsigned int tabCount) 
//Summary:  outputs the X3D Coordinate tag with the DEF attribute if the tag 
//          has not been previously output for this polygonal mesh; with the 
//          USE attribute otherwise
//Args   :  os - an output stream to write to
//          tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
{
    unsigned int vertexCount = fVertexArray.length();
    if (0 == vertexCount) {
        return MStatus::kFailure;
    }

    outputTabs(os, tabCount);
    //tag has already been output for this mesh, so just re-use that tag
    //
    if (fTagFlags & COORDINATE_FLAG) {
        os << "<Coordinate USE=\"" << fMesh->partialPathName() << "_coordinates";
    //tag has not been output for this mesh, so define a new tag with the
    //necessary data
    //
    } else {
        fTagFlags |= COORDINATE_FLAG;
        os << "<Coordinate DEF=\"" << fMesh->partialPathName() << "_coordinates\" point=\"";
        unsigned int i;
        for (i = 0; i < vertexCount; i++) {
            os << fVertexArray[i].x << " " 
               << fVertexArray[i].y << " " 
               << fVertexArray[i].z << ", ";
        }
    }

    os << "\"/>\n";

    return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DNormalTag(ostream & os, 
                                      const unsigned int tabCount) 
//Summary:  outputs the X3D Normal tag with the DEF attribute if the Normal tag
//          has not been previously output for this polygonal mesh; with the 
//          USE attribute otherwise
//Args   :  os - an output stream to write to
//          tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
{
    unsigned int normalCount = fNormalArray.length();
    if (0 == normalCount) {
        return MStatus::kFailure;
    }

    outputTabs(os, tabCount);
    //tag has already been output for this mesh, so just re-use that tag
    //
    if (fTagFlags & NORMAL_FLAG) {
        os << "<Normal USE=\"" << fMesh->partialPathName() << "_normals";
    //tag has not been output for this mesh, so define a new tag with the
    //necessary data
    //
    } else {
        fTagFlags |= NORMAL_FLAG;
        os << "<Normal DEF=\"" << fMesh->partialPathName() << "_normals\" vector=\"";
        unsigned int i;
        for (i = 0; i < normalCount; i++) {
            os << fNormalArray[i].x << " " 
               << fNormalArray[i].y << " " 
               << fNormalArray[i].z << ", ";
        }
    }
    os << "\"/>\n";

    return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DTextureCoordinateTag(ostream & os, 
                                                 const unsigned int tabCount) 
//Summary:  outputs the X3D TextureCoordinate tag with the DEF attribute if the 
//          tag has not been previously output for this polygonal mesh; with 
//          the USE attribute otherwise
//Args   :  os - an output stream to write to
//          tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
{
    unsigned int uvCount = fUArray.length();
    if (0 == uvCount) {
        return MStatus::kFailure;
    }

    outputTabs(os, tabCount);
    //tag has already been output for this mesh, so just re-use that tag
    //
    if (fTagFlags & TEXTURE_FLAG) {
        os << "<TextureCoordinate USE=\"" << fMesh->partialPathName() << "_texCoordinates";
    //tag has not been output for this mesh, so define a new tag with the
    //necessary data
    //
    } else {
        fTagFlags |= TEXTURE_FLAG;
        os << "<TextureCoordinate DEF=\"" << fMesh->partialPathName() << "_texCoordinates\" point=\"";
        unsigned int i;
        for (i = 0; i < uvCount; i++) {
            os << fUArray[i] << " " << fVArray[i] << ", ";
        }
    }
    os << "\"/>\n";

    return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DColorTag(ostream & os, 
                                     const unsigned int tabCount) 
//Summary:  outputs the X3D Color tag with the DEF attribute if the tag has not 
//          been previously output for this polygonal mesh; with the USE 
//          attribute otherwise
//Args   :  os - an output stream to write to
//          tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//          MStatus::kFailure otherwise
{
    unsigned int colorCount = fColorArray.length();
    if (0 == colorCount) {
        return MStatus::kFailure;
    }
    
    outputTabs(os, tabCount);
    //tag has already been output for this mesh, so just re-use that tag
    //
    if (fTagFlags & COLOR_FLAG) {
        os << "<Color USE=\"" << fMesh->partialPathName() << "_colors";
    //tag has not been output for this mesh, so define a new tag with the
    //necessary data
    //
    } else {
        fTagFlags |= COLOR_FLAG;
        os << "<Color DEF=\"" << fMesh->partialPathName() << "_colors\" color=\"";
        unsigned int i;
        for (i = 0; i < colorCount; i++) {
            //an rgb value of -1 -1 -1 in Maya indicates no color, so if any
            //component is not -1, color info is present.  Note: only need to check
            //r, g, or b; r was chosen arbitrarily
            //
            if (-1 != fColorArray[i].r) {
                os << fColorArray[i].r << " " 
                   << fColorArray[i].g << " " 
                   << fColorArray[i].b << ", ";
            //use default coloring
            //
            } else {
                os << DEFAULT_COLOR << ", ";
            }
        }
    }
    os << "\"/>\n";

    return MStatus::kSuccess;
}