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

/*      ==========================================================================
 *      (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()
{
        mMaterialName                           =       "";
        mSkeletallyAnimated     =       false;

        //      Initializa the mesh bounds.
        mMeshBounds.minx                        =       0.0;
        mMeshBounds.miny                        =       0.0;
        mMeshBounds.minz                        =       0.0;
        mMeshBounds.maxx                        =       0.0;
        mMeshBounds.maxy                        =       0.0;
        mMeshBounds.maxz                        =       0.0;
        mMeshBounds.radius              =       0.0;
}

GeoMeshSaver::GeoMeshSaver(GeometryBounds bounds)
{
        mMaterialName                           =       "";
        mSkeletallyAnimated     =       false;

        //      Initializa the mesh bounds.
        mMeshBounds.minx                        =       bounds.minx;
        mMeshBounds.miny                        =       bounds.miny;
        mMeshBounds.minz                        =       bounds.minz;
        mMeshBounds.maxx                        =       bounds.maxx;
        mMeshBounds.maxy                        =       bounds.maxy;
        mMeshBounds.maxz                        =       bounds.maxz;
        mMeshBounds.radius              =       bounds.radius;
}

//////////////////
//      Destroyer.      //
//////////////////
GeoMeshSaver::~GeoMeshSaver()
{
}

//      Saves a Mesh into a file.
int     GeoMeshSaver::save(Mesh *geoMesh,       const   char    *fileNameMesh)
{
        int                     size;
        String  name(fileNameMesh);
        
        //      Open the file.
        mSerializer     =       new     Serializer(     name,
                                                                                                                                Serializer::WRITE);

        //      Set the mesh.
        mGeoMesh        =       geoMesh;

        //      Write the file header.
        writeFileHeader();

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

        //      Debug.
        cout    <<      "Write mesh finish"
                                <<      endl;
        
        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)
{
        //      Debug.
        cout    <<      "Write the chunk header"
                                <<      endl;
        
        // Header
        writeChunkHeader(M_MESH, calcMeshSize(geoMesh));

        //      Write the skeletally animated flag.
        writeBools(mSkeletallyAnimated,1);
        
        cout    <<      "1 - VertexCount: "
                                <<      geoMesh->mVertexBuffer->mVertexCount
                                <<      endl;

        //      Write shared geometry.
        if (geoMesh->mVertexBuffer->mVertexCount > 0)
        {
                //      Debug.
                cout    <<      "Write the shared vertex buffer"
                                        <<      endl;
                
                writeGeometry(geoMesh->mVertexBuffer);
        }

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

        //      Write the mesh bounds.
        writeMeshBounds(mMeshBounds);
        
        /*
        // Write skeleton info if required
        if (pMesh->hasSkeleton())
        {
        LogManager::getSingleton().logMessage("Exporting skeleton link...");
        // Write skeleton link
        writeSkeletonLink(pMesh->getSkeletonName());
        LogManager::getSingleton().logMessage("Skeleton link exported.");

        // Write bone assignments
        if (!pMesh->mBoneAssignments.empty())
        {
        LogManager::getSingleton().logMessage("Exporting shared geometry bone assignments...");

        Mesh::VertexBoneAssignmentList::const_iterator vi;
        for (vi = pMesh->mBoneAssignments.begin(); 
        vi != pMesh->mBoneAssignments.end(); ++vi)
        {
        writeMeshBoneAssignment(vi->second);
        }

        LogManager::getSingleton().logMessage("Shared geometry bone assignments exported.");
        }
        }

        // 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");
        }
        */
}

