ALMesh.cpp

Go to the documentation of this file.

 
#include "SO3SceneLoader/ALSceneLoader.h"
#include "SO3SceneLoader/ALMesh.h"
#include "SO3SceneLoader/ALScene.h"
#include <OgreHardwareBuffer.h>
#include <OgreMesh.h>
#include <OgreSubMesh.h>
#include <OgreLog.h>
#include <OgreLogManager.h>
 
#include "OgreMeshLodGenerator.h"
#include "OgrePixelCountLodStrategy.h"
#include "OgreLodData.h"
#include "OgreLodConfig.h"
#include "OgreLodCollapser.h"
 
#include "SO3SceneLoader/ALStringCleaner.h"
#include "SO3Renderer/SO3Root.h"
 
namespace SO3
{
  ALMesh::ALMesh(aiNode* meNode, ALScene* alscene)
  {
    mOrigin = meNode;
    mScene = alscene;
    mHasBone = false;
    mSkeleton.reset();
    mOgreMesh.reset();
    mBounding.setNull();
  }
 
  ALMesh::~ALMesh()
  {
    //delete resource
    if (mOgreMesh)
    {
      Ogre::MeshManager::getSingleton().remove(mOgreMesh->getHandle());
 
      // force resource destruction
      while (mOgreMesh)
        mOgreMesh.reset();
    }
  }
 
  void ALMesh::updateBounds(Ogre::Vector3 pos)
  {
    Ogre::Vector3 minB = mBounding.getMinimum();
    Ogre::Vector3 maxB = mBounding.getMaximum();
    minB.x = std::min(minB.x, pos.x);
    minB.y = std::min(minB.y, pos.y);
    minB.z = std::min(minB.z, pos.z);
    maxB.x = std::max(maxB.x, pos.x);
    maxB.y = std::max(maxB.y, pos.y);
    maxB.z = std::max(maxB.z, pos.z);
    mBounding.setMinimum(minB);
    mBounding.setMaximum(maxB);
 
    mSphereRadius = std::max(mSphereRadius, pos.length());
  }
 
