ALNode.cpp

Go to the documentation of this file.

#include "SO3SceneLoader/ALSceneLoader.h"
#include "SO3SceneLoader/ALNode.h"
#include "SO3SceneLoader/ALScene.h"
#include "SO3SceneLoader/ALStringCleaner.h"
#include "SO3SceneLoader/ALMesh.h"
 
namespace SO3
{
  ALNode::ALNode(aiNode* asNode, SNode* pNode, ALScene* alscene, std::vector<aiCamera*> camerasNames, std::vector<aiLight*> lightsNames)
  {
    mCameras = camerasNames;
    mLights = lightsNames;
    mScene = alscene;
    mOrigin = asNode;
    mParent = pNode;
 
    // building NodeAnim vector.
    aiAnimation** anims = alscene->getAiScene()->mAnimations;
    for(unsigned int n=0; n<alscene->getAiScene()->mNumAnimations; ++n)
    {
      //nodes animation
      for(unsigned int i=0; i<anims[n]->mNumChannels; ++i)
      {
        if(anims[n]->mChannels[i]->mNodeName == mOrigin->mName)
        {
          ALConverterNodeAnim nodeAnim(mScene, anims[n], anims[n]->mChannels[i], mOrigin, anims[n]->mTicksPerSecond);
          mNodeAnim.push_back(nodeAnim);
        }
      }
    }
  }
 
  ALNode::ALNode(aiNode* asNode, SNode* pNode, ALScene* alscene, std::vector<aiCamera*> camerasNames, std::vector<aiLight*> lightsNames, tinyxml2::XMLElement* xmlParent)
  {
    mScene = alscene;
    mCameras = camerasNames;
    mLights = lightsNames;
 
    mOrigin = asNode;
    mParent = pNode;
    mParentNodeXml = xmlParent;
 
    // building NodeAnim vector.
    aiAnimation** anims = alscene->getAiScene()->mAnimations;
    for(unsigned int n=0; n<alscene->getAiScene()->mNumAnimations; ++n)
    {
      for(unsigned int i=0; i<anims[n]->mNumChannels; ++i)
      {
        if(anims[n]->mChannels[i]->mNodeName == mOrigin->mName)
        {
          ALConverterNodeAnim nodeAnim(mScene, anims[n], anims[n]->mChannels[i], mOrigin, anims[n]->mTicksPerSecond);
          mNodeAnim.push_back(nodeAnim);
        }
      }
    }
  }
 
  ALNode::~ALNode()
  {
    mNodeAnim.clear();
    mCameras.clear();
    mLights.clear();
  }
 
  float ALNode::processRange(aiLight* light)
  {
    if ((ConversionTools::fequal(light->mAttenuationLinear, 0.0f)) && (ConversionTools::fequal(light->mAttenuationQuadratic, 0.0f)))
      return 100.0f;
 
    if (ConversionTools::fequal(light->mAttenuationConstant, 0.0f))
      light->mAttenuationConstant = 1.0f;
 
    if (ConversionTools::fequal(light->mAttenuationQuadratic, 0.0f))
      light->mAttenuationQuadratic = 0.000001f;
 
    float range = (sqrt(4 * light->mAttenuationConstant * light->mAttenuationQuadratic + light->mAttenuationLinear + 4 * light->mAttenuationQuadratic) - light->mAttenuationLinear) / (2 * light->mAttenuationQuadratic);
 
    aiVector3D scale;
    aiVector3D pos;
    aiQuaternion quat;
    mScene->getFullTransform(mOrigin).Decompose(scale, quat, pos);
    float coef = (scale.x + scale.y + scale.z) / 3.0f;
    return range * coef;
  }
 
