source: GTP/trunk/Lib/Geom/shared/GeoTool/src/GeoMeshSaver.cpp @ 985

/*      ==========================================================================
 *      (C) 2005 Universitat Jaume I
 *      ==========================================================================
 *      PROYECT:        GAME TOOLS
 *      ==========================================================================*/
/**     CONTENT:        
        *
        *
        *       @file   GeoMeshSaver.cpp
/*===========================================================================*/
#include        <GeoMeshSaver.h>

using   namespace       Geometry;
using   namespace       std;

//------------------------------------------
//              Public:
//------------------------------------------

////////////////////
//      Constructors.   //
////////////////////
GeoMeshSaver::GeoMeshSaver()
{
}

//////////////////
//      Destroyer.      //
//////////////////
GeoMeshSaver::~GeoMeshSaver()
{
        delete  mGeoMesh;
}

//      Saves a Mesh into a file.
int     GeoMeshSaver::save(Mesh *geoMesh,       const   char    *fileNameMesh)
{
        int                     size;
        String  name(fileNameMesh);

        mGeoMesh        =       new Mesh();

        //      Set the mesh.
        *mGeoMesh       =       *geoMesh;

        //      Debug.
        cout    <<      endl
                                <<      endl
                                <<      "-----------------------------------"
                                <<      endl
                                <<      "\t SAVE MESH"
                                <<      endl
                                <<      "-----------------------------------"
                                <<      endl
                                <<      endl;

        //      Unnormalize geometry model.
        unnormalizeModel(mGeoMesh);

        //      Open the file.
        mSerializer     =       new     Serializer(     name,
                                                                                                                                Serializer::WRITE);


        //      Write the file header.
        writeFileHeader();

        //      Write the mesh data.
        writeMesh(mGeoMesh);

        size    =       mSerializer->GetSize();
        
        //      Close the file.
        delete  mSerializer;
        
        //      Return the number of bytes written.
        return  size;
}

//------------------------------------------
//              Private:
//------------------------------------------

//      Write the main mesh.
void    GeoMeshSaver::writeMesh(Mesh    *geoMesh)
{
        // Header
        writeChunkHeader(M_MESH, calcMeshSize(geoMesh));

        //      Debug.
        cout    <<      "               M_MESH"
                                <<      endl;

        //      Write the skeletally animated flag.
        writeBools(geoMesh->hasSkeleton,1);
        
        //      Write shared geometry.
        if (geoMesh->mVertexBuffer->mVertexCount > 0)
        {
                writeGeometry(geoMesh->mVertexBuffer);
        }

        //      Write submeshes.
        for (int i = 0; i < geoMesh->mSubMeshCount;     i++)
        {
                writeSubMesh(&geoMesh->mSubMesh[i]);
        }

        //OSCAR
        // Write skeleton info if required
        if (geoMesh->hasSkeleton)
        {
                // Write skeleton link
                writeSkeletonLink(geoMesh->mSkeletonName);

                // Write bone assignments
                if (!geoMesh->mBones.empty())
                {

                        for (int i=0; i< geoMesh->mBones.size(); i++)
                        {
                                writeMeshBoneAssignment(geoMesh->mBones[i]);
                        }

                }
        }

        //      Write the mesh bounds.
        writeMeshBounds(geoMesh);

        /*
        // Write LOD data if any
        if (pMesh->getNumLodLevels() > 1)
        {
        LogManager::getSingleton().logMessage("Exporting LOD information....");
        writeLodInfo(pMesh);
        LogManager::getSingleton().logMessage("LOD information exported.");

        }
        // Write bounds information
        LogManager::getSingleton().logMessage("Exporting bounds information....");
        writeBoundsInfo(pMesh);
        LogManager::getSingleton().logMessage("Bounds information exported.");

        // Write submesh name table
        LogManager::getSingleton().logMessage("Exporting submesh name table...");
        writeSubMeshNameTable(pMesh);
        LogManager::getSingleton().logMessage("Submesh name table exported.");

        // Write edge lists
        if (pMesh->isEdgeListBuilt())
        {
        LogManager::getSingleton().logMessage("Exporting edge lists...");
        writeEdgeList(pMesh);
        LogManager::getSingleton().logMessage("Edge lists exported");
        }
        */
}//     End write mesh.