  Ogre::MeshPtr ALMesh::generateMesh()
  {
    std::string meshName = std::string(mOrigin->mName.C_Str());
 
    //For complex ifc node names we remove the hash
    if (meshName.find("Ifc") != std::string::npos)
      meshName = meshName.substr(0, meshName.length() - 22);
 
    if (meshName == "")
      meshName = ALStringCleaner::cleanString(mScene->getSceneName());
    else
      meshName = ALStringCleaner::cleanString(meshName);
 
    // Build the main Mesh.
    try
    {
      mOgreMesh = Ogre::MeshManager::getSingleton().createManual(meshName.c_str(), mScene->getRessourceGroup());
    }
    catch(Ogre::Exception &)
    {
      // Mesh name duplicated or group ressource error
      return mOgreMesh;
    }
 
    //check if bones are present
    unsigned int nbSubMeshes = mOrigin->mNumMeshes;
    for(unsigned int n=0; n < mOrigin->mNumMeshes; ++n)
    {
      aiMesh* subMesh = mScene->getAiScene()->mMeshes[mOrigin->mMeshes[n]];
 
      if (subMesh->HasBones())
      {
        mHasBone = true;
        break;
      }
    }
 
    if (mHasBone)
    {
      std::string skeletonName = mOgreMesh->getName() + ".skeleton";
      mSkeleton = Ogre::SkeletonManager::getSingleton().create(skeletonName, mScene->getRessourceGroup(), true);
      ALSkeleton sklAnim(mScene, mSkeleton, mOrigin);
      mSkeletonAnim = sklAnim;
    }
 
    //TODO if computer compatible or flag generate shared vertices buffer
    generateSubMesh(mOgreMesh);
    
    //disable log warning
    bool lastLogstate = SRoot::getSingletonPtr()->GetLogEnable();
    SRoot::getSingletonPtr()->SetLogEnable(false);
 
    if (mHasBone)
    {
      aiMatrix4x4 meshInverseTrans = (mOrigin->mParent != NULL) ? mOrigin->mParent->mTransformation * mOrigin->mTransformation : mOrigin->mTransformation;
      meshInverseTrans.Inverse();
      mSkeletonAnim.makeHierarchy(meshInverseTrans);
      mSkeletonAnim.processAnimation();
      try
      {
        mOgreMesh->setSkeletonName(mOgreMesh->getName() + ".skeleton");
      }
      catch(Ogre::Exception &)
      {
        //ignore loading exception
      }
    }
 
    // The bounding box of the mesh :
    Ogre::AxisAlignedBox bbox = mOgreMesh->getBounds();
    Ogre::Vector3 min1 = mBounding.getMinimum();
    Ogre::Vector3 max1 = mBounding.getMaximum();
 
    //reverse Z need it ?
    Ogre::Vector3 min2(min1.x, min1.y, min1.z);
    Ogre::Vector3 max2(max1.x, max1.y, max1.z);
    Ogre::AxisAlignedBox newbbox;
    newbbox.setExtents(min2, max2);
    bbox.merge(newbbox);
 
    // Set Tangeant
    bool canBuild;
    unsigned short srcTex, destTex;
    Ogre::VertexElementSemantic targetSemantic = Ogre::VES_TANGENT;
    try
    {
      canBuild = !mOgreMesh->suggestTangentVectorBuildParams(Ogre::VES_TANGENT, srcTex, destTex);
 
      if (canBuild)
        mOgreMesh->buildTangentVectors(targetSemantic, srcTex, destTex, false, false, false);
    }
    catch (Ogre::Exception &)
    {
      canBuild = false;
    }
 
    // enable logs again
    SRoot::getSingletonPtr()->SetLogEnable(lastLogstate);
 
    // Define mesh bounds
    mOgreMesh->_setBounds(bbox, false);
    mOgreMesh->_setBoundingSphereRadius(mSphereRadius);
 
    // Optimize the mesh buffers
    if (mOgreMesh->sharedVertexData)
    {
      Ogre::VertexData* vdata = mOgreMesh->getVertexDataByTrackHandle(0);
      Ogre::VertexDeclaration* newadcl = vdata->vertexDeclaration->getAutoOrganisedDeclaration(mOgreMesh->hasSkeleton(), mOgreMesh->hasVertexAnimation(), mOgreMesh->getSharedVertexDataAnimationIncludesNormals());
      vdata->reorganiseBuffers(newadcl);
      vdata->removeUnusedBuffers();
 
      // Automatic
      Ogre::VertexDeclaration* newDcl = mOgreMesh->sharedVertexData->vertexDeclaration->getAutoOrganisedDeclaration(
      mOgreMesh->hasSkeleton(), mOgreMesh->hasVertexAnimation(), mOgreMesh->getSharedVertexDataAnimationIncludesNormals());
      
      vdata->reorganiseBuffers(newDcl);
 
      mOgreMesh->sharedVertexData->removeUnusedBuffers();
    }
 
    const Ogre::Mesh::SubMeshList submeshes = mOgreMesh->getSubMeshes();
    int subIdx = 0;
    for (unsigned int i = 0; i < submeshes.size(); i++)
    {
      Ogre::SubMesh* sm = submeshes[i];
      if (!sm->useSharedVertices)
      {
        const bool hasVertexAnim = sm->getVertexAnimationType() != Ogre::VAT_NONE;
 
        Ogre::VertexData* vdata = mOgreMesh->getVertexDataByTrackHandle(subIdx + 1);
        Ogre::VertexDeclaration* newadcl = vdata->vertexDeclaration->getAutoOrganisedDeclaration(mOgreMesh->hasSkeleton(), hasVertexAnim, sm->getVertexAnimationIncludesNormals());
        vdata->reorganiseBuffers(newadcl);
        vdata->removeUnusedBuffers();
 
        // Automatic
        Ogre::VertexDeclaration* newDcl = sm->vertexData->vertexDeclaration->getAutoOrganisedDeclaration(
                mOgreMesh->hasSkeleton(), hasVertexAnim, sm->getVertexAnimationIncludesNormals());
 
        if (*newDcl != *(sm->vertexData->vertexDeclaration))
          sm->vertexData->reorganiseBuffers(newDcl);
 
        sm->vertexData->removeUnusedBuffers();
      }
      subIdx++;
    }
    
    return mOgreMesh;
  }
 