  tinyxml2::XMLElement* ALNode::convert(boost::filesystem::path expPath)
  {
    if (!isSceneDependent(mOrigin))
      return 0;
 
    // Before converting the asimmp node in a scol one, we need to clean the name.
    // It's very important since a lot of 3d application allow a lot of things
    // ( like space, redundant name, non-ASCII char, ... ) in ressources and nodes name,
    // which is nice from a user stand point but generate a lot of troubles for the programmer
    // ( especially when dealing with Ogre and his way of handling things by name ).
    // So we clean all those nasty things before hand.
    std::string basename((mOrigin->mName).C_Str());
 
    if (basename.find(mScene->getRessourcePath()) != std::string::npos)
      basename = boost::filesystem::path(basename).stem().generic_string();
 
    //For complex ifc node names we remove the hash
    if (basename.find("Ifc") != std::string::npos)
      basename = basename.substr(0, basename.length() - 22);
 
    if (basename == "")
     basename = ALStringCleaner::cleanString(mScene->getSceneName());
    else
     basename = ALStringCleaner::cleanString(basename);
    
    tinyxml2::XMLDocument* dotScene = mParentNodeXml->GetDocument();
    tinyxml2::XMLElement* xmlNode = dotScene->NewElement("node");
    xmlNode->SetAttribute("name", basename.c_str());
    xmlNode->SetAttribute("id", ALStringCleaner::curentUID().c_str());
    xmlNode->SetAttribute("isTarget", "false");
 
    // Node animations :
    for(unsigned int n=0; n<mNodeAnim.size(); ++n)
    {
      if(mNodeAnim[n].isAffected(mOrigin->mName))
        mNodeAnim[n].convert(xmlNode, (n == 0) ? true : false);
    }
    
    Ogre::Vector3 direction(Ogre::Vector3::UNIT_Z);
    if(isMesh(mOrigin))
    {
      convertMesh(expPath, xmlNode);
    }
    else if(isLight(mOrigin))
    {
      aiLight* cLight=0;
      for(unsigned int n=0; n<mLights.size(); ++n)
      {
        if(mOrigin->mName == mLights[n]->mName)
        {
          cLight = mLights[n];
          break;
        }
      }
 
      if(cLight==0)
        throw "No light associated to this node.";
 
      tinyxml2::XMLElement* xmlight = dotScene->NewElement("light");
      direction = Ogre::Vector3(cLight->mDirection.x, cLight->mDirection.y, cLight->mDirection.z);
      xmlight->SetAttribute("name", basename.c_str());
      xmlight->SetAttribute("id", ALStringCleaner::curentUID().c_str());
      if(cLight->mType == aiLightSource_POINT)
        xmlight->SetAttribute("type", "point");
      else if(cLight->mType == aiLightSource_SPOT)
        xmlight->SetAttribute("type", "spot");
      else
        xmlight->SetAttribute("type", "directional");
 
                  xmlight->SetAttribute("castShadows", (cLight->mType == aiLightSource_DIRECTIONAL) ? true : false);
 
      tinyxml2::XMLElement* diffuse = dotScene->NewElement("colourDiffuse");
      diffuse->SetAttribute("r", cLight->mColorDiffuse.r);
      diffuse->SetAttribute("g", cLight->mColorDiffuse.g);
      diffuse->SetAttribute("b", cLight->mColorDiffuse.b);
      xmlight->InsertEndChild(diffuse);
 
      tinyxml2::XMLElement* specular = dotScene->NewElement("colourSpecular");
      specular->SetAttribute("r", cLight->mColorSpecular.r);
      specular->SetAttribute("g", cLight->mColorSpecular.g);
      specular->SetAttribute("b", cLight->mColorSpecular.b);
      xmlight->InsertEndChild(specular);
 
      tinyxml2::XMLElement* atten = dotScene->NewElement("lightAttenuation");
      atten->SetAttribute("range", ConversionTools::formatFloatToString(processRange(cLight)).c_str());
      atten->SetAttribute("constant", ConversionTools::formatFloatToString(cLight->mAttenuationConstant).c_str());
      atten->SetAttribute("linear", ConversionTools::formatFloatToString(cLight->mAttenuationLinear).c_str());
      atten->SetAttribute("quadratic", ConversionTools::formatFloatToString(cLight->mAttenuationQuadratic).c_str());
      xmlight->InsertEndChild(atten);
 
      if(cLight->mType == aiLightSource_SPOT)
      {
        tinyxml2::XMLElement* lrange = dotScene->NewElement("lightRange");
        lrange->SetAttribute("inner", ConversionTools::formatFloatToString(cLight->mAngleInnerCone).c_str());
        lrange->SetAttribute("outer", ConversionTools::formatFloatToString(cLight->mAngleOuterCone).c_str());
        //lrange->SetAttribute("falloff", cLight->);
        xmlight->InsertEndChild(lrange);
      }
 
      xmlNode->InsertEndChild(xmlight);
    }
    else if(isCamera(mOrigin))
    {
      aiCamera* cCamera=0;
      for(unsigned int n=0; n<mCameras.size(); ++n)
      {
        if(mOrigin->mName == mCameras[n]->mName)
        {
          cCamera = mCameras[n];
          break;
        }
      }
 
      tinyxml2::XMLElement* xmlcam = dotScene->NewElement("camera");
 
      float fovY = cCamera->mHorizontalFOV * cCamera->mAspect;
      Ogre::Radian gfovY(fovY);
      
      if (fovY < 0.1f)
        gfovY = Ogre::Radian(3.14f / 4.0f);
 
      xmlcam->SetAttribute("name", basename.c_str());
      xmlcam->SetAttribute("id", ALStringCleaner::curentUID().c_str());
      xmlcam->SetAttribute("fov", ConversionTools::formatFloatToString(gfovY.valueRadians()).c_str());
 
      tinyxml2::XMLElement* clipping = dotScene->NewElement("clipping");
      clipping->SetAttribute("near", ConversionTools::formatFloatToString(cCamera->mClipPlaneNear).c_str());
      clipping->SetAttribute("far", ConversionTools::formatFloatToString(cCamera->mClipPlaneFar).c_str());
      xmlcam->InsertEndChild(clipping);
 
      xmlNode->InsertEndChild(xmlcam);
    }
 
    // Set up the transformation
    aiMatrix4x4 transformation = mOrigin->mTransformation;
    aiVector3D scale;
    aiVector3D pos;
    aiQuaternion rotation;
    transformation.Decompose(scale, rotation, pos);
 
    tinyxml2::XMLElement* xmlposition = dotScene->NewElement("position");
    xmlposition->SetAttribute("x", ConversionTools::formatFloatToString(pos.x).c_str());
    xmlposition->SetAttribute("y", ConversionTools::formatFloatToString(pos.y).c_str());
    xmlposition->SetAttribute("z", ConversionTools::formatFloatToString(pos.z).c_str());
    xmlNode->InsertFirstChild(xmlposition);
 
    Ogre::Quaternion oRot(rotation.w, rotation.x, rotation.y, rotation.z);
    if (!mParent && mScene->GetSceneLoader()->getFlags() & so3Converter_RotateX)
      oRot = oRot * Ogre::Quaternion(sqrt(0.5f), -sqrt(0.5f), 0.0f, 0.0f);
 
    if(isLight(mOrigin) || isCamera(mOrigin))
    {
      Ogre::Vector3 xaxis = Ogre::Vector3::UNIT_X * direction.x;
      Ogre::Vector3 yaxis = Ogre::Vector3::UNIT_Y * direction.y;
      Ogre::Vector3 zaxis = Ogre::Vector3::UNIT_Z * direction.z;
      Ogre::Quaternion dirRotation(xaxis, yaxis, zaxis);
 
      oRot = oRot * dirRotation;
    }
 
    tinyxml2::XMLElement* xmlrotation = dotScene->NewElement("rotation");
    xmlrotation->SetAttribute("qx", ConversionTools::formatFloatToString(oRot.x).c_str());
    xmlrotation->SetAttribute("qy", ConversionTools::formatFloatToString(oRot.y).c_str());
    xmlrotation->SetAttribute("qz", ConversionTools::formatFloatToString(oRot.z).c_str());
    xmlrotation->SetAttribute("qw", ConversionTools::formatFloatToString(oRot.w).c_str());
    xmlNode->InsertFirstChild(xmlrotation);
 
    tinyxml2::XMLElement* xmlscale = dotScene->NewElement("scale");
    xmlscale->SetAttribute("x", ConversionTools::formatFloatToString(scale.x).c_str());
    xmlscale->SetAttribute("y", ConversionTools::formatFloatToString(scale.y).c_str());
    xmlscale->SetAttribute("z", ConversionTools::formatFloatToString(scale.z).c_str());
    xmlNode->InsertFirstChild(xmlscale);
 
 
    mParentNodeXml->InsertEndChild(xmlNode);
 
    return xmlNode;
  }
 