//      Write a submesh.
void    GeoMeshSaver::writeSubMesh(SubMesh      *geoSubMesh)
{
        bool                                            idx32bit;
        unsigned        long    indexCount;
        Index                                           *index;
        Index                                           *indexBegin;
        Index                                           *indexEnd;
        
        // Header.
        writeChunkHeader(M_SUBMESH, calcSubMeshSize(geoSubMesh));

        //      Debug.
        cout    <<      "               M_SUBMESH"
                                <<      endl;

        // Material Name.
        mSerializer->WriteData(geoSubMesh->mMaterialName);

        // bool useSharedVertices
        writeBools(geoSubMesh->mSharedVertexBuffer, 1);

        indexCount      =       geoSubMesh->mIndexCount;

        //      If the submesh is in triangle strips.
        if (geoSubMesh->mType == GEO_TRIANGLE_STRIPS)
        {
                indexCount      +=      2 * geoSubMesh->mStripCount - 2;
        }
        
        //      Write index count.
        writeInts(indexCount, 1);

        // bool indexes32Bit
        idx32bit        =       true;
        writeBools(idx32bit, 1);

        //      If the submesh is in triangle strips.
        if (geoSubMesh->mType == GEO_TRIANGLE_STRIPS)
        {
                //      For each one of the strips.
                for (int strip = 0; strip < geoSubMesh->mStripCount; strip++)
                {
                        //      First index of the strip.
                        indexBegin      =       geoSubMesh->mStrip[strip];

                        //      If is the final strip
                        if (strip       == (geoSubMesh->mStripCount - 1))
                        {
                                //      The end of the index array.
                                indexEnd        = &geoSubMesh->mIndex[geoSubMesh->mIndexCount];
                        }
                        else
                        {
                                //      The beginning of the next strip.
                                indexEnd        = geoSubMesh->mStrip[strip + 1];
                        }

                        int i;
                        i       = 0;

                        if (strip != 0)
                        {
                                writeInts(indexBegin[i], 1);
                        }
                        
                        //      For each index of the strip.
                        for (index = indexBegin; index < indexEnd; index++)
                        {
                                writeInts(indexBegin[i], 1);
                                
                                //      Increments i.
                                i++;
                        }

                        if (strip       != (geoSubMesh->mStripCount - 1))
                        {
                                writeInts(indexBegin[i - 1], 1);
                        }

                }
        }
        //      If the submesh is in triangle list.
        else
        {
                //      Write the index array.
                for (int i = 0; i < geoSubMesh->mIndexCount; i++)
                {
                        writeInts(geoSubMesh->mIndex[i], 1);
                }
        }

        // M_GEOMETRY stream (Optional: present only if useSharedVertices = false)
        if (!geoSubMesh->mSharedVertexBuffer)
        {
                writeGeometry(geoSubMesh->mVertexBuffer);
        }

        // Operation type
        writeSubMeshOperation(geoSubMesh);

        // Bone assignments
        if (!geoSubMesh->mBones.empty())
        {
                for (int i = 0; i < geoSubMesh->mBones.size(); i++)
                {
                        writeSubMeshBoneAssignment(geoSubMesh->mBones[i]);
                }
        }
}

//      Write the submesh operation chunk and data.
void GeoMeshSaver::writeSubMeshOperation(const  SubMesh *geoSubMesh)
{
        unsigned        short opType;
        unsigned        long    size;

        size    =       CHUNK_OVERHEAD_SIZE     +       sizeof(unsigned short);
        
        // Header
        writeChunkHeader(M_SUBMESH_OPERATION, size);

        //      Debug.
        cout    <<      "               M_SUBMESH_OPERATION"
                                <<      endl;

        //      If the mesh is in triangle strips.
        if (geoSubMesh->mType   ==      GEO_TRIANGLE_STRIPS)
        {
                opType  =       5;
        }
        //      If the mesh is in triangle list.
        else
        {
                opType  =       4;
        }
        
        writeShorts(opType, 1);
}