  void ALMesh::generateSubMesh(Ogre::MeshPtr ogMesh)
  {
    // Build all the submeshes.
    const std::vector<std::string> materialNames = mScene->getMaterialNames();
    unsigned int nbSubMeshes = mOrigin->mNumMeshes;
    Ogre::MaterialManager* materialManager = Ogre::MaterialManager::getSingletonPtr();
    std::string matName;
 
    for(unsigned int n=0; n<nbSubMeshes; ++n)
    {
      aiMesh* currentSubMesh = mScene->getAiScene()->mMeshes[mOrigin->mMeshes[n]];
      std::string smName = currentSubMesh->mName.C_Str();
      smName = ALStringCleaner::cleanString(smName);
 
      Ogre::SubMesh* submesh = ogMesh->createSubMesh(smName);
      submesh->operationType = (currentSubMesh->HasFaces()) ? Ogre::RenderOperation::OT_TRIANGLE_LIST : Ogre::RenderOperation::OT_POINT_LIST;
 
      // TODO
      submesh->useSharedVertices = false;
 
      matName = materialNames[currentSubMesh->mMaterialIndex];
      //Material need to be created in group to make setMaterialName working in last version of Ogre
      if (!matName.empty())
      {
        if (!materialManager->getByName(matName, mScene->getRessourceGroup()))
          materialManager->create(matName, mScene->getRessourceGroup());
        submesh->setMaterialName(matName);
      }
 
      //adjust vertices with bones bind pose
      //TODO remove when aiSkeleton is available
      if (currentSubMesh->mNumBones > 0)
      {
        aiMatrix4x4 meshInverseTrans = mScene->getFullTransform(mOrigin);
        meshInverseTrans.Inverse();
        std::vector<aiVector3D> vertices(currentSubMesh->mNumVertices);
        std::vector<aiVector3D> normals(currentSubMesh->mNumVertices);
      
        //copy vextices pos
        for (unsigned int i=0; i<currentSubMesh->mNumVertices; ++i)
        {
          vertices[i] = currentSubMesh->mVertices[i];
          normals[i] = currentSubMesh->mNormals[i];
          currentSubMesh->mVertices[i] = aiVector3D(0, 0, 0);
          currentSubMesh->mNormals[i] = aiVector3D(0, 0, 0);
        }
      
        for(unsigned int j=0; j<currentSubMesh->mNumBones; ++j)
        {
          aiBone* bone = currentSubMesh->mBones[j];
          aiNode* bnode = mScene->getAiScene()->mRootNode->FindNode(bone->mName);
      
          if (bnode)
          {
            for(unsigned int w=0; w<bone->mNumWeights; ++w)
            {
              aiVertexWeight aiWeight = bone->mWeights[w];
              aiMatrix4x4 boneMat = meshInverseTrans * mScene->getFullTransform(bnode) * bone->mOffsetMatrix;
              aiMatrix3x3 normMat = aiMatrix3x3(boneMat);
              aiVector3D vertPos = vertices[aiWeight.mVertexId];
              aiVector3D normal = normals[aiWeight.mVertexId];
              currentSubMesh->mVertices[aiWeight.mVertexId] += boneMat * vertPos * aiWeight.mWeight;
              currentSubMesh->mNormals[aiWeight.mVertexId] += normMat * normal * aiWeight.mWeight;
            }
          }
        }
      
        vertices.clear();
        normals.clear();
      }
 
      makeIndexBuffer(currentSubMesh, submesh);
      makeVertexBuffer(currentSubMesh, submesh);
 
      if (currentSubMesh->mNumBones > 0)
      {
        for(unsigned int n=0; n<currentSubMesh->mNumBones; ++n)
        {
          aiNode* bnode = mScene->getAiScene()->mRootNode->FindNode(currentSubMesh->mBones[n]->mName);
          aiNode* newBone = 0;
          aiNode* curBone = bnode;
          while(curBone && (curBone->mNumMeshes == 0) && (curBone != mScene->getAiScene()->mRootNode))
          {
            newBone = curBone;
            curBone = curBone->mParent;
          }
 
          if (newBone)
          {
            //add current
            mSkeletonAnim.addBone(newBone, 0, submesh);
 
            // add all sons
            std::queue<aiNode*> nodes;
            nodes.push(newBone);
            while(!nodes.empty())
            {
              newBone = nodes.front();
              nodes.pop();
 
              // Get the number of son.
              unsigned int nbSons = newBone->mNumChildren;
 
              // while there is still sons, we go through each of them add
              // add them to the queue.
              if(nbSons>0)
              {
                aiNode** sons = newBone->mChildren;
 
                for(unsigned int n=0; n<nbSons; ++n)
                {
                  // We get the son 1 by 1.
                  aiNode* son = sons[n];
                  if (son && mScene->isBone(son) && (son->mNumMeshes == 0) && (son != mScene->getAiScene()->mRootNode))
                  {
                    mSkeletonAnim.addBone(son, 0, submesh);
                    nodes.push(son);
                  }
                }
              }
            }
          }
 
          // add the bone with mesh weights
          if (bnode)
            mSkeletonAnim.addBone(bnode, currentSubMesh->mBones[n], submesh);
        }
      }
      ogMesh->_updateCompiledBoneAssignments();
 
      //optim memory for very big object when the scene only have one mesh (otherwise it can be used in instances nodes)
      if (/*(!mScene->IsLoaderModeEnable()) &&*/ (mScene->getAiScene()->mNumMeshes == 1) && (mScene->getAiScene()->mRootNode->mNumChildren == 0))
      {
        aiScene* curScene = const_cast<aiScene*>(mScene->getAiScene());
        delete currentSubMesh;
        curScene->mMeshes[mOrigin->mMeshes[n]] = 0;
        curScene->mNumMeshes -= 1;
      }
    }
  }
 
