Keos3DSLoader.cpp

Go to the documentation of this file.

/*
 * This source file is part of KEOS (Free 3D Engine)
 * For the latest info, see http://www.keosengine.org/
 * E-mails : thierry.vouriot@keosengine.org, yeri@keosengine.org
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307, USA, or go to
 * http://www.gnu.org/copyleft/lesser.txt.
 *
 */
#include "Keos3DSLoader.h"
#include "KeosRenderSystem.h"
#include "KeosLogger.h"
#include "KeosMesh.h"
#include "KeosString.h"
#include "KeosUtil.h"
#include <fstream>

namespace Keos
{
  //=======================================================================
  // C3DSLoader implementation
  //=======================================================================

  //-----------------------------------------------------------------------
  C3DSLoader::C3DSLoader()
  {
    m_pTexCoords = NULL;
    m_pVertices = NULL;

    m_nNumTexVertex = 0;
    m_nObjectWithMultMaterial = 0;
  }

  //-----------------------------------------------------------------------
  CMesh* C3DSLoader::LoadFromFile(const String& strFilename)
  {
    m_CurrentChunk = new TChunk;    // Initialize and allocate our current chunk
    m_TempChunk = new TChunk;     // Initialize and allocate a temporary chunk

    // Open the 3DS file
    m_FilePointer = fopen(strFilename.c_str(), "rb");

    ILogger::Log("Load of the mesh : %s", strFilename.c_str());

    // Make sure we have a valid file pointer (we found the file)
    if (!m_FilePointer)
      LOADINGFAILED_EXCEPT(strFilename, "Unable to find the file !", "C3DSLoader::LoadFromFile");

    // Once we have the file open, we need to read the very first data chunk
    // to see if it's a 3DS file.  That way we don't read an invalid file.
    // If it is a 3DS file, then the first chunk ID will be equal to PRIMARY (some hex num)

    // Read the first chuck of the file to see if it's a 3DS file
    ReadChunk(m_CurrentChunk);

    // Make sure this is a 3DS file
    if (m_CurrentChunk->ID != CHUNK_PRIMARY)
      LOADINGFAILED_EXCEPT(strFilename, "The file is not a valid model 3DS !", "C3DSLoader::LoadFromFile");

    CMesh* pMesh = new CMesh();

    // Now we actually start reading in the data.  ProcessNextChunk() is recursive
    ProcessNextChunk(pMesh, m_CurrentChunk);

    // Clean up after everything
    CleanUp();

    // Calculate normals
    pMesh->ComputeNormals();

    return pMesh;
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::CleanUp()
  {
    fclose(m_FilePointer);      // Close the current file pointer
    delete m_CurrentChunk;      // Free the current chunk
    delete m_TempChunk;       // Free our temporary chunk
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ProcessNextChunk(CMesh *pMesh, TChunk *pPreviousChunk)
  {
    unsigned int version = 0;     // This will hold the file version
    int buffer[50000] = {0};     // This is used to read past unwanted data
    char strBuffer[256] = {0};

    m_CurrentChunk = new TChunk;    // Allocate a new chunk

    // Below we check our chunk ID each time we read a new chunk.  Then, if
    // we want to extract the information from that chunk, we do so.
    // If we don't want a chunk, we just read past it.

    // Continue to read the sub chunks until we have reached the length.
    // After we read ANYTHING we add the bytes read to the chunk and then check
    // check against the length.
    while (pPreviousChunk->bytesRead < pPreviousChunk->length)
    {
      // Read next Chunk
      ReadChunk(m_CurrentChunk);

      // Check the chunk ID
      switch (m_CurrentChunk->ID)
      {
        case CHUNK_VERSION:       // This holds the version of the file

          // This chunk has an unsigned short that holds the file version.
          // Since there might be new additions to the 3DS file format in 4.0,
          // we give a warning to that problem.

          // Read the file version and add the bytes read to our bytesRead variable
          m_CurrentChunk->bytesRead += fread(&version, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);

          // If the file version is over 3, give a warning that there could be a problem
          if (version > 0x03)
            ILogger::Log("WARNING - This 3DS file is over version 3 so it may load incorrectly");
          break;

        case CHUNK_OBJECTINFO:      // This holds the version of the mesh

          // This chunk holds the version of the mesh.  It is also the head of the MATERIAL
          // and OBJECT chunks.  From here on we start reading in the material and object info.

          // Read the next chunk
          ReadChunk(m_TempChunk);

          // Get the version of the mesh
          m_TempChunk->bytesRead += fread(&version, 1, m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer);

          // Increase the bytesRead by the bytes read from the last chunk
          m_CurrentChunk->bytesRead += m_TempChunk->bytesRead;

          // Go to the next chunk, which is the object has a texture, it should be MATERIAL, then OBJECT.
          ProcessNextChunk(pMesh, m_CurrentChunk);
          break;

        case CHUNK_MATERIAL:       // This holds the material information
        {
          // This chunk is the header for the material info chunks

          // Add a empty material to mesh material list.
          CMaterial* pMaterial = new CMaterial();
          pMesh->GetMaterialList().push_back(pMaterial);

          // Proceed to the material loading function
          ProcessNextMaterialChunk(pMesh, m_CurrentChunk);
        }
        break;

        case CHUNK_OBJECT:       // This holds the name of the object being read

          // This chunk is the header for the object info chunks.  It also
          // holds the name of the object.

          // Get the name of the object and store it, then add the read bytes to our byte counter.
          m_CurrentChunk->bytesRead += GetString(strBuffer);

          // Now proceed to read in the rest of the object information
          ProcessNextObjectChunk(pMesh, strBuffer, m_CurrentChunk);

          break;

        case CHUNK_EDITKEYFRAME:

          // Not supported
          //ProcessNextKeyFrameChunk(pMesh, m_CurrentChunk);

          // Read past this chunk and add the bytes read to the byte counter
          m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
          break;

        default:

          // If we didn't care about a chunk, then we get here.  We still need
          // to read past the unknown or ignored chunk and add the bytes read to the byte counter.
          m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
          break;
      }

      // Add the bytes read from the last chunk to the previous chunk passed in.
      pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;
    }

    // Free the current chunk and set it back to the previous chunk (since it started that way)
    delete m_CurrentChunk;
    m_CurrentChunk = pPreviousChunk;
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ProcessNextObjectChunk(CMesh *pMesh, char* strObjectName, TChunk *pPreviousChunk)
  {
    int buffer[50000] = {0};     // This is used to read past unwanted data

    // Allocate a new chunk to work with
    m_CurrentChunk = new TChunk;

    // Continue to read these chunks until we read the end of this sub chunk
    while (pPreviousChunk->bytesRead < pPreviousChunk->length)
    {
      // Read the next chunk
      ReadChunk(m_CurrentChunk);

      // Check which chunk we just read
      switch (m_CurrentChunk->ID)
      {
        case CHUNK_OBJECT_MESH:     // This lets us know that we are reading a new object
        {
          // We found a new object, so let's read in it's info using recursion
          ProcessNextObjectChunk(pMesh, strObjectName, m_CurrentChunk);

          // Create the index buffers
          // For each different material, we create a new TGeom struct
          std::vector<TGeom*> GeomList;
          TGeom* CurrentGeom;
          std::map<int, uint> MaterialSet;
          std::map<int, uint>::const_iterator SetIter;
          uint nNumDiffMat = 0;
          for (uint i = 0; i < m_Faces.size(); ++i)
          {
            // Search if this material has already been used
            SetIter = MaterialSet.find(m_Faces[i].materialID);
            if (SetIter == MaterialSet.end())
            {
              // Add a new TGeom
              MaterialSet[m_Faces[i].materialID] = nNumDiffMat;
              GeomList.push_back(new TGeom);
              CurrentGeom = GeomList[nNumDiffMat];
              nNumDiffMat++;
            }
            // Get the TGeom for this material
            else CurrentGeom = GeomList[SetIter->second];

            CurrentGeom->materialID = m_Faces[i].materialID;

            // Addition in the index buffer
            CurrentGeom->Indicies.push_back(m_Faces[i].vertIndex[0]);
            CurrentGeom->Indicies.push_back(m_Faces[i].vertIndex[1]);
            CurrentGeom->Indicies.push_back(m_Faces[i].vertIndex[2]);
          }

          // Create the vertex buffer
          TVertexList Vertices;
          Vertices.reserve(m_nNumVerts);
          for (int i = 0; i < m_nNumVerts; ++i)
          {
            // Recovery of the information on the current point
            CMeshGeom::TVertex v;
            v.Position.x  = m_pVertices[i].x;
            v.Position.y  = m_pVertices[i].y;
            v.Position.z  = m_pVertices[i].z;

            v.Normal      = TVector3F(0.0, 0.0, 0.0);
            if (GeomList[0]->materialID != -1)
              v.Color = Renderer->ConvertColor(pMesh->GetMaterial(GeomList[0]->materialID)->GetDiffuseColor());
            else v.Color = Renderer->ConvertColor(CColor::White);

            if (i < m_nNumTexVertex)
              v.TexCoords = m_pTexCoords[i];
            else v.TexCoords = TVector2F(0, 0);

            // Addition in the vertex buffer
            Vertices.push_back(v);
          }

          KEOS_DELETE_ARRAY(m_pTexCoords);
          KEOS_DELETE_ARRAY(m_pVertices);
          m_nNumTexVertex = 0;

#if KEOS_MESH_SHARED_VERTEX_BUFFER
          // If this object has more than one material
          if (GeomList.size() > 1)
          {
            // Test if there is only one object with multiple materials
            if (m_nObjectWithMultMaterial >= 1)
              ILogger::Log("WARNING - This 3DS model has more than one object with multiple materials, the loader may not support this correctly !");
            m_nObjectWithMultMaterial++;

            // Create a shared vertex buffer in the mesh class
            // We create a shared vertex buffer only for the first object with multiple materials

            if (m_nObjectWithMultMaterial == 1)
              pMesh->CreateSharedVertexBuffer(&Vertices[0], (int)Vertices.size());
          }
#endif

          // We create one MeshGeom for one TGeom struct
          for (uint i = 0; i < GeomList.size(); i++)
          {
            CurrentGeom = GeomList[i];

            // Create MeshGeom
            CMeshGeom *pMeshGeom;
#if KEOS_MESH_SHARED_VERTEX_BUFFER
            if (m_nObjectWithMultMaterial == 1)
              pMeshGeom = new CMeshGeom(&(CurrentGeom->Indicies[0]), (int)CurrentGeom->Indicies.size());
            else
#endif
              pMeshGeom = new CMeshGeom(&Vertices[0], (int)Vertices.size(), &(CurrentGeom->Indicies[0]), (int)CurrentGeom->Indicies.size());

            // Add MeshGeom to the mesh
            pMesh->AddMeshGeom(pMeshGeom, String(strObjectName) + CStringConverter::ToString((int)i));

            // Set the material index of the MeshGeom
            pMeshGeom->SetMaterialIndex(CurrentGeom->materialID);
          }
          std::for_each(GeomList.begin(), GeomList.end(), Delete());

        }
        break;

        case CHUNK_OBJECT_VERTICES:    // This is the objects vertices
          ReadVertices(m_CurrentChunk);
          break;

        case CHUNK_OBJECT_FACES:     // This is the objects face information
          ReadVertexIndices(m_CurrentChunk);
          break;

        case CHUNK_OBJECT_MATERIAL:    // This holds the material name that the object has
          ReadObjectMaterial(pMesh, m_CurrentChunk);
          break;

        case CHUNK_OBJECT_UV:      // This holds the UV texture coordinates for the object

          // This chunk holds all of the UV coordinates for our object.  Let's read them in.
          ReadUVCoordinates(m_CurrentChunk);
          break;

        default:

          // Read past the ignored or unknown chunks
          m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
          break;
      }

      // Add the bytes read from the last chunk to the previous chunk passed in.
      pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;
    }

    // Free the current chunk and set it back to the previous chunk (since it started that way)
    delete m_CurrentChunk;
    m_CurrentChunk = pPreviousChunk;
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ProcessNextMaterialChunk(CMesh *pMesh, TChunk *pPreviousChunk)
  {
    int buffer[50000] = {0};     // This is used to read past unwanted data
    char  strBuffer[255];

    // Allocate a new chunk to work with
    m_CurrentChunk = new TChunk;

    // Continue to read these chunks until we read the end of this sub chunk
    while (pPreviousChunk->bytesRead < pPreviousChunk->length)
    {
      // Read the next chunk
      ReadChunk(m_CurrentChunk);

      CMaterial* pMaterial = pMesh->GetMaterialList()[pMesh->GetLastAddedMaterialIndex()];

      // Check which chunk we just read in
      switch (m_CurrentChunk->ID)
      {
        case CHUNK_MATNAME:       // This chunk holds the name of the material

          // Here we read in the material name
          m_CurrentChunk->bytesRead += fread(strBuffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
          pMaterial->SetName(strBuffer);
          break;

        case CHUNK_MATDIFFUSE:      // This holds the R G B color of our object
          ReadColorChunk(pMaterial, m_CurrentChunk);
          break;

        case CHUNK_MATMAP:       // This is the header for the texture info

          // Proceed to read in the material information
          ProcessNextMaterialChunk(pMesh, m_CurrentChunk);
          break;

        case CHUNK_MATMAPFILE:      // This stores the file name of the material

          // Here we read in the material's file name
          m_CurrentChunk->bytesRead += fread(strBuffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
          pMaterial->CreateTexture(String(strBuffer));

          // We flip the image texture, because else the texture coordinates are false
          // I don't know why ?
          pMaterial->GetTexture()->GetPixels().Flip();
          pMaterial->GetTexture()->Update();
          break;

        default:

          // Read past the ignored or unknown chunks
          m_CurrentChunk->bytesRead += fread(buffer, 1, m_CurrentChunk->length - m_CurrentChunk->bytesRead, m_FilePointer);
          break;
      }

      // Add the bytes read from the last chunk to the previous chunk passed in.
      pPreviousChunk->bytesRead += m_CurrentChunk->bytesRead;
    }

    // Free the current chunk and set it back to the previous chunk (since it started that way)
    delete m_CurrentChunk;
    m_CurrentChunk = pPreviousChunk;
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ReadChunk(TChunk *pChunk)
  {
    // This reads the chunk ID which is 2 bytes.
    // The chunk ID is like OBJECT or MATERIAL.  It tells what data is
    // able to be read in within the chunks section.
    pChunk->bytesRead = fread(&pChunk->ID, 1, 2, m_FilePointer);

    // Then, we read the length of the chunk which is 4 bytes.
    // This is how we know how much to read in, or read past.
    pChunk->bytesRead += fread(&pChunk->length, 1, 4, m_FilePointer);
  }

  //-----------------------------------------------------------------------
  size_t C3DSLoader::GetString(char *pBuffer)
  {
    int index = 0;

    // Read 1 byte of data which is the first letter of the string
    fread(pBuffer, 1, 1, m_FilePointer);

    // Loop until we get NULL
    while (*(pBuffer + index++) != 0)
    {

      // Read in a character at a time until we hit NULL.
      fread(pBuffer + index, 1, 1, m_FilePointer);
    }

    // Return the string length, which is how many bytes we read in (including the NULL)
    return strlen(pBuffer) + 1;
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ReadColorChunk(CMaterial *pMaterial, TChunk *pChunk)
  {
    // Read the color chunk info
    ReadChunk(m_TempChunk);

    unsigned char color[4];
    // Read in the R G B color (3 bytes - 0 through 255)
    m_TempChunk->bytesRead += fread(color, 1, m_TempChunk->length - m_TempChunk->bytesRead, m_FilePointer);
    pMaterial->SetDiffuseColor(CColor(color[0], color[1], color[2]));

    // Add the bytes read to our chunk
    pChunk->bytesRead += m_TempChunk->bytesRead;
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ReadVertexIndices(TChunk *pPreviousChunk)
  {
    unsigned short index = 0;     // This is used to read in the current face index

    // In order to read in the vertex indices for the object, we need to first
    // read in the number of them, then read them in.  Remember,
    // we only want 3 of the 4 values read in for each face.  The fourth is
    // a visibility flag for 3D Studio Max that doesn't mean anything to us.

    // Read in the number of faces that are in this object (int)
    int nNumOfFaces = 0;
    pPreviousChunk->bytesRead += fread(&nNumOfFaces, 1, 2, m_FilePointer);

    // Initialize
    m_Faces.clear();
    TFace Face = {0};
    Face.materialID = -1;

    // Go through all of the faces in this object
    for (int i = 0; i < nNumOfFaces; i++)
    {
      // Next, we read in the A then B then C index for the face, but ignore the 4th value.
      // The fourth value is a visibility flag for 3D Studio Max, we don't care about this.
      for (int j = 0; j < 4; j++)
      {
        // Read the first vertice index for the current face
        pPreviousChunk->bytesRead += fread(&index, 1, sizeof(index), m_FilePointer);

        if (j < 3)
        {
          // Store the index in our face structure.
          Face.vertIndex[j] = index;
        }
      }
      m_Faces.push_back(Face);
    }
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ReadUVCoordinates(TChunk *pPreviousChunk)
  {
    // In order to read in the UV indices for the object, we need to first
    // read in the amount there are, then read them in.

    // Read in the number of UV coordinates there are (int)
    m_nNumTexVertex = 0;
    pPreviousChunk->bytesRead += fread(&m_nNumTexVertex, 1, 2, m_FilePointer);

    // Allocate memory to hold the UV coordinates
    m_pTexCoords = new TVector2F [m_nNumTexVertex];

    // Read in the texture coodinates (an array 2 float)
    pPreviousChunk->bytesRead += fread(m_pTexCoords, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ReadVertices(TChunk *pPreviousChunk)
  {
    // Like most chunks, before we read in the actual vertices, we need
    // to find out how many there are to read in.  Once we have that number
    // we then fread() them into our vertice array.

    // Read in the number of vertices (int)
    m_nNumVerts = 0;
    pPreviousChunk->bytesRead += fread(&m_nNumVerts, 1, 2, m_FilePointer);

    // Allocate the memory for the verts and initialize the structure
    m_pVertices = new TVector3F [m_nNumVerts];
    memset(m_pVertices, 0, sizeof(TVector3F) * m_nNumVerts);

    // Read in the array of vertices (an array of 3 floats)
    pPreviousChunk->bytesRead += fread(m_pVertices, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);

    // Now we should have all of the vertices read in.  Because 3D Studio Max
    // Models with the Z-Axis pointing up (strange and ugly I know!), we need
    // to flip the y values with the z values in our vertices.  That way it
    // will be normal, with Y pointing up.  If you prefer to work with Z pointing
    // up, then just delete this next loop.  Also, because we swap the Y and Z
    // we need to negate the Z to make it come out correctly.

    // Go through all of the vertices that we just read and swap the Y and Z values
    /*for(int i = 0; i < pObject->numOfVerts; i++)
    {
     // Store off the Y value
     float fTempY = pObject->pVerts[i].y;

     // Set the Y value to the Z value
     pObject->pVerts[i].y = pObject->pVerts[i].z;

     // Set the Z value to the Y value, 
     // but negative Z because 3D Studio max does the opposite.
     pObject->pVerts[i].z = -fTempY;
    }*/
  }

  //-----------------------------------------------------------------------
  void C3DSLoader::ReadObjectMaterial(CMesh *pMesh, TChunk *pPreviousChunk)
  {
    char strMaterial[255] = {0};   // This is used to hold the objects material name
    int buffer[50000] = {0};    // This is used to read past unwanted data
    int nMaterialIndex = -1;    // Index in the model material list

    // *What is a material?*  - A material is either the color or the texture map of the object.
    // It can also hold other information like the brightness, shine, etc... Stuff we don't
    // really care about.  We just want the color, or the texture map file name really.

    // Here we read the material name that is assigned to the current object.
    // strMaterial should now have a string of the material name, like "Material #2" etc..
    pPreviousChunk->bytesRead += GetString(strMaterial);

    // Now that we have a material name, we need to go through all of the materials
    // and check the name against each material.  When we find a material in our material
    // list that matches this name we just read in, then we assign the materialID
    // of the object to that material index.  You will notice that we passed in the
    // model to this function.  This is because we need the number of textures.

    // Go through all of the textures
    for (uint i = 0; i < pMesh->GetMaterialsCount(); i++)
    {
      // If the material we just read in matches the current texture name
      if (strcmp(strMaterial, pMesh->GetMaterialList()[i]->GetName().c_str()) == 0)
      {
        // Set the material ID to the current index 'i' and stop checking
        nMaterialIndex = i;
        break;
      }
      else
      {
        // Set the ID to -1 to show there is no material for this object
        nMaterialIndex = -1;
      }
    }

    // Read the number of faces which use this material
    ushort iNumFaces = 0;
    pPreviousChunk->bytesRead += fread(&iNumFaces, 1, 2, m_FilePointer);

    ushort* pFaceAssignedThisMaterial = new ushort[iNumFaces];
    memset(pFaceAssignedThisMaterial, 0, sizeof(ushort) * iNumFaces);

    // Read in the array of ushort
    pPreviousChunk->bytesRead += fread(pFaceAssignedThisMaterial, 1, iNumFaces * sizeof(ushort), m_FilePointer);

    // We assign for each face the corresponding material
    for (int i = 0; i < iNumFaces; i++)
    {
      int iIndex = pFaceAssignedThisMaterial[i];
      m_Faces[iIndex].materialID = nMaterialIndex;
    }

    KEOS_DELETE_ARRAY(pFaceAssignedThisMaterial);

    // Read past the rest of the chunk since we don't care about shared vertices
    // You will notice we subtract the bytes already read in this chunk from the total length.
    pPreviousChunk->bytesRead += fread(buffer, 1, pPreviousChunk->length - pPreviousChunk->bytesRead, m_FilePointer);
  }
}

---