source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSaver.cpp @ 2341

/*========================================================================
 *      (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()
{
        leavesSubMesh   =       -1;
        leavesVB                        =       NULL;
        numindices              =       0;
        indices                         =       NULL;
}

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

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

        mGeoMesh        =       new Mesh();

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

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

        //      Unnormalize geometry model.
        unnormalizeModel(mGeoMesh);

        if ((leavesSubMesh > -1) && leavesVB)
        {
                //      Gets the leaves submesh.
                geosubmesh      =       &mGeoMesh->mSubMesh[leavesSubMesh];
                
                Vector3 bmax(   geoMesh->mMeshBounds.maxX,
                                                                        geoMesh->mMeshBounds.maxY,
                                                                        geoMesh->mMeshBounds.maxZ);
                
                Vector3 bmin(   geoMesh->mMeshBounds.minX,
                                                                        geoMesh->mMeshBounds.minY,
                                                                        geoMesh->mMeshBounds.minZ);
                
                Vector3 center = (bmax + bmin) * 0.5f;
                
                float   scale   =       geoMesh->mMeshBounds.scaleFactor;
                
                geosubmesh->mSharedVertexBuffer =       false;
                geosubmesh->mStripCount                                 =       0;
                geosubmesh->mIndexCount                                 =       numindices;
                
                size_t  icount  =       geosubmesh->mIndexCount;
                
                geosubmesh->mIndex      =       new Index[icount];
                
                for (size_t     i       =       0;      i < icount;     i++)
                {
                        geosubmesh->mIndex[i]   =       indices[i];
                }

                geosubmesh->mType                                       =       GEO_TRIANGLE_LIST;
                geosubmesh->mVertexBuffer       =       new VertexBuffer();
                geosubmesh->mVertexBuffer->mVertexInfo
                                                                                                                                                                                                                =       VERTEX_POSITION;
                
                geosubmesh->mVertexBuffer->mVertexCount
                                                                                                                                                                                                                =       leavesVB->mVertexCount;
                
                size_t  vcount;
                        
                vcount = geosubmesh->mVertexBuffer->mVertexCount;
                
                geosubmesh->mVertexBuffer->mPosition
                                                                                                                                                                                                                =       new Vector3[vcount];
                
                geosubmesh->mVertexBuffer->mNormal
                                                                                                                                                                                                                =       new Vector3[vcount];
                
                geosubmesh->mVertexBuffer->mTexCoords
                                                                                                                                                                                                                =       new Vector2[vcount];
                
                for (size_t     i       =       0;      i < vcount;     i++)
                {
                        geosubmesh->mVertexBuffer->mPosition[i].x = leavesVB->mPosition[i].x / scale + center.x;
                        geosubmesh->mVertexBuffer->mPosition[i].y = leavesVB->mPosition[i].y / scale + center.y;
                        geosubmesh->mVertexBuffer->mPosition[i].z = leavesVB->mPosition[i].z / scale + center.z;
                        geosubmesh->mVertexBuffer->mNormal[i].x = leavesVB->mNormal[i].x;
                        geosubmesh->mVertexBuffer->mNormal[i].y = leavesVB->mNormal[i].y;
                        geosubmesh->mVertexBuffer->mNormal[i].z = leavesVB->mNormal[i].z;
                        geosubmesh->mVertexBuffer->mTexCoords[i].x = leavesVB->mTexCoords[i].x;
                        geosubmesh->mVertexBuffer->mTexCoords[i].y = leavesVB->mTexCoords[i].y;
                }
        }

        //      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, (unsigned long)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 (size_t i = 0;      i < geoMesh->mSubMeshCount;     i++)
        {
                writeSubMesh(&geoMesh->mSubMesh[i]);
        }

        // Write skeleton info if required
        if (geoMesh->hasSkeleton)
        {
                strcat(geoMesh->mSkeletonName,"\n");

                // Write skeleton link
                writeSkeletonLink(geoMesh->mSkeletonName);

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

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

                }
        }

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

        // Write submesh name table.
        writeSubMeshNameTable(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 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;
        size_t                                  indexCount;
        //Index                                         *index;
        //Index                                         *indexBegin;
        //Index                                         *indexEnd;

        // Header.
        writeChunkHeader(M_SUBMESH, (unsigned long)calcSubMeshSize(geoSubMesh));

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

        // Material Name.
        strcat(geoSubMesh->mMaterialName,"\n");
        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((unsigned long)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;

                        //      Degenerate.
                        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++;
                        }

                        //      Degenerate.
                        if (strip       != (geoSubMesh->mStripCount - 1))
                        {
                                writeInts(indexBegin[i - 1], 1);
                        }
                }
        }
        //      If the submesh is in triangle list.
        else
        {
        */
                //      Write the index array.
                for (size_t 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 (size_t 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    =       (unsigned long)calcGeometrySize(vertexBuffer);
                
        //      Header.
        //
        //      Write the M_GEOMETRY header.
        writeChunkHeader(M_GEOMETRY, size);

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

        writeInts((unsigned long)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, (unsigned long)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);
}

//-------------------------------------------------------------------------
// Write submesh name table.
//-------------------------------------------------------------------------
void    GeoMeshSaver::writeSubMeshNameTable(Mesh        *geoMesh)
{
        size_t  size;
        size_t  names_size;

        //      Size of the names of the submeshes.
        names_size      =       0;

        //      For each submesh.
        for (size_t     i = 0; i < geoMesh->mSubMeshCount;      i++)
        {
                names_size      =       strlen(geoMesh->mSubMesh[i].mName);
        }

        size    =       CHUNK_OVERHEAD_SIZE
                                        +
                                        names_size
                                        +
                                        (CHUNK_OVERHEAD_SIZE + sizeof(short)) * geoMesh->mSubMeshCount;

        writeChunkHeader(M_SUBMESH_NAME_TABLE, (unsigned long)size);

        //      For each submesh.
        for (size_t     i = 0;  i < geoMesh->mSubMeshCount;     i++)
        {
                size    =       CHUNK_OVERHEAD_SIZE
                                                +
                                                sizeof(short)
                                                +
                                                strlen(geoMesh->mSubMesh[i].mName);

                writeChunkHeader(M_SUBMESH_NAME_TABLE_ELEMENT, (unsigned long)size);

                writeShorts(i, 1);

                strcat(geoMesh->mSubMesh[i].mName,"\n");
                mSerializer->WriteData(geoMesh->mSubMesh[i].mName);
        }
}

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

//-------------------------------------------------------------------------
//      Write skeleton filename.
//-------------------------------------------------------------------------
void GeoMeshSaver::writeSkeletonLink(const String& skelName)
{       
        writeChunkHeader(       M_MESH_SKELETON_LINK, 
                                                                                (unsigned long)calcSkeletonLinkSize(mGeoMesh));

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

        writeString(skelName);
}

//-------------------------------------------------------------------------
//      Write bones assignmets.
//-------------------------------------------------------------------------
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, (unsigned long)size);

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

//-------------------------------------------------------------------------
//      Write bones assignmets.
//-------------------------------------------------------------------------
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, (unsigned long)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.0f;
        cy = (maxy + miny) / 2.0f;
        cz = (maxz + minz) / 2.0f;

        //      Translate around center then scale.
        //      For each submesh.

        bool sharedScaled       =       false;

        for (size_t submesh = 0; submesh < geoMesh->mSubMeshCount; submesh++)
        {
                //      Gets the actual submesh.
                vertex_buffer   =       geoMesh->mSubMesh[submesh].mVertexBuffer;

                if (geoMesh->mSubMesh[submesh].mSharedVertexBuffer && sharedScaled)
                {
                        continue;
                }

                //      For each index of the strip.
                for (size_t 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)
                {
                        sharedScaled    =       true;
                }
        }
}