//      Write a submesh.
void    GeoMeshSaver::writeSubMesh(SubMesh      *geoSubMesh)
{
        bool                                            idx32bit;
        unsigned        long    indexCount;
        String                                  materialName;
        
        //      Debug.
        cout    <<      "Write the submesh chunk header"
                                <<      endl;
        
        // Header.
        writeChunkHeader(M_SUBMESH, calcSubMeshSize(geoSubMesh));

        //      Debug.
        cout    <<      "Write the material name"
                                <<      endl;

        // Material Name.
        materialName    =       getMaterialName();
        writeString(materialName);

        //      Debug.
        cout    <<      "Write the shared vertex buffer flag: "
                                <<      endl;

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

        indexCount      =       geoSubMesh->mIndexCount;

        writeInts(indexCount, 1);

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

        //      Debug.
        cout    <<      "Write the mIndex array"
                                <<      endl;

        //      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)
        {
                //      Debug.
                cout    <<      "Write the geometry of the submesh"
                                        <<      endl;

                writeGeometry(geoSubMesh->mVertexBuffer);
        }

        //      Debug.
        cout    <<      "mIndex array written"
                                <<      endl;

        // Operation type
        writeSubMeshOperation(geoSubMesh);

        //TODO:Bones.
        /*
        // Bone assignments
        if (!s->mBoneAssignments.empty())
        {
                LogManager::getSingleton().logMessage("Exporting dedicated geometry bone assignments...");

                SubMesh::VertexBoneAssignmentList::const_iterator vi;

                for (vi = s->mBoneAssignments.begin(); 
                                vi != s->mBoneAssignments.end(); ++vi)
                {
                        writeSubMeshBoneAssignment(vi->second);
                }

                LogManager::getSingleton().logMessage("Dedicated geometry bone assignments exported.");
        }
        */
}

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

        //      Debug.
        cout    <<      "Write submesh operation"
                                <<      endl;
        
        size    =       CHUNK_OVERHEAD_SIZE     +       sizeof(unsigned short);
        
        // Header
        writeChunkHeader(M_SUBMESH_OPERATION, size);

        //      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);

        //      Debug.
        cout    <<      "Submesh operation Written"
                                <<      endl;
}

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

        buffer_count    =       3;

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

        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);

        //      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);

        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);
        
        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);
        
        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);

        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);

        //      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);

        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);

        //      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);

        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    <<      "-7-"   <<      endl;

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

        //      Debug.
        cout    <<      "-8-"   <<      endl;

}

//      TODO: Write Mesh Bounds.
void    GeoMeshSaver::writeMeshBounds(GeometryBounds bounds)
{
        size_t  size;

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

        writeChunkHeader(M_MESH_BOUNDS, size);

        writeFloats(bounds.minx,1);
        writeFloats(bounds.miny,1);
        writeFloats(bounds.minz,1);
        writeFloats(bounds.maxx,1);
        writeFloats(bounds.maxy,1);
        writeFloats(bounds.maxz,1);
        writeFloats(bounds.radius,1);
}

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

        //      Debug.
        cout    <<      "Calc the size of the mesh"
                                <<      endl;
        
        // Num shared vertices
        size += sizeof(uint32);

        //      Debug.
        cout    <<      "VertexCount: "
                                <<      geoMesh->mVertexBuffer->mVertexCount
                                <<      endl;

        // Geometry
        if (geoMesh->mVertexBuffer->mVertexCount > 0)
        {
                //      Debug.
                cout    <<      "Calc the size of the shared vertex buffer"
                                        <<      endl;
                
                size += calcGeometrySize(geoMesh->mVertexBuffer);
        }

        // Submeshes
        for (unsigned short i = 0; i < geoMesh->mSubMeshCount; ++i)
        {
                //      Debug.
                cout    <<      "Calc the size of the submesh "
                                        <<      i
                                        <<      endl;

                size += calcSubMeshSize(&geoMesh->mSubMesh[i]);
        }

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

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

        /*
        // 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 += getMaterialName().length() + 1;

        // 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;
}

//      Calc 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;
}

//      Write the file header.
void GeoMeshSaver::writeFileHeader(void)
{
        String  mesh_version("[MeshSerializer_v1.30]");
        
        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);
}

//      Sets the material of the mesh.
void    GeoMeshSaver::setMaterialName(String    materialName)
{
        mMaterialName   =       materialName;
}

//      Gets the material of the mesh.
String  GeoMeshSaver::getMaterialName()
{
        return  mMaterialName;
}

//      Set Mesh Bounds.
void    GeoMeshSaver::setMeshBounds(GeometryBounds      bounds)
{
        mMeshBounds.minx                =       bounds.minx;
        mMeshBounds.miny                =       bounds.miny;
        mMeshBounds.minz                =       bounds.minz;
        mMeshBounds.maxx                =       bounds.maxx;
        mMeshBounds.maxy                =       bounds.maxy;
        mMeshBounds.maxz                =       bounds.maxz;
        mMeshBounds.radius      =       bounds.radius;
}