  SNode* ALNode::load()
  {
    // Before converting the asimmp node in a scol one, we need to clean the name.
    // It's very important since a lot of 3d application allow a lot of things
    // ( like space, redundant name, non-ASCII char, ... ) in ressources and nodes name,
    // which is nice from a user stand point but generate a lot of troubles for the programmer
    // ( especially when dealing with Ogre and his way of handling things by name ).
    // So we clean all those nasty things before hand.
    std::string basename((mOrigin->mName).C_Str());
 
    //For complex ifc node names we remove the hash
    if (basename.find("Ifc") != std::string::npos)
      basename = basename.substr(0, basename.length() - 22);
    
    basename = ALStringCleaner::cleanString(basename);
 
    // Now we create the SNode.
    // Note that the constructor we use should create a unique name by suffixing the basename
    // with the position of the node in the list.
    SNode* gudNode = 0;
    Ogre::Vector3 direction;
 
    try
    {
      if(isMesh(mOrigin))
      {
        SEntity* entity = loadMesh();
        gudNode = static_cast<SNode*>(entity);
      }
      else if(isLight(mOrigin))
      {
        SLight* nlight = makeLight(mOrigin, direction);
        gudNode = static_cast<SNode*>(nlight);
      }
      else if (!isBone(mOrigin))
      {
        gudNode = mScene->getSScene()->CreateNodeWithUniqueName(basename);
      }
 
      if (gudNode)
      {
        gudNode->AttachToParent(mParent);
 
        // Now we need to add the position of the Node.
        aiMatrix4x4 transformation = mOrigin->mTransformation;
        aiVector3D scale;
        aiVector3D pos;
        aiQuaternion rotation;
 
        transformation.Decompose(scale, rotation, pos);
        Ogre::Vector3 oScale(scale.x, scale.y, scale.z);
        Ogre::Vector3 oPos(pos.x, pos.y, pos.z);
 
        Ogre::Quaternion oRot(rotation.w, rotation.x, rotation.y, rotation.z);
        if (!mParent && mScene->GetSceneLoader()->getFlags() & so3Converter_RotateX)
          oRot = oRot * Ogre::Quaternion(sqrt(0.5f), -sqrt(0.5f), 0.0f, 0.0f);
 
        gudNode->SetPosition(oPos);
        gudNode->SetScale(oScale);
        gudNode->SetOrientation(oRot);
 
        // Node animations :
        for(unsigned int n=0; n<mNodeAnim.size(); ++n)
        {
          if(mNodeAnim[n].isAffected(mOrigin->mName))
            mNodeAnim[n].load(gudNode);
        }
      }
    }
    catch(Ogre::Exception&)
    {
      //error on creation
    }
 
    return gudNode;
  }
 