  void ALMesh::makeIndexBuffer(aiMesh* asSubMesh, Ogre::SubMesh* ogSubMesh)
  {
    ogSubMesh->vertexData = new Ogre::VertexData();
    ogSubMesh->vertexData->vertexStart = 0;
    ogSubMesh->vertexData->vertexCount = asSubMesh->mNumVertices;
 
    if (asSubMesh->mNumFaces > 0)
    {
      bool bUse32BitIndexes = (asSubMesh->mNumVertices > 65535) ? true : false;
 
      // Create a new index buffer
      ogSubMesh->indexData->indexStart = 0;
      ogSubMesh->indexData->indexCount = asSubMesh->mNumFaces * 3;
 
      ogSubMesh->indexData->indexBuffer = Ogre::HardwareBufferManager::getSingleton().createIndexBuffer(
        bUse32BitIndexes ? Ogre::HardwareIndexBuffer::IT_32BIT : Ogre::HardwareIndexBuffer::IT_16BIT,
        ogSubMesh->indexData->indexCount,
        Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
 
      std::vector<std::vector<int>> facesIndex;
      facesIndex.resize(asSubMesh->mNumFaces);
 
      // rebuild vertices index, it must start on 0
      for (unsigned int i = 0; i < asSubMesh->mNumFaces; i++)
      {
        facesIndex[i].resize(3);
        for (size_t j = 0; j < 3; j++)
        {
          if (asSubMesh->mFaces[i].mIndices[j] >= asSubMesh->mNumVertices)
            facesIndex[i][j] = 0;
          else
            facesIndex[i][j] = asSubMesh->mFaces[i].mIndices[j];
        }
      }
      //delete [] asSubMesh->mFaces;
      //asSubMesh->mFaces = NULL;
      //asSubMesh->mNumFaces = 0;
 
      // Fill the index buffer with faces data
      if (bUse32BitIndexes)
      {
        Ogre::uint32* pIdx = static_cast<Ogre::uint32*>(ogSubMesh->indexData->indexBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD));
        for (unsigned int i = 0; i < facesIndex.size(); i++)
        {
          *pIdx++ = static_cast<Ogre::uint32>(facesIndex[i][0]);
          *pIdx++ = static_cast<Ogre::uint32>(facesIndex[i][1]);
          *pIdx++ = static_cast<Ogre::uint32>(facesIndex[i][2]);
        }
        ogSubMesh->indexData->indexBuffer->unlock();
      }
      else
      {
        Ogre::uint16* pIdx = static_cast<Ogre::uint16*>(ogSubMesh->indexData->indexBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD));
        for (unsigned int i = 0; i < facesIndex.size(); i++)
        {
          *pIdx++ = static_cast<Ogre::uint16>(facesIndex[i][0]);
          *pIdx++ = static_cast<Ogre::uint16>(facesIndex[i][1]);
          *pIdx++ = static_cast<Ogre::uint16>(facesIndex[i][2]);
        }
        ogSubMesh->indexData->indexBuffer->unlock();
      }
      facesIndex.clear();
    }
  }
 
  void ALMesh::makeVertexBuffer(aiMesh* asSubMesh, Ogre::SubMesh* ogSubMesh)
  {
    // The arrays that contain the mesh data.
    aiVector3D* vertices = asSubMesh->mVertices;
    aiVector3D* normals = asSubMesh->mNormals;
    aiVector3D* tangents = asSubMesh->mTangents;
    aiVector3D* bitangent = asSubMesh->mBitangents;
 
    // For the time being, we only take the first texture coords of the mesh.
    std::vector<aiVector3D*> uv;
    unsigned int nbUV = asSubMesh->GetNumUVChannels();
    for(unsigned int n=0; n<nbUV; ++n)
    {
      uv.push_back(asSubMesh->mTextureCoords[n]);
    }
 
    std::vector<aiColor4D*> color;
    unsigned int nbCol = asSubMesh->GetNumColorChannels();
    for(unsigned int n=0; n<nbCol; ++n)
    {
      color.push_back(asSubMesh->mColors[n]);
    }
 
    // We prepare Ogre before feeding the datas.
    Ogre::VertexDeclaration* declaration = ogSubMesh->vertexData->vertexDeclaration;
    Ogre::VertexBufferBinding* bind = ogSubMesh->vertexData->vertexBufferBinding;
 
    size_t vBufSegmentSize = 0;
    size_t texSegmentSize = 0;
 
    declaration->addElement(0, vBufSegmentSize, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
    vBufSegmentSize += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
 
    // Set up the offset.
    if(normals)
    {
      declaration->addElement(0, vBufSegmentSize, Ogre::VET_FLOAT3, Ogre::VES_NORMAL);
      vBufSegmentSize += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
    }
 
    if (tangents)
    {
      declaration->addElement(0, vBufSegmentSize, Ogre::VET_FLOAT3, Ogre::VES_TANGENT);
      vBufSegmentSize += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
    }
 
    if (bitangent)
    {
      declaration->addElement(0, vBufSegmentSize, Ogre::VET_FLOAT3, Ogre::VES_BINORMAL);
      vBufSegmentSize += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
    }
 
    for(unsigned int n=0; n<color.size(); ++n)
    {
      declaration->addElement(0, vBufSegmentSize, Ogre::VET_COLOUR, Ogre::VES_DIFFUSE);
      vBufSegmentSize += Ogre::VertexElement::getTypeSize(Ogre::VET_COLOUR);
    }
 
    int countTex = 0;
    if (nbUV == 0)
    {
      declaration->addElement(1, texSegmentSize, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, countTex);
      texSegmentSize += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2);
      countTex++;
    }
    else
    {
      for (unsigned int n = 0; n < uv.size(); ++n)
      {
        declaration->addElement(1, texSegmentSize, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, countTex);
        texSegmentSize += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2);
        countTex++;
      }
    }
 
    // Now create the vertex buffers.
    Ogre::HardwareVertexBufferSharedPtr vbuffer = Ogre::HardwareBufferManager::getSingletonPtr()
      ->createVertexBuffer(vBufSegmentSize, ogSubMesh->vertexData->vertexCount, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
 
    //add UV buffer even if there are none for D3D shaders.
    Ogre::HardwareVertexBufferSharedPtr texBuf = Ogre::HardwareBufferManager::getSingletonPtr()
      ->createVertexBuffer(texSegmentSize, ogSubMesh->vertexData->vertexCount, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
 
    // Bind them.
    bind->setBinding(0, vbuffer);
    bind->setBinding(1, texBuf);
 
    // Lock them. pVert & pTexVert are pointers to the start of the hardware buffers.
    unsigned char* pVert = static_cast<unsigned char*>(vbuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD));
    unsigned char* pTexVert = static_cast<unsigned char*>(texBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
 
    Ogre::ARGB* pCol;
    float* pFloat;
 
    // Get the element lists for the buffers.
    Ogre::VertexDeclaration::VertexElementList elems = declaration->findElementsBySource(0);
    Ogre::VertexDeclaration::VertexElementList texElems = declaration->findElementsBySource(1);
 
    // Buffers are set up, so iterate the vertices.
    int iTexCoord = 0;
    for (unsigned int i = 0; i < asSubMesh->mNumVertices; ++i)
    {
      Ogre::VertexDeclaration::VertexElementList::const_iterator elemItr, elemEnd;
      elemEnd = elems.end();
      for (elemItr = elems.begin(); elemItr != elemEnd; ++elemItr)
      {
        // VertexElement corresponds to a part of a vertex definition eg. position, normal
        const Ogre::VertexElement& elem = *elemItr;
        switch (elem.getSemantic())
        {
        case Ogre::VES_POSITION:
          {
            elem.baseVertexPointerToElement(pVert, &pFloat);
 
            if (mBounding.isNull())
              mBounding = Ogre::AxisAlignedBox(Ogre::Vector3(vertices[i].x, vertices[i].y, vertices[i].z), Ogre::Vector3(vertices[i].x, vertices[i].y, vertices[i].z));
            else
              updateBounds(Ogre::Vector3(vertices[i].x, vertices[i].y, vertices[i].z));
            *pFloat++ = vertices[i].x;
            *pFloat++ = vertices[i].y;
            *pFloat++ = vertices[i].z;
          }
          break;
        case Ogre::VES_NORMAL:
          {
            elem.baseVertexPointerToElement(pVert, &pFloat);
            *pFloat++ = normals[i].x;
            *pFloat++ = normals[i].y;
            *pFloat++ = normals[i].z;
          }
          break;
        case Ogre::VES_TANGENT:
          {
            elem.baseVertexPointerToElement(pVert, &pFloat);
            *pFloat++ = tangents[i].x;
            *pFloat++ = tangents[i].y;
            *pFloat++ = tangents[i].z;
          }
          break;
        case Ogre::VES_BINORMAL:
          {
            elem.baseVertexPointerToElement(pVert, &pFloat);
            *pFloat++ = bitangent[i].x;
            *pFloat++ = bitangent[i].y;
            *pFloat++ = bitangent[i].z;
          }
          break;
        case Ogre::VES_DIFFUSE:
          {
            elem.baseVertexPointerToElement(pVert, &pCol);
            Ogre::ColourValue cv(color[0][i].r, color[0][i].g, color[0][i].b, color[0][i].a);
            *pCol = Ogre::VertexElement::convertColourValue(cv, Ogre::VertexElement::getBestColourVertexElementType());
          }
          break;
        default:
          break;
        } // Deal with an individual vertex element (position or normal).
      } // Loop positions and normals.
 
      iTexCoord = 0;
      elemEnd = texElems.end();
      for (elemItr = texElems.begin(); elemItr != elemEnd; ++elemItr)
      {
        // VertexElement corresponds to a part of a vertex definition eg. tex coord
        const Ogre::VertexElement& elem = *elemItr;
        switch (elem.getSemantic())
        {
        case Ogre::VES_TEXTURE_COORDINATES:
          {
            elem.baseVertexPointerToElement(pTexVert, &pFloat);
            if (nbUV == 0)
            {
              *pFloat++ = 0.0;
              *pFloat++ = 0.0;
            }
            else
            {
              *pFloat++ = uv[iTexCoord][i].x;
              *pFloat++ = 1 - uv[iTexCoord][i].y;
            }
 
            iTexCoord++;
          }
          break;
        default:
          break;
        } // Deal with an individual vertex element (tex coords).
      } // Loop tex coords.
 
      pVert += vbuffer->getVertexSize();
      pTexVert += texBuf->getVertexSize();
    } // Loop vertices.
 
    vbuffer->unlock();
    texBuf->unlock();
 
    //cleanup memory
    /*for (unsigned int n = 0; n<nbUV; ++n)
    {
      if (asSubMesh->mTextureCoords[n])
        delete [] asSubMesh->mTextureCoords[n];
      asSubMesh->mTextureCoords[n] = NULL;
    }
 
    for (unsigned int n = 0; n<nbCol; ++n)
    {
      if (asSubMesh->mColors[n])
        delete[] asSubMesh->mColors[n];
      asSubMesh->mColors[n] = NULL;
    }
 
    if (asSubMesh->mVertices)
      delete[] asSubMesh->mVertices;
    asSubMesh->mVertices = NULL;
 
    if (asSubMesh->mNormals)
      delete[] asSubMesh->mNormals;
    asSubMesh->mNormals = NULL;
    
    asSubMesh->mNumVertices = 0;
    */
  }
 
  void ALMesh::saveMesh(Ogre::MeshPtr ogMesh, boost::filesystem::path path, tinyxml2::XMLElement* parent)
  {
    if(mHasBone)
    {
      Ogre::SkeletonSerializer sklSer;
      boost::filesystem::path sklPath(path);
      sklPath /= "meshes/";
      std::string sklFile(sklPath.generic_string()+ogMesh->getName()+".skeleton");
      sklSer.exportSkeleton(mSkeleton.get(), sklFile);
    }
 
    size_t nbsubmesh = ogMesh->getNumSubMeshes();
    size_t numVertices = 0;
    for (unsigned int n = 0; n<nbsubmesh; ++n)
    {
      Ogre::SubMesh* submesh = ogMesh->getSubMesh(n);
      if (submesh->vertexData)
        numVertices += submesh->vertexData->vertexCount;
    }
    
    tinyxml2::XMLDocument* doc = parent->GetDocument();
    tinyxml2::XMLElement* xmlMesh = doc->NewElement("entity");
    xmlMesh->SetAttribute("name", ogMesh->getName().c_str());
    xmlMesh->SetAttribute("id", ALStringCleaner::curentUID().c_str());
    std::string file = "meshes/" + ogMesh->getName()+".mesh";
    xmlMesh->SetAttribute("meshFile", file.c_str());
    xmlMesh->SetAttribute("castShadows", true);
    tinyxml2::XMLElement* xmlSub = doc->NewElement("subentities");
 
    for(unsigned int n=0; n<nbsubmesh; ++n)
    {
      tinyxml2::XMLElement* xmlsubmesh = doc->NewElement("subentity");
      xmlsubmesh->SetAttribute("index", n);
      xmlsubmesh->SetAttribute("materialName", ogMesh->getSubMesh(n)->getMaterialName().c_str());
      xmlSub->InsertEndChild(xmlsubmesh);
    }
 
    xmlMesh->InsertEndChild(xmlSub);
    parent->InsertEndChild(xmlMesh);
 
    //Generate LOD
    int nbLevels = 4;
    if ((numVertices > 64) && (mScene->GetSceneLoader()->getFlags() & so3Converter_GenerateLod))
    {
      try //std
      {
        try
        {
          Ogre::LodConfig lodConfig;
          lodConfig.levels.clear();
          lodConfig.mesh = ogMesh;
          lodConfig.strategy = Ogre::ScreenRatioPixelCountLodStrategy::getSingletonPtr();
          lodConfig.advanced.useCompression = true;
          lodConfig.advanced.useVertexNormals = true;
          //lodConfig.advanced.preventPunchingHoles = true;
          //lodConfig.advanced.preventBreakingLines = true;
 
          int nbl = nbLevels + 2;
          Ogre::Real reduction = 0.7f / nbLevels;
          for (int i = 2; i < nbl; i++)
          {
            Ogre::Real i4 = (Ogre::Real)(i * i * i * i);
            lodConfig.createGeneratedLodLevel(Ogre::Real(2.0) / i4, reduction * i, Ogre::LodLevel::VRM_PROPORTIONAL);
          }
 
          Ogre::MeshLodGenerator::getSingleton().generateLodLevels(lodConfig);
        }
        catch (Ogre::Exception &)
        {
          ogMesh->removeLodLevels();
          MMechostr(MSKRUNTIME, "SO3Engine : failed to generate LOD levels on %s", ogMesh->getName().c_str());
        }
      }
      catch (std::exception &)
      {
        //catch memory alloc fail
        ogMesh->removeLodLevels();
        MMechostr(MSKRUNTIME, "SO3Engine : failed to generate LOD levels, out of memory on %s", ogMesh->getName().c_str());
      }
    }
 
    Ogre::MeshSerializer meshSer;
    boost::filesystem::path meshPath(path);
    meshPath /= "meshes/";
    std::string meshFile(meshPath.generic_string() + ogMesh->getName() + ".mesh");
    meshSer.exportMesh(ogMesh.get(), meshFile);
 
    //delete resource
    Ogre::MeshManager::getSingleton().remove(ogMesh->getHandle());
 
    // force resource destruction
    while (ogMesh)
      ogMesh.reset();
 
    if (mSkeleton)
    {
      Ogre::SkeletonManager::getSingleton().remove(mSkeleton->getHandle());
      mSkeleton.reset();
    }
  }
 
  void ALMesh::convert(boost::filesystem::path expPath, tinyxml2::XMLElement* parent)
  {
    Ogre::MeshPtr loadedMesh = generateMesh();
    saveMesh(loadedMesh, expPath, parent);
  }
 
  SEntity* ALMesh::load()
  {
    Ogre::MeshPtr loadedMesh = generateMesh();
    if (mSkeleton)
      loadedMesh->_notifySkeleton(mSkeleton);
 
    SEntity* scolMesh = mScene->getSScene()->CreateEntity(loadedMesh->getName(), mScene->getRessourceGroup(), loadedMesh);
 
    return scolMesh;
  }
}