ALScene.cpp

Go to the documentation of this file.

#include "SO3SceneLoader/ALScene.h"
#include "SO3SceneLoader/ALSceneLoader.h"
 
#include <vector>
#include <sstream>
#include <queue>
#include <utility>
 
#include "SO3SceneLoader/ALNode.h"
#include "SO3SceneLoader/tinyxml2.h"
 
namespace SO3
{
  ALScene::ALScene()
  {
    mScene = 0;
    scolScene = 0;
    parentNode = 0;
    isConverted = false;
    resGroup = "";
    resPath = "";
  }
 
  ALScene::ALScene(ALSceneLoader* alSceneLoader, SScene* scene, std::string ressourceGroup, const aiScene* loadedScene, SNode* parent, const std::string &sceneName, bool isLoaderMode)
  {
    mSceneLoader = alSceneLoader;
    mScene = loadedScene;
    scolScene = scene;
    isConverted = false;
    mIsLoaderMode = isLoaderMode;
    resGroup = ressourceGroup;
    mSceneName = sceneName;
 
    // the ressource path is the directory where the original file is contained, so we get
    // the path up to the last slash.
    resPath = mSceneLoader->getFilePath().remove_filename().generic_string();
 
    parentNode = parent;
  }
 
  ALScene::~ALScene()
  {
  }
 
  bool ALScene::isEmpty()
  {
    return (mScene) ? true : false;
  }
 
  const std::vector<std::string> ALScene::getMaterialNames()
  {
    return mMaterialNames;
  }
 
  bool ALScene::IsLoaderModeEnable()
  {
    return mIsLoaderMode;
  }
 
  aiMatrix4x4 ALScene::getFullTransform(aiNode* toThis)
  {
    aiMatrix4x4 fullTrans = toThis->mTransformation;
          aiNode* parent = toThis->mParent;
          while(parent && parent != mScene->mRootNode)
          {
                  fullTrans = parent->mTransformation * fullTrans;
                  parent = parent->mParent;
          }
 
    return fullTrans;
  }
 
  bool ALScene::load(std::vector<SNode*> &scolNodes, std::vector<SMaterial*> &scolMats)
  {
    // If the mScene has not been set ( first constructor, we return nothing ).
    if(mScene != 0)
    {
      if(!isConverted)
      {
        // run through the entire list of object and create the hierarchy.
        // We need assimp to have at least one node, wich should always be the case ( assimp always create at least one root node ).
        if(mScene->mRootNode != 0)
        {
          // get vertex color list
          std::vector<bool> vertexColorList;
          vertexColorList.resize(mScene->mNumMaterials, false);
          for (unsigned int n = 0; n<mScene->mNumMeshes; ++n)
          {
            if (mScene->mMeshes[n]->GetNumColorChannels() > 0)
              vertexColorList[mScene->mMeshes[n]->mMaterialIndex] = true;
          }
 
          // Loading all the materials.
          loadMaterials(vertexColorList, scolMats);
 
          for (unsigned int i=0; i < scolMats.size(); ++i)
          {
            mMaterialNames.push_back(scolMats[i]->GetName());
          }
 
          // To avoid ending up with names like mesh3215654 we reset the uid each time finished with one type of data.
          ALStringCleaner::resetUID();
 
          // Loading all the bones names.
          for(unsigned int n=0; n<mScene->mNumMeshes; ++n)
          {
            for(unsigned int i=0; i<mScene->mMeshes[n]->mNumBones; ++i)
            {
              aiNode* bnode = mScene->mRootNode->FindNode(mScene->mMeshes[n]->mBones[i]->mName);
              setBones(bnode);
            }
          }
 
          // Loading all the cameras and light.
          std::vector<aiCamera*> cams;
          for(unsigned int n=0; n<mScene->mNumCameras; ++n)
            cams.push_back(mScene->mCameras[n]);
 
          std::vector<aiLight*> light;
          for(unsigned int n=0; n<mScene->mNumLights; ++n)
            light.push_back(mScene->mLights[n]);
 
          // Create nodes, meshes, cameras and lights.
          aiNode* asRootNode = mScene->mRootNode;
          if (!loadNodes(asRootNode, cams, light, scolNodes))
          {
            // error on loading, remove all created nodes
            for (unsigned int i = 0; i < scolNodes.size(); ++i)
            {
              scolScene->DeleteNode(scolNodes[i]);
            }
            scolNodes.clear();
          }
 
          ALStringCleaner::resetUID();
        }
      }
 
      return true;
    }
    else
    {
      return false;
    }
  }
 
