KeosMesh.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 "KeosMesh.h"
#include "KeosException.h"
#include "KeosRoot.h"
#include "KeosRenderSystem.h"
#include "KeosUtil.h"

namespace Keos
{
#define Renderer CRoot::Instance().GetRenderSystem()


  //=======================================================================
  // CMesh implementation
  //=======================================================================

  //-----------------------------------------------------------------------
  CMesh::CMesh()
  {}

  //-----------------------------------------------------------------------
  CMesh::~CMesh()
  {
    std::for_each(m_MeshGeomList.begin(), m_MeshGeomList.end(), Delete());
    std::for_each(m_MaterialList.begin(), m_MaterialList.end(), Delete());
  }

  //-----------------------------------------------------------------------
  void CMesh::Render() const
  {
    CMeshGeom* pTemp;
    for (uint i = 0; i < m_MeshGeomList.size(); i++)
    {
      pTemp = m_MeshGeomList[i];
      if (pTemp->GetMaterialIndex() != -1)
      {
        CMaterial* pMaterial = m_MaterialList[pTemp->GetMaterialIndex()];
        if (pMaterial->HasTexture()) // For the moment only the texture is used
        {
          //Renderer->SetupTextureUnit(0, TXO_COLOR_FIRSTARG, TXA_TEXTURE);
          //Renderer->SetupTextureUnit(0, TXO_ALPHA_FIRSTARG, TXA_TEXTURE);
          Renderer->SetTexture(0, pMaterial->GetTexture()->GetTextureBase());
        }
        else Renderer->SetTexture(0, NULL);
      }
      Renderer->SetDeclaration(pTemp->m_pDeclaration);
      if (pTemp->m_bUseSharedVertexBuffer)
        Renderer->SetVertexBuffer(0, m_SharedVertexBuffer);
      else Renderer->SetVertexBuffer(0, pTemp->m_VertexBuffer);
      Renderer->SetIndexBuffer(pTemp->m_IndexBuffer);
      Renderer->DrawIndexedPrimitives(pTemp->m_PrimitiveType, 0, pTemp->m_nPrimitivesCount);

    }
  }

  //-----------------------------------------------------------------------
  uint CMesh::GetTrianglesCount(void)
  {
    uint nRes = 0;
    for (uint i = 0; i < m_MeshGeomList.size(); i++)
    {
      nRes += m_MeshGeomList[i]->GetTrianglesCount();

    }
    return nRes;
  }

  //-----------------------------------------------------------------------
  void CMesh::CreateSharedVertexBuffer(const CMeshGeom::TVertex* pVertices, ulong nVerticesCount)
  {
    Assert(pVertices != NULL);
    m_SharedVertexBuffer  = Renderer->CreateVertexBuffer(nVerticesCount, 0, pVertices);
  }