  void ALNode::convertMesh(boost::filesystem::path expPath, tinyxml2::XMLElement* nParent)
  {
    ALMesh meshConverter(mOrigin, mScene);
    meshConverter.convert(expPath, nParent);
  }
 
  SEntity* ALNode::loadMesh()
  {
    ALMesh meshConverter(mOrigin, mScene);
    SEntity* convertedMesh = meshConverter.load();
 
    return convertedMesh;
  }
 
  bool ALNode::isMesh(aiNode* node)
  {
    return (node->mNumMeshes > 0) ? true : false;
  }
 
  bool ALNode::isCamera(aiNode* node)
  {
    for(unsigned int n=0; n<mCameras.size(); ++n)
    {
      if(node->mName == mCameras[n]->mName)
        return true;
    }
 
    return false;
  }
 
  bool ALNode::isLight(aiNode* node)
  {
    for(unsigned int n=0; n<mLights.size(); ++n)
    {
      if(node->mName == mLights[n]->mName)
        return true;
    }
 
    return false;
  }
 
  bool ALNode::isBone(aiNode* node)
  {
    return mScene->isBone(node);
  }
 
  bool ALNode::isSceneDependent(aiNode* node)
  {
    return mScene->isSceneDependent(node);
  }
 
  SCamera* ALNode::makeCamera(aiNode* node)
  {
    aiCamera* cCamera=0;
    for(unsigned int n=0; n<mCameras.size(); ++n)
    {
      if(node->mName == mCameras[n]->mName)
      {
        cCamera = mCameras[n];
        break;
      }
    }
 
    float fovY = cCamera->mHorizontalFOV * cCamera->mAspect;
    Ogre::Radian gfovY(fovY);
      
    if (fovY < 0.1f)
      gfovY = Ogre::Radian(3.14f / 4.0f);
 
    SCamera* scolCam = mScene->getSScene()->CreateCamera(ALStringCleaner::cleanString(cCamera->mName.C_Str()));
    scolCam->SetAutoAspectRatio(true);
    scolCam->SetFarClipDistance(cCamera->mClipPlaneFar);
    scolCam->SetNearClipDistance(cCamera->mClipPlaneNear);
    scolCam->SetFOVy(gfovY.valueRadians());
    scolCam->LookAt(Ogre::Vector3(cCamera->mLookAt.x, cCamera->mLookAt.y, cCamera->mLookAt.z), SNode::SO3_WORLD_TS);
 
    return scolCam;
  }
 