//      Write geometry.
void    GeoMeshSaver::writeGeometry(VertexBuffer        *vertexBuffer)
{
        unsigned        short   element;
        unsigned        long    size;
        unsigned        short   buffer_count;

        buffer_count    =       3;

        
        //      Calculate the size in bytes of the geometry chunk.
        size    =       calcGeometrySize(vertexBuffer);
                
        //      Header.
        //
        //      Write the M_GEOMETRY header.
        writeChunkHeader(M_GEOMETRY, size);

        //      Debug.
        cout    <<      "               M_GEOMETRY"
                                <<      endl;

        writeInts(vertexBuffer->mVertexCount,1);

        //      Vertex declaration.
        //      Calculate the size of vertex declaration.
        size    =       CHUNK_OVERHEAD_SIZE
                                        +
                                        buffer_count
                                        *
                                        (CHUNK_OVERHEAD_SIZE    +       (sizeof(unsigned short) *       5));

        //      Write the vertex declaration header.
        writeChunkHeader(       M_GEOMETRY_VERTEX_DECLARATION,size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_DECLARATION"
                                <<      endl;

        //      Obtain the size of the vertex element chunk.
        size    =       CHUNK_OVERHEAD_SIZE     +       (sizeof(unsigned short) *       5);

        //      Positions.
        //      Write the vertex element header for position.
        writeChunkHeader(       M_GEOMETRY_VERTEX_ELEMENT,size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_ELEMENT"
                                <<      endl;

        element =       0;
        writeShorts(element,1);

        element =       VET_FLOAT3;
        writeShorts(element,1);
        
        element =       VES_POSITION;
        writeShorts(element,1);
        
        element =       0;
        writeShorts(element,1);
        
        element =       0;
        writeShorts(element,1);

        //      Normals.
        //      Write the vertex element header for position.
        writeChunkHeader(       M_GEOMETRY_VERTEX_ELEMENT,size);
        
        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_ELEMENT"
                                <<      endl;

        element =       1;
        writeShorts(element,1);
        
        element =       VET_FLOAT3;
        writeShorts(element,1);
        
        element =       VES_NORMAL;
        writeShorts(element,1);
        
        element =       0;
        writeShorts(element,1);
        
        element =       0;
        writeShorts(element,1);

        //      Textures.
        //      Write the vertex element header for position.
        writeChunkHeader(M_GEOMETRY_VERTEX_ELEMENT,size);
        
        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_ELEMENT"
                                <<      endl;

        element =       2;
        writeShorts(element,1);
        
        element =       VET_FLOAT2;
        writeShorts(element,1);
        
        element =       VES_TEXTURE_COORDINATES;
        writeShorts(element,1);
        
        element =       0;
        writeShorts(element,1);
        
        element =       0;
        writeShorts(element,1);

        //      Obtain the size for vertex buffer header for positons.
        size    =       (2      *       CHUNK_OVERHEAD_SIZE)    +       (2      *       sizeof(unsigned short));

        //      Write the vertex buffer header for positions.
        writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER,      size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_BUFFER"
                                <<      endl;

        element =       0;
        writeShorts(element,1);
        
        element =       12;
        writeShorts(element,1);

        //      Obtain the size for the vertex buffer data header for positions.
        size    =       CHUNK_OVERHEAD_SIZE
                                        +
                                        ((sizeof(float) *       3)      *       vertexBuffer->mVertexCount);

        //      Write the vertex buffer data header for positions.
        writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER_DATA, size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_BUFFER_DATA"
                                <<      endl;

        //      Write all the positions coords.
        mSerializer->WriteArray(vertexBuffer->mPosition,
                                                                                                        vertexBuffer->mVertexCount);

        //      Obtain the size for vertex buffer header for normals.
        size    =       (2      *       CHUNK_OVERHEAD_SIZE)    +       (2      *       sizeof(unsigned short));

        //      Write the vertex buffer header.
        writeChunkHeader(       M_GEOMETRY_VERTEX_BUFFER,       size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_BUFFER"
                                <<      endl;

        element =       1;
        writeShorts(element,1);
        
        element =       12;
        writeShorts(element,1);

        //      Obtain the size for the vertex buffer data header for normals.
        size    =       CHUNK_OVERHEAD_SIZE
                                        +
                                        ((sizeof(float) *       3)      *       vertexBuffer->mVertexCount);

        //      Write the vertex buffer data header for normals.
        writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER_DATA, size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_BUFFER_DATA"
                                <<      endl;

        //      Write all the normals coords.
        mSerializer->WriteArray(vertexBuffer->mNormal,
                                                                                                        vertexBuffer->mVertexCount);

        //      Obtain the size for vertex buffer header for textures.
        size    =       (2      *       CHUNK_OVERHEAD_SIZE)    +       (2      *       sizeof(unsigned short));

        //      Write the vertex buffer header for textures.
        writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER,      size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_BUFFER"
                                <<      endl;

        element =       2;
        writeShorts(element,1);
        
        element =       8;
        writeShorts(element,1);

        //      Obtain the size for the vertex buffer data header for textures.
        size    =       CHUNK_OVERHEAD_SIZE
                                        +
                                        ((sizeof(float) *       2)      *       vertexBuffer->mVertexCount);

        //      Write the vertex buffer data header for textures.
        writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER_DATA, size);

        //      Debug.
        cout    <<      "               M_GEOMETRY_VERTEX_BUFFER_DATA"
                                <<      endl;

        //      Write all the texture coords.
        mSerializer->WriteArray(vertexBuffer->mTexCoords,
                                                                                                        vertexBuffer->mVertexCount);
}

//      Write Mesh Bounds.
void    GeoMeshSaver::writeMeshBounds(Mesh      *geoMesh)
{
        size_t  size;

        size    =       CHUNK_OVERHEAD_SIZE
                                        +
                                        (sizeof(float)  *       7);

        writeChunkHeader(M_MESH_BOUNDS, size);

        //      Debug.
        cout    <<      "               M_MESH_BOUNDS"
                                <<      endl;

        writeFloats(geoMesh->mMeshBounds.minX,1);
        writeFloats(geoMesh->mMeshBounds.minY,1);
        writeFloats(geoMesh->mMeshBounds.minZ,1);
        writeFloats(geoMesh->mMeshBounds.maxX,1);
        writeFloats(geoMesh->mMeshBounds.maxY,1);
        writeFloats(geoMesh->mMeshBounds.maxZ,1);
        writeFloats(geoMesh->mMeshBounds.radius,1);
}

//      Calculate the mesh size in bytes.
size_t GeoMeshSaver::calcMeshSize(const Mesh    *geoMesh)
{
        size_t size = CHUNK_OVERHEAD_SIZE;

        // Number of shared vertices
        size += sizeof(uint32);

        // Geometry
        if (geoMesh->mVertexBuffer->mVertexCount > 0)
        {
                size += calcGeometrySize(geoMesh->mVertexBuffer);
        }

        // Submeshes
        for (unsigned short i = 0; i < geoMesh->mSubMeshCount; ++i)
        {
                size += calcSubMeshSize(&geoMesh->mSubMesh[i]);
        }

        //      Mesh Bounds size added.
        size    +=      CHUNK_OVERHEAD_SIZE
                                                +
                                                (sizeof(float)  *       7);

        // Skeleton link
        if (geoMesh->hasSkeleton)
        {
                size += calcSkeletonLinkSize(geoMesh);
        }

        /*
        // Submesh name table
        size += calcSubMeshNameTableSize(geoMesh);

        // Edge list
        if (geoMesh->isEdgeListBuilt())
        {
                size += calcEdgeListSize(geoMesh);
        }
        */
        
        return size;
}

//      Calc the size in bytes for the submesh.
size_t GeoMeshSaver::calcSubMeshSize(const SubMesh      *geoSubMesh)
{
        size_t size = CHUNK_OVERHEAD_SIZE;

        // Material name
        size += strlen(geoSubMesh->mMaterialName);

        // bool useSharedVertices
        size += sizeof(bool);
        // unsigned int indexCount
        size += sizeof(unsigned int);
        // bool indexes32bit
        size += sizeof(bool);

        // unsigned int* faceVertexIndices 
        size += sizeof(unsigned int) * geoSubMesh->mIndexCount;

        // Geometry
        if (!geoSubMesh->mSharedVertexBuffer)
        {
                size += calcGeometrySize(geoSubMesh->mVertexBuffer);
        }

        return size;
}

//      Calculate the geometry size in bytes.
size_t GeoMeshSaver::calcGeometrySize(const VertexBuffer* vertexBuffer)
{
        unsigned        long            size;
        unsigned        long            buffer_count;

        //      and another for normals.
        buffer_count    =       3;

        //      Calculate the size of the Geometry chunk.
        size    =       CHUNK_OVERHEAD_SIZE     +       sizeof(unsigned int);
        size    =       size
                                        +
                                        CHUNK_OVERHEAD_SIZE
                                        +
                                        buffer_count
                                        *
                                        (CHUNK_OVERHEAD_SIZE    +       (sizeof(unsigned short) *       5));
        size    =       size
                                        +
                                        buffer_count
                                        *
                                        (       (CHUNK_OVERHEAD_SIZE            *       2)
                                                +
                                                (sizeof(unsigned short) *       2)
                                                +
                                                vertexBuffer->mVertexCount
                                        );

        return size;
}

//      Calculate the skeleton link size in bytes.
size_t  GeoMeshSaver::calcSkeletonLinkSize(const Mesh   *geoMesh)
{
        size_t  size    =               CHUNK_OVERHEAD_SIZE;
        size                                    +=      strlen(geoMesh->mSkeletonName);

        //      Debug.
        cout    <<      "Length Skeleton Link: "
                                <<      strlen(geoMesh->mSkeletonName)
                                <<      endl;

        return  size;
}

//      Write the file header.
void GeoMeshSaver::writeFileHeader(void)
{
        String  mesh_version("[MeshSerializer_v1.30]\n");
        
        writeShorts(M_HEADER, 1);

        writeString(mesh_version);

}

//      Write a header chunk given.
void GeoMeshSaver::writeChunkHeader(unsigned short      id,
                                                                                                                                                unsigned long           size)
{
        mSerializer->WriteData(&id,sizeof(unsigned short),1);
        mSerializer->WriteData(&size,sizeof(unsigned long),1);
}

//      Write integers into the file.
void    GeoMeshSaver::writeInts(unsigned long   id,
                                                                                                                        unsigned long   count)
{
        mSerializer->WriteData(&id,sizeof(id),count);
}

//      Write shorts into the file
void    GeoMeshSaver::writeShorts(unsigned short        id,
                                                                                                                                unsigned long           count)
{
        mSerializer->WriteData(&id,sizeof(id),count);
}

//      Write float into the file.
void    GeoMeshSaver::writeFloats(float                                         id,
                                                                                                                                unsigned long           count)
{
        mSerializer->WriteData(&id,sizeof(id),count);
}

//      Write a string into the file.
void GeoMeshSaver::writeString(const    String  &string)
{
        mSerializer->WriteData(string);
}

//      Write booleans into the file.
void    GeoMeshSaver::writeBools(       const bool id,
                                                                                                                                unsigned        long            count)
{
        mSerializer->WriteData(&id,sizeof(bool),count);
}

void GeoMeshSaver::writeSkeletonLink(const String& skelName)
{       
        writeChunkHeader(M_MESH_SKELETON_LINK, calcSkeletonLinkSize(mGeoMesh));

        //      Debug.
        cout    <<      "               M_MESH_SKELETON_LINK"
                                <<      endl;

    writeString(skelName);
}

void GeoMeshSaver::writeMeshBoneAssignment(const VertexBoneAssignment& assign)
{
        size_t size = CHUNK_OVERHEAD_SIZE + sizeof(unsigned int) + sizeof(unsigned short)+ sizeof(float);

        writeChunkHeader(M_MESH_BONE_ASSIGNMENT, size);

        // unsigned int vertexIndex;
        writeInts(assign.vertexIndex, 1);
        // unsigned short boneIndex;
        writeShorts(assign.boneIndex, 1);
        // float weight;
        writeFloats(assign.weight, 1);
}

void GeoMeshSaver::writeSubMeshBoneAssignment(const VertexBoneAssignment& assign)
{
        size_t size = CHUNK_OVERHEAD_SIZE + sizeof(unsigned int) + sizeof(unsigned short)+ sizeof(float);

        writeChunkHeader(M_SUBMESH_BONE_ASSIGNMENT, size);

        // unsigned int vertexIndex;
        writeInts(assign.vertexIndex, 1);
        // unsigned short boneIndex;
        writeShorts(assign.boneIndex, 1);
        // float weight;
        writeFloats(assign.weight, 1);
}

//      unnormalize geometry model.
void    GeoMeshSaver::unnormalizeModel(Mesh     *geoMesh)
{
        float   maxx;
        float   maxy;
        float   maxz;
        float   minx;
        float   miny;
        float   minz;
        float   cx;
        float   cy;
        float   cz;
        float   scale;
        
        VertexBuffer    *vertex_buffer;

        maxx    =       geoMesh->mMeshBounds.maxX;
        maxy    =       geoMesh->mMeshBounds.maxY;
        maxz    =       geoMesh->mMeshBounds.maxZ;
        minx    =       geoMesh->mMeshBounds.minX;
        miny    =       geoMesh->mMeshBounds.minY;
        minz    =       geoMesh->mMeshBounds.minZ;
        scale   =       geoMesh->mMeshBounds.scaleFactor;
        
        //      Calculate center of the model.
        cx = (maxx + minx) / 2.0;
        cy = (maxy + miny) / 2.0;
        cz = (maxz + minz) / 2.0;

        //      Translate around center then scale.
        //      For each submesh.
        for (int submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
        {
                //      Gets the actual submesh.
                vertex_buffer   =       geoMesh->mSubMesh[submesh].mVertexBuffer;

                //      For each index of the strip.
                for (int i = 0; i < vertex_buffer->mVertexCount; i++)
                {
                        vertex_buffer->mPosition[i].x /= scale;
                        vertex_buffer->mPosition[i].y /= scale;
                        vertex_buffer->mPosition[i].z /= scale;
                        vertex_buffer->mPosition[i].x += cx;
                        vertex_buffer->mPosition[i].y += cy;
                        vertex_buffer->mPosition[i].z += cz;
                }

                //      If is a shared vertex Buffer.
                if (geoMesh->mSubMesh[submesh].mSharedVertexBuffer)
                {
                        break;
                }
        }
}