  //-----------------------------------------------------------------------
  void CMesh::ComputeNormals()
  {

    TVector3F vVector1, vVector2, vNormal, vPoly[3];

    // Calculate the face normals, then you take the average of all the normals around each
    // vertex.  It's just averaging.  That way you get a better approximation for that vertex.

    // Go through each of the MeshGeom to calculate their normals
    for (uint index = 0; index < m_MeshGeomList.size(); index++)
    {
      uint i;

      // Get the current MeshGeom
      CMeshGeom* pMeshGeom = m_MeshGeomList[index];

      // Here we allocate all the memory we need to calculate the normals
      TVector3F *pNormals  = new TVector3F [pMeshGeom->GetTrianglesCount()];
      TVector3F *pTempNormals = new TVector3F [pMeshGeom->GetTrianglesCount()];

      // Lock buffers
      uint nVertexBufferSize;
      CMeshGeom::TVertex* Vertices;
      if (pMeshGeom->m_bUseSharedVertexBuffer)
      {
        Vertices = m_SharedVertexBuffer.Lock(0, 0, LOCK_WRITEONLY);
        nVertexBufferSize = m_SharedVertexBuffer.GetCount();
      }
      else
      {
        Vertices = pMeshGeom->m_VertexBuffer.Lock(0, 0, LOCK_WRITEONLY);
        nVertexBufferSize = pMeshGeom->m_VertexBuffer.GetCount();
      }
      CMeshGeom::TIndex* Indicies = pMeshGeom->m_IndexBuffer.Lock(0, 0, LOCK_READONLY);

      // Go though all of the faces of this object
      for (i = 0; i < pMeshGeom->GetTrianglesCount(); i++)
      {
        // To cut down LARGE code, we extract the 3 points of this face
        vPoly[0] = Vertices[Indicies[i*3+0]].Position;
        vPoly[1] = Vertices[Indicies[i*3+1]].Position;
        vPoly[2] = Vertices[Indicies[i*3+2]].Position;

        // Now let's calculate the face normals (Get 2 vectors and find the cross product of those 2)

        vVector1 = VectorBetweenTwoPoints(vPoly[0], vPoly[2]);  // Get the vector of the polygon (we just need 2 sides for the normal)
        vVector2 = VectorBetweenTwoPoints(vPoly[2], vPoly[1]);  // Get a second vector of the polygon

        vNormal  = VectorCross(vVector1, vVector2);  // Return the cross product of the 2 vectors (normalize vector, but not a unit vector)
        pTempNormals[i] = vNormal;     // Save the un-normalized normal for the vertex normals
        vNormal.Normalize();    // Normalize the cross product to give us the polygons normal

        pNormals[i] = vNormal;      // Assign the normal to the list of normals
      }

      // Now Get The Vertex Normals
      TVector3F vSum = TVector3F(0.0, 0.0, 0.0);
      TVector3F vZero = vSum;
      int shared = 0;

      for (i = 0; i < nVertexBufferSize; i++)   // Go through all of the vertices
      {
        for (uint j = 0; j < pMeshGeom->GetTrianglesCount(); j++) // Go through all of the triangles
        {            // Check if the vertex is shared by another face
          if (Indicies[j*3+0] == i ||
              Indicies[j*3+1] == i ||
              Indicies[j*3+2] == i)
          {
            vSum += pTempNormals[j];// Add the un-normalized normal of the shared face
            shared++;    // Increase the number of shared triangles
          }
        }

        // Get the normal by dividing the sum by the shared.  We negate the shared so it has the normals pointing out.
        if (pMeshGeom->m_bUseSharedVertexBuffer && (Vertices[i].Normal.LengthSq() != 0))
          Vertices[i].Normal = (vSum + Vertices[i].Normal / float(-(shared + 1)));
        Vertices[i].Normal = (vSum / float(-shared));

        // Normalize the normal for the final vertex normal
        Vertices[i].Normal.Normalize();

        vSum = vZero;         // Reset the sum
        shared = 0;          // Reset the shared
      }

      // Unlock buffers
      if (pMeshGeom->m_bUseSharedVertexBuffer)
        m_SharedVertexBuffer.Unlock();
      else pMeshGeom->m_VertexBuffer.Unlock();
      pMeshGeom->m_IndexBuffer.Unlock();

      // Free our memory and start over on the next MeshGeom
      delete [] pTempNormals;
      delete [] pNormals;
    }
  }

  //-----------------------------------------------------------------------
  CMeshGeom* CMesh::GetMeshGeom(const String& strName) const
  {
    ushort nIndex = _GetMeshGeomIndex(strName);
    return GetMeshGeom(nIndex);
  }

  //-----------------------------------------------------------------------
  CMeshGeom* CMesh::GetMeshGeom(ushort nIndex) const
  {
    TMeshGeomList::const_iterator i = m_MeshGeomList.begin();
    return const_cast<CMeshGeom*>(i[nIndex]);
  }

  //---------------------------------------------------------------------
  ushort CMesh::_GetMeshGeomIndex(const String& strName) const
  {
    TMeshGeomNameMap::const_iterator i = m_MeshGeomNameMap.find(strName) ;
    if (i == m_MeshGeomNameMap.end())
      throw new CException("No MeshGeom named " + strName + " found.");

    return i->second;
  }

} // namespace Keos

---