  SLight* ALNode::makeLight(aiNode* node, Ogre::Vector3& direction)
  {
    aiLight* cLight=0;
    for(unsigned int n=0; n<mLights.size(); ++n)
    {
      if(node->mName == mLights[n]->mName)
      {
        cLight = mLights[n];
        break;
      }
    }
 
    if(cLight==0)
      throw "No light associated to this node.";
 
    SLight* scolLight = mScene->getSScene()->CreateLight(ALStringCleaner::cleanString(cLight->mName.C_Str()));
    //scolLight->SetAttenuation(solveLightRange(light[n]), light[n]->mAttenuationConstant, light[n]->mAttenuationLinear, light[n]->mAttenuationQuadratic);
 
    scolLight->SetAttenuation(processRange(cLight));
    scolLight->SetDiffuseColour(Ogre::ColourValue(cLight->mColorDiffuse.r, cLight->mColorDiffuse.g, cLight->mColorDiffuse.b, 1.f));
    scolLight->SetSpecularColour(Ogre::ColourValue(cLight->mColorSpecular.r, cLight->mColorSpecular.g, cLight->mColorSpecular.b, 1.f));
 
    scolLight->SetDirection(Ogre::Vector3(cLight->mDirection.x, cLight->mDirection.y, cLight->mDirection.z));
 
    if(cLight->mType == aiLightSource_SPOT)
      scolLight->SetType(SLight::SO3_SPOT_LIGHT);
    else if(cLight->mType == aiLightSource_POINT)
      scolLight->SetType(SLight::SO3_POINT_LIGHT);
    else if(cLight->mType == aiLightSource_AREA)
      scolLight->SetType(SLight::SO3_RECT_LIGHT);
    else
      scolLight->SetType(SLight::SO3_DIRECTIONAL_LIGHT);
 
    scolLight->SetSourceSize(cLight->mSize.x, cLight->mSize.y);
    scolLight->SetSpotlightInnerAngle(cLight->mAngleInnerCone);
    scolLight->SetSpotlightOuterAngle(cLight->mAngleOuterCone);
 
    return scolLight;
  }
}