  void ALScene::setBones(aiNode* bone)
  {
    //add all the parent nodes as bones
    aiNode* newBone = 0;
    aiNode* curBone = bone;
    while(curBone && (curBone->mNumMeshes == 0) && (curBone != mScene->mRootNode))
    {
      newBone = curBone;
      curBone = curBone->mParent;
    }
 
    if (newBone)
    {
      //add current
      mBonesNames.insert(std::string(newBone->mName.C_Str()));
 
      // 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 && (son->mNumMeshes == 0) && (son != mScene->mRootNode))
            {
              mBonesNames.insert(std::string(son->mName.C_Str()));
              nodes.push(son);
            }
          }
        }
      }
    }
  }
 
  void ALScene::convert(boost::filesystem::path expFolder)
  {
    // If the mScene has not been set ( first constructor, we return nothing ).
    if(mScene != 0)
    {
      if(!isConverted)
      {
        boost::filesystem::path expFile = expFolder;
        expFile /= mSceneName + ".scene";
 
        // run through the entire list of object and create the hierarchy.
        // We need assimp to have at least one node, wich should always be the case ( assimp always create at least one root node ).
        if(mScene->mRootNode != 0)
        {
          // Create the Dot Scene file for Ogre.
          std::string sceneFileName = expFile.generic_string();
          tinyxml2::XMLDocument dotScene;
          //dotScene.LoadFile(exportFile.c_str());
 
          // Initializing the scene :
          tinyxml2::XMLElement*  mainElem = dotScene.NewElement("scene");
          mainElem->SetAttribute("upAxis", "y");
          mainElem->SetAttribute("unitType", "meters");
          mainElem->SetAttribute("formatVersion", "1.0");
          mainElem->SetAttribute("minOgreVersion", "1.8");
          mainElem->SetAttribute("author", "Scol_Assimp_Exporter");
          dotScene.InsertEndChild(mainElem);
 
          // Set environnement
          tinyxml2::XMLElement*  env = dotScene.NewElement("environnement");
          tinyxml2::XMLElement*  colAmbient = dotScene.NewElement("ColourAmbient");
          tinyxml2::XMLElement*  colBack = dotScene.NewElement("ColourBackground");
          colAmbient->SetAttribute("r", 0.25f);
          colAmbient->SetAttribute("g", 0.25f);
          colAmbient->SetAttribute("b", 0.25f);
          colBack->SetAttribute("r", 0);
          colBack->SetAttribute("g", 0);
          colBack->SetAttribute("b", 0);
 
          env->InsertEndChild(colAmbient);
          env->InsertEndChild(colBack);
          mainElem->InsertEndChild(env);
          
          // get vertex color list
          std::vector<bool> vertexColorList;
          vertexColorList.resize(mScene->mNumMaterials, false);
          for (unsigned int n = 0; n<mScene->mNumMeshes; ++n)
          {
            if (mScene->mMeshes[n]->GetNumColorChannels() > 0)
              vertexColorList[mScene->mMeshes[n]->mMaterialIndex] = true;
          }
 
          // convert embedded texture
          if (mScene->HasTextures())
          {
            for (unsigned int i = 0; i < mScene->mNumTextures; i++)
            {
              aiTexture* tex = mScene->mTextures[i];
              bool compressed = (tex->mHeight == 0);
              //TODO build png texture from data
              /*
              if (compressed)
              {
                for (unsigned int n = 0; n < tex->mWidth;++n)
                {
                  fprintf(out,"\t\t\t%2x",reinterpret_cast<uint8_t*>(tex->pcData)[n]);
                  if (n && !(n % 50))
                    fprintf(out,"\n");
                }
              }
              else
              for (unsigned int y = 0; y < tex->mHeight;++y)
              {
                                              for (unsigned int x = 0; x < tex->mWidth;++x)
                {
                                                      aiTexel* tx = tex->pcData + y*tex->mWidth+x;
                                                      unsigned int r = tx->r,g=tx->g,b=tx->b,a=tx->a;
                                                      fprintf(out,"\t\t\t%2x %2x %2x %2x",r,g,b,a);
 
                                                      // group by four for readibility
                                                      if (0 == (x+y*tex->mWidth) % 4)
                                                              fprintf(out,"\n");
                                              }
                                      }
              */
            }
          }
 
          // Loading all the materials.
          convertMaterials(expFolder, vertexColorList, mMaterialNames);
 
          // To avoid ending up with names like mesh3215654 we reset the uid each time finished with one type of data.
          ALStringCleaner::resetUID();
 
          // Loading all the cameras and light.
          std::vector<aiCamera*> cams;
          for(unsigned int n=0; n<mScene->mNumCameras; ++n)
            cams.push_back(mScene->mCameras[n]);
 
          std::vector<aiLight*> light;
          for(unsigned int n=0; n<mScene->mNumLights; ++n)
            light.push_back(mScene->mLights[n]);
 
          // Loading all the bones names.
          for(unsigned int n=0; n<mScene->mNumMeshes; ++n)
          {
            for(unsigned int i=0; i<mScene->mMeshes[n]->mNumBones; ++i)
            {
              aiNode* bnode = mScene->mRootNode->FindNode(mScene->mMeshes[n]->mBones[i]->mName);
              setBones(bnode);
            }
          }
 
          // Create nodes, meshes, cameras and lights.
          tinyxml2::XMLElement* xmlnodes = dotScene.NewElement("nodes");
          aiNode* asRootNode = mScene->mRootNode;
          convertNodes(asRootNode, cams, light, expFolder, xmlnodes);
          ALStringCleaner::resetUID();
 
          mainElem->InsertEndChild(xmlnodes);
 
          dotScene.SaveFile(sceneFileName.c_str());
        }
      }
    }
  }
 
  void ALScene::loadMaterials(std::vector<bool> &vertexColorList, std::vector<SMaterial*> &matsList)
  {
    unsigned int nbMat = mScene->mNumMaterials;
    aiMaterial** materials = mScene->mMaterials;
 
    for(unsigned int n=0; n<nbMat; ++n)
    {
      ALMaterial matConv(this, materials[n], vertexColorList[n]);
      SMaterial* nmat = matConv.load();
 
      if (nmat)
        matsList.push_back(nmat);
    }
  }
 
  void ALScene::convertMaterials(boost::filesystem::path expPath, std::vector<bool> &vertexColorList, std::vector<std::string> &matNames)
  {
    unsigned int nbMat = mScene->mNumMaterials;
    aiMaterial** materials = mScene->mMaterials;
 
    bool Clear = true;
    for(unsigned int n=0; n<nbMat; ++n)
    {
      ALMaterial matConv(this, materials[n], vertexColorList[n]);
      matNames.push_back(matConv.convert(expPath, Clear));
      Clear = false;
    }
  }
 
  bool ALScene::loadNodes(aiNode* rootNode, std::vector<aiCamera*> cameras, std::vector<aiLight*> lights, std::vector<SNode*>& outNodes)
  {
    ALNode nconv(rootNode, (parentNode == 0) ? scolScene->GetRootNode() : parentNode, this, cameras, lights);
    SNode* rootScolNode = nconv.load();
 
    std::pair<aiNode*,SNode*> currentRoot(rootNode, (parentNode == 0) ? scolScene->GetRootNode() : parentNode);
    std::queue< std::pair<aiNode*,SNode*> > file;
    file.push(currentRoot);
 
    // do not add the root node
    outNodes.push_back(rootScolNode);
 
    // If the queue is not empty that mean that we have not gone through all the nodes
    // So, we continue until the queue is empty.
    while(!file.empty())
    {
      // Since we are searching for the children of the first Node in the queue,
      // it become the current root node for this iteration.
      currentRoot = file.front();
      file.pop();
 
      // Get the number of son.
      unsigned int nbSons = currentRoot.first->mNumChildren;
 
      // while there is still sons, we go through each of them add
      // add them to the queue.
      if(nbSons>0)
      {
        aiNode** sons = currentRoot.first->mChildren;
 
        for(unsigned int n=0; n<nbSons; ++n)
        {
          // We get the son 1 by 1.
          aiNode* son = sons[n];
 
          // Convert the current Node, attach it to his parent and compute the transformation.
          ALNode nconv(son, currentRoot.second, this, cameras, lights);
          SNode* scolSon = nconv.load();
 
          // error on loading
          if (scolSon)
          {
            // Add the son to the queue
            std::pair<aiNode*, SNode*> sonNodes(son, scolSon);
            file.push(sonNodes);
 
            // Now we just put the SNode in our list.
            outNodes.push_back(scolSon);
          }
        }
      }
    }
 
    return true;
  }
 
  void ALScene::convertNodes(aiNode* rootNode, std::vector<aiCamera*> cameras, std::vector<aiLight*> lights, boost::filesystem::path expPath, tinyxml2::XMLElement* xmlParent)
  {
    SNode* rootScolNode = parentNode;
    ALNode nodeConverter(rootNode, rootScolNode, this, cameras, lights, xmlParent);
 
    // We begin the algorithm with the root node of the scene.
    // We use a pair because we need to know the SNode parent of the node we are dealing with.
    // This is the simpliest way I found to keep track of the Node in both system ( assimp and scol )
    // since we need both of them at any point.
    tinyxml2::XMLElement* xmlRootNode = nodeConverter.convert(expPath);
 
    aiNode* currentRoot(rootNode);
    std::pair<aiNode*,tinyxml2::XMLElement*> rootinfo(currentRoot, xmlRootNode);
    std::queue<std::pair<aiNode*,tinyxml2::XMLElement*>> file;
    file.push(rootinfo); 
 
    // If the queue is not empty that mean that we have not gone through all the nodes
    // So, we continue until the queue is empty.
    while(!file.empty())
    {
      // Since we are searching for the children of the first Node in the queue,
      // it become the current root node for this iteration.
      rootinfo = file.front();
      currentRoot = rootinfo.first;
      file.pop();
 
      //ignore bones but keep nodes with meshes
      if (!isSceneDependent(currentRoot))
        continue;
 
      // Get the number of son.
      unsigned int nbSons = currentRoot->mNumChildren;
 
      // while there is still sons, we go through each of them add
      // add them to the queue.
      if(nbSons>0)
      {
        aiNode** sons = currentRoot->mChildren;
 
        for(unsigned int n=0; n<nbSons; ++n)
        {
          // We get the son 1 by 1.
          aiNode* son = sons[n];
 
          //ignore bones
          if (!isSceneDependent(son))
            continue;
 
          // Convert the current Node, attach it to his parent and compute the transformation.
          ALNode nconv(son, 0, this, cameras, lights, rootinfo.second);
          tinyxml2::XMLElement* xnode = nconv.convert(expPath);
 
          // Add the son to the queue
          std::pair<aiNode*,tinyxml2::XMLElement*> sonInfo(son, xnode);
 
          file.push(sonInfo);
        }
      }
    }
  }
 
  bool ALScene::addTextureRef(std::string name, std::string path)
  {
    AlTexturesMap::iterator iTextureSearched = mTextureMap.find(path);
    if(iTextureSearched != mTextureMap.end())
      return false;
 
    mTextureMap.insert(AlTexturesMap::value_type(path, name));
    return true;
  }
 
  std::string ALScene::getTextureRef(std::string path)
  {
    AlTexturesMap::iterator iTextureSearched = mTextureMap.find(path);
    if(iTextureSearched == mTextureMap.end())
      return "";
 
    return iTextureSearched->second;
  }
 
  SScene* ALScene::getSScene()
  {
    return scolScene;
  }
 
  const aiScene* ALScene::getAiScene()
  {
    return mScene;
  }
 
  std::string ALScene::getRessourceGroup()
  {
    return resGroup;
  }
 
  std::string ALScene::getRessourcePath()
  {
    return resPath;
  }
 
  std::string ALScene::getSceneName()
  {
    return mSceneName;
  }
 
  std::set<std::string> ALScene::getBonesNames()
  {
    return mBonesNames;
  }
 
  bool ALScene::isBone(aiNode* node)
  {
    if(mBonesNames.find(std::string(node->mName.C_Str())) != mBonesNames.end())
      return true;
    else
      return false;
  }
 
  bool ALScene::haveMeshInHierarchy(aiNode* node)
  {
    bool haveMesh = node->mNumMeshes > 0;
    unsigned int nbSons = node->mNumChildren;
 
    if (nbSons > 0)
    {
      aiNode** sons = node->mChildren;
 
      for (unsigned int n = 0; n < nbSons && !haveMesh; ++n)
      {
        aiNode* son = sons[n];
        haveMesh = son->mNumMeshes > 0;
        if (!haveMesh)
          haveMesh = haveMeshInHierarchy(son);
      }
    }
    return haveMesh;
  }
 
  bool ALScene::isSceneDependent(aiNode* node)
  {
    if (!isBone(node) || haveMeshInHierarchy(node))
      return true;
    else
      return false;